git.meshlink.io Git - catta/blob - 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 <unistd.h>
  31 #include <fcntl.h>
  32 #include <sys/time.h>
  33 #include <sys/ioctl.h>
  34 #include <assert.h>
  35
  36 #include <sys/types.h>
  37 #include <sys/socket.h>
  38 #include <netinet/in.h>
  39 #include <arpa/inet.h>
  40 #include <net/if.h>
  41 #include <sys/uio.h>
  42
  43 #ifdef IP_RECVIF
  44 #include <net/if_dl.h>
  45 #endif
  46
  47 #include "dns.h"
  48 #include "fdutil.h"
  49 #include "socket.h"
  50 #include "log.h"
  51
  52 /* this is a portability hack */
  53 #ifndef IPV6_ADD_MEMBERSHIP
  54 #ifdef  IPV6_JOIN_GROUP
  55 #define IPV6_ADD_MEMBERSHIP IPV6_JOIN_GROUP
  56 #endif
  57 #endif
  58
  59 #ifndef IPV6_DROP_MEMBERSHIP
  60 #ifdef  IPV6_LEAVE_GROUP
  61 #define IPV6_DROP_MEMBERSHIP IPV6_LEAVE_GROUP
  62 #endif
  63 #endif
  64
  65 static void mdns_mcast_group_ipv4(struct sockaddr_in *ret_sa) {
  66     assert(ret_sa);
  67
  68     memset(ret_sa, 0, sizeof(struct sockaddr_in));
  69     ret_sa->sin_family = AF_INET;
  70     ret_sa->sin_port = htons(AVAHI_MDNS_PORT);
  71     inet_pton(AF_INET, AVAHI_IPV4_MCAST_GROUP, &ret_sa->sin_addr);
  72 }
  73
  74 static void mdns_mcast_group_ipv6(struct sockaddr_in6 *ret_sa) {
  75     assert(ret_sa);
  76
  77     memset(ret_sa, 0, sizeof(struct sockaddr_in6));
  78     ret_sa->sin6_family = AF_INET6;
  79     ret_sa->sin6_port = htons(AVAHI_MDNS_PORT);
  80     inet_pton(AF_INET6, AVAHI_IPV6_MCAST_GROUP, &ret_sa->sin6_addr);
  81 }
  82
  83 static void ipv4_address_to_sockaddr(struct sockaddr_in *ret_sa, const AvahiIPv4Address *a, uint16_t port) {
  84     assert(ret_sa);
  85     assert(a);
  86     assert(port > 0);
  87
  88     memset(ret_sa, 0, sizeof(struct sockaddr_in));
  89     ret_sa->sin_family = AF_INET;
  90     ret_sa->sin_port = htons(port);
  91     memcpy(&ret_sa->sin_addr, a, sizeof(AvahiIPv4Address));
  92 }
  93
  94 static void ipv6_address_to_sockaddr(struct sockaddr_in6 *ret_sa, const AvahiIPv6Address *a, uint16_t port) {
  95     assert(ret_sa);
  96     assert(a);
  97     assert(port > 0);
  98
  99     memset(ret_sa, 0, sizeof(struct sockaddr_in6));
 100     ret_sa->sin6_family = AF_INET6;
 101     ret_sa->sin6_port = htons(port);
 102     memcpy(&ret_sa->sin6_addr, a, sizeof(AvahiIPv6Address));
 103 }
 104
 105 int avahi_mdns_mcast_join_ipv4(int fd, const AvahiIPv4Address *a, int idx, int join) {
 106 #ifdef HAVE_STRUCT_IP_MREQN
 107     struct ip_mreqn mreq;
 108 #else
 109     struct ip_mreq mreq;
 110 #endif
 111     struct sockaddr_in sa;
 112
 113     assert(fd >= 0);
 114     assert(idx >= 0);
 115     assert(a);
 116
 117     memset(&mreq, 0, sizeof(mreq));
 118 #ifdef HAVE_STRUCT_IP_MREQN
 119     mreq.imr_ifindex = idx;
 120     mreq.imr_address.s_addr = a->address;
 121 #else
 122     mreq.imr_interface.s_addr = a->address;
 123 #endif
 124     mdns_mcast_group_ipv4(&sa);
 125     mreq.imr_multiaddr = sa.sin_addr;
 126
 127     if (setsockopt(fd, IPPROTO_IP, join ? IP_ADD_MEMBERSHIP : IP_DROP_MEMBERSHIP, &mreq, sizeof(mreq)) < 0) {
 128         avahi_log_warn("%s failed: %s", join ? "IP_ADD_MEMBERSHIP" : "IP_DROP_MEMBERSHIP", strerror(errno));
 129         return -1;
 130     }
 131
 132     return 0;
 133 }
 134
 135 int avahi_mdns_mcast_join_ipv6(int fd, const AvahiIPv6Address *a, int idx, int join) {
 136     struct ipv6_mreq mreq6;
 137     struct sockaddr_in6 sa6;
 138
 139     assert(fd >= 0);
 140     assert(idx >= 0);
 141     assert(a);
 142
 143     memset(&mreq6, 0, sizeof(mreq6));
 144     mdns_mcast_group_ipv6 (&sa6);
 145     mreq6.ipv6mr_multiaddr = sa6.sin6_addr;
 146     mreq6.ipv6mr_interface = idx;
 147
 148     if (setsockopt(fd, IPPROTO_IPV6, join ? IPV6_ADD_MEMBERSHIP : IPV6_DROP_MEMBERSHIP, &mreq6, sizeof(mreq6)) < 0) {
 149         avahi_log_warn("%s failed: %s", join ? "IPV6_ADD_MEMBERSHIP" : "IPV6_DROP_MEMBERSHIP", strerror(errno));
 150         return -1;
 151     }
 152
 153     return 0;
 154 }
 155
 156 static int reuseaddr(int fd) {
 157     int yes;
 158
 159     yes = 1;
 160     if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes)) < 0) {
 161         avahi_log_warn("SO_REUSEADDR failed: %s", strerror(errno));
 162         return -1;
 163     }
 164
 165 #ifdef SO_REUSEPORT
 166     yes = 1;
 167     if (setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &yes, sizeof(yes)) < 0) {
 168         avahi_log_warn("SO_REUSEPORT failed: %s", strerror(errno));
 169         return -1;
 170     }
 171 #endif
 172
 173     return 0;
 174 }
 175
 176 static int bind_with_warn(int fd, const struct sockaddr *sa, socklen_t l) {
 177
 178     assert(fd >= 0);
 179     assert(sa);
 180     assert(l > 0);
 181
 182     if (bind(fd, sa, l) < 0) {
 183
 184         if (errno != EADDRINUSE) {
 185             avahi_log_warn("bind() failed: %s", strerror(errno));
 186             return -1;
 187         }
 188
 189         avahi_log_warn("*** WARNING: Detected another %s mDNS stack running on this host. This makes mDNS unreliable and is thus not recommended. ***",
 190                        sa->sa_family == AF_INET ? "IPv4" : "IPv6");
 191
 192         /* Try again, this time with SO_REUSEADDR set */
 193         if (reuseaddr(fd) < 0)
 194             return -1;
 195
 196         if (bind(fd, sa, l) < 0) {
 197             avahi_log_warn("bind() failed: %s", strerror(errno));
 198             return -1;
 199         }
 200     } else {
 201
 202         /* We enable SO_REUSEADDR afterwards, to make sure that the
 203          * user may run other mDNS implementations if he really
 204          * wants. */
 205
 206         if (reuseaddr(fd) < 0)
 207             return -1;
 208     }
 209
 210     return 0;
 211 }
 212
 213 static int ipv4_pktinfo(int fd) {
 214     int yes;
 215
 216 #ifdef IP_PKTINFO
 217     yes = 1;
 218     if (setsockopt(fd, IPPROTO_IP, IP_PKTINFO, &yes, sizeof(yes)) < 0) {
 219         avahi_log_warn("IP_PKTINFO failed: %s", strerror(errno));
 220         return -1;
 221     }
 222 #else
 223
 224 #ifdef IP_RECVINTERFACE
 225     yes = 1;
 226     if (setsockopt (fd, IPPROTO_IP, IP_RECVINTERFACE, &yes, sizeof(yes)) < 0) {
 227         avahi_log_warn("IP_RECVINTERFACE failed: %s", strerror(errno));
 228         return -1;
 229     }
 230 #elif defined(IP_RECVIF)
 231     yes = 1;
 232     if (setsockopt (fd, IPPROTO_IP, IP_RECVIF, &yes, sizeof(yes)) < 0) {
 233         avahi_log_warn("IP_RECVIF failed: %s", strerror(errno));
 234         return -1;
 235     }
 236 #endif
 237
 238 #ifdef IP_RECVDSTADDR
 239     yes = 1;
 240     if (setsockopt (fd, IPPROTO_IP, IP_RECVDSTADDR, &yes, sizeof(yes)) < 0) {
 241         avahi_log_warn("IP_RECVDSTADDR failed: %s", strerror(errno));
 242         return -1;
 243     }
 244 #endif
 245
 246 #endif /* IP_PKTINFO */
 247
 248 #ifdef IP_RECVTTL
 249     yes = 1;
 250     if (setsockopt(fd, IPPROTO_IP, IP_RECVTTL, &yes, sizeof(yes)) < 0) {
 251         avahi_log_warn("IP_RECVTTL failed: %s", strerror(errno));
 252         return -1;
 253     }
 254 #endif
 255
 256     return 0;
 257 }
 258
 259 static int ipv6_pktinfo(int fd) {
 260     int yes;
 261
 262 #ifdef IPV6_RECVPKTINFO
 263     yes = 1;
 264     if (setsockopt(fd, IPPROTO_IPV6, IPV6_RECVPKTINFO, &yes, sizeof(yes)) < 0) {
 265         avahi_log_warn("IPV6_RECVPKTINFO failed: %s", strerror(errno));
 266         return -1;
 267     }
 268 #elif defined(IPV6_PKTINFO)
 269     yes = 1;
 270     if (setsockopt(fd, IPPROTO_IPV6, IPV6_PKTINFO, &yes, sizeof(yes)) < 0) {
 271         avahi_log_warn("IPV6_PKTINFO failed: %s", strerror(errno));
 272         return -1;
 273     }
 274 #endif
 275
 276 #ifdef IPV6_RECVHOPS
 277     yes = 1;
 278     if (setsockopt(fd, IPPROTO_IPV6, IPV6_RECVHOPS, &yes, sizeof(yes)) < 0) {
 279         avahi_log_warn("IPV6_RECVHOPS failed: %s", strerror(errno));
 280         return -1;
 281     }
 282 #elif defined(IPV6_RECVHOPLIMIT)
 283     yes = 1;
 284     if (setsockopt(fd, IPPROTO_IPV6, IPV6_RECVHOPLIMIT, &yes, sizeof(yes)) < 0) {
 285         avahi_log_warn("IPV6_RECVHOPLIMIT failed: %s", strerror(errno));
 286         return -1;
 287     }
 288 #elif defined(IPV6_HOPLIMIT)
 289     yes = 1;
 290     if (setsockopt(fd, IPPROTO_IPV6, IPV6_HOPLIMIT, &yes, sizeof(yes)) < 0) {
 291         avahi_log_warn("IPV6_HOPLIMIT failed: %s", strerror(errno));
 292         return -1;
 293     }
 294 #endif
 295
 296     return 0;
 297 }
 298
 299 int avahi_open_socket_ipv4(int no_reuse) {
 300     struct sockaddr_in local;
 301     int fd = -1, r, ittl;
 302     uint8_t ttl, cyes;
 303
 304     if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
 305         avahi_log_warn("socket() failed: %s", strerror(errno));
 306         goto fail;
 307     }
 308
 309     ttl = 255;
 310     if (setsockopt(fd, IPPROTO_IP, IP_MULTICAST_TTL, &ttl, sizeof(ttl)) < 0) {
 311         avahi_log_warn("IP_MULTICAST_TTL failed: %s", strerror(errno));
 312         goto fail;
 313     }
 314
 315     ittl = 255;
 316     if (setsockopt(fd, IPPROTO_IP, IP_TTL, &ittl, sizeof(ittl)) < 0) {
 317         avahi_log_warn("IP_TTL failed: %s", strerror(errno));
 318         goto fail;
 319     }
 320
 321     cyes = 1;
 322     if (setsockopt(fd, IPPROTO_IP, IP_MULTICAST_LOOP, &cyes, sizeof(cyes)) < 0) {
 323         avahi_log_warn("IP_MULTICAST_LOOP failed: %s", strerror(errno));
 324         goto fail;
 325     }
 326
 327     memset(&local, 0, sizeof(local));
 328     local.sin_family = AF_INET;
 329     local.sin_port = htons(AVAHI_MDNS_PORT);
 330
 331     if (no_reuse)
 332         r = bind(fd, (struct sockaddr*) &local, sizeof(local));
 333     else
 334         r = bind_with_warn(fd, (struct sockaddr*) &local, sizeof(local));
 335
 336     if (r < 0)
 337         goto fail;
 338
 339     if (ipv4_pktinfo (fd) < 0)
 340          goto fail;
 341
 342     if (avahi_set_cloexec(fd) < 0) {
 343         avahi_log_warn("FD_CLOEXEC failed: %s", strerror(errno));
 344         goto fail;
 345     }
 346
 347     if (avahi_set_nonblock(fd) < 0) {
 348         avahi_log_warn("O_NONBLOCK failed: %s", strerror(errno));
 349         goto fail;
 350     }
 351
 352     return fd;
 353
 354 fail:
 355     if (fd >= 0)
 356         close(fd);
 357
 358     return -1;
 359 }
 360
 361 int avahi_open_socket_ipv6(int no_reuse) {
 362     struct sockaddr_in6 sa, local;
 363     int fd = -1, yes, r;
 364     int ttl;
 365
 366     mdns_mcast_group_ipv6(&sa);
 367
 368     if ((fd = socket(AF_INET6, SOCK_DGRAM, 0)) < 0) {
 369         avahi_log_warn("socket() failed: %s", strerror(errno));
 370         goto fail;
 371     }
 372
 373     ttl = 255;
 374     if (setsockopt(fd, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, &ttl, sizeof(ttl)) < 0) {
 375         avahi_log_warn("IPV6_MULTICAST_HOPS failed: %s", strerror(errno));
 376         goto fail;
 377     }
 378
 379     ttl = 255;
 380     if (setsockopt(fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &ttl, sizeof(ttl)) < 0) {
 381         avahi_log_warn("IPV6_UNICAST_HOPS failed: %s", strerror(errno));
 382         goto fail;
 383     }
 384
 385     yes = 1;
 386     if (setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, &yes, sizeof(yes)) < 0) {
 387         avahi_log_warn("IPV6_V6ONLY failed: %s", strerror(errno));
 388         goto fail;
 389     }
 390
 391     yes = 1;
 392     if (setsockopt(fd, IPPROTO_IPV6, IPV6_MULTICAST_LOOP, &yes, sizeof(yes)) < 0) {
 393         avahi_log_warn("IPV6_MULTICAST_LOOP failed: %s", strerror(errno));
 394         goto fail;
 395     }
 396
 397     memset(&local, 0, sizeof(local));
 398     local.sin6_family = AF_INET6;
 399     local.sin6_port = htons(AVAHI_MDNS_PORT);
 400
 401     if (no_reuse)
 402         r = bind(fd, (struct sockaddr*) &local, sizeof(local));
 403     else
 404         r = bind_with_warn(fd, (struct sockaddr*) &local, sizeof(local));
 405
 406     if (r < 0)
 407         goto fail;
 408
 409     if (ipv6_pktinfo(fd) < 0)
 410         goto fail;
 411
 412     if (avahi_set_cloexec(fd) < 0) {
 413         avahi_log_warn("FD_CLOEXEC failed: %s", strerror(errno));
 414         goto fail;
 415     }
 416
 417     if (avahi_set_nonblock(fd) < 0) {
 418         avahi_log_warn("O_NONBLOCK failed: %s", strerror(errno));
 419         goto fail;
 420     }
 421
 422     return fd;
 423
 424 fail:
 425     if (fd >= 0)
 426         close(fd);
 427
 428     return -1;
 429 }
 430
 431 static int sendmsg_loop(int fd, struct msghdr *msg, int flags) {
 432     assert(fd >= 0);
 433     assert(msg);
 434
 435     for (;;) {
 436
 437         if (sendmsg(fd, msg, flags) >= 0)
 438             break;
 439
 440         if (errno != EAGAIN) {
 441             avahi_log_debug("sendmsg() failed: %s", strerror(errno));
 442             return -1;
 443         }
 444
 445         if (avahi_wait_for_write(fd) < 0)
 446             return -1;
 447     }
 448
 449     return 0;
 450 }
 451
 452 int avahi_send_dns_packet_ipv4(int fd, int interface, AvahiDnsPacket *p, const AvahiIPv4Address *a, uint16_t port) {
 453     struct sockaddr_in sa;
 454     struct msghdr msg;
 455     struct iovec io;
 456 #ifdef IP_PKTINFO
 457     struct cmsghdr *cmsg;
 458     uint8_t cmsg_data[sizeof(struct cmsghdr) + sizeof(struct in_pktinfo)];
 459 #endif
 460
 461     assert(fd >= 0);
 462     assert(p);
 463     assert(avahi_dns_packet_check_valid(p) >= 0);
 464     assert(!a || port > 0);
 465
 466     if (!a)
 467         mdns_mcast_group_ipv4(&sa);
 468     else
 469         ipv4_address_to_sockaddr(&sa, a, port);
 470
 471     memset(&io, 0, sizeof(io));
 472     io.iov_base = AVAHI_DNS_PACKET_DATA(p);
 473     io.iov_len = p->size;
 474
 475     memset(&msg, 0, sizeof(msg));
 476     msg.msg_name = &sa;
 477     msg.msg_namelen = sizeof(sa);
 478     msg.msg_iov = &io;
 479     msg.msg_iovlen = 1;
 480     msg.msg_flags = 0;
 481     msg.msg_control = NULL;
 482     msg.msg_controllen = 0;
 483
 484 #ifdef IP_PKTINFO
 485     if (interface >= 0) {
 486         struct in_pktinfo *pkti;
 487
 488         memset(cmsg_data, 0, sizeof(cmsg_data));
 489         cmsg = (struct cmsghdr*) cmsg_data;
 490         cmsg->cmsg_len = sizeof(cmsg_data);
 491         cmsg->cmsg_level = IPPROTO_IP;
 492         cmsg->cmsg_type = IP_PKTINFO;
 493
 494         pkti = (struct in_pktinfo*) (cmsg_data + sizeof(struct cmsghdr));
 495         pkti->ipi_ifindex = interface;
 496
 497         msg.msg_control = cmsg_data;
 498         msg.msg_controllen = sizeof(cmsg_data);
 499     }
 500 #else
 501 #ifdef __GNUC__
 502 #warning "FIXME: We need some code to set the outgoing interface here if IP_PKTINFO is not available"
 503 #endif
 504 #endif
 505
 506     return sendmsg_loop(fd, &msg, 0);
 507 }
 508
 509 int avahi_send_dns_packet_ipv6(int fd, int interface, AvahiDnsPacket *p, const AvahiIPv6Address *a, uint16_t port) {
 510     struct sockaddr_in6 sa;
 511     struct msghdr msg;
 512     struct iovec io;
 513     struct cmsghdr *cmsg;
 514     uint8_t cmsg_data[sizeof(struct cmsghdr) + sizeof(struct in6_pktinfo)];
 515
 516     assert(fd >= 0);
 517     assert(p);
 518     assert(avahi_dns_packet_check_valid(p) >= 0);
 519
 520     if (!a)
 521         mdns_mcast_group_ipv6(&sa);
 522     else
 523         ipv6_address_to_sockaddr(&sa, a, port);
 524
 525     memset(&io, 0, sizeof(io));
 526     io.iov_base = AVAHI_DNS_PACKET_DATA(p);
 527     io.iov_len = p->size;
 528
 529
 530     memset(&msg, 0, sizeof(msg));
 531     msg.msg_name = &sa;
 532     msg.msg_namelen = sizeof(sa);
 533     msg.msg_iov = &io;
 534     msg.msg_iovlen = 1;
 535     msg.msg_flags = 0;
 536
 537     if (interface >= 0) {
 538         struct in6_pktinfo *pkti;
 539
 540         memset(cmsg_data, 0, sizeof(cmsg_data));
 541         cmsg = (struct cmsghdr*) cmsg_data;
 542         cmsg->cmsg_len = sizeof(cmsg_data);
 543         cmsg->cmsg_level = IPPROTO_IPV6;
 544         cmsg->cmsg_type = IPV6_PKTINFO;
 545
 546         pkti = (struct in6_pktinfo*) (cmsg_data + sizeof(struct cmsghdr));
 547         pkti->ipi6_ifindex = interface;
 548
 549         msg.msg_control = cmsg_data;
 550         msg.msg_controllen = sizeof(cmsg_data);
 551     } else {
 552         msg.msg_control = NULL;
 553         msg.msg_controllen = 0;
 554     }
 555
 556     return sendmsg_loop(fd, &msg, 0);
 557 }
 558
 559 AvahiDnsPacket* avahi_recv_dns_packet_ipv4(int fd, struct sockaddr_in *ret_sa, AvahiIPv4Address *ret_dest_address, int *ret_iface, uint8_t* ret_ttl) {
 560     AvahiDnsPacket *p= NULL;
 561     struct msghdr msg;
 562     struct iovec io;
 563     uint8_t aux[1024];
 564     ssize_t l;
 565     struct cmsghdr *cmsg;
 566     int found_iface = 0, found_addr = 0;
 567     int ms;
 568
 569     assert(fd >= 0);
 570
 571     if (ioctl(fd, FIONREAD, &ms) < 0) {
 572         avahi_log_warn("ioctl(): %s", strerror(errno));
 573         goto fail;
 574     }
 575
 576     p = avahi_dns_packet_new(ms + AVAHI_DNS_PACKET_EXTRA_SIZE);
 577
 578     io.iov_base = AVAHI_DNS_PACKET_DATA(p);
 579     io.iov_len = p->max_size;
 580
 581     memset(&msg, 0, sizeof(msg));
 582     if (ret_sa) {
 583         msg.msg_name = ret_sa;
 584         msg.msg_namelen = sizeof(struct sockaddr_in);
 585     } else {
 586         msg.msg_name = NULL;
 587         msg.msg_namelen = 0;
 588     }
 589     msg.msg_iov = &io;
 590     msg.msg_iovlen = 1;
 591     msg.msg_control = aux;
 592     msg.msg_controllen = sizeof(aux);
 593     msg.msg_flags = 0;
 594
 595     if ((l = recvmsg(fd, &msg, 0)) < 0) {
 596         avahi_log_warn("recvmsg(): %s", strerror(errno));
 597         goto fail;
 598     }
 599
 600     if (ret_sa && ret_sa->sin_addr.s_addr == INADDR_ANY) {
 601         /* Linux 2.4 behaves very strangely sometimes! */
 602
 603         /*avahi_hexdump(AVAHI_DNS_PACKET_DATA(p), l); */
 604         goto fail;
 605     }
 606
 607     assert(!(msg.msg_flags & MSG_CTRUNC));
 608     assert(!(msg.msg_flags & MSG_TRUNC));
 609     p->size = (size_t) l;
 610
 611     if (ret_ttl)
 612         *ret_ttl = 255;
 613
 614     for (cmsg = CMSG_FIRSTHDR(&msg); cmsg != NULL; cmsg = CMSG_NXTHDR(&msg, cmsg)) {
 615
 616         if (cmsg->cmsg_level == IPPROTO_IP) {
 617             switch (cmsg->cmsg_type) {
 618 #ifdef IP_RECVTTL
 619                 case IP_RECVTTL:
 620 #endif
 621                 case IP_TTL:
 622                     if (ret_ttl)
 623                         *ret_ttl = (uint8_t) (*(int *) CMSG_DATA(cmsg));
 624
 625                     break;
 626
 627 #ifdef IP_PKTINFO
 628                 case IP_PKTINFO: {
 629                     struct in_pktinfo *i = (struct in_pktinfo*) CMSG_DATA(cmsg);
 630
 631                     if (ret_iface)
 632                         *ret_iface = (int) i->ipi_ifindex;
 633
 634                     if (ret_dest_address)
 635                         ret_dest_address->address = i->ipi_addr.s_addr;
 636
 637                     found_addr = found_iface = 1;
 638
 639                     break;
 640                 }
 641 #elif defined(IP_RECVIF)
 642                 case IP_RECVIF: {
 643                     struct sockaddr_dl *sdl = (struct sockaddr_dl *) CMSG_DATA (cmsg);
 644
 645                     if (ret_iface)
 646                         *ret_iface = (int) sdl->sdl_index;
 647
 648                     found_iface = 1;
 649                     break;
 650                 }
 651 #endif
 652
 653 #ifdef IP_RECVDSTADDR
 654                 case IP_RECVDSTADDR:
 655                     if (ret_dest_address)
 656                         memcpy(&ret_dest_address->address, CMSG_DATA (cmsg), 4);
 657                     found_addr = 1;
 658                     break;
 659
 660 #endif
 661
 662                 default:
 663                     avahi_log_warn("Unhandled cmsg_type : %d", cmsg->cmsg_type);
 664                     break;
 665             }
 666         }
 667     }
 668
 669     assert(found_iface);
 670     assert(found_addr);
 671
 672     return p;
 673
 674 fail:
 675     if (p)
 676         avahi_dns_packet_free(p);
 677
 678     return NULL;
 679 }
 680
 681 AvahiDnsPacket* avahi_recv_dns_packet_ipv6(int fd, struct sockaddr_in6 *ret_sa, AvahiIPv6Address *ret_dest_address, int *ret_iface, uint8_t* ret_ttl) {
 682     AvahiDnsPacket *p = NULL;
 683     struct msghdr msg;
 684     struct iovec io;
 685     uint8_t aux[64];
 686     ssize_t l;
 687     int ms;
 688     struct cmsghdr *cmsg;
 689     int found_ttl = 0, found_iface = 0;
 690
 691     assert(fd >= 0);
 692
 693     if (ioctl(fd, FIONREAD, &ms) < 0) {
 694         avahi_log_warn("ioctl(): %s", strerror(errno));
 695         goto fail;
 696     }
 697
 698     p = avahi_dns_packet_new(ms + AVAHI_DNS_PACKET_EXTRA_SIZE);
 699
 700     io.iov_base = AVAHI_DNS_PACKET_DATA(p);
 701     io.iov_len = p->max_size;
 702
 703     memset(&msg, 0, sizeof(msg));
 704     if (ret_sa) {
 705         msg.msg_name = ret_sa;
 706         msg.msg_namelen = sizeof(struct sockaddr_in6);
 707     } else {
 708         msg.msg_name = NULL;
 709         msg.msg_namelen = 0;
 710     }
 711
 712     msg.msg_iov = &io;
 713     msg.msg_iovlen = 1;
 714     msg.msg_control = aux;
 715     msg.msg_controllen = sizeof(aux);
 716     msg.msg_flags = 0;
 717
 718     if ((l = recvmsg(fd, &msg, 0)) < 0) {
 719         avahi_log_warn("recvmsg(): %s", strerror(errno));
 720         goto fail;
 721     }
 722
 723     p->size = (size_t) l;
 724
 725     if (ret_ttl)
 726         *ret_ttl = 0;
 727
 728     for (cmsg = CMSG_FIRSTHDR(&msg); cmsg != NULL; cmsg = CMSG_NXTHDR(&msg, cmsg)) {
 729         if (cmsg->cmsg_level == IPPROTO_IPV6 && cmsg->cmsg_type == IPV6_HOPLIMIT) {
 730
 731             if (ret_ttl)
 732                 *ret_ttl = (uint8_t) (*(int *) CMSG_DATA(cmsg));
 733
 734             found_ttl = 1;
 735         }
 736
 737         if (cmsg->cmsg_level == IPPROTO_IPV6 && cmsg->cmsg_type == IPV6_PKTINFO) {
 738             struct in6_pktinfo *i = (struct in6_pktinfo*) CMSG_DATA(cmsg);
 739
 740             if (ret_iface)
 741                 *ret_iface = i->ipi6_ifindex;
 742
 743             if (ret_dest_address)
 744                 memcpy(ret_dest_address->address, i->ipi6_addr.s6_addr, 16);
 745
 746             found_iface = 1;
 747         }
 748     }
 749
 750     assert(found_iface);
 751     assert(found_ttl);
 752
 753     return p;
 754
 755 fail:
 756     if (p)
 757         avahi_dns_packet_free(p);
 758
 759     return NULL;
 760 }
 761
 762 int avahi_open_unicast_socket_ipv4(void) {
 763     struct sockaddr_in local;
 764     int fd = -1;
 765
 766     if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
 767         avahi_log_warn("socket() failed: %s", strerror(errno));
 768         goto fail;
 769     }
 770
 771     memset(&local, 0, sizeof(local));
 772     local.sin_family = AF_INET;
 773
 774     if (bind(fd, (struct sockaddr*) &local, sizeof(local)) < 0) {
 775         avahi_log_warn("bind() failed: %s", strerror(errno));
 776         goto fail;
 777     }
 778
 779     if (ipv4_pktinfo(fd) < 0) {
 780          goto fail;
 781     }
 782
 783     if (avahi_set_cloexec(fd) < 0) {
 784         avahi_log_warn("FD_CLOEXEC failed: %s", strerror(errno));
 785         goto fail;
 786     }
 787
 788     if (avahi_set_nonblock(fd) < 0) {
 789         avahi_log_warn("O_NONBLOCK failed: %s", strerror(errno));
 790         goto fail;
 791     }
 792
 793     return fd;
 794
 795 fail:
 796     if (fd >= 0)
 797         close(fd);
 798
 799     return -1;
 800 }
 801
 802 int avahi_open_unicast_socket_ipv6(void) {
 803     struct sockaddr_in6 local;
 804     int fd = -1;
 805
 806     if ((fd = socket(AF_INET6, SOCK_DGRAM, 0)) < 0) {
 807         avahi_log_warn("socket() failed: %s", strerror(errno));
 808         goto fail;
 809     }
 810
 811     memset(&local, 0, sizeof(local));
 812     local.sin6_family = AF_INET6;
 813
 814     if (bind(fd, (struct sockaddr*) &local, sizeof(local)) < 0) {
 815         avahi_log_warn("bind() failed: %s", strerror(errno));
 816         goto fail;
 817     }
 818
 819     if (ipv6_pktinfo(fd) < 0)
 820         goto fail;
 821
 822     if (avahi_set_cloexec(fd) < 0) {
 823         avahi_log_warn("FD_CLOEXEC failed: %s", strerror(errno));
 824         goto fail;
 825     }
 826
 827     if (avahi_set_nonblock(fd) < 0) {
 828         avahi_log_warn("O_NONBLOCK failed: %s", strerror(errno));
 829         goto fail;
 830     }
 831
 832     return fd;
 833
 834 fail:
 835     if (fd >= 0)
 836         close(fd);
 837
 838     return -1;
 839 }