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