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