• 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 (!inp)
237                 return;
238 
239         if (debug > 1) {
240                 char buf[256];
241 
242                 fprintf(stderr, "RX ipv4: %s\n", iface->name);
243                 fprintf(stderr, "  multicast: %d\n", iface->multicast);
244                 inet_ntop(AF_INET, &from.sin_addr, buf, 256);
245                 fprintf(stderr, "  src %s:%d\n", buf, ntohs(from.sin_port));
246                 inet_ntop(AF_INET, &inp->ipi_spec_dst, buf, 256);
247                 fprintf(stderr, "  dst %s\n", buf);
248                 inet_ntop(AF_INET, &inp->ipi_addr, buf, 256);
249                 fprintf(stderr, "  real %s\n", buf);
250                 fprintf(stderr, "  ttl %u\n", ttl);
251         }
252 
253         if (inp->ipi_ifindex != iface->ifindex)
254                 fprintf(stderr, "invalid iface index %d != %d\n", ifindex, iface->ifindex);
255         else if (!interface_valid_src((void *) &iface->v4_addr, (void *) &iface->v4_netmask, (void *) &from.sin_addr, 4))
256                 dns_handle_packet(iface, (struct sockaddr *) &from, ntohs(from.sin_port), buffer, len);
257 }
258 
259 static void
260 read_socket6(struct uloop_fd *u, unsigned int events)
261 {
262         struct interface *iface = container_of(u, struct interface, fd);
263         static uint8_t buffer[8 * 1024];
264         struct iovec iov[1];
265         char cmsg6[CMSG_SPACE(sizeof(struct in6_pktinfo)) + CMSG_SPACE(sizeof(int)) + 1];
266         struct cmsghdr *cmsgptr;
267         struct msghdr msg;
268         socklen_t len;
269         struct sockaddr_in6 from;
270         int flags = 0, ifindex = -1;
271         int ttl = 0;
272         struct in6_pktinfo *inp = NULL;
273 
274         if (u->eof) {
275                 interface_close(iface);
276                 uloop_timeout_set(&iface->reconnect, 1000);
277                 return;
278         }
279 
280         iov[0].iov_base = buffer;
281         iov[0].iov_len = sizeof(buffer);
282 
283         memset(&msg, 0, sizeof(msg));
284         msg.msg_name = (struct sockaddr *) &from;
285         msg.msg_namelen = sizeof(struct sockaddr_in6);
286         msg.msg_iov = iov;
287         msg.msg_iovlen = 1;
288         msg.msg_control = &cmsg6;
289         msg.msg_controllen = sizeof(cmsg6);
290 
291         len = recvmsg(u->fd, &msg, flags);
292         if (len == -1) {
293                 perror("read failed");
294                 return;
295         }
296         for (cmsgptr = CMSG_FIRSTHDR(&msg); cmsgptr != NULL; cmsgptr = CMSG_NXTHDR(&msg, cmsgptr)) {
297                 void *c = CMSG_DATA(cmsgptr);
298 
299                 switch (cmsgptr->cmsg_type) {
300                 case IPV6_PKTINFO:
301                         inp = ((struct in6_pktinfo *) c);
302                         break;
303 
304                 case IPV6_HOPLIMIT:
305                         ttl = (uint8_t) *((int *) c);
306                         break;
307 
308                 default:
309                         fprintf(stderr, "unknown cmsg %x\n", cmsgptr->cmsg_type);
310                         return;
311                 }
312         }
313 
314         if (!inp)
315                 return;
316 
317         if (debug > 1) {
318                 char buf[256];
319 
320                 fprintf(stderr, "RX ipv6: %s\n", iface->name);
321                 fprintf(stderr, "  multicast: %d\n", iface->multicast);
322                 inet_ntop(AF_INET6, &from.sin6_addr, buf, 256);
323                 fprintf(stderr, "  src %s:%d\n", buf, ntohs(from.sin6_port));
324                 inet_ntop(AF_INET6, &inp->ipi6_addr, buf, 256);
325                 fprintf(stderr, "  dst %s\n", buf);
326                 fprintf(stderr, "  ttl %u\n", ttl);
327         }
328 
329         if (inp->ipi6_ifindex != iface->ifindex)
330                 fprintf(stderr, "invalid iface index %d != %d\n", ifindex, iface->ifindex);
331         else if (!interface_valid_src((void *) &iface->v6_addr, (void *) &iface->v6_netmask, (void *) &from.sin6_addr, 16))
332                 dns_handle_packet(iface, (struct sockaddr *) &from, ntohs(from.sin6_port), buffer, len);
333 }
334 
335 static int
336 interface_mcast_setup4(struct interface *iface)
337 {
338         struct ip_mreqn mreq;
339         uint8_t ttl = 255;
340         int no = 0;
341         struct sockaddr_in sa = { 0 };
342         int fd = iface->fd.fd;
343 
344         sa.sin_family = AF_INET;
345         sa.sin_port = htons(MCAST_PORT);
346         inet_pton(AF_INET, MCAST_ADDR, &sa.sin_addr);
347 
348         memset(&mreq, 0, sizeof(mreq));
349         mreq.imr_address.s_addr = iface->v4_addr.s_addr;
350         mreq.imr_multiaddr = sa.sin_addr;
351         mreq.imr_ifindex = iface->ifindex;
352 
353         if (setsockopt(fd, IPPROTO_IP, IP_MULTICAST_TTL, &ttl, sizeof(ttl)) < 0)
354                 fprintf(stderr, "ioctl failed: IP_MULTICAST_TTL\n");
355 
356         /* Some network drivers have issues with dropping membership of
357          * mcast groups when the iface is down, but don't allow rejoining
358          * when it comes back up. This is an ugly workaround
359          * -- this was copied from avahi --
360          */
361         setsockopt(fd, IPPROTO_IP, IP_DROP_MEMBERSHIP, &mreq, sizeof(mreq));
362 
363         if (setsockopt(fd, IPPROTO_IP, IP_ADD_MEMBERSHIP, &mreq, sizeof(mreq)) < 0) {
364                 fprintf(stderr, "failed to join multicast group: %m\n");
365                 close(fd);
366                 iface->fd.fd = -1;
367                 return -1;
368         }
369 
370         if (setsockopt(fd, IPPROTO_IP, IP_MULTICAST_LOOP, &no, sizeof(no)) < 0)
371                 fprintf(stderr, "ioctl failed: IP_MULTICAST_LOOP\n");
372 
373         return 0;
374 }
375 
376 static int
377 interface_socket_setup6(struct interface *iface)
378 {
379         struct ipv6_mreq mreq;
380         int ttl = 255;
381         int no = 0;
382         struct sockaddr_in6 sa = { 0 };
383         int fd = iface->fd.fd;
384 
385         sa.sin6_family = AF_INET6;
386         sa.sin6_port = htons(MCAST_PORT);
387         inet_pton(AF_INET6, MCAST_ADDR6, &sa.sin6_addr);
388 
389         memset(&mreq, 0, sizeof(mreq));
390         mreq.ipv6mr_multiaddr = sa.sin6_addr;
391         mreq.ipv6mr_interface = iface->ifindex;
392 
393         if (setsockopt(fd, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, &ttl, sizeof(ttl)) < 0)
394                 fprintf(stderr, "ioctl failed: IPV6_MULTICAST_HOPS\n");
395 
396         setsockopt(fd, IPPROTO_IPV6, IPV6_LEAVE_GROUP, &mreq, sizeof(mreq));
397         if (setsockopt(fd, IPPROTO_IPV6, IPV6_ADD_MEMBERSHIP, &mreq, sizeof(mreq)) < 0) {
398                 fprintf(stderr, "failed to join multicast group: %m\n");
399                 close(fd);
400                 iface->fd.fd = -1;
401                 return -1;
402         }
403 
404         if (setsockopt(fd, IPPROTO_IPV6, IPV6_MULTICAST_LOOP, &no, sizeof(no)) < 0)
405                 fprintf(stderr, "ioctl failed: IPV6_MULTICAST_LOOP\n");
406 
407         return 0;
408 }
409 
410 static void
411 reconnect_socket4(struct uloop_timeout *timeout)
412 {
413         struct interface *iface = container_of(timeout, struct interface, reconnect);
414         int ttl = 255;
415         int yes = 1;
416 
417         iface->fd.fd = usock(USOCK_UDP | USOCK_SERVER | USOCK_NONBLOCK | USOCK_IPV4ONLY,
418                 (iface->multicast) ? (iface->mcast_addr) : (iface->v4_addrs), "5353");
419         if (iface->fd.fd < 0) {
420                 fprintf(stderr, "failed to add listener %s: %m\n", iface->mcast_addr);
421                 goto retry;
422         }
423 
424         if (setsockopt(iface->fd.fd, SOL_SOCKET, SO_BINDTODEVICE, iface->name, strlen(iface->name) < 0))
425                 fprintf(stderr, "ioctl failed: SO_BINDTODEVICE\n");
426 
427         if (setsockopt(iface->fd.fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes)) < 0)
428                 fprintf(stderr, "ioctl failed: SO_REUSEADDR\n");
429 
430         if (setsockopt(iface->fd.fd, IPPROTO_IP, IP_TTL, &ttl, sizeof(ttl)) < 0)
431                 fprintf(stderr, "ioctl failed: IP_TTL\n");
432 
433         if (setsockopt(iface->fd.fd, IPPROTO_IP, IP_RECVTTL, &yes, sizeof(yes)) < 0)
434                 fprintf(stderr, "ioctl failed: IP_RECVTTL\n");
435 
436         if (setsockopt(iface->fd.fd, IPPROTO_IP, IP_PKTINFO, &yes, sizeof(yes)) < 0)
437                 fprintf(stderr, "ioctl failed: IP_PKTINFO\n");
438 
439         if (iface->multicast && interface_mcast_setup4(iface)) {
440                 iface->fd.fd = -1;
441                 goto retry;
442         }
443 
444         uloop_fd_add(&iface->fd, ULOOP_READ);
445         if (iface->multicast) {
446                 dns_send_question(iface, NULL, C_DNS_SD, TYPE_PTR, 0);
447                 announce_init(iface);
448         }
449 
450         return;
451 
452 retry:
453         uloop_timeout_set(timeout, 1000);
454 }
455 
456 static void
457 reconnect_socket6(struct uloop_timeout *timeout)
458 {
459         struct interface *iface = container_of(timeout, struct interface, reconnect);
460         char mcast_addr[128];
461         int ttl = 255;
462         int yes = 1;
463 
464         snprintf(mcast_addr, sizeof(mcast_addr), "%s%%%s", (iface->multicast) ? (iface->mcast_addr) : (iface->v6_addrs), iface->name);
465         iface->fd.fd = usock(USOCK_UDP | USOCK_SERVER | USOCK_NONBLOCK | USOCK_IPV6ONLY, mcast_addr, "5353");
466         if (iface->fd.fd < 0) {
467                 fprintf(stderr, "failed to add listener %s: %m\n", mcast_addr);
468                 goto retry;
469         }
470 
471         if (setsockopt(iface->fd.fd, SOL_SOCKET, SO_BINDTODEVICE, iface->name, strlen(iface->name) < 0))
472                 fprintf(stderr, "ioctl failed: SO_BINDTODEVICE\n");
473 
474         if (setsockopt(iface->fd.fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &ttl, sizeof(ttl)) < 0)
475                 fprintf(stderr, "ioctl failed: IPV6_UNICAST_HOPS\n");
476 
477         if (setsockopt(iface->fd.fd, IPPROTO_IPV6, IPV6_RECVPKTINFO, &yes, sizeof(yes)) < 0)
478                 fprintf(stderr, "ioctl failed: IPV6_RECVPKTINFO\n");
479 
480         if (setsockopt(iface->fd.fd, IPPROTO_IPV6, IPV6_RECVHOPLIMIT, &yes, sizeof(yes)) < 0)
481                 fprintf(stderr, "ioctl failed: IPV6_RECVHOPLIMIT\n");
482 
483         if (setsockopt(iface->fd.fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes)) < 0)
484                 fprintf(stderr, "ioctl failed: SO_REUSEADDR\n");
485 
486         if (iface->multicast && interface_socket_setup6(iface)) {
487                 iface->fd.fd = -1;
488                 goto retry;
489         }
490 
491         uloop_fd_add(&iface->fd, ULOOP_READ);
492 
493         if (iface->multicast) {
494                 dns_send_question(iface, NULL, C_DNS_SD, TYPE_PTR, 0);
495                 announce_init(iface);
496         }
497 
498         return;
499 
500 retry:
501         uloop_timeout_set(timeout, 1000);
502 }
503 
504 
505 static void interface_start(struct interface *iface)
506 {
507         if (iface->v6) {
508                 iface->fd.cb = read_socket6;
509                 iface->reconnect.cb = reconnect_socket6;
510         } else {
511                 iface->fd.cb = read_socket4;
512                 iface->reconnect.cb = reconnect_socket4;
513         }
514         uloop_timeout_set(&iface->reconnect, 1000);
515 }
516 
517 static void
518 iface_update_cb(struct vlist_tree *tree, struct vlist_node *node_new,
519                 struct vlist_node *node_old)
520 {
521         struct interface *iface;
522 
523         if (node_old) {
524                 iface = container_of(node_old, struct interface, node);
525                 cache_cleanup(iface);
526                 interface_free(iface);
527         }
528 
529         if (node_new) {
530                 iface = container_of(node_new, struct interface, node);
531                 interface_start(iface);
532         }
533 }
534 
535 static struct interface* _interface_add(const char *name, int multicast, int v6)
536 {
537         struct interface *iface;
538         char *name_buf;
539         char *id_buf;
540 
541         iface = calloc_a(sizeof(*iface),
542                 &name_buf, strlen(name) + 1,
543                 &id_buf, strlen(name) + 5);
544 
545         sprintf(id_buf, "%d_%d_%s", multicast, v6, name);
546         iface->name = strcpy(name_buf, name);
547         iface->id = id_buf;
548         iface->ifindex = if_nametoindex(name);
549         iface->fd.fd = -1;
550         iface->multicast = multicast;
551         iface->v6 = v6;
552         if (v6)
553                 iface->mcast_addr = MCAST_ADDR6;
554         else
555                 iface->mcast_addr = MCAST_ADDR;
556 
557         if (iface->ifindex <= 0)
558                 goto error;
559 
560         vlist_add(&interfaces, &iface->node, iface->id);
561         return iface;
562 
563 error:
564         free(iface);
565         return NULL;
566 }
567 
568 int interface_add(const char *name)
569 {
570         struct interface *v4 = NULL, *v6 = NULL, *unicast;
571         struct ifaddrs *ifap, *ifa;
572 
573         getifaddrs(&ifap);
574 
575         for (ifa = ifap; ifa; ifa = ifa->ifa_next) {
576                 if (strcmp(ifa->ifa_name, name))
577                         continue;
578                 if (ifa->ifa_addr->sa_family == AF_INET && !v4) {
579                         struct sockaddr_in *sa;
580 
581                         if (cfg_proto && (cfg_proto != 4))
582                                 continue;
583 
584                         unicast = _interface_add(name, 0, 0);
585                         if (!unicast)
586                                 continue;
587                         v4 = _interface_add(name, 1, 0);
588                         if (!v4)
589                                 continue;
590 
591                         sa = (struct sockaddr_in *) ifa->ifa_addr;
592                         memcpy(&v4->v4_addr, &sa->sin_addr, sizeof(v4->v4_addr));
593                         memcpy(&unicast->v4_addr, &sa->sin_addr, sizeof(unicast->v4_addr));
594 
595                         inet_ntop(AF_INET, &sa->sin_addr, v4->v4_addrs, sizeof(v4->v4_addrs));
596                         inet_ntop(AF_INET, &sa->sin_addr, unicast->v4_addrs, sizeof(unicast->v4_addrs));
597 
598                         sa = (struct sockaddr_in *) ifa->ifa_netmask;
599                         memcpy(&unicast->v4_netmask, &sa->sin_addr, sizeof(unicast->v4_netmask));
600                         memcpy(&v4->v4_netmask, &sa->sin_addr, sizeof(v4->v4_netmask));
601 
602                         v4->peer = unicast;
603                         unicast->peer = v4;
604                 }
605 
606                 if (ifa->ifa_addr->sa_family == AF_INET6 && !v6) {
607                         uint8_t ll_prefix[] = {0xfe, 0x80 };
608                         struct sockaddr_in6 *sa6;
609 
610                         if (cfg_proto && (cfg_proto != 6))
611                                 continue;
612 
613                         sa6 = (struct sockaddr_in6 *) ifa->ifa_addr;
614                         if (memcmp(&sa6->sin6_addr, &ll_prefix, 2))
615                                 continue;
616 
617                         unicast = _interface_add(name, 0, 1);
618                         if (!unicast)
619                                 continue;
620                         v6 = _interface_add(name, 1, 1);
621                         if (!v6)
622                                 continue;
623 
624                         memcpy(&v6->v6_addr, &sa6->sin6_addr, sizeof(v6->v6_addr));
625                         memcpy(&unicast->v6_addr, &sa6->sin6_addr, sizeof(unicast->v6_addr));
626 
627                         inet_ntop(AF_INET6, &sa6->sin6_addr, v6->v6_addrs, sizeof(v6->v6_addrs));
628                         inet_ntop(AF_INET6, &sa6->sin6_addr, unicast->v6_addrs, sizeof(unicast->v6_addrs));
629 
630                         sa6 = (struct sockaddr_in6 *) ifa->ifa_netmask;
631                         memcpy(&v6->v6_netmask, &sa6->sin6_addr, sizeof(v6->v6_netmask));
632                         memcpy(&unicast->v6_netmask, &sa6->sin6_addr, sizeof(unicast->v6_netmask));
633 
634                         v6->peer = unicast;
635                         unicast->peer = v6;
636                 }
637         }
638 
639         freeifaddrs(ifap);
640 
641         return !v4 && !v6;
642 }
643 
644 void interface_shutdown(void)
645 {
646         struct interface *iface;
647 
648         vlist_for_each_element(&interfaces, iface, node)
649                 if (iface->fd.fd > 0 && iface->multicast) {
650                         dns_reply_a(iface, NULL, 0);
651                         service_announce_services(iface, NULL, 0);
652                 }
653         vlist_for_each_element(&interfaces, iface, node)
654                 interface_close(iface);
655 }
656 
657 struct interface*
658 interface_get(const char *name, int v6, int multicast)
659 {
660         char id_buf[32];
661         snprintf(id_buf, sizeof(id_buf), "%d_%d_%s", multicast, v6, name);
662         struct interface *iface = vlist_find(&interfaces, id_buf, iface, node);
663         return iface;
664 }
665 
666 VLIST_TREE(interfaces, avl_strcmp, iface_update_cb, false, false);
667 

This page was automatically generated by LXR 0.3.1.  •  OpenWrt