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