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