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