]> git.meshlink.io Git - catta/blob - avahi-core/socket.c
Include qt mainloop adapter in build system. Moc finding code is cracktastic thanks to
[catta] / avahi-core / socket.c
1 /* $Id$ */
2
3 /***
4   This file is part of avahi.
5  
6   avahi is free software; you can redistribute it and/or modify it
7   under the terms of the GNU Lesser General Public License as
8   published by the Free Software Foundation; either version 2.1 of the
9   License, or (at your option) any later version.
10  
11   avahi is distributed in the hope that it will be useful, but WITHOUT
12   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
13   or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General
14   Public License for more details.
15  
16   You should have received a copy of the GNU Lesser General Public
17   License along with avahi; if not, write to the Free Software
18   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
19   USA.
20 ***/
21
22 #ifdef HAVE_CONFIG_H
23 #include <config.h>
24 #endif
25
26 #include <inttypes.h>
27 #include <errno.h>
28 #include <string.h>
29 #include <stdio.h>
30 #include <sys/socket.h>
31 #include <netinet/in.h>
32 #include <arpa/inet.h>
33 #include <unistd.h>
34 #include <fcntl.h>
35 #include <sys/time.h>
36 #include <net/if.h>
37 #include <sys/ioctl.h>
38 #include <assert.h>
39
40 #include "dns.h"
41 #include "fdutil.h"
42 #include "socket.h"
43 #include "log.h"
44
45 static void mdns_mcast_group_ipv4(struct sockaddr_in *ret_sa) {
46     assert(ret_sa);
47
48     memset(ret_sa, 0, sizeof(struct sockaddr_in));
49     ret_sa->sin_family = AF_INET;
50     ret_sa->sin_port = htons(AVAHI_MDNS_PORT);
51     inet_pton(AF_INET, AVAHI_IPV4_MCAST_GROUP, &ret_sa->sin_addr);
52 }
53
54 static void mdns_mcast_group_ipv6(struct sockaddr_in6 *ret_sa) {
55     assert(ret_sa);
56
57     memset(ret_sa, 0, sizeof(struct sockaddr_in6));
58     ret_sa->sin6_family = AF_INET6;
59     ret_sa->sin6_port = htons(AVAHI_MDNS_PORT);
60     inet_pton(AF_INET6, AVAHI_IPV6_MCAST_GROUP, &ret_sa->sin6_addr);
61 }
62
63 static void ipv4_address_to_sockaddr(struct sockaddr_in *ret_sa, const AvahiIPv4Address *a, uint16_t port) {
64     assert(ret_sa);
65     assert(a);
66     assert(port > 0);
67
68     memset(ret_sa, 0, sizeof(struct sockaddr_in));
69     ret_sa->sin_family = AF_INET;
70     ret_sa->sin_port = htons(port);
71     memcpy(&ret_sa->sin_addr, a, sizeof(AvahiIPv4Address));
72 }
73
74 static void ipv6_address_to_sockaddr(struct sockaddr_in6 *ret_sa, const AvahiIPv6Address *a, uint16_t port) {
75     assert(ret_sa);
76     assert(a);
77     assert(port > 0);
78
79     memset(ret_sa, 0, sizeof(struct sockaddr_in6));
80     ret_sa->sin6_family = AF_INET6;
81     ret_sa->sin6_port = htons(port);
82     memcpy(&ret_sa->sin6_addr, a, sizeof(AvahiIPv6Address));
83 }
84
85 int avahi_mdns_mcast_join_ipv4(int fd, int idx) {
86     struct ip_mreqn mreq; 
87     struct sockaddr_in sa;
88
89     mdns_mcast_group_ipv4 (&sa);
90  
91     memset(&mreq, 0, sizeof(mreq));
92     mreq.imr_multiaddr = sa.sin_addr;
93     mreq.imr_ifindex = idx;
94  
95     if (setsockopt(fd, SOL_IP, IP_ADD_MEMBERSHIP, &mreq, sizeof(mreq)) < 0) {
96         avahi_log_warn("IP_ADD_MEMBERSHIP failed: %s\n", strerror(errno));
97         return -1;
98     } 
99
100     return 0;
101 }
102
103 int avahi_mdns_mcast_join_ipv6(int fd, int idx) {
104     struct ipv6_mreq mreq6; 
105     struct sockaddr_in6 sa6;
106
107     mdns_mcast_group_ipv6 (&sa6);
108
109     memset(&mreq6, 0, sizeof(mreq6));
110     mreq6.ipv6mr_multiaddr = sa6.sin6_addr;
111     mreq6.ipv6mr_interface = idx;
112
113     if (setsockopt(fd, SOL_IPV6, IPV6_ADD_MEMBERSHIP, &mreq6, sizeof(mreq6)) < 0) {
114         avahi_log_warn("IPV6_ADD_MEMBERSHIP failed: %s\n", strerror(errno));
115         return -1;
116     }
117
118     return 0;
119 }
120
121 int avahi_mdns_mcast_leave_ipv4(int fd, int idx) {
122     struct ip_mreqn mreq; 
123     struct sockaddr_in sa;
124     
125     mdns_mcast_group_ipv4 (&sa);
126  
127     memset(&mreq, 0, sizeof(mreq));
128     mreq.imr_multiaddr = sa.sin_addr;
129     mreq.imr_ifindex = idx;
130  
131     if (setsockopt(fd, SOL_IP, IP_DROP_MEMBERSHIP, &mreq, sizeof(mreq)) < 0) {
132         avahi_log_warn("IP_DROP_MEMBERSHIP failed: %s\n", strerror(errno));
133         return -1;
134     }
135
136     return 0;
137 }
138
139 int avahi_mdns_mcast_leave_ipv6(int fd, int idx) {
140     struct ipv6_mreq mreq6; 
141     struct sockaddr_in6 sa6;
142
143     mdns_mcast_group_ipv6 (&sa6);
144
145     memset(&mreq6, 0, sizeof(mreq6));
146     mreq6.ipv6mr_multiaddr = sa6.sin6_addr;
147     mreq6.ipv6mr_interface = idx;
148
149     if (setsockopt(fd, SOL_IPV6, IPV6_DROP_MEMBERSHIP, &mreq6, sizeof(mreq6)) < 0) {
150         avahi_log_warn("IPV6_DROP_MEMBERSHIP failed: %s\n", strerror(errno));
151         return -1;
152     }
153
154     return 0;
155 }
156
157 static int bind_with_warn(int fd, const struct sockaddr *sa, socklen_t l) {
158     int yes;
159     
160     assert(fd >= 0);
161     assert(sa);
162     assert(l > 0);
163     
164     if (bind(fd, sa, l) < 0) {
165
166         if (errno != EADDRINUSE) {
167             avahi_log_warn("bind() failed: %s\n", strerror(errno));
168             return -1;
169         }
170             
171         avahi_log_warn("*** WARNING: Detected another %s mDNS stack running on this host. This makes mDNS unreliable and is thus not recommended. ***",
172                        sa->sa_family == AF_INET ? "IPv4" : "IPv6");
173
174         /* Try again, this time with SO_REUSEADDR set */
175         yes = 1;
176         if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes)) < 0) {
177             avahi_log_warn("SO_REUSEADDR failed: %s\n", strerror(errno));
178             return -1;
179         }
180
181         if (bind(fd, sa, l) < 0) {
182             avahi_log_warn("bind() failed: %s\n", strerror(errno));
183             return -1;
184         }
185     } else {
186
187         /* We enable SO_REUSEADDR afterwards, to make sure that the
188          * user may run other mDNS implementations if he really
189          * wants. */
190         
191         yes = 1;
192         if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes)) < 0) {
193             avahi_log_warn("SO_REUSEADDR failed: %s\n", strerror(errno));
194             return -1;
195         }
196     }
197
198     return 0;
199 }
200
201 int avahi_open_socket_ipv4(void) {
202     struct sockaddr_in local;
203     int fd = -1, ttl, yes;
204         
205     if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
206         avahi_log_warn("socket() failed: %s\n", strerror(errno));
207         goto fail;
208     }
209     
210     ttl = 255;
211     if (setsockopt(fd, SOL_IP, IP_MULTICAST_TTL, &ttl, sizeof(ttl)) < 0) {
212         avahi_log_warn("IP_MULTICAST_TTL failed: %s\n", strerror(errno));
213         goto fail;
214     }
215
216     ttl = 255;
217     if (setsockopt(fd, SOL_IP, IP_TTL, &ttl, sizeof(ttl)) < 0) {
218         avahi_log_warn("IP_TTL failed: %s\n", strerror(errno));
219         goto fail;
220     }
221     
222     yes = 1;
223     if (setsockopt(fd, SOL_IP, IP_MULTICAST_LOOP, &yes, sizeof(yes)) < 0) {
224         avahi_log_warn("IP_MULTICAST_LOOP failed: %s\n", strerror(errno));
225         goto fail;
226     }
227     
228     memset(&local, 0, sizeof(local));
229     local.sin_family = AF_INET;
230     local.sin_port = htons(AVAHI_MDNS_PORT);
231
232     if (bind_with_warn(fd, (struct sockaddr*) &local, sizeof(local)) < 0)
233         goto fail;
234
235     yes = 1;
236     if (setsockopt(fd, SOL_IP, IP_RECVTTL, &yes, sizeof(yes)) < 0) {
237         avahi_log_warn("IP_RECVTTL failed: %s\n", strerror(errno));
238         goto fail;
239     }
240
241     yes = 1;
242     if (setsockopt(fd, SOL_IP, IP_PKTINFO, &yes, sizeof(yes)) < 0) {
243         avahi_log_warn("IP_PKTINFO failed: %s\n", strerror(errno));
244         goto fail;
245     }
246     
247     if (avahi_set_cloexec(fd) < 0) {
248         avahi_log_warn("FD_CLOEXEC failed: %s\n", strerror(errno));
249         goto fail;
250     }
251     
252     if (avahi_set_nonblock(fd) < 0) {
253         avahi_log_warn("O_NONBLOCK failed: %s\n", strerror(errno));
254         goto fail;
255     }
256
257     return fd;
258
259 fail:
260     if (fd >= 0)
261         close(fd);
262
263     return -1;
264 }
265
266 int avahi_open_socket_ipv6(void) {
267     struct sockaddr_in6 sa, local;
268     int fd = -1, ttl, yes;
269
270     mdns_mcast_group_ipv6(&sa);
271         
272     if ((fd = socket(AF_INET6, SOCK_DGRAM, 0)) < 0) {
273         avahi_log_warn("socket() failed: %s\n", strerror(errno));
274         goto fail;
275     }
276     
277     ttl = 255;
278     if (setsockopt(fd, SOL_IPV6, IPV6_MULTICAST_HOPS, &ttl, sizeof(ttl)) < 0) {
279         avahi_log_warn("IPV6_MULTICAST_HOPS failed: %s\n", strerror(errno));
280         goto fail;
281     }
282
283     ttl = 255;
284     if (setsockopt(fd, SOL_IPV6, IPV6_UNICAST_HOPS, &ttl, sizeof(ttl)) < 0) {
285         avahi_log_warn("IPV6_UNICAST_HOPS failed: %s\n", strerror(errno));
286         goto fail;
287     }
288     
289     yes = 1;
290     if (setsockopt(fd, SOL_IPV6, IPV6_V6ONLY, &yes, sizeof(yes)) < 0) {
291         avahi_log_warn("IPV6_V6ONLY failed: %s\n", strerror(errno));
292         goto fail;
293     }
294
295     yes = 1;
296     if (setsockopt(fd, SOL_IPV6, IPV6_MULTICAST_LOOP, &yes, sizeof(yes)) < 0) {
297         avahi_log_warn("IPV6_MULTICAST_LOOP failed: %s\n", strerror(errno));
298         goto fail;
299     }
300
301     memset(&local, 0, sizeof(local));
302     local.sin6_family = AF_INET6;
303     local.sin6_port = htons(AVAHI_MDNS_PORT);
304     
305     if (bind_with_warn(fd, (struct sockaddr*) &local, sizeof(local)) < 0)
306         goto fail;
307
308     yes = 1;
309     if (setsockopt(fd, SOL_IPV6, IPV6_HOPLIMIT, &yes, sizeof(yes)) < 0) {
310         avahi_log_warn("IPV6_HOPLIMIT failed: %s\n", strerror(errno));
311         goto fail;
312     }
313
314     yes = 1;
315     if (setsockopt(fd, SOL_IPV6, IPV6_PKTINFO, &yes, sizeof(yes)) < 0) {
316         avahi_log_warn("IPV6_PKTINFO failed: %s\n", strerror(errno));
317         goto fail;
318     }
319     
320     if (avahi_set_cloexec(fd) < 0) {
321         avahi_log_warn("FD_CLOEXEC failed: %s\n", strerror(errno));
322         goto fail;
323     }
324     
325     if (avahi_set_nonblock(fd) < 0) {
326         avahi_log_warn("O_NONBLOCK failed: %s\n", strerror(errno));
327         goto fail;
328     }
329
330     return fd;
331
332 fail:
333     if (fd >= 0)
334         close(fd);
335
336     return -1;
337 }
338
339 static int sendmsg_loop(int fd, struct msghdr *msg, int flags) {
340     assert(fd >= 0);
341     assert(msg);
342
343     for (;;) {
344     
345         if (sendmsg(fd, msg, flags) >= 0)
346             break;
347         
348         if (errno != EAGAIN) {
349             avahi_log_debug("sendmsg() failed: %s\n", strerror(errno));
350             return -1;
351         }
352         
353         if (avahi_wait_for_write(fd) < 0)
354             return -1;
355     }
356
357     return 0;
358 }
359
360 int avahi_send_dns_packet_ipv4(int fd, int interface, AvahiDnsPacket *p, const AvahiIPv4Address *a, uint16_t port) {
361     struct sockaddr_in sa;
362     struct msghdr msg;
363     struct iovec io;
364     struct cmsghdr *cmsg;
365     struct in_pktinfo *pkti;
366     uint8_t cmsg_data[sizeof(struct cmsghdr) + sizeof(struct in_pktinfo)];
367
368     assert(fd >= 0);
369     assert(p);
370     assert(avahi_dns_packet_is_valid(p) >= 0);
371     assert(!a || port > 0);
372
373     if (!a)
374         mdns_mcast_group_ipv4(&sa);
375     else
376         ipv4_address_to_sockaddr(&sa, a, port);
377
378     memset(&io, 0, sizeof(io));
379     io.iov_base = AVAHI_DNS_PACKET_DATA(p);
380     io.iov_len = p->size;
381
382     memset(cmsg_data, 0, sizeof(cmsg_data));
383     cmsg = (struct cmsghdr*) cmsg_data;
384     cmsg->cmsg_len = sizeof(cmsg_data);
385     cmsg->cmsg_level = IPPROTO_IP;
386     cmsg->cmsg_type = IP_PKTINFO;
387
388     pkti = (struct in_pktinfo*) (cmsg_data + sizeof(struct cmsghdr));
389     pkti->ipi_ifindex = interface;
390     
391     memset(&msg, 0, sizeof(msg));
392     msg.msg_name = &sa;
393     msg.msg_namelen = sizeof(sa);
394     msg.msg_iov = &io;
395     msg.msg_iovlen = 1;
396     msg.msg_control = cmsg_data;
397     msg.msg_controllen = sizeof(cmsg_data);
398     msg.msg_flags = 0;
399
400     return sendmsg_loop(fd, &msg, 0 /*MSG_DONTROUTE*/);
401 }
402
403 int avahi_send_dns_packet_ipv6(int fd, int interface, AvahiDnsPacket *p, const AvahiIPv6Address *a, uint16_t port) {
404     struct sockaddr_in6 sa;
405     struct msghdr msg;
406     struct iovec io;
407     struct cmsghdr *cmsg;
408     struct in6_pktinfo *pkti;
409     uint8_t cmsg_data[sizeof(struct cmsghdr) + sizeof(struct in6_pktinfo)];
410
411     assert(fd >= 0);
412     assert(p);
413     assert(avahi_dns_packet_is_valid(p) >= 0);
414
415     if (!a)
416         mdns_mcast_group_ipv6(&sa);
417     else
418         ipv6_address_to_sockaddr(&sa, a, port);
419
420     memset(&io, 0, sizeof(io));
421     io.iov_base = AVAHI_DNS_PACKET_DATA(p);
422     io.iov_len = p->size;
423
424     memset(cmsg_data, 0, sizeof(cmsg_data));
425     cmsg = (struct cmsghdr*) cmsg_data;
426     cmsg->cmsg_len = sizeof(cmsg_data);
427     cmsg->cmsg_level = IPPROTO_IPV6;
428     cmsg->cmsg_type = IPV6_PKTINFO;
429
430     pkti = (struct in6_pktinfo*) (cmsg_data + sizeof(struct cmsghdr));
431     pkti->ipi6_ifindex = interface;
432     
433     memset(&msg, 0, sizeof(msg));
434     msg.msg_name = &sa;
435     msg.msg_namelen = sizeof(sa);
436     msg.msg_iov = &io;
437     msg.msg_iovlen = 1;
438     msg.msg_control = cmsg_data;
439     msg.msg_controllen = sizeof(cmsg_data);
440     msg.msg_flags = 0;
441
442     return sendmsg_loop(fd, &msg, 0 /*MSG_DONTROUTE*/);
443 }
444
445 AvahiDnsPacket* avahi_recv_dns_packet_ipv4(int fd, struct sockaddr_in *ret_sa, AvahiIPv4Address *ret_dest_address, int *ret_iface, uint8_t* ret_ttl) {
446     AvahiDnsPacket *p= NULL;
447     struct msghdr msg;
448     struct iovec io;
449     uint8_t aux[1024];
450     ssize_t l;
451     struct cmsghdr *cmsg;
452     int found_ttl = 0, found_iface = 0;
453     int ms;
454
455     assert(fd >= 0);
456     assert(ret_sa);
457     assert(ret_dest_address);
458     assert(ret_iface);
459     assert(ret_ttl);
460
461     if (ioctl(fd, FIONREAD, &ms) < 0) {
462         avahi_log_warn("ioctl(): %s", strerror(errno));
463         goto fail;
464     }
465
466     p = avahi_dns_packet_new(ms + AVAHI_DNS_PACKET_EXTRA_SIZE);
467
468     io.iov_base = AVAHI_DNS_PACKET_DATA(p);
469     io.iov_len = p->max_size;
470     
471     memset(&msg, 0, sizeof(msg));
472     msg.msg_name = ret_sa;
473     msg.msg_namelen = sizeof(struct sockaddr_in);
474     msg.msg_iov = &io;
475     msg.msg_iovlen = 1;
476     msg.msg_control = aux;
477     msg.msg_controllen = sizeof(aux);
478     msg.msg_flags = 0;
479     
480     if ((l = recvmsg(fd, &msg, 0)) < 0) {
481         avahi_log_warn("recvmsg(): %s", strerror(errno));
482         goto fail;
483     }
484
485     if (ret_sa->sin_addr.s_addr == INADDR_ANY) {
486         /* Linux 2.4 behaves very strangely sometimes! */
487
488         /*avahi_hexdump(AVAHI_DNS_PACKET_DATA(p), l); */
489         goto fail;
490     }
491     
492     assert(!(msg.msg_flags & MSG_CTRUNC));
493     assert(!(msg.msg_flags & MSG_TRUNC));
494     p->size = (size_t) l;
495     
496     *ret_ttl = 0;
497
498 /*     avahi_hexdump(msg.msg_control, msg.msg_controllen); */
499         
500     for (cmsg = CMSG_FIRSTHDR(&msg); cmsg != NULL; cmsg = CMSG_NXTHDR(&msg, cmsg)) {
501
502 /*         avahi_hexdump(CMSG_DATA(cmsg), cmsg->cmsg_len - sizeof(struct cmsghdr)); */
503         
504         if (cmsg->cmsg_level == SOL_IP) {
505             
506             if (cmsg->cmsg_type == IP_TTL) {
507                 *ret_ttl = (uint8_t) (*(int *) CMSG_DATA(cmsg));
508                 found_ttl = 1;
509             } else if (cmsg->cmsg_type == IP_PKTINFO) {
510                 struct in_pktinfo *i = (struct in_pktinfo*) CMSG_DATA(cmsg);
511                 *ret_iface = (int) i->ipi_ifindex;
512                 ret_dest_address->address = i->ipi_addr.s_addr;
513                 found_iface = 1;
514             }
515         }
516     }
517
518 /*     avahi_log_debug("ttl=%u iface=%i", *ret_ttl, *ret_iface); */
519
520     assert(found_iface);
521     assert(found_ttl);
522
523     return p;
524
525 fail:
526     if (p)
527         avahi_dns_packet_free(p);
528
529     return NULL;
530 }
531
532 AvahiDnsPacket* avahi_recv_dns_packet_ipv6(int fd, struct sockaddr_in6 *ret_sa, AvahiIPv6Address *ret_dest_address, int *ret_iface, uint8_t* ret_ttl) {
533     AvahiDnsPacket *p = NULL;
534     struct msghdr msg;
535     struct iovec io;
536     uint8_t aux[64];
537     ssize_t l;
538     int ms;
539     
540     struct cmsghdr *cmsg;
541     int found_ttl = 0, found_iface = 0;
542
543     assert(fd >= 0);
544     assert(ret_sa);
545     assert(ret_dest_address);
546     assert(ret_iface);
547     assert(ret_ttl);
548
549     if (ioctl(fd, FIONREAD, &ms) < 0) {
550         avahi_log_warn("ioctl(): %s", strerror(errno));
551         goto fail;
552     }
553     
554     p = avahi_dns_packet_new(ms + AVAHI_DNS_PACKET_EXTRA_SIZE);
555
556     io.iov_base = AVAHI_DNS_PACKET_DATA(p);
557     io.iov_len = p->max_size;
558     
559     memset(&msg, 0, sizeof(msg));
560     msg.msg_name = ret_sa;
561     msg.msg_namelen = sizeof(struct sockaddr_in6);
562     msg.msg_iov = &io;
563     msg.msg_iovlen = 1;
564     msg.msg_control = aux;
565     msg.msg_controllen = sizeof(aux);
566     msg.msg_flags = 0;
567     
568     if ((l = recvmsg(fd, &msg, 0)) < 0) {
569         avahi_log_warn("recvmsg(): %s", strerror(errno));
570         goto fail;
571     }
572
573     p->size = (size_t) l;
574     
575     *ret_ttl = 0;
576
577     for (cmsg = CMSG_FIRSTHDR(&msg); cmsg != NULL; cmsg = CMSG_NXTHDR(&msg, cmsg)) {
578         if (cmsg->cmsg_level == SOL_IPV6 && cmsg->cmsg_type == IPV6_HOPLIMIT) {
579             *ret_ttl = (uint8_t) (*(int *) CMSG_DATA(cmsg));
580             found_ttl = 1;
581         }
582             
583         if (cmsg->cmsg_level == SOL_IPV6 && cmsg->cmsg_type == IPV6_PKTINFO) {
584             struct in6_pktinfo *i = (struct in6_pktinfo*) CMSG_DATA(cmsg);
585             *ret_iface = i->ipi6_ifindex;
586             memcpy(ret_dest_address->address, i->ipi6_addr.s6_addr, 16);
587             found_iface = 1;
588         }
589     }
590
591     assert(found_iface);
592     assert(found_ttl);
593
594     return p;
595
596 fail:
597     if (p)
598         avahi_dns_packet_free(p);
599
600     return NULL;
601 }
602
603 int avahi_open_legacy_unicast_socket_ipv4(void) {
604     struct sockaddr_in local;
605     int fd = -1, yes;
606         
607     if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
608         avahi_log_warn("socket() failed: %s\n", strerror(errno));
609         goto fail;
610     }
611     
612     memset(&local, 0, sizeof(local));
613     local.sin_family = AF_INET;
614     
615     if (bind(fd, (struct sockaddr*) &local, sizeof(local)) < 0) {
616         avahi_log_warn("bind() failed: %s\n", strerror(errno));
617         goto fail;
618     }
619
620     yes = 1;
621     if (setsockopt(fd, SOL_IP, IP_RECVTTL, &yes, sizeof(yes)) < 0) {
622         avahi_log_warn("IP_RECVTTL failed: %s\n", strerror(errno));
623         goto fail;
624     }
625
626     yes = 1;
627     if (setsockopt(fd, SOL_IP, IP_PKTINFO, &yes, sizeof(yes)) < 0) {
628         avahi_log_warn("IP_PKTINFO failed: %s\n", strerror(errno));
629         goto fail;
630     }
631     
632     if (avahi_set_cloexec(fd) < 0) {
633         avahi_log_warn("FD_CLOEXEC failed: %s\n", strerror(errno));
634         goto fail;
635     }
636     
637     if (avahi_set_nonblock(fd) < 0) {
638         avahi_log_warn("O_NONBLOCK failed: %s\n", strerror(errno));
639         goto fail;
640     }
641
642     return fd;
643
644 fail:
645     if (fd >= 0)
646         close(fd);
647
648     return -1;
649 }
650
651 int avahi_open_legacy_unicast_socket_ipv6(void) {
652     struct sockaddr_in local;
653     int fd = -1, yes;
654         
655     if ((fd = socket(AF_INET6, SOCK_DGRAM, 0)) < 0) {
656         avahi_log_warn("socket() failed: %s\n", strerror(errno));
657         goto fail;
658     }
659     
660     memset(&local, 0, sizeof(local));
661     local.sin_family = AF_INET;
662     
663     if (bind(fd, (struct sockaddr*) &local, sizeof(local)) < 0) {
664         avahi_log_warn("bind() failed: %s\n", strerror(errno));
665         goto fail;
666     }
667
668     yes = 1;
669     if (setsockopt(fd, SOL_IPV6, IPV6_HOPLIMIT, &yes, sizeof(yes)) < 0) {
670         avahi_log_warn("IPV6_HOPLIMIT failed: %s\n", strerror(errno));
671         goto fail;
672     }
673
674     yes = 1;
675     if (setsockopt(fd, SOL_IPV6, IPV6_PKTINFO, &yes, sizeof(yes)) < 0) {
676         avahi_log_warn("IPV6_PKTINFO failed: %s\n", strerror(errno));
677         goto fail;
678     }
679     
680     if (avahi_set_cloexec(fd) < 0) {
681         avahi_log_warn("FD_CLOEXEC failed: %s\n", strerror(errno));
682         goto fail;
683     }
684     
685     if (avahi_set_nonblock(fd) < 0) {
686         avahi_log_warn("O_NONBLOCK failed: %s\n", strerror(errno));
687         goto fail;
688     }
689
690     return fd;
691
692 fail:
693     if (fd >= 0)
694         close(fd);
695
696     return -1;
697 }