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