• source navigation  • diff markup  • identifier search  • freetext search  • 

Sources/mdnsd/interface.c

  1 /*
  2  * Copyright (C) 2014 John Crispin <blogic@openwrt.org>
  3  * Copyright (C) 2014 Felix Fietkau <nbd@openwrt.org>
  4  *
  5  * This program is free software; you can redistribute it and/or modify
  6  * it under the terms of the GNU Lesser General Public License version 2.1
  7  * as published by the Free Software Foundation
  8  *
  9  * This program is distributed in the hope that it will be useful,
 10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 12  * GNU General Public License for more details.
 13  */
 14 
 15 #define _GNU_SOURCE
 16 #include <sys/socket.h>
 17 #include <sys/ioctl.h>
 18 #include <sys/types.h>
 19 #include <sys/stat.h>
 20 #include <sys/utsname.h>
 21 #include <net/if.h>
 22 #include <netinet/in.h>
 23 #include <arpa/inet.h>
 24 #include <sys/types.h>
 25 
 26 #include <ifaddrs.h>
 27 #include <stdlib.h>
 28 #include <string.h>
 29 #include <unistd.h>
 30 #include <stdio.h>
 31 #include <errno.h>
 32 
 33 #include <libubox/usock.h>
 34 #include <libubox/uloop.h>
 35 #include <libubox/avl-cmp.h>
 36 #include <libubox/utils.h>
 37 #include "cache.h"
 38 #include "interface.h"
 39 #include "util.h"
 40 #include "dns.h"
 41 #include "announce.h"
 42 #include "service.h"
 43 
 44 static int
 45 interface_send_packet4(struct interface *iface, struct sockaddr_in *to, struct iovec *iov, int iov_len)
 46 {
 47         static size_t cmsg_data[( CMSG_SPACE(sizeof(struct in_pktinfo)) / sizeof(size_t)) + 1];
 48         static struct sockaddr_in a;
 49         static struct msghdr m = {
 50                 .msg_name = (struct sockaddr *) &a,
 51                 .msg_namelen = sizeof(a),
 52                 .msg_control = cmsg_data,
 53                 .msg_controllen = CMSG_LEN(sizeof(struct in_pktinfo)),
 54         };
 55         struct in_pktinfo *pkti;
 56         struct cmsghdr *cmsg;
 57         int fd = iface->fd.fd;
 58 
 59         a.sin_family = AF_INET;
 60         a.sin_port = htons(MCAST_PORT);
 61         m.msg_iov = iov;
 62         m.msg_iovlen = iov_len;
 63 
 64         memset(cmsg_data, 0, sizeof(cmsg_data));
 65         cmsg = CMSG_FIRSTHDR(&m);
 66         cmsg->cmsg_len = m.msg_controllen;
 67         cmsg->cmsg_level = IPPROTO_IP;
 68         cmsg->cmsg_type = IP_PKTINFO;
 69 
 70         pkti = (struct in_pktinfo*) CMSG_DATA(cmsg);
 71         pkti->ipi_ifindex = iface->ifindex;
 72 
 73         if (iface->multicast) {
 74                 a.sin_addr.s_addr = inet_addr(MCAST_ADDR);
 75                 if (to)
 76                         fprintf(stderr, "Ignoring IPv4 address for multicast interface\n");
 77         } else {
 78                 a.sin_addr.s_addr = to->sin_addr.s_addr;
 79         }
 80 
 81         return sendmsg(fd, &m, 0);
 82 }
 83 
 84 static int
 85 interface_send_packet6(struct interface *iface, struct sockaddr_in6 *to, struct iovec *iov, int iov_len)
 86 {
 87         static size_t cmsg_data[( CMSG_SPACE(sizeof(struct in6_pktinfo)) / sizeof(size_t)) + 1];
 88         static struct sockaddr_in6 a;
 89         static struct msghdr m = {
 90                 .msg_name = (struct sockaddr *) &a,
 91                 .msg_namelen = sizeof(a),
 92                 .msg_control = cmsg_data,
 93                 .msg_controllen = CMSG_LEN(sizeof(struct in6_pktinfo)),
 94         };
 95         struct in6_pktinfo *pkti;
 96         struct cmsghdr *cmsg;
 97         int fd = iface->fd.fd;
 98 
 99         a.sin6_family = AF_INET6;
100         a.sin6_port = htons(MCAST_PORT);
101         m.msg_iov = iov;
102         m.msg_iovlen = iov_len;
103 
104         memset(cmsg_data, 0, sizeof(cmsg_data));
105         cmsg = CMSG_FIRSTHDR(&m);
106         cmsg->cmsg_len = m.msg_controllen;
107         cmsg->cmsg_level = IPPROTO_IPV6;
108         cmsg->cmsg_type = IPV6_PKTINFO;
109 
110         pkti = (struct in6_pktinfo*) CMSG_DATA(cmsg);
111         pkti->ipi6_ifindex = iface->ifindex;
112 
113         if (iface->multicast) {
114                 inet_pton(AF_INET6, MCAST_ADDR6, &a.sin6_addr);
115                 if (to)
116                         fprintf(stderr, "Ignoring IPv6 address for multicast interface\n");
117         } else {
118                 a.sin6_addr = to->sin6_addr;
119         }
120 
121         return sendmsg(fd, &m, 0);
122 }
123 
124 int
125 interface_send_packet(struct interface *iface, struct sockaddr *to, struct iovec *iov, int iov_len)
126 {
127         if (!iface->multicast && !to) {
128                 fprintf(stderr, "No IP address specified for unicast interface\n");
129                 errno = EINVAL;
130                 return -1;
131         }
132 
133         if (debug > 1) {
134                 fprintf(stderr, "TX ipv%d: %s\n", iface->v6 * 2 + 4, iface->name);
135                 fprintf(stderr, "  multicast: %d\n", iface->multicast);
136         }
137 
138         if (iface->v6)
139                 return interface_send_packet6(iface, (struct sockaddr_in6 *)to, iov, iov_len);
140 
141         return interface_send_packet4(iface, (struct sockaddr_in *)to, iov, iov_len);
142 }
143 
144 static void interface_close(struct interface *iface)
145 {
146         if (iface->fd.fd < 0)
147                 return;
148 
149         announce_free(iface);
150         uloop_fd_delete(&iface->fd);
151         close(iface->fd.fd);
152         iface->fd.fd = -1;
153 }
154 
155 static void interface_free(struct interface *iface)
156 {
157         uloop_timeout_cancel(&iface->reconnect);
158         interface_close(iface);
159         free(iface);
160 }
161 
162 static int
163 interface_valid_src(void *ip1, void *mask, void *ip2, int len)
164 {
165         uint8_t *i1 = ip1;
166         uint8_t *i2 = ip2;
167         uint8_t *m = mask;
168         int i;
169 
170         if (cfg_no_subnet)
171                 return 0;
172 
173         for (i = 0; i < len; i++, i1++, i2++, m++) {
174                 if ((*i1 & *m) != (*i2 & *m))
175                         return -1;
176         }
177 
178         return 0;
179 }
180 
181 static void
182 read_socket4(struct uloop_fd *u, unsigned int events)
183 {
184         struct interface *iface = container_of(u, struct interface, fd);
185         static uint8_t buffer[8 * 1024];
186         struct iovec iov[1];
187         char cmsg[CMSG_SPACE(sizeof(struct in_pktinfo)) + CMSG_SPACE(sizeof(int)) + 1];
188         struct cmsghdr *cmsgptr;
189         struct msghdr msg;
190         socklen_t len;
191         struct sockaddr_in from;
192         int flags = 0, ifindex = -1;
193         uint8_t ttl = 0;
194         struct in_pktinfo *inp = NULL;
195 
196         if (u->eof) {
197                 interface_close(iface);
198                 uloop_timeout_set(&iface->reconnect, 1000);
199                 return;
200         }
201 
202         iov[0].iov_base = buffer;
203         iov[0].iov_len = sizeof(buffer);
204 
205         memset(&msg, 0, sizeof(msg));
206         msg.msg_name = (struct sockaddr *) &from;
207         msg.msg_namelen = sizeof(struct sockaddr_in);
208         msg.msg_iov = iov;
209         msg.msg_iovlen = 1;
210         msg.msg_control = &cmsg;
211         msg.msg_controllen = sizeof(cmsg);
212 
213         len = recvmsg(u->fd, &msg, flags);
214         if (len == -1) {
215                 perror("read failed");
216                 return;
217         }
218         for (cmsgptr = CMSG_FIRSTHDR(&msg); cmsgptr != NULL; cmsgptr = CMSG_NXTHDR(&msg, cmsgptr)) {
219                 void *c = CMSG_DATA(cmsgptr);
220 
221                 switch (cmsgptr->cmsg_type) {
222                 case IP_PKTINFO:
223                         inp = ((struct in_pktinfo *) c);
224                         break;
225 
226                 case IP_TTL:
227                         ttl = (uint8_t) *((int *) c);
228                         break;
229 
230                 default:
231                         fprintf(stderr, "unknown cmsg %x\n", cmsgptr->cmsg_type);
232                         return;
233                 }
234         }
235 
236         if (debug > 1) {
237                 char buf[256];
238 
239                 fprintf(stderr, "RX ipv4: %s\n", iface->name);
240                 fprintf(stderr, "  multicast: %d\n", iface->multicast);
241                 inet_ntop(AF_INET, &from.sin_addr, buf, 256);
242                 fprintf(stderr, "  src %s:%d\n", buf, ntohs(from.sin_port));
243                 inet_ntop(AF_INET, &inp->ipi_spec_dst, buf, 256);
244                 fprintf(stderr, "  dst %s\n", buf);
245                 inet_ntop(AF_INET, &inp->ipi_addr, buf, 256);
246                 fprintf(stderr, "  real %s\n", buf);
247                 fprintf(stderr, "  ttl %u\n", ttl);
248         }
249 
250         if (inp->ipi_ifindex != iface->ifindex)
251                 fprintf(stderr, "invalid iface index %d != %d\n", ifindex, iface->ifindex);
252         else if (!interface_valid_src((void *) &iface->v4_addr, (void *) &iface->v4_netmask, (void *) &from.sin_addr, 4))
253                 dns_handle_packet(iface, (struct sockaddr *) &from, ntohs(from.sin_port), buffer, len);
254 }
255 
256 static void
257 read_socket6(struct uloop_fd *u, unsigned int events)
258 {
259         struct interface *iface = container_of(u, struct interface, fd);
260         static uint8_t buffer[8 * 1024];
261         struct iovec iov[1];
262         char cmsg6[CMSG_SPACE(sizeof(struct in6_pktinfo)) + CMSG_SPACE(sizeof(int)) + 1];
263         struct cmsghdr *cmsgptr;
264         struct msghdr msg;
265         socklen_t len;
266         struct sockaddr_in6 from;
267         int flags = 0, ifindex = -1;
268         int ttl = 0;
269         struct in6_pktinfo *inp = NULL;
270 
271         if (u->eof) {
272                 interface_close(iface);
273                 uloop_timeout_set(&iface->reconnect, 1000);
274                 return;
275         }
276 
277         iov[0].iov_base = buffer;
278         iov[0].iov_len = sizeof(buffer);
279 
280         memset(&msg, 0, sizeof(msg));
281         msg.msg_name = (struct sockaddr *) &from;
282         msg.msg_namelen = sizeof(struct sockaddr_in6);
283         msg.msg_iov = iov;
284         msg.msg_iovlen = 1;
285         msg.msg_control = &cmsg6;
286         msg.msg_controllen = sizeof(cmsg6);
287 
288         len = recvmsg(u->fd, &msg, flags);
289         if (len == -1) {
290                 perror("read failed");
291                 return;
292         }
293         for (cmsgptr = CMSG_FIRSTHDR(&msg); cmsgptr != NULL; cmsgptr = CMSG_NXTHDR(&msg, cmsgptr)) {
294                 void *c = CMSG_DATA(cmsgptr);
295 
296                 switch (cmsgptr->cmsg_type) {
297                 case IPV6_PKTINFO:
298                         inp = ((struct in6_pktinfo *) c);
299                         break;
300 
301                 case IPV6_HOPLIMIT:
302                         ttl = (uint8_t) *((int *) c);
303                         break;
304 
305                 default:
306                         fprintf(stderr, "unknown cmsg %x\n", cmsgptr->cmsg_type);
307                         return;
308                 }
309         }
310 
311         if (debug > 1) {
312                 char buf[256];
313 
314                 fprintf(stderr, "RX ipv6: %s\n", iface->name);
315                 fprintf(stderr, "  multicast: %d\n", iface->multicast);
316                 inet_ntop(AF_INET6, &from.sin6_addr, buf, 256);
317                 fprintf(stderr, "  src %s:%d\n", buf, ntohs(from.sin6_port));
318                 inet_ntop(AF_INET6, &inp->ipi6_addr, buf, 256);
319                 fprintf(stderr, "  dst %s\n", buf);
320                 fprintf(stderr, "  ttl %u\n", ttl);
321         }
322 
323         if (inp->ipi6_ifindex != iface->ifindex)
324                 fprintf(stderr, "invalid iface index %d != %d\n", ifindex, iface->ifindex);
325         else if (!interface_valid_src((void *) &iface->v6_addr, (void *) &iface->v6_netmask, (void *) &from.sin6_addr, 16))
326                 dns_handle_packet(iface, (struct sockaddr *) &from, ntohs(from.sin6_port), buffer, len);
327 }
328 
329 static int
330 interface_mcast_setup4(struct interface *iface)
331 {
332         struct ip_mreqn mreq;
333         uint8_t ttl = 255;
334         int no = 0;
335         struct sockaddr_in sa = { 0 };
336         int fd = iface->fd.fd;
337 
338         sa.sin_family = AF_INET;
339         sa.sin_port = htons(MCAST_PORT);
340         inet_pton(AF_INET, MCAST_ADDR, &sa.sin_addr);
341 
342         memset(&mreq, 0, sizeof(mreq));
343         mreq.imr_address.s_addr = iface->v4_addr.s_addr;
344         mreq.imr_multiaddr = sa.sin_addr;
345         mreq.imr_ifindex = iface->ifindex;
346 
347         if (setsockopt(fd, IPPROTO_IP, IP_MULTICAST_TTL, &ttl, sizeof(ttl)) < 0)
348                 fprintf(stderr, "ioctl failed: IP_MULTICAST_TTL\n");
349 
350         /* Some network drivers have issues with dropping membership of
351          * mcast groups when the iface is down, but don't allow rejoining
352          * when it comes back up. This is an ugly workaround
353          * -- this was copied from avahi --
354          */
355         setsockopt(fd, IPPROTO_IP, IP_DROP_MEMBERSHIP, &mreq, sizeof(mreq));
356 
357         if (setsockopt(fd, IPPROTO_IP, IP_ADD_MEMBERSHIP, &mreq, sizeof(mreq)) < 0) {
358                 fprintf(stderr, "failed to join multicast group: %m\n");
359                 close(fd);
360                 fd = -1;
361                 return -1;
362         }
363 
364         if (setsockopt(fd, IPPROTO_IP, IP_MULTICAST_LOOP, &no, sizeof(no)) < 0)
365                 fprintf(stderr, "ioctl failed: IP_MULTICAST_LOOP\n");
366 
367         return 0;
368 }
369 
370 static int
371 interface_socket_setup6(struct interface *iface)
372 {
373         struct ipv6_mreq mreq;
374         int ttl = 255;
375         int no = 0;
376         struct sockaddr_in6 sa = { 0 };
377         int fd = iface->fd.fd;
378 
379         sa.sin6_family = AF_INET6;
380         sa.sin6_port = htons(MCAST_PORT);
381         inet_pton(AF_INET6, MCAST_ADDR6, &sa.sin6_addr);
382 
383         memset(&mreq, 0, sizeof(mreq));
384         mreq.ipv6mr_multiaddr = sa.sin6_addr;
385         mreq.ipv6mr_interface = iface->ifindex;
386 
387         if (setsockopt(fd, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, &ttl, sizeof(ttl)) < 0)
388                 fprintf(stderr, "ioctl failed: IPV6_MULTICAST_HOPS\n");
389 
390         setsockopt(fd, IPPROTO_IPV6, IPV6_LEAVE_GROUP, &mreq, sizeof(mreq));
391         if (setsockopt(fd, IPPROTO_IPV6, IPV6_ADD_MEMBERSHIP, &mreq, sizeof(mreq)) < 0) {
392                 fprintf(stderr, "failed to join multicast group: %m\n");
393                 close(fd);
394                 fd = -1;
395                 return -1;
396         }
397 
398         if (setsockopt(fd, IPPROTO_IPV6, IPV6_MULTICAST_LOOP, &no, sizeof(no)) < 0)
399                 fprintf(stderr, "ioctl failed: IPV6_MULTICAST_LOOP\n");
400 
401         return 0;
402 }
403 
404 static void
405 reconnect_socket4(struct uloop_timeout *timeout)
406 {
407         struct interface *iface = container_of(timeout, struct interface, reconnect);
408         int ttl = 255;
409         int yes = 1;
410 
411         iface->fd.fd = usock(USOCK_UDP | USOCK_SERVER | USOCK_NONBLOCK | USOCK_IPV4ONLY,
412                 (iface->multicast) ? (iface->mcast_addr) : (iface->v4_addrs), "5353");
413         if (iface->fd.fd < 0) {
414                 fprintf(stderr, "failed to add listener %s: %m\n", iface->mcast_addr);
415                 goto retry;
416         }
417 
418         if (setsockopt(iface->fd.fd, SOL_SOCKET, SO_BINDTODEVICE, iface->name, strlen(iface->name) < 0))
419                 fprintf(stderr, "ioctl failed: SO_BINDTODEVICE\n");
420 
421         if (setsockopt(iface->fd.fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes)) < 0)
422                 fprintf(stderr, "ioctl failed: SO_REUSEADDR\n");
423 
424         if (setsockopt(iface->fd.fd, IPPROTO_IP, IP_TTL, &ttl, sizeof(ttl)) < 0)
425                 fprintf(stderr, "ioctl failed: IP_TTL\n");
426 
427         if (setsockopt(iface->fd.fd, IPPROTO_IP, IP_RECVTTL, &yes, sizeof(yes)) < 0)
428                 fprintf(stderr, "ioctl failed: IP_RECVTTL\n");
429 
430         if (setsockopt(iface->fd.fd, IPPROTO_IP, IP_PKTINFO, &yes, sizeof(yes)) < 0)
431                 fprintf(stderr, "ioctl failed: IP_PKTINFO\n");
432 
433         if (iface->multicast && interface_mcast_setup4(iface)) {
434                 iface->fd.fd = -1;
435                 goto retry;
436         }
437 
438         uloop_fd_add(&iface->fd, ULOOP_READ);
439         if (iface->multicast) {
440                 dns_send_question(iface, NULL, C_DNS_SD, TYPE_PTR, 0);
441                 announce_init(iface);
442         }
443 
444         return;
445 
446 retry:
447         uloop_timeout_set(timeout, 1000);
448 }
449 
450 static void
451 reconnect_socket6(struct uloop_timeout *timeout)
452 {
453         struct interface *iface = container_of(timeout, struct interface, reconnect);
454         char mcast_addr[128];
455         int ttl = 255;
456         int yes = 1;
457 
458         snprintf(mcast_addr, sizeof(mcast_addr), "%s%%%s", (iface->multicast) ? (iface->mcast_addr) : (iface->v6_addrs), iface->name);
459         iface->fd.fd = usock(USOCK_UDP | USOCK_SERVER | USOCK_NONBLOCK | USOCK_IPV6ONLY, mcast_addr, "5353");
460         if (iface->fd.fd < 0) {
461                 fprintf(stderr, "failed to add listener %s: %m\n", mcast_addr);
462                 goto retry;
463         }
464 
465         if (setsockopt(iface->fd.fd, SOL_SOCKET, SO_BINDTODEVICE, iface->name, strlen(iface->name) < 0))
466                 fprintf(stderr, "ioctl failed: SO_BINDTODEVICE\n");
467 
468         if (setsockopt(iface->fd.fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &ttl, sizeof(ttl)) < 0)
469                 fprintf(stderr, "ioctl failed: IPV6_UNICAST_HOPS\n");
470 
471         if (setsockopt(iface->fd.fd, IPPROTO_IPV6, IPV6_RECVPKTINFO, &yes, sizeof(yes)) < 0)
472                 fprintf(stderr, "ioctl failed: IPV6_RECVPKTINFO\n");
473 
474         if (setsockopt(iface->fd.fd, IPPROTO_IPV6, IPV6_RECVHOPLIMIT, &yes, sizeof(yes)) < 0)
475                 fprintf(stderr, "ioctl failed: IPV6_RECVHOPLIMIT\n");
476 
477         if (setsockopt(iface->fd.fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes)) < 0)
478                 fprintf(stderr, "ioctl failed: SO_REUSEADDR\n");
479 
480         if (iface->multicast && interface_socket_setup6(iface)) {
481                 iface->fd.fd = -1;
482                 goto retry;
483         }
484 
485         uloop_fd_add(&iface->fd, ULOOP_READ);
486 
487         if (iface->multicast) {
488                 dns_send_question(iface, NULL, C_DNS_SD, TYPE_PTR, 0);
489                 announce_init(iface);
490         }
491 
492         return;
493 
494 retry:
495         uloop_timeout_set(timeout, 1000);
496 }
497 
498 
499 static void interface_start(struct interface *iface)
500 {
501         if (iface->v6) {
502                 iface->fd.cb = read_socket6;
503                 iface->reconnect.cb = reconnect_socket6;
504         } else {
505                 iface->fd.cb = read_socket4;
506                 iface->reconnect.cb = reconnect_socket4;
507         }
508         uloop_timeout_set(&iface->reconnect, 100);
509 }
510 
511 static void
512 iface_update_cb(struct vlist_tree *tree, struct vlist_node *node_new,
513                 struct vlist_node *node_old)
514 {
515         struct interface *iface;
516 
517         if (node_old) {
518                 iface = container_of(node_old, struct interface, node);
519                 cache_cleanup(iface);
520                 interface_free(iface);
521         }
522 
523         if (node_new) {
524                 iface = container_of(node_new, struct interface, node);
525                 interface_start(iface);
526         }
527 }
528 
529 static struct interface* _interface_add(const char *name, int multicast, int v6)
530 {
531         struct interface *iface;
532         char *name_buf;
533         char *id_buf;
534 
535         iface = calloc_a(sizeof(*iface),
536                 &name_buf, strlen(name) + 1,
537                 &id_buf, strlen(name) + 5);
538 
539         sprintf(id_buf, "%d_%d_%s", multicast, v6, name);
540         iface->name = strcpy(name_buf, name);
541         iface->id = id_buf;
542         iface->ifindex = if_nametoindex(name);
543         iface->fd.fd = -1;
544         iface->multicast = multicast;
545         iface->v6 = v6;
546         if (v6)
547                 iface->mcast_addr = MCAST_ADDR6;
548         else
549                 iface->mcast_addr = MCAST_ADDR;
550 
551         if (iface->ifindex <= 0)
552                 goto error;
553 
554         vlist_add(&interfaces, &iface->node, iface->id);
555         return iface;
556 
557 error:
558         free(iface);
559         return NULL;
560 }
561 
562 int interface_add(const char *name)
563 {
564         struct interface *v4 = NULL, *v6 = NULL, *unicast;
565         struct ifaddrs *ifap, *ifa;
566 
567         getifaddrs(&ifap);
568 
569         for (ifa = ifap; ifa; ifa = ifa->ifa_next) {
570                 if (strcmp(ifa->ifa_name, name))
571                         continue;
572                 if (ifa->ifa_addr->sa_family == AF_INET && !v4) {
573                         struct sockaddr_in *sa;
574 
575                         if (cfg_proto && (cfg_proto != 4))
576                                 continue;
577 
578                         unicast = _interface_add(name, 0, 0);
579                         if (!unicast)
580                                 continue;
581                         v4 = _interface_add(name, 1, 0);
582                         if (!v4)
583                                 continue;
584 
585                         sa = (struct sockaddr_in *) ifa->ifa_addr;
586                         memcpy(&v4->v4_addr, &sa->sin_addr, sizeof(v4->v4_addr));
587                         memcpy(&unicast->v4_addr, &sa->sin_addr, sizeof(unicast->v4_addr));
588 
589                         inet_ntop(AF_INET, &sa->sin_addr, v4->v4_addrs, sizeof(v4->v4_addrs));
590                         inet_ntop(AF_INET, &sa->sin_addr, unicast->v4_addrs, sizeof(unicast->v4_addrs));
591 
592                         sa = (struct sockaddr_in *) ifa->ifa_netmask;
593                         memcpy(&unicast->v4_netmask, &sa->sin_addr, sizeof(unicast->v4_netmask));
594                         memcpy(&v4->v4_netmask, &sa->sin_addr, sizeof(v4->v4_netmask));
595 
596                         v4->peer = unicast;
597                         unicast->peer = v4;
598                 }
599 
600                 if (ifa->ifa_addr->sa_family == AF_INET6 && !v6) {
601                         uint8_t ll_prefix[] = {0xfe, 0x80 };
602                         struct sockaddr_in6 *sa6;
603 
604                         if (cfg_proto && (cfg_proto != 6))
605                                 continue;
606 
607                         sa6 = (struct sockaddr_in6 *) ifa->ifa_addr;
608                         if (memcmp(&sa6->sin6_addr, &ll_prefix, 2))
609                                 continue;
610 
611                         unicast = _interface_add(name, 0, 1);
612                         if (!unicast)
613                                 continue;
614                         v6 = _interface_add(name, 1, 1);
615                         if (!v6)
616                                 continue;
617 
618                         memcpy(&v6->v6_addr, &sa6->sin6_addr, sizeof(v6->v6_addr));
619                         memcpy(&unicast->v6_addr, &sa6->sin6_addr, sizeof(unicast->v6_addr));
620 
621                         inet_ntop(AF_INET6, &sa6->sin6_addr, v6->v6_addrs, sizeof(v6->v6_addrs));
622                         inet_ntop(AF_INET6, &sa6->sin6_addr, unicast->v6_addrs, sizeof(unicast->v6_addrs));
623 
624                         sa6 = (struct sockaddr_in6 *) ifa->ifa_netmask;
625                         memcpy(&v6->v6_netmask, &sa6->sin6_addr, sizeof(v6->v6_netmask));
626                         memcpy(&unicast->v6_netmask, &sa6->sin6_addr, sizeof(unicast->v6_netmask));
627 
628                         v6->peer = unicast;
629                         unicast->peer = v6;
630                 }
631         }
632 
633         freeifaddrs(ifap);
634 
635         return !v4 && !v6;
636 }
637 
638 void interface_shutdown(void)
639 {
640         struct interface *iface;
641 
642         vlist_for_each_element(&interfaces, iface, node)
643                 if (iface->fd.fd > 0 && iface->multicast) {
644                         dns_reply_a(iface, NULL, 0);
645                         service_announce_services(iface, NULL, 0);
646                 }
647         vlist_for_each_element(&interfaces, iface, node)
648                 interface_close(iface);
649 }
650 
651 struct interface*
652 interface_get(const char *name, int v6, int multicast)
653 {
654         char id_buf[32];
655         snprintf(id_buf, sizeof(id_buf), "%d_%d_%s", multicast, v6, name);
656         struct interface *iface = vlist_find(&interfaces, id_buf, iface, node);
657         return iface;
658 }
659 
660 VLIST_TREE(interfaces, avl_strcmp, iface_update_cb, false, false);
661 

This page was automatically generated by LXR 0.3.1.  •  OpenWrt