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