faithd.c revision 1.6
1 /* $NetBSD: faithd.c,v 1.6 1999/12/20 16:03:19 itojun Exp $ */ 2 3 /* 4 * Copyright (C) 1997 and 1998 WIDE Project. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. Neither the name of the project nor the names of its contributors 16 * may be used to endorse or promote products derived from this software 17 * without specific prior written permission. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND 20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 22 * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE 23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 29 * SUCH DAMAGE. 30 */ 31 32 /* 33 * User level translator from IPv6 to IPv4. 34 * 35 * Usage: faithd [<port> <progpath> <arg1(progname)> <arg2> ...] 36 * e.g. faithd telnet /usr/local/v6/sbin/telnetd telnetd 37 */ 38 39 #include <sys/param.h> 40 #include <sys/types.h> 41 #include <sys/sysctl.h> 42 #include <sys/socket.h> 43 #include <sys/wait.h> 44 #include <sys/stat.h> 45 #include <sys/time.h> 46 #include <sys/ioctl.h> 47 #ifdef __FreeBSD__ 48 #include <libutil.h> 49 #endif 50 51 #include <stdio.h> 52 #include <stdlib.h> 53 #include <stdarg.h> 54 #include <string.h> 55 #include <syslog.h> 56 #include <unistd.h> 57 #include <errno.h> 58 #include <signal.h> 59 #include <fcntl.h> 60 #include <termios.h> 61 62 #include <net/if_types.h> 63 #ifdef IFT_FAITH 64 # define USE_ROUTE 65 # include <net/if.h> 66 # include <net/route.h> 67 # include <net/if_dl.h> 68 #endif 69 70 #include <netinet/in.h> 71 #include <arpa/inet.h> 72 #include <netdb.h> 73 74 #ifdef FAITH4 75 #include <resolv.h> 76 #include <arpa/nameser.h> 77 #ifndef FAITH_NS 78 #define FAITH_NS "FAITH_NS" 79 #endif 80 #endif 81 82 #include "faithd.h" 83 84 char *serverpath = NULL; 85 char *serverarg[MAXARGV + 1]; 86 static char *faithdname = NULL; 87 char logname[BUFSIZ]; 88 struct myaddrs { 89 struct myaddrs *next; 90 struct sockaddr *addr; 91 }; 92 struct myaddrs *myaddrs = NULL; 93 static char *service; 94 #ifdef USE_ROUTE 95 static int sockfd = 0; 96 #endif 97 int dflag = 0; 98 static int pflag = 0; 99 100 int main __P((int, char **)); 101 static void play_service __P((int)); 102 static void play_child __P((int, struct sockaddr *)); 103 static int faith_prefix __P((struct sockaddr *)); 104 static int map6to4 __P((struct sockaddr_in6 *, struct sockaddr_in *)); 105 #ifdef FAITH4 106 static int map4to6 __P((struct sockaddr_in *, struct sockaddr_in6 *)); 107 #endif 108 static void sig_child __P((int)); 109 static void sig_terminate __P((int)); 110 static void start_daemon __P((void)); 111 static unsigned int if_maxindex __P((void)); 112 static void grab_myaddrs __P((void)); 113 static void free_myaddrs __P((void)); 114 static void update_myaddrs __P((void)); 115 static void usage __P((void)); 116 117 int 118 main(int argc, char *argv[]) 119 { 120 struct addrinfo hints, *res; 121 int s_wld, error, i, serverargc, on = 1; 122 int family = AF_INET6; 123 int c; 124 #ifdef FAITH_NS 125 char *ns; 126 #endif /* FAITH_NS */ 127 extern int optind; 128 extern char *optarg; 129 130 /* 131 * Initializing stuff 132 */ 133 134 faithdname = strrchr(argv[0], '/'); 135 if (faithdname) 136 faithdname++; 137 else 138 faithdname = argv[0]; 139 140 while ((c = getopt(argc, argv, "dp46")) != -1) { 141 switch (c) { 142 case 'd': 143 dflag++; 144 break; 145 case 'p': 146 pflag++; 147 break; 148 #ifdef FAITH4 149 case '4': 150 family = AF_INET; 151 break; 152 case '6': 153 family = AF_INET6; 154 break; 155 #endif 156 default: 157 usage(); 158 break; 159 } 160 } 161 argc -= optind; 162 argv += optind; 163 164 #ifdef FAITH_NS 165 if ((ns = getenv(FAITH_NS)) != NULL) { 166 struct sockaddr_storage ss; 167 struct addrinfo hints, *res; 168 char serv[NI_MAXSERV]; 169 170 memset(&ss, 0, sizeof(ss)); 171 memset(&hints, 0, sizeof(hints)); 172 sprintf(serv, "%u", NAMESERVER_PORT); 173 hints.ai_flags = AI_NUMERICHOST; 174 if (getaddrinfo(ns, serv, &hints, &res) == 0) { 175 res_init(); 176 memcpy(&_res_ext.nsaddr, res->ai_addr, res->ai_addrlen); 177 _res.nscount = 1; 178 } 179 } 180 #endif /* FAITH_NS */ 181 182 #ifdef USE_ROUTE 183 grab_myaddrs(); 184 #endif 185 186 switch (argc) { 187 case 0: 188 serverpath = DEFAULT_PATH; 189 serverarg[0] = DEFAULT_NAME; 190 serverarg[1] = NULL; 191 service = DEFAULT_PORT_NAME; 192 break; 193 default: 194 serverargc = argc - NUMARG; 195 if (serverargc > MAXARGV) 196 exit_error("too many augments"); 197 198 serverpath = malloc(strlen(argv[NUMPRG])); 199 strcpy(serverpath, argv[NUMPRG]); 200 for (i = 0; i < serverargc; i++) { 201 serverarg[i] = malloc(strlen(argv[i + NUMARG])); 202 strcpy(serverarg[i], argv[i + NUMARG]); 203 } 204 serverarg[i] = NULL; 205 /* fall throuth */ 206 case 1: /* no local service */ 207 service = argv[NUMPRT]; 208 break; 209 } 210 211 /* 212 * Opening wild card socket for this service. 213 */ 214 215 memset(&hints, 0, sizeof(hints)); 216 hints.ai_flags = AI_PASSIVE; 217 hints.ai_family = family; 218 hints.ai_socktype = SOCK_STREAM; 219 hints.ai_protocol = 0; 220 error = getaddrinfo(NULL, service, &hints, &res); 221 if (error) 222 exit_error("getaddrinfo: %s", gai_strerror(error)); 223 224 s_wld = socket(res->ai_family, res->ai_socktype, res->ai_protocol); 225 if (s_wld == -1) 226 exit_error("socket: %s", ERRSTR); 227 228 #ifdef IPV6_FAITH 229 if (res->ai_family == AF_INET6) { 230 error = setsockopt(s_wld, IPPROTO_IPV6, IPV6_FAITH, &on, sizeof(on)); 231 if (error == -1) 232 exit_error("setsockopt(IPV6_FAITH): %s", ERRSTR); 233 } 234 #endif 235 #ifdef FAITH4 236 #ifdef IP_FAITH 237 if (res->ai_family == AF_INET) { 238 error = setsockopt(s_wld, IPPROTO_IP, IP_FAITH, &on, sizeof(on)); 239 if (error == -1) 240 exit_error("setsockopt(IP_FAITH): %s", ERRSTR); 241 } 242 #endif 243 #endif /* FAITH4 */ 244 245 error = setsockopt(s_wld, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)); 246 if (error == -1) 247 exit_error("setsockopt(SO_REUSEADDR): %s", ERRSTR); 248 249 error = setsockopt(s_wld, SOL_SOCKET, SO_OOBINLINE, &on, sizeof(on)); 250 if (error == -1) 251 exit_error("setsockopt(SO_OOBINLINE): %s", ERRSTR); 252 253 error = bind(s_wld, (struct sockaddr *)res->ai_addr, res->ai_addrlen); 254 if (error == -1) 255 exit_error("bind: %s", ERRSTR); 256 257 error = listen(s_wld, 5); 258 if (error == -1) 259 exit_error("listen: %s", ERRSTR); 260 261 #ifdef USE_ROUTE 262 sockfd = socket(PF_ROUTE, SOCK_RAW, PF_UNSPEC); 263 if (sockfd < 0) { 264 exit_error("socket(PF_ROUTE): %s", ERRSTR); 265 /*NOTREACHED*/ 266 } 267 #endif 268 269 /* 270 * Everything is OK. 271 */ 272 273 start_daemon(); 274 275 sprintf(logname, "accepting port %s", service); 276 openlog(logname, LOG_PID | LOG_NOWAIT, LOG_DAEMON); 277 syslog(LOG_INFO, "Staring faith daemon for %s port", service); 278 279 play_service(s_wld); 280 /*NOTRECHED*/ 281 exit(1); /*pacify gcc*/ 282 } 283 284 static void 285 play_service(int s_wld) 286 { 287 struct sockaddr_storage srcaddr; 288 int len; 289 int s_src; 290 pid_t child_pid; 291 fd_set rfds; 292 int error; 293 int maxfd; 294 295 /* 296 * Wait, accept, fork, faith.... 297 */ 298 again: 299 setproctitle(logname); 300 301 FD_ZERO(&rfds); 302 FD_SET(s_wld, &rfds); 303 maxfd = s_wld; 304 #ifdef USE_ROUTE 305 if (sockfd) { 306 FD_SET(sockfd, &rfds); 307 maxfd = (maxfd < sockfd) ? sockfd : maxfd; 308 } 309 #endif 310 311 error = select(maxfd + 1, &rfds, NULL, NULL, NULL); 312 if (error < 0) { 313 if (errno == EINTR) 314 goto again; 315 exit_failure("select: %s", ERRSTR); 316 /*NOTREACHED*/ 317 } 318 319 #ifdef USE_ROUTE 320 if (FD_ISSET(sockfd, &rfds)) { 321 update_myaddrs(); 322 } 323 #endif 324 if (FD_ISSET(s_wld, &rfds)) { 325 len = sizeof(srcaddr); 326 s_src = accept(s_wld, (struct sockaddr *)&srcaddr, 327 &len); 328 if (s_src == -1) 329 exit_failure("socket: %s", ERRSTR); 330 331 child_pid = fork(); 332 333 if (child_pid == 0) { 334 /* child process */ 335 close(s_wld); 336 closelog(); 337 openlog(logname, LOG_PID | LOG_NOWAIT, LOG_DAEMON); 338 play_child(s_src, (struct sockaddr *)&srcaddr); 339 exit_failure("should never reach here"); 340 } else { 341 /* parent process */ 342 close(s_src); 343 if (child_pid == -1) 344 syslog(LOG_ERR, "can't fork"); 345 } 346 } 347 goto again; 348 } 349 350 static void 351 play_child(int s_src, struct sockaddr *srcaddr) 352 { 353 struct sockaddr_storage dstaddr6; 354 struct sockaddr_storage dstaddr4; 355 char src[MAXHOSTNAMELEN]; 356 char dst6[MAXHOSTNAMELEN]; 357 char dst4[MAXHOSTNAMELEN]; 358 int len = sizeof(dstaddr6); 359 int s_dst, error, hport, nresvport, on = 1; 360 struct timeval tv; 361 struct sockaddr *sa4; 362 363 tv.tv_sec = 1; 364 tv.tv_usec = 0; 365 366 getnameinfo(srcaddr, srcaddr->sa_len, 367 src, sizeof(src), NULL, 0, NI_NUMERICHOST); 368 syslog(LOG_INFO, "accepted a client from %s", src); 369 370 error = getsockname(s_src, (struct sockaddr *)&dstaddr6, &len); 371 if (error == -1) 372 exit_failure("getsockname: %s", ERRSTR); 373 374 getnameinfo((struct sockaddr *)&dstaddr6, len, 375 dst6, sizeof(dst6), NULL, 0, NI_NUMERICHOST); 376 syslog(LOG_INFO, "the client is connecting to %s", dst6); 377 378 if (!faith_prefix((struct sockaddr *)&dstaddr6)) { 379 if (serverpath) { 380 /* 381 * Local service 382 */ 383 syslog(LOG_INFO, "executing local %s", serverpath); 384 dup2(s_src, 0); 385 close(s_src); 386 dup2(0, 1); 387 dup2(0, 2); 388 execv(serverpath, serverarg); 389 syslog(LOG_ERR, "execv %s: %s", serverpath, ERRSTR); 390 _exit(EXIT_FAILURE); 391 } else { 392 close(s_src); 393 exit_success("no local service for %s", service); 394 } 395 } 396 397 /* 398 * Act as a translator 399 */ 400 401 switch (((struct sockaddr *)&dstaddr6)->sa_family) { 402 case AF_INET6: 403 if (!map6to4((struct sockaddr_in6 *)&dstaddr6, 404 (struct sockaddr_in *)&dstaddr4)) { 405 close(s_src); 406 exit_error("map6to4 failed"); 407 } 408 syslog(LOG_INFO, "translating from v6 to v4"); 409 break; 410 #ifdef FAITH4 411 case AF_INET: 412 if (!map4to6((struct sockaddr_in *)&dstaddr6, 413 (struct sockaddr_in6 *)&dstaddr4)) { 414 close(s_src); 415 exit_error("map4to6 failed"); 416 } 417 syslog(LOG_INFO, "translating from v4 to v6"); 418 break; 419 #endif 420 default: 421 close(s_src); 422 exit_error("family not supported"); 423 /*NOTREACHED*/ 424 } 425 426 sa4 = (struct sockaddr *)&dstaddr4; 427 getnameinfo(sa4, sa4->sa_len, 428 dst4, sizeof(dst4), NULL, 0, NI_NUMERICHOST); 429 syslog(LOG_INFO, "the translator is connecting to %s", dst4); 430 431 setproctitle("port %s, %s -> %s", service, src, dst4); 432 433 if (sa4->sa_family == AF_INET6) 434 hport = ntohs(((struct sockaddr_in6 *)&dstaddr4)->sin6_port); 435 else /* AF_INET */ 436 hport = ntohs(((struct sockaddr_in *)&dstaddr4)->sin_port); 437 438 switch (hport) { 439 case RLOGIN_PORT: 440 case RSH_PORT: 441 s_dst = rresvport_af(&nresvport, sa4->sa_family); 442 break; 443 default: 444 if (pflag) 445 s_dst = rresvport_af(&nresvport, sa4->sa_family); 446 else 447 s_dst = socket(sa4->sa_family, SOCK_STREAM, 0); 448 break; 449 } 450 if (s_dst == -1) 451 exit_failure("socket: %s", ERRSTR); 452 453 error = setsockopt(s_dst, SOL_SOCKET, SO_OOBINLINE, &on, sizeof(on)); 454 if (error == -1) 455 exit_error("setsockopt(SO_OOBINLINE): %s", ERRSTR); 456 457 error = setsockopt(s_src, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv)); 458 if (error == -1) 459 exit_error("setsockopt(SO_SNDTIMEO): %s", ERRSTR); 460 error = setsockopt(s_dst, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv)); 461 if (error == -1) 462 exit_error("setsockopt(SO_SNDTIMEO): %s", ERRSTR); 463 464 error = connect(s_dst, sa4, sa4->sa_family); 465 if (error == -1) 466 exit_failure("connect: %s", ERRSTR); 467 468 switch (hport) { 469 case FTP_PORT: 470 ftp_relay(s_src, s_dst); 471 break; 472 case RSH_PORT: 473 rsh_relay(s_src, s_dst); 474 break; 475 default: 476 tcp_relay(s_src, s_dst, service); 477 break; 478 } 479 480 /* NOTREACHED */ 481 } 482 483 /* 0: non faith, 1: faith */ 484 static int 485 faith_prefix(struct sockaddr *dst) 486 { 487 #ifndef USE_ROUTE 488 int mib[4], size; 489 struct in6_addr faith_prefix; 490 struct sockaddr_in6 *dst6 = (struct sockaddr_in *)dst; 491 492 if (dst->sa_family != AF_INET6) 493 return 0; 494 495 mib[0] = CTL_NET; 496 mib[1] = PF_INET6; 497 mib[2] = IPPROTO_IPV6; 498 mib[3] = IPV6CTL_FAITH_PREFIX; 499 size = sizeof(struct in6_addr); 500 if (sysctl(mib, 4, &faith_prefix, &size, NULL, 0) < 0) 501 exit_error("sysctl: %s", ERRSTR); 502 503 if (memcmp(dst, &faith_prefix, 504 sizeof(struct in6_addr) - sizeof(struct in_addr) == 0) { 505 return 1; 506 } 507 return 0; 508 #else 509 struct myaddrs *p; 510 struct sockaddr_in6 *sin6; 511 struct sockaddr_in *sin4; 512 struct sockaddr_in6 *dst6; 513 struct sockaddr_in *dst4; 514 struct sockaddr_in dstmap; 515 516 dst6 = (struct sockaddr_in6 *)dst; 517 if (dst->sa_family == AF_INET6 518 && IN6_IS_ADDR_V4MAPPED(&dst6->sin6_addr)) { 519 /* ugly... */ 520 memset(&dstmap, 0, sizeof(dstmap)); 521 dstmap.sin_family = AF_INET; 522 dstmap.sin_len = sizeof(dstmap); 523 memcpy(&dstmap.sin_addr, &dst6->sin6_addr.s6_addr[12], 524 sizeof(dstmap.sin_addr)); 525 dst = (struct sockaddr *)&dstmap; 526 } 527 528 dst6 = (struct sockaddr_in6 *)dst; 529 dst4 = (struct sockaddr_in *)dst; 530 531 for (p = myaddrs; p; p = p->next) { 532 sin6 = (struct sockaddr_in6 *)p->addr; 533 sin4 = (struct sockaddr_in *)p->addr; 534 535 if (p->addr->sa_len != dst->sa_len 536 || p->addr->sa_family != dst->sa_family) 537 continue; 538 539 switch (dst->sa_family) { 540 case AF_INET6: 541 if (sin6->sin6_scope_id == dst6->sin6_scope_id 542 && IN6_ARE_ADDR_EQUAL(&sin6->sin6_addr, &dst6->sin6_addr)) 543 return 0; 544 break; 545 case AF_INET: 546 if (sin4->sin_addr.s_addr == dst4->sin_addr.s_addr) 547 return 0; 548 break; 549 } 550 } 551 return 1; 552 #endif 553 } 554 555 /* 0: non faith, 1: faith */ 556 static int 557 map6to4(struct sockaddr_in6 *dst6, struct sockaddr_in *dst4) 558 { 559 memset(dst4, 0, sizeof(*dst4)); 560 dst4->sin_len = sizeof(*dst4); 561 dst4->sin_family = AF_INET; 562 dst4->sin_port = dst6->sin6_port; 563 memcpy(&dst4->sin_addr, &dst6->sin6_addr.s6_addr[12], 564 sizeof(dst4->sin_addr)); 565 566 if (dst4->sin_addr.s_addr == INADDR_ANY 567 || dst4->sin_addr.s_addr == INADDR_BROADCAST 568 || IN_MULTICAST(dst4->sin_addr.s_addr)) 569 return 0; 570 571 return 1; 572 } 573 574 #ifdef FAITH4 575 /* 0: non faith, 1: faith */ 576 static int 577 map4to6(struct sockaddr_in *dst4, struct sockaddr_in6 *dst6) 578 { 579 char host[NI_MAXHOST]; 580 char serv[NI_MAXSERV]; 581 struct addrinfo hints, *res; 582 int ai_errno; 583 584 if (getnameinfo((struct sockaddr *)dst4, dst4->sin_len, host, sizeof(host), 585 serv, sizeof(serv), NI_NAMEREQD|NI_NUMERICSERV) != 0) 586 return 0; 587 588 memset(&hints, 0, sizeof(hints)); 589 hints.ai_flags = 0; 590 hints.ai_family = AF_INET6; 591 hints.ai_socktype = SOCK_STREAM; 592 hints.ai_protocol = 0; 593 594 if ((ai_errno = getaddrinfo(host, serv, &hints, &res)) != 0) { 595 syslog(LOG_INFO, "%s %s: %s", host, serv, gai_strerror(ai_errno)); 596 return 0; 597 } 598 599 memcpy(dst6, res->ai_addr, res->ai_addrlen); 600 601 freeaddrinfo(res); 602 603 return 1; 604 } 605 #endif /* FAITH4 */ 606 607 static void 608 sig_child(int sig) 609 { 610 int status; 611 pid_t pid; 612 613 pid = wait3(&status, WNOHANG, (struct rusage *)0); 614 if (pid && status) 615 syslog(LOG_WARNING, "child %d exit status 0x%x", pid, status); 616 } 617 618 void 619 sig_terminate(int sig) 620 { 621 syslog(LOG_INFO, "Terminating faith daemon"); 622 exit(EXIT_SUCCESS); 623 } 624 625 static void 626 start_daemon(void) 627 { 628 if (daemon(0, 0) == -1) 629 exit_error("daemon: %s", ERRSTR); 630 631 if (signal(SIGCHLD, sig_child) == SIG_ERR) 632 exit_failure("signal CHLD: %s", ERRSTR); 633 634 if (signal(SIGTERM, sig_terminate) == SIG_ERR) 635 exit_failure("signal TERM: %s", ERRSTR); 636 } 637 638 void 639 exit_error(const char *fmt, ...) 640 { 641 va_list ap; 642 char buf[BUFSIZ]; 643 644 va_start(ap, fmt); 645 vsprintf(buf, fmt, ap); 646 va_end(ap); 647 fprintf(stderr, "%s\n", buf); 648 exit(EXIT_FAILURE); 649 } 650 651 void 652 exit_failure(const char *fmt, ...) 653 { 654 va_list ap; 655 char buf[BUFSIZ]; 656 657 va_start(ap, fmt); 658 vsprintf(buf, fmt, ap); 659 va_end(ap); 660 syslog(LOG_ERR, buf); 661 exit(EXIT_FAILURE); 662 } 663 664 void 665 exit_success(const char *fmt, ...) 666 { 667 va_list ap; 668 char buf[BUFSIZ]; 669 670 va_start(ap, fmt); 671 vsprintf(buf, fmt, ap); 672 va_end(ap); 673 syslog(LOG_INFO, buf); 674 exit(EXIT_SUCCESS); 675 } 676 677 #ifdef USE_ROUTE 678 static unsigned int 679 if_maxindex() 680 { 681 struct if_nameindex *p, *p0; 682 unsigned int max = 0; 683 684 p0 = if_nameindex(); 685 for (p = p0; p && p->if_index && p->if_name; p++) { 686 if (max < p->if_index) 687 max = p->if_index; 688 } 689 if_freenameindex(p0); 690 return max; 691 } 692 693 static void 694 grab_myaddrs() 695 { 696 int s; 697 unsigned int maxif; 698 struct ifreq *iflist; 699 struct ifconf ifconf; 700 struct ifreq *ifr, *ifr_end; 701 struct myaddrs *p; 702 struct sockaddr_in6 *sin6; 703 704 maxif = if_maxindex() + 1; 705 iflist = (struct ifreq *)malloc(maxif * BUFSIZ); /* XXX */ 706 if (!iflist) { 707 exit_failure("not enough core"); 708 /*NOTREACHED*/ 709 } 710 711 if ((s = socket(PF_INET, SOCK_DGRAM, 0)) < 0) { 712 exit_failure("socket(SOCK_DGRAM)"); 713 /*NOTREACHED*/ 714 } 715 memset(&ifconf, 0, sizeof(ifconf)); 716 ifconf.ifc_req = iflist; 717 ifconf.ifc_len = maxif * BUFSIZ; /* XXX */ 718 if (ioctl(s, SIOCGIFCONF, &ifconf) < 0) { 719 exit_failure("ioctl(SIOCGIFCONF)"); 720 /*NOTREACHED*/ 721 } 722 close(s); 723 724 /* Look for this interface in the list */ 725 ifr_end = (struct ifreq *) (ifconf.ifc_buf + ifconf.ifc_len); 726 for (ifr = ifconf.ifc_req; 727 ifr < ifr_end; 728 ifr = (struct ifreq *) ((char *) &ifr->ifr_addr 729 + ifr->ifr_addr.sa_len)) { 730 switch (ifr->ifr_addr.sa_family) { 731 case AF_INET: 732 case AF_INET6: 733 p = (struct myaddrs *)malloc(sizeof(struct myaddrs) 734 + ifr->ifr_addr.sa_len); 735 if (!p) { 736 exit_failure("not enough core"); 737 /*NOTREACHED*/ 738 } 739 memcpy(p + 1, &ifr->ifr_addr, ifr->ifr_addr.sa_len); 740 p->next = myaddrs; 741 p->addr = (struct sockaddr *)(p + 1); 742 #ifdef __KAME__ 743 if (ifr->ifr_addr.sa_family == AF_INET6) { 744 sin6 = (struct sockaddr_in6 *)p->addr; 745 if (IN6_IS_ADDR_LINKLOCAL(&sin6->sin6_addr) 746 || IN6_IS_ADDR_SITELOCAL(&sin6->sin6_addr)) { 747 sin6->sin6_scope_id = 748 ntohs(*(u_int16_t *)&sin6->sin6_addr.s6_addr[2]); 749 sin6->sin6_addr.s6_addr[2] = 0; 750 sin6->sin6_addr.s6_addr[3] = 0; 751 } 752 } 753 #endif 754 myaddrs = p; 755 if (dflag) { 756 char hbuf[NI_MAXHOST]; 757 getnameinfo(p->addr, p->addr->sa_len, 758 hbuf, sizeof(hbuf), NULL, 0, 759 NI_NUMERICHOST); 760 syslog(LOG_INFO, "my interface: %s %s", hbuf, ifr->ifr_name); 761 } 762 break; 763 default: 764 break; 765 } 766 } 767 768 free(iflist); 769 } 770 771 static void 772 free_myaddrs() 773 { 774 struct myaddrs *p, *q; 775 776 p = myaddrs; 777 while (p) { 778 q = p->next; 779 free(p); 780 p = q; 781 } 782 myaddrs = NULL; 783 } 784 785 static void 786 update_myaddrs() 787 { 788 char msg[BUFSIZ]; 789 int len; 790 struct rt_msghdr *rtm; 791 792 len = read(sockfd, msg, sizeof(msg)); 793 if (len < 0) { 794 syslog(LOG_ERR, "read(PF_ROUTE) failed"); 795 return; 796 } 797 rtm = (struct rt_msghdr *)msg; 798 if (len < 4 || len < rtm->rtm_msglen) { 799 syslog(LOG_ERR, "read(PF_ROUTE) short read"); 800 return; 801 } 802 if (rtm->rtm_version != RTM_VERSION) { 803 syslog(LOG_ERR, "routing socket version mismatch"); 804 close(sockfd); 805 sockfd = 0; 806 return; 807 } 808 switch (rtm->rtm_type) { 809 case RTM_NEWADDR: 810 case RTM_DELADDR: 811 case RTM_IFINFO: 812 break; 813 default: 814 return; 815 } 816 /* XXX more filters here? */ 817 818 syslog(LOG_INFO, "update interface address list"); 819 free_myaddrs(); 820 grab_myaddrs(); 821 } 822 #endif /*USE_ROUTE*/ 823 824 static void 825 usage() 826 { 827 fprintf(stderr, "usage: %s [-dp] [service [serverpath [serverargs]]]\n", 828 faithdname); 829 exit(0); 830 } 831
Indexes created Tue Sep 30 06:09:59 GMT 2025