1 /* 2 * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 3 * Use is subject to license terms. 4 * 5 * Copyright (c) 1983, 1988, 1993 6 * The Regents of the University of California. 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. All advertising materials mentioning features or use of this software 17 * must display the following acknowledgment: 18 * This product includes software developed by the University of 19 * California, Berkeley and its contributors. 20 * 4. Neither the name of the University nor the names of its contributors 21 * may be used to endorse or promote products derived from this software 22 * without specific prior written permission. 23 * 24 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 25 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 27 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 28 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 29 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 30 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 31 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 32 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 33 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 34 * SUCH DAMAGE. 35 * 36 * $FreeBSD: src/sbin/routed/main.c,v 1.14 2000/08/11 08:24:38 sheldonh Exp $ 37 * char copyright[] = "@(#) Copyright (c) 1983, 1988, 1993\n" 38 * " The Regents of the University of California. All rights reserved.\n"; 39 */ 40 41 #include "defs.h" 42 #include "pathnames.h" 43 #include <signal.h> 44 #include <fcntl.h> 45 #include <sys/file.h> 46 #include <userdefs.h> 47 #include <sys/stat.h> 48 49 #define IN_ROUTED_VERSION "2.22" 50 51 int stopint; 52 boolean_t supplier; /* supply or broadcast updates */ 53 boolean_t supplier_set; 54 /* -S option. _B_TRUE=treat all RIP speakers as default routers. */ 55 boolean_t save_space = _B_FALSE; 56 57 static boolean_t default_gateway; /* _B_TRUE=advertise default */ 58 static boolean_t background = _B_TRUE; 59 boolean_t ridhosts; /* _B_TRUE=reduce host routes */ 60 boolean_t mhome; /* _B_TRUE=want multi-homed host route */ 61 boolean_t advertise_mhome; /* _B_TRUE=must continue advertising it */ 62 boolean_t auth_ok = _B_TRUE; /* _B_TRUE=ignore auth if we don't care */ 63 boolean_t no_install; /* _B_TRUE=don't install in kernel */ 64 65 struct timeval epoch; /* when started */ 66 struct timeval clk; 67 static struct timeval prev_clk; 68 static int usec_fudge; 69 struct timeval now; /* current idea of time */ 70 /* If a route's rts_time is <= to now_stale, the route is stale. */ 71 time_t now_stale; 72 /* If a route's rts_time is <= to now_expire, the route is expired */ 73 time_t now_expire; 74 /* If a route's rts_time is <= to now_garbage, the route needs to be deleted */ 75 time_t now_garbage; 76 77 static struct timeval next_bcast; /* next general broadcast */ 78 struct timeval no_flash = { /* inhibit flash update */ 79 EPOCH+SUPPLY_INTERVAL, 0 80 }; 81 82 /* When now reaches this time, it's time to call sync_kern() */ 83 static struct timeval sync_kern_timer; 84 85 static fd_set fdbits; 86 static int sock_max; 87 int rip_sock = -1; /* RIP socket */ 88 boolean_t rip_enabled; 89 static boolean_t openlog_done; 90 91 /* 92 * The interface to which rip_sock is currently pointing for 93 * output. 94 */ 95 struct interface *rip_sock_interface; 96 97 int rt_sock; /* routing socket */ 98 99 100 static int open_rip_sock(); 101 static void timevalsub(struct timeval *, struct timeval *, struct timeval *); 102 static void sigalrm(int); 103 static void sigterm(int); 104 105 int 106 main(int argc, char *argv[]) 107 { 108 int n, off; 109 char *p, *q; 110 const char *cp; 111 struct timeval select_timeout, result; 112 fd_set ibits; 113 in_addr_t p_net, p_mask; 114 struct parm parm; 115 char *tracename = NULL; 116 boolean_t vflag = _B_FALSE; 117 boolean_t version = _B_FALSE; 118 int sigerr = 0; 119 FILE *pidfp; 120 mode_t pidmode = (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH); /* 0644 */ 121 122 (void) setlocale(LC_ALL, ""); 123 124 #if !defined(TEXT_DOMAIN) /* Should be defined by cc -D */ 125 #define TEXT_DOMAIN "SYS_TEXT" 126 #endif /* ! TEXT_DOMAIN */ 127 128 (void) textdomain(TEXT_DOMAIN); 129 130 /* 131 * Some shells are badly broken and send SIGHUP to backgrounded 132 * processes. 133 */ 134 if (signal(SIGHUP, SIG_IGN) == SIG_ERR) 135 sigerr = errno; 136 137 ftrace = stdout; 138 139 if (gettimeofday(&clk, 0) == -1) { 140 logbad(_B_FALSE, "gettimeofday: %s", rip_strerror(errno)); 141 } 142 prev_clk = clk; 143 epoch = clk; 144 epoch.tv_sec -= EPOCH; 145 now.tv_sec = EPOCH; 146 now_stale = EPOCH - STALE_TIME; 147 now_expire = EPOCH - EXPIRE_TIME; 148 now_garbage = EPOCH - GARBAGE_TIME; 149 select_timeout.tv_sec = 0; 150 151 while ((n = getopt(argc, argv, "sSqdghmpAztVvnT:F:P:")) != -1) { 152 switch (n) { 153 case 'A': 154 /* 155 * Ignore authentication if we do not care. 156 * Crazy as it is, that is what RFC 2453 requires. 157 */ 158 auth_ok = _B_FALSE; 159 break; 160 161 case 't': 162 if (new_tracelevel < 2) 163 new_tracelevel = 2; 164 background = _B_FALSE; 165 break; 166 167 case 'd': /* put in.routed in foreground */ 168 background = _B_FALSE; 169 break; 170 171 case 'F': /* minimal routes for SLIP */ 172 n = FAKE_METRIC; 173 p = strchr(optarg, ','); 174 if (p != NULL) { 175 n = (int)strtoul(p+1, &q, 0); 176 if (*q == '\0' && p+1 != q && 177 n <= HOPCNT_INFINITY-1 && n >= 1) 178 *p = '\0'; 179 } 180 if (!getnet(optarg, &p_net, &p_mask)) { 181 if (p != NULL) 182 *p = ','; 183 msglog(gettext("bad network; \"-F %s\""), 184 optarg); 185 break; 186 } 187 (void) memset(&parm, 0, sizeof (parm)); 188 parm.parm_net = p_net; 189 parm.parm_mask = p_mask; 190 parm.parm_d_metric = n; 191 cp = insert_parm(&parm); 192 if (cp != NULL) 193 msglog(gettext("bad -F: %s"), cp); 194 break; 195 196 case 'g': 197 (void) memset(&parm, 0, sizeof (parm)); 198 parm.parm_d_metric = 1; 199 cp = insert_parm(&parm); 200 if (cp != NULL) 201 msglog(gettext("bad -g: %s"), cp); 202 else 203 default_gateway = _B_TRUE; 204 break; 205 206 case 'h': /* suppress extra host routes */ 207 ridhosts = _B_TRUE; 208 break; 209 210 case 'm': /* advertise host route */ 211 mhome = _B_TRUE; /* on multi-homed hosts */ 212 break; 213 214 case 'n': /* No-install mode */ 215 no_install = _B_TRUE; 216 break; 217 218 case 'P': 219 /* handle arbitrary parameters. */ 220 q = strdup(optarg); 221 if (q == NULL) 222 logbad(_B_FALSE, "strdup: %s", 223 rip_strerror(errno)); 224 cp = parse_parms(q, _B_FALSE); 225 if (cp != NULL) 226 msglog(gettext("%1$s in \"-P %2$s\""), cp, 227 optarg); 228 free(q); 229 break; 230 231 case 'q': 232 supplier = _B_FALSE; 233 supplier_set = _B_TRUE; 234 break; 235 236 case 's': 237 supplier = _B_TRUE; 238 supplier_set = _B_TRUE; 239 break; 240 241 case 'S': /* save-space option */ 242 save_space = _B_TRUE; 243 break; 244 245 case 'T': 246 tracename = optarg; 247 break; 248 249 case 'V': 250 /* display version */ 251 version = _B_TRUE; 252 msglog(gettext("version " IN_ROUTED_VERSION)); 253 break; 254 255 case 'v': 256 /* display route changes to supplied logfile */ 257 new_tracelevel = 1; 258 vflag = _B_TRUE; 259 break; 260 261 case 'z': /* increase debug-level */ 262 new_tracelevel++; 263 break; 264 265 default: 266 goto usage; 267 } 268 } 269 argc -= optind; 270 argv += optind; 271 272 if (tracename == NULL && argc >= 1) { 273 tracename = *argv++; 274 argc--; 275 } 276 if (tracename != NULL && tracename[0] == '\0') 277 goto usage; 278 if (vflag && tracename == NULL) 279 goto usage; 280 if (argc != 0) { 281 usage: 282 (void) fprintf(stderr, gettext( 283 "usage: in.routed [-AdghmnqsStVvz] " 284 "[-T <tracefile>]\n")); 285 (void) fprintf(stderr, 286 gettext("\t[-F <net>[/<mask>][,<metric>]] [-P <parms>]\n")); 287 logbad(_B_FALSE, gettext("excess arguments")); 288 } 289 if (geteuid() != 0) { 290 /* 291 * Regular users are allowed to run in.routed for the 292 * sole purpose of obtaining the version number. In 293 * that case, exit(EXIT_SUCCESS) without complaining. 294 */ 295 if (version) 296 exit(EXIT_SUCCESS); 297 logbad(_B_FALSE, gettext("requires UID 0")); 298 } 299 300 if (default_gateway) { 301 if (supplier_set && !supplier) { 302 msglog(gettext("-g and -q are incompatible")); 303 } else { 304 supplier = _B_TRUE; 305 supplier_set = _B_TRUE; 306 } 307 } 308 309 if (signal(SIGALRM, sigalrm) == SIG_ERR) 310 sigerr = errno; 311 /* SIGHUP fatal during debugging */ 312 if (!background) 313 if (signal(SIGHUP, sigterm) == SIG_ERR) 314 sigerr = errno; 315 if (signal(SIGTERM, sigterm) == SIG_ERR) 316 sigerr = errno; 317 if (signal(SIGINT, sigterm) == SIG_ERR) 318 sigerr = errno; 319 if (signal(SIGUSR1, sigtrace_more) == SIG_ERR) 320 sigerr = errno; 321 if (signal(SIGUSR2, sigtrace_less) == SIG_ERR) 322 sigerr = errno; 323 if (signal(SIGHUP, sigtrace_dump) == SIG_ERR) 324 sigerr = errno; 325 326 if (sigerr) 327 msglog("signal: %s", rip_strerror(sigerr)); 328 329 /* get into the background */ 330 if (background && daemon(0, 0) < 0) 331 BADERR(_B_FALSE, "daemon()"); 332 333 /* Store our process id, blow away any existing file if it exists. */ 334 if ((pidfp = fopen(PATH_PID, "w")) == NULL) { 335 (void) fprintf(stderr, 336 gettext("in.routed: unable to open " PATH_PID ": %s\n"), 337 strerror(errno)); 338 } else { 339 (void) fprintf(pidfp, "%ld\n", getpid()); 340 (void) fclose(pidfp); 341 (void) chmod(PATH_PID, pidmode); 342 } 343 344 srandom((int)(clk.tv_sec ^ clk.tv_usec ^ getpid())); 345 346 /* allocate the interface tables */ 347 iftbl_alloc(); 348 349 /* prepare socket connected to the kernel. */ 350 rt_sock = socket(PF_ROUTE, SOCK_RAW, AF_INET); 351 if (rt_sock < 0) 352 BADERR(_B_TRUE, "rt_sock = socket()"); 353 if (fcntl(rt_sock, F_SETFL, O_NONBLOCK) == -1) 354 logbad(_B_TRUE, "fcntl(rt_sock) O_NONBLOCK: %s", 355 rip_strerror(errno)); 356 off = 0; 357 if (setsockopt(rt_sock, SOL_SOCKET, SO_USELOOPBACK, 358 &off, sizeof (off)) < 0) 359 LOGERR("setsockopt(SO_USELOOPBACK,0)"); 360 361 fix_select(); 362 363 364 if (tracename != NULL) { 365 (void) strlcpy(inittracename, tracename, 366 sizeof (inittracename)); 367 set_tracefile(inittracename, "%s", -1); 368 } else { 369 tracelevel_msg("%s", -1); /* turn on tracing to stdio */ 370 } 371 372 bufinit(); 373 374 /* initialize radix tree */ 375 rtinit(); 376 377 /* 378 * Pick a random part of the second for our output to minimize 379 * collisions. 380 * 381 * Start broadcasting after hearing from other routers, and 382 * at a random time so a bunch of systems do not get synchronized 383 * after a power failure. 384 * 385 * Since now is the number of seconds since epoch (this is initially 386 * EPOCH seconds), these times are really relative to now. 387 */ 388 intvl_random(&next_bcast, EPOCH+MIN_WAITTIME, EPOCH+SUPPLY_INTERVAL); 389 age_timer.tv_usec = next_bcast.tv_usec; 390 age_timer.tv_sec = EPOCH+MIN_WAITTIME; 391 rdisc_timer = next_bcast; 392 ifscan_timer.tv_usec = next_bcast.tv_usec; 393 394 /* 395 * Open the global rip socket. From now on, this socket can be 396 * assumed to be open. It will remain open until in.routed 397 * exits. 398 */ 399 rip_sock = open_rip_sock(); 400 401 /* 402 * Collect an initial view of the world by checking the interface 403 * configuration and the kludge file. 404 * 405 * gwkludge() could call addroutefordefault(), resulting in a call to 406 * iflookup, and thus ifscan() to find the physical interfaces. 407 * ifscan() will attempt to use the rip_sock in order to join 408 * mcast groups, so gwkludge *must* be called after opening 409 * the rip_sock. 410 */ 411 gwkludge(); 412 413 ifscan(); 414 415 /* Ask for routes */ 416 rip_query(); 417 rdisc_sol(); 418 419 /* Now turn off stdio if not tracing */ 420 if (new_tracelevel == 0) 421 trace_close(background); 422 423 /* Loop until a fatal error occurs, listening and broadcasting. */ 424 for (;;) { 425 prev_clk = clk; 426 if (gettimeofday(&clk, 0) == -1) { 427 logbad(_B_FALSE, "gettimeofday: %s", 428 rip_strerror(errno)); 429 } 430 if (prev_clk.tv_sec == clk.tv_sec && 431 prev_clk.tv_usec == clk.tv_usec+usec_fudge) { 432 /* 433 * Much of `in.routed` depends on time always advancing. 434 * On systems that do not guarantee that gettimeofday() 435 * produces unique timestamps even if called within 436 * a single tick, use trickery like that in classic 437 * BSD kernels. 438 */ 439 clk.tv_usec += ++usec_fudge; 440 441 } else { 442 time_t dt; 443 444 usec_fudge = 0; 445 446 timevalsub(&result, &clk, &prev_clk); 447 if (result.tv_sec < 0 || result.tv_sec > 448 select_timeout.tv_sec + 5) { 449 /* 450 * Deal with time changes before other 451 * housekeeping to keep everything straight. 452 */ 453 dt = result.tv_sec; 454 if (dt > 0) 455 dt -= select_timeout.tv_sec; 456 trace_act("time changed by %d sec", (int)dt); 457 epoch.tv_sec += dt; 458 } 459 } 460 timevalsub(&now, &clk, &epoch); 461 now_stale = now.tv_sec - STALE_TIME; 462 now_expire = now.tv_sec - EXPIRE_TIME; 463 now_garbage = now.tv_sec - GARBAGE_TIME; 464 465 /* deal with signals that should affect tracing */ 466 set_tracelevel(); 467 468 if (stopint != 0) { 469 trace_off("exiting with signal %d", stopint); 470 break; 471 } 472 473 /* look for new or dead interfaces */ 474 timevalsub(&select_timeout, &ifscan_timer, &now); 475 if (select_timeout.tv_sec <= 0) { 476 select_timeout.tv_sec = 0; 477 ifscan(); 478 rip_query(); 479 continue; 480 } 481 482 /* 483 * Check the kernel table occassionally for mysteriously 484 * evaporated routes 485 */ 486 timevalsub(&result, &sync_kern_timer, &now); 487 if (result.tv_sec <= 0) { 488 sync_kern(); 489 sync_kern_timer.tv_sec = (now.tv_sec 490 + CHECK_QUIET_INTERVAL); 491 continue; 492 } 493 if (timercmp(&result, &select_timeout, < /* */)) 494 select_timeout = result; 495 496 /* If it is time, then broadcast our routes. */ 497 if (should_supply(NULL) || advertise_mhome) { 498 timevalsub(&result, &next_bcast, &now); 499 if (result.tv_sec <= 0) { 500 /* 501 * Synchronize the aging and broadcast 502 * timers to minimize awakenings 503 */ 504 age(0); 505 age_peer_info(); 506 507 rip_bcast(0); 508 509 /* 510 * It is desirable to send routing updates 511 * regularly. So schedule the next update 512 * 30 seconds after the previous one was 513 * scheduled, instead of 30 seconds after 514 * the previous update was finished. 515 * Even if we just started after discovering 516 * a 2nd interface or were otherwise delayed, 517 * pick a 30-second aniversary of the 518 * original broadcast time. 519 */ 520 n = 1 + (0-result.tv_sec)/SUPPLY_INTERVAL; 521 next_bcast.tv_sec += n*SUPPLY_INTERVAL; 522 523 continue; 524 } 525 526 if (timercmp(&result, &select_timeout, < /* */)) 527 select_timeout = result; 528 } 529 530 /* 531 * If we need a flash update, either do it now or 532 * set the delay to end when it is time. 533 * 534 * If we are within MIN_WAITTIME seconds of a full update, 535 * do not bother. 536 */ 537 if (need_flash && should_supply(NULL) && 538 no_flash.tv_sec+MIN_WAITTIME < next_bcast.tv_sec) { 539 /* accurate to the millisecond */ 540 if (!timercmp(&no_flash, &now, > /* */)) 541 rip_bcast(1); 542 timevalsub(&result, &no_flash, &now); 543 if (timercmp(&result, &select_timeout, < /* */)) 544 select_timeout = result; 545 } 546 547 /* trigger the main aging timer. */ 548 timevalsub(&result, &age_timer, &now); 549 if (result.tv_sec <= 0) { 550 age(0); 551 continue; 552 } 553 if (timercmp(&result, &select_timeout, < /* */)) 554 select_timeout = result; 555 556 /* update the kernel routing table */ 557 timevalsub(&result, &need_kern, &now); 558 if (result.tv_sec <= 0) { 559 age(0); 560 continue; 561 } 562 if (timercmp(&result, &select_timeout, < /* */)) 563 select_timeout = result; 564 565 /* 566 * take care of router discovery. We compare timeval 567 * structures here to have millisecond granularity. 568 */ 569 if (!timercmp(&rdisc_timer, &now, > /* */)) { 570 rdisc_age(0); 571 continue; 572 } 573 timevalsub(&result, &rdisc_timer, &now); 574 if (timercmp(&result, &select_timeout, < /* */)) 575 select_timeout = result; 576 577 /* 578 * Well-known bit of select(3c) silliness inherited 579 * from BSD: anything over 100 million seconds is 580 * considered an "error." Reset that to zero. 581 */ 582 if (select_timeout.tv_sec > 100000000) 583 select_timeout.tv_sec = 0; 584 585 /* wait for input or a timer to expire. */ 586 trace_flush(); 587 ibits = fdbits; 588 n = select(sock_max, &ibits, 0, 0, &select_timeout); 589 if (n <= 0) { 590 if (n < 0 && errno != EINTR && errno != EAGAIN) 591 BADERR(_B_TRUE, "select"); 592 continue; 593 } 594 595 if (FD_ISSET(rt_sock, &ibits)) { 596 read_rt(); 597 n--; 598 } 599 if (rdisc_sock >= 0 && FD_ISSET(rdisc_sock, &ibits)) { 600 read_d(); 601 n--; 602 } 603 if (rdisc_mib_sock >= 0 && FD_ISSET(rdisc_mib_sock, &ibits)) { 604 process_d_mib_sock(); 605 n--; 606 } 607 if (rip_sock >= 0 && FD_ISSET(rip_sock, &ibits)) { 608 if (read_rip() == -1) { 609 rip_enabled = _B_FALSE; 610 trace_off("main rip socket failed"); 611 (void) close(rip_sock); 612 rip_sock = -1; 613 fix_select(); 614 break; 615 } 616 n--; 617 } 618 } 619 rip_bcast(0); 620 rdisc_adv(_B_FALSE); 621 (void) unlink(PATH_PID); 622 return (stopint | 128); 623 } 624 625 626 static void 627 sigalrm(int sig) 628 { 629 /* 630 * Historically, SIGALRM would cause the daemon to check for 631 * new and broken interfaces. 632 */ 633 ifscan_timer.tv_sec = now.tv_sec; 634 trace_act("SIGALRM"); 635 if (signal(sig, sigalrm) == SIG_ERR) 636 msglog("signal: %s", rip_strerror(errno)); 637 } 638 639 640 /* watch for fatal signals */ 641 static void 642 sigterm(int sig) 643 { 644 stopint = sig; 645 if (signal(sig, SIG_DFL) == SIG_ERR) /* catch it only once */ 646 msglog("signal: %s", rip_strerror(errno)); 647 } 648 649 650 void 651 fix_select(void) 652 { 653 (void) FD_ZERO(&fdbits); 654 sock_max = 0; 655 656 FD_SET(rt_sock, &fdbits); 657 if (sock_max <= rt_sock) 658 sock_max = rt_sock+1; 659 if (rip_sock >= 0) { 660 FD_SET(rip_sock, &fdbits); 661 if (sock_max <= rip_sock) 662 sock_max = rip_sock+1; 663 } 664 if (rdisc_sock >= 0) { 665 FD_SET(rdisc_sock, &fdbits); 666 if (sock_max <= rdisc_sock) 667 sock_max = rdisc_sock+1; 668 FD_SET(rdisc_mib_sock, &fdbits); 669 if (sock_max <= rdisc_mib_sock) 670 sock_max = rdisc_mib_sock+1; 671 } 672 } 673 674 675 void 676 fix_sock(int sock, 677 const char *name) 678 { 679 int on; 680 #define MIN_SOCKBUF (4*1024) 681 static int rbuf; 682 683 if (fcntl(sock, F_SETFL, O_NONBLOCK) == -1) 684 logbad(_B_TRUE, "fcntl(%s) O_NONBLOCK: %s", name, 685 rip_strerror(errno)); 686 on = 1; 687 if (setsockopt(sock, SOL_SOCKET, SO_BROADCAST, &on, sizeof (on)) < 0) 688 msglog("setsockopt(%s,SO_BROADCAST): %s", 689 name, rip_strerror(errno)); 690 691 if (rbuf >= MIN_SOCKBUF) { 692 if (setsockopt(sock, SOL_SOCKET, SO_RCVBUF, 693 &rbuf, sizeof (rbuf)) < 0) 694 msglog("setsockopt(%s,SO_RCVBUF=%d): %s", 695 name, rbuf, rip_strerror(errno)); 696 } else { 697 for (rbuf = 60*1024; ; rbuf -= 4096) { 698 if (setsockopt(sock, SOL_SOCKET, SO_RCVBUF, 699 &rbuf, sizeof (rbuf)) == 0) { 700 trace_act("RCVBUF=%d", rbuf); 701 break; 702 } 703 if (rbuf < MIN_SOCKBUF) { 704 msglog("setsockopt(%s,SO_RCVBUF = %d): %s", 705 name, rbuf, rip_strerror(errno)); 706 break; 707 } 708 } 709 } 710 } 711 712 713 /* 714 * Open and return the global rip socket. It is guaranteed to return 715 * a good file descriptor. 716 */ 717 static int 718 open_rip_sock() 719 { 720 struct sockaddr_in sin; 721 unsigned char ttl; 722 int s; 723 int on = 1; 724 725 726 if ((s = socket(PF_INET, SOCK_DGRAM, 0)) < 0) 727 BADERR(_B_TRUE, "rip_sock = socket()"); 728 729 (void) memset(&sin, 0, sizeof (sin)); 730 sin.sin_family = AF_INET; 731 sin.sin_port = htons(RIP_PORT); 732 sin.sin_addr.s_addr = INADDR_ANY; 733 if (bind(s, (struct sockaddr *)&sin, sizeof (sin)) < 0) { 734 BADERR(_B_FALSE, "bind(rip_sock)"); 735 } 736 fix_sock(s, "rip_sock"); 737 738 ttl = 1; 739 if (setsockopt(s, IPPROTO_IP, IP_MULTICAST_TTL, 740 &ttl, sizeof (ttl)) < 0) 741 DBGERR(_B_TRUE, "rip_sock setsockopt(IP_MULTICAST_TTL)"); 742 743 if (setsockopt(s, IPPROTO_IP, IP_RECVIF, &on, sizeof (on))) 744 BADERR(_B_FALSE, "setsockopt(IP_RECVIF)"); 745 746 return (s); 747 } 748 749 750 /* 751 * Disable RIP. Note that we don't close the global rip socket since 752 * it is used even when RIP is disabled to receive and answer certain 753 * queries. 754 */ 755 void 756 rip_off(void) 757 { 758 struct ip_mreq m; 759 struct interface *ifp; 760 char addrstr[INET_ADDRSTRLEN]; 761 762 if (rip_enabled && !mhome) { 763 trace_act("turn off RIP"); 764 765 /* 766 * Unsubscribe from the 224.0.0.9 RIP multicast 767 * group address 768 */ 769 for (ifp = ifnet; ifp != NULL; ifp = ifp->int_next) { 770 if ((ifp->int_if_flags & IFF_MULTICAST) && 771 !IS_IFF_QUIET(ifp->int_if_flags) && 772 !IS_RIP_IN_OFF(ifp->int_state) && 773 !(ifp->int_state & IS_DUP)) { 774 m.imr_multiaddr.s_addr = 775 htonl(INADDR_RIP_GROUP); 776 m.imr_interface.s_addr = 777 (ifp->int_if_flags & IFF_POINTOPOINT) ? 778 ifp->int_dstaddr : ifp->int_addr; 779 (void) strlcpy(addrstr, 780 inet_ntoa(m.imr_multiaddr), 781 sizeof (addrstr)); 782 if (setsockopt(rip_sock, IPPROTO_IP, 783 IP_DROP_MEMBERSHIP, &m, 784 sizeof (m)) < 0 && 785 errno != EADDRNOTAVAIL && errno != ENOENT) 786 writelog(LOG_WARNING, 787 "%s: setsockopt(IP_DROP_MEMBERSHIP " 788 "%s, %s): %s", ifp->int_name, 789 addrstr, inet_ntoa(m.imr_interface), 790 rip_strerror(errno)); 791 } 792 } 793 rip_enabled = _B_FALSE; 794 795 age(0); 796 } 797 } 798 799 800 /* turn on RIP multicast input via an interface */ 801 void 802 rip_mcast_on(struct interface *ifp) 803 { 804 struct ip_mreq m; 805 806 if (!IS_RIP_IN_OFF(ifp->int_state) && 807 (ifp->int_if_flags & IFF_MULTICAST) && 808 !IS_IFF_QUIET(ifp->int_if_flags) && 809 !(ifp->int_state & IS_DUP)) { 810 m.imr_multiaddr.s_addr = htonl(INADDR_RIP_GROUP); 811 m.imr_interface.s_addr = (ifp->int_if_flags & IFF_POINTOPOINT) ? 812 ifp->int_dstaddr : ifp->int_addr; 813 if ((setsockopt(rip_sock, IPPROTO_IP, IP_ADD_MEMBERSHIP, 814 &m, sizeof (m)) < 0) && !(ifp->int_state & IS_BROKE)) 815 writelog(LOG_WARNING, 816 "Could not join 224.0.0.9 on interface %s: %s", 817 ifp->int_name, rip_strerror(errno)); 818 } 819 } 820 821 /* turn off RIP multicast input via an interface */ 822 void 823 rip_mcast_off(struct interface *ifp) 824 { 825 struct ip_mreq m; 826 827 if ((ifp->int_if_flags & IFF_MULTICAST) && 828 !IS_IFF_QUIET(ifp->int_if_flags) && rip_enabled) { 829 m.imr_multiaddr.s_addr = htonl(INADDR_RIP_GROUP); 830 m.imr_interface.s_addr = (ifp->int_if_flags & IFF_POINTOPOINT) ? 831 ifp->int_dstaddr : ifp->int_addr; 832 if ((setsockopt(rip_sock, IPPROTO_IP, IP_DROP_MEMBERSHIP, 833 &m, sizeof (m)) < 0) && errno != EADDRNOTAVAIL && 834 errno != ENOENT) 835 writelog(LOG_WARNING, 836 "setsockopt(IP_DROP_MEMBERSHIP RIP) for %s: %s", 837 ifp->int_name, rip_strerror(errno)); 838 } 839 } 840 841 /* enable RIP */ 842 void 843 rip_on(struct interface *ifp) 844 { 845 /* 846 * If RIP is already enabled, only start receiving 847 * multicasts for this interface. 848 */ 849 if (rip_enabled) { 850 if (ifp != NULL) 851 rip_mcast_on(ifp); 852 return; 853 } 854 855 /* 856 * If RIP is disabled and it makes sense to enable it, then enable 857 * it on all of the interfaces. It makes sense if either router 858 * discovery is off, or if router discovery is on and at most one 859 * interface is doing RIP. 860 */ 861 if (rip_interfaces > 0 && (!rdisc_ok || rip_interfaces > 1)) { 862 trace_act("turn on RIP"); 863 864 rip_enabled = _B_TRUE; 865 rip_sock_interface = NULL; 866 867 /* Do not advertise anything until we have heard something */ 868 if (next_bcast.tv_sec < now.tv_sec+MIN_WAITTIME) 869 next_bcast.tv_sec = now.tv_sec+MIN_WAITTIME; 870 871 for (ifp = ifnet; ifp != NULL; ifp = ifp->int_next) { 872 ifp->int_query_time = NEVER; 873 rip_mcast_on(ifp); 874 } 875 ifscan_timer.tv_sec = now.tv_sec; 876 } 877 878 fix_select(); 879 } 880 881 882 /* die if malloc(3) fails */ 883 void * 884 rtmalloc(size_t size, 885 const char *msg) 886 { 887 void *p = malloc(size); 888 if (p == NULL) 889 logbad(_B_TRUE, "malloc(%lu) failed in %s: %s", (ulong_t)size, 890 msg, rip_strerror(errno)); 891 return (p); 892 } 893 894 895 /* get a random instant in an interval */ 896 void 897 intvl_random(struct timeval *tp, /* put value here */ 898 ulong_t lo, /* value is after this second */ 899 ulong_t hi) /* and before this */ 900 { 901 tp->tv_sec = (time_t)(hi == lo ? lo : (lo + random() % ((hi - lo)))); 902 tp->tv_usec = random() % 1000000; 903 } 904 905 906 void 907 timevaladd(struct timeval *t1, 908 struct timeval *t2) 909 { 910 911 t1->tv_sec += t2->tv_sec; 912 if ((t1->tv_usec += t2->tv_usec) >= 1000000) { 913 t1->tv_sec++; 914 t1->tv_usec -= 1000000; 915 } 916 } 917 918 919 /* t1 = t2 - t3 */ 920 static void 921 timevalsub(struct timeval *t1, 922 struct timeval *t2, 923 struct timeval *t3) 924 { 925 t1->tv_sec = t2->tv_sec - t3->tv_sec; 926 if ((t1->tv_usec = t2->tv_usec - t3->tv_usec) < 0) { 927 t1->tv_sec--; 928 t1->tv_usec += 1000000; 929 } 930 } 931 932 static void 933 do_openlog(void) 934 { 935 openlog_done = _B_TRUE; 936 openlog("in.routed", LOG_PID | LOG_ODELAY, LOG_DAEMON); 937 } 938 939 /* put a LOG_ERR message into the system log */ 940 void 941 msglog(const char *p, ...) 942 { 943 va_list args; 944 945 trace_flush(); 946 947 if (!openlog_done) 948 do_openlog(); 949 va_start(args, p); 950 vsyslog(LOG_ERR, p, args); 951 952 if (ftrace != 0) { 953 if (ftrace == stdout) 954 (void) fputs("in.routed: ", ftrace); 955 (void) vfprintf(ftrace, p, args); 956 (void) fputc('\n', ftrace); 957 } 958 } 959 960 961 /* 962 * Put a message about a bad system into the system log if 963 * we have not complained about it recently. 964 * 965 * It is desirable to complain about all bad systems, but not too often. 966 * In the worst case, it is not practical to keep track of all bad systems. 967 * For example, there can be many systems with the wrong password. 968 */ 969 void 970 msglim(struct msg_limit *lim, in_addr_t addr, const char *p, ...) 971 { 972 va_list args; 973 int i; 974 struct msg_sub *ms1, *ms; 975 const char *p1; 976 977 va_start(args, p); 978 979 /* 980 * look for the oldest slot in the table 981 * or the slot for the bad router. 982 */ 983 ms = ms1 = lim->subs; 984 for (i = MSG_SUBJECT_N; ; i--, ms1++) { 985 if (i == 0) { 986 /* Reuse a slot at most once every 10 minutes. */ 987 if (lim->reuse > now.tv_sec) { 988 ms = NULL; 989 } else { 990 lim->reuse = now.tv_sec + 10*60; 991 } 992 break; 993 } 994 if (ms->addr == addr) { 995 /* 996 * Repeat a complaint about a given system at 997 * most once an hour. 998 */ 999 if (ms->until > now.tv_sec) 1000 ms = NULL; 1001 break; 1002 } 1003 if (ms->until < ms1->until) 1004 ms = ms1; 1005 } 1006 if (ms != NULL) { 1007 ms->addr = addr; 1008 ms->until = now.tv_sec + 60*60; /* 60 minutes */ 1009 1010 if (!openlog_done) 1011 do_openlog(); 1012 trace_flush(); 1013 for (p1 = p; *p1 == ' '; p1++) 1014 continue; 1015 vsyslog(LOG_ERR, p1, args); 1016 } 1017 1018 /* always display the message if tracing */ 1019 if (ftrace != 0) { 1020 (void) vfprintf(ftrace, p, args); 1021 (void) fputc('\n', ftrace); 1022 } 1023 } 1024 1025 1026 void 1027 logbad(boolean_t dump, const char *p, ...) 1028 { 1029 va_list args; 1030 1031 trace_flush(); 1032 1033 if (!openlog_done) 1034 do_openlog(); 1035 va_start(args, p); 1036 vsyslog(LOG_ERR, p, args); 1037 1038 (void) fputs(gettext("in.routed: "), stderr); 1039 (void) vfprintf(stderr, p, args); 1040 (void) fputs(gettext("; giving up\n"), stderr); 1041 (void) fflush(stderr); 1042 1043 if (dump) 1044 abort(); 1045 exit(EXIT_FAILURE); 1046 } 1047 1048 /* put a message into the system log */ 1049 void 1050 writelog(int level, const char *p, ...) 1051 { 1052 va_list args; 1053 1054 trace_flush(); 1055 1056 if (!openlog_done) 1057 do_openlog(); 1058 va_start(args, p); 1059 vsyslog(level, p, args); 1060 1061 if (ftrace != 0) { 1062 if (ftrace == stdout) 1063 (void) fputs("in.routed: ", ftrace); 1064 (void) vfprintf(ftrace, p, args); 1065 (void) fputc('\n', ftrace); 1066 } 1067 } 1068