1 /* 2 * Copyright (c) 1983, 1988, 1993 3 * The Regents of the University of California. All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 3. Neither the name of the University nor the names of its contributors 14 * may be used to endorse or promote products derived from this software 15 * without specific prior written permission. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 * 29 * @(#)main.c 8.1 (Berkeley) 6/5/93 30 * $FreeBSD: src/sbin/routed/main.c,v 1.11.2.1 2000/08/14 17:00:03 sheldonh Exp $ 31 */ 32 33 #include "defs.h" 34 #include "pathnames.h" 35 #include <signal.h> 36 #include <fcntl.h> 37 #include <sys/file.h> 38 39 pid_t mypid; 40 41 naddr myaddr; /* system address */ 42 char myname[MAXHOSTNAMELEN+1]; 43 44 int verbose; 45 46 int supplier; /* supply or broadcast updates */ 47 int supplier_set; 48 int ipforwarding = 1; /* kernel forwarding on */ 49 50 int default_gateway; /* 1=advertise default */ 51 int background = 1; 52 int ridhosts; /* 1=reduce host routes */ 53 int mhome; /* 1=want multi-homed host route */ 54 int advertise_mhome; /* 1=must continue advertising it */ 55 int auth_ok = 1; /* 1=ignore auth if we do not care */ 56 57 struct timeval epoch; /* when started */ 58 struct timeval clk, prev_clk; 59 static int usec_fudge; 60 struct timeval now; /* current idea of time */ 61 time_t now_stale; 62 time_t now_expire; 63 time_t now_garbage; 64 65 struct timeval next_bcast; /* next general broadcast */ 66 struct timeval no_flash = { /* inhibit flash update */ 67 EPOCH+SUPPLY_INTERVAL, 0 68 }; 69 70 struct timeval flush_kern_timer; 71 72 fd_set fdbits; 73 int sock_max; 74 int rip_sock = -1; /* RIP socket */ 75 struct interface *rip_sock_mcast; /* current multicast interface */ 76 int rt_sock; /* routing socket */ 77 int rt_sock_seqno; 78 79 80 static int get_rip_sock(naddr, int); 81 static void timevalsub(struct timeval *, struct timeval *, struct timeval *); 82 83 int 84 main(int argc, 85 char *argv[]) 86 { 87 int n, mib[4], off; 88 size_t len; 89 char *p, *q; 90 const char *cp; 91 struct timeval wtime, t2; 92 time_t dt; 93 fd_set ibits; 94 naddr p_net, p_mask; 95 struct interface *ifp; 96 struct parm parm; 97 char *tracename = 0; 98 99 100 /* Some shells are badly broken and send SIGHUP to backgrounded 101 * processes. 102 */ 103 signal(SIGHUP, SIG_IGN); 104 105 openlog("routed", LOG_PID | LOG_ODELAY, LOG_DAEMON); 106 ftrace = stdout; 107 108 gettimeofday(&clk, 0); 109 prev_clk = clk; 110 epoch = clk; 111 epoch.tv_sec -= EPOCH; 112 now.tv_sec = EPOCH; 113 now_stale = EPOCH - STALE_TIME; 114 now_expire = EPOCH - EXPIRE_TIME; 115 now_garbage = EPOCH - GARBAGE_TIME; 116 wtime.tv_sec = 0; 117 118 gethostname(myname, sizeof(myname)-1); 119 gethost(myname, &myaddr); 120 121 while ((n = getopt(argc, argv, "sqdghmpAtvT:F:P:")) != -1) { 122 switch (n) { 123 case 's': 124 supplier = 1; 125 supplier_set = 1; 126 break; 127 128 case 'q': 129 supplier = 0; 130 supplier_set = 1; 131 break; 132 133 case 'd': 134 background = 0; 135 break; 136 137 case 'g': 138 memset(&parm, 0, sizeof(parm)); 139 parm.parm_d_metric = 1; 140 cp = check_parms(&parm); 141 if (cp != 0) 142 msglog("bad -g: %s", cp); 143 else 144 default_gateway = 1; 145 break; 146 147 case 'h': /* suppress extra host routes */ 148 ridhosts = 1; 149 break; 150 151 case 'm': /* advertise host route */ 152 mhome = 1; /* on multi-homed hosts */ 153 break; 154 155 case 'A': 156 /* Ignore authentication if we do not care. 157 * Crazy as it is, that is what RFC 1723 requires. 158 */ 159 auth_ok = 0; 160 break; 161 162 case 't': 163 new_tracelevel++; 164 break; 165 166 case 'T': 167 tracename = optarg; 168 break; 169 170 case 'F': /* minimal routes for SLIP */ 171 n = FAKE_METRIC; 172 p = strchr(optarg,','); 173 if (p && *p != '\0') { 174 n = (int)strtoul(p+1, &q, 0); 175 if (*q == '\0' 176 && n <= HOPCNT_INFINITY-1 177 && n >= 1) 178 *p = '\0'; 179 } 180 if (!getnet(optarg, &p_net, &p_mask)) { 181 msglog("bad network; \"-F %s\"", 182 optarg); 183 break; 184 } 185 memset(&parm, 0, sizeof(parm)); 186 parm.parm_net = p_net; 187 parm.parm_mask = p_mask; 188 parm.parm_d_metric = n; 189 cp = check_parms(&parm); 190 if (cp != 0) 191 msglog("bad -F: %s", cp); 192 break; 193 194 case 'P': 195 /* handle arbitrary parameters. 196 */ 197 q = strdup(optarg); 198 cp = parse_parms(q, 0); 199 if (cp != 0) 200 msglog("%s in \"-P %s\"", cp, optarg); 201 free(q); 202 break; 203 204 case 'v': 205 /* display version */ 206 verbose++; 207 msglog("version 2.22"); 208 break; 209 210 default: 211 goto usage; 212 } 213 } 214 argc -= optind; 215 argv += optind; 216 217 if (tracename == 0 && argc >= 1) { 218 tracename = *argv++; 219 argc--; 220 } 221 if (tracename != 0 && tracename[0] == '\0') 222 goto usage; 223 if (argc != 0) { 224 usage: 225 logbad(0, "usage: routed [-sqdghmpAtv] [-T tracefile]" 226 " [-F net[,metric]] [-P parms]"); 227 } 228 if (geteuid() != 0) { 229 if (verbose) 230 exit(0); 231 logbad(0, "requires UID 0"); 232 } 233 234 mib[0] = CTL_NET; 235 mib[1] = PF_INET; 236 mib[2] = IPPROTO_IP; 237 mib[3] = IPCTL_FORWARDING; 238 len = sizeof(ipforwarding); 239 if (sysctl(mib, 4, &ipforwarding, &len, 0, 0) < 0) 240 LOGERR("sysctl(IPCTL_FORWARDING)"); 241 242 if (!ipforwarding) { 243 if (supplier) 244 msglog("-s incompatible with ipforwarding=0"); 245 if (default_gateway) { 246 msglog("-g incompatible with ipforwarding=0"); 247 default_gateway = 0; 248 } 249 supplier = 0; 250 supplier_set = 1; 251 } 252 if (default_gateway) { 253 if (supplier_set && !supplier) { 254 msglog("-g and -q incompatible"); 255 } else { 256 supplier = 1; 257 supplier_set = 1; 258 } 259 } 260 261 262 signal(SIGALRM, sigalrm); 263 if (!background) 264 signal(SIGHUP, sigterm); /* SIGHUP fatal during debugging */ 265 signal(SIGTERM, sigterm); 266 signal(SIGINT, sigterm); 267 signal(SIGUSR1, sigtrace_on); 268 signal(SIGUSR2, sigtrace_off); 269 270 /* get into the background */ 271 if (background && daemon(0, 1) < 0) 272 BADERR(0,"daemon()"); 273 274 mypid = getpid(); 275 srandom((int)(clk.tv_sec ^ clk.tv_usec ^ mypid)); 276 277 /* prepare socket connected to the kernel. 278 */ 279 rt_sock = socket(AF_ROUTE, SOCK_RAW, 0); 280 if (rt_sock < 0) 281 BADERR(1,"rt_sock = socket()"); 282 if (fcntl(rt_sock, F_SETFL, O_NONBLOCK) == -1) 283 logbad(1, "fcntl(rt_sock) O_NONBLOCK: %s", strerror(errno)); 284 off = 0; 285 if (setsockopt(rt_sock, SOL_SOCKET,SO_USELOOPBACK, 286 &off,sizeof(off)) < 0) 287 LOGERR("setsockopt(SO_USELOOPBACK,0)"); 288 289 fix_select(); 290 291 292 if (tracename != 0) { 293 strncpy(inittracename, tracename, sizeof(inittracename)-1); 294 set_tracefile(inittracename, "%s", -1); 295 } else { 296 tracelevel_msg("%s", -1); /* turn on tracing to stdio */ 297 } 298 299 bufinit(); 300 301 /* initialize radix tree */ 302 rtinit(); 303 304 /* Pick a random part of the second for our output to minimize 305 * collisions. 306 * 307 * Start broadcasting after hearing from other routers, and 308 * at a random time so a bunch of systems do not get synchronized 309 * after a power failure. 310 */ 311 intvl_random(&next_bcast, EPOCH+MIN_WAITTIME, EPOCH+SUPPLY_INTERVAL); 312 age_timer.tv_usec = next_bcast.tv_usec; 313 age_timer.tv_sec = EPOCH+MIN_WAITTIME; 314 rdisc_timer = next_bcast; 315 ifinit_timer.tv_usec = next_bcast.tv_usec; 316 317 /* Collect an initial view of the world by checking the interface 318 * configuration and the kludge file. 319 */ 320 gwkludge(); 321 ifinit(); 322 323 /* Ask for routes */ 324 rip_query(); 325 rdisc_sol(); 326 327 /* Now turn off stdio if not tracing */ 328 if (new_tracelevel == 0) 329 trace_close(background); 330 331 /* Loop forever, listening and broadcasting. 332 */ 333 for (;;) { 334 prev_clk = clk; 335 gettimeofday(&clk, 0); 336 if (prev_clk.tv_sec == clk.tv_sec 337 && prev_clk.tv_usec == clk.tv_usec+usec_fudge) { 338 /* Much of `routed` depends on time always advancing. 339 * On systems that do not guarantee that gettimeofday() 340 * produces unique timestamps even if called within 341 * a single tick, use trickery like that in classic 342 * BSD kernels. 343 */ 344 clk.tv_usec += ++usec_fudge; 345 346 } else { 347 usec_fudge = 0; 348 349 timevalsub(&t2, &clk, &prev_clk); 350 if (t2.tv_sec < 0 351 || t2.tv_sec > wtime.tv_sec + 5) { 352 /* Deal with time changes before other 353 * housekeeping to keep everything straight. 354 */ 355 dt = t2.tv_sec; 356 if (dt > 0) 357 dt -= wtime.tv_sec; 358 trace_act("time changed by %d sec", (int)dt); 359 epoch.tv_sec += dt; 360 } 361 } 362 timevalsub(&now, &clk, &epoch); 363 now_stale = now.tv_sec - STALE_TIME; 364 now_expire = now.tv_sec - EXPIRE_TIME; 365 now_garbage = now.tv_sec - GARBAGE_TIME; 366 367 /* deal with signals that should affect tracing */ 368 set_tracelevel(); 369 370 if (stopint != 0) { 371 rip_bcast(0); 372 rdisc_adv(); 373 trace_off("exiting with signal %d", stopint); 374 exit(stopint | 128); 375 } 376 377 /* look for new or dead interfaces */ 378 timevalsub(&wtime, &ifinit_timer, &now); 379 if (wtime.tv_sec <= 0) { 380 wtime.tv_sec = 0; 381 ifinit(); 382 rip_query(); 383 continue; 384 } 385 386 /* Check the kernel table occassionally for mysteriously 387 * evaporated routes 388 */ 389 timevalsub(&t2, &flush_kern_timer, &now); 390 if (t2.tv_sec <= 0) { 391 flush_kern(); 392 flush_kern_timer.tv_sec = (now.tv_sec 393 + CHECK_QUIET_INTERVAL); 394 continue; 395 } 396 if (timercmp(&t2, &wtime, <)) 397 wtime = t2; 398 399 /* If it is time, then broadcast our routes. 400 */ 401 if (supplier || advertise_mhome) { 402 timevalsub(&t2, &next_bcast, &now); 403 if (t2.tv_sec <= 0) { 404 /* Synchronize the aging and broadcast 405 * timers to minimize awakenings 406 */ 407 age(0); 408 409 rip_bcast(0); 410 411 /* It is desirable to send routing updates 412 * regularly. So schedule the next update 413 * 30 seconds after the previous one was 414 * scheduled, instead of 30 seconds after 415 * the previous update was finished. 416 * Even if we just started after discovering 417 * a 2nd interface or were otherwise delayed, 418 * pick a 30-second aniversary of the 419 * original broadcast time. 420 */ 421 n = 1 + (0-t2.tv_sec)/SUPPLY_INTERVAL; 422 next_bcast.tv_sec += n*SUPPLY_INTERVAL; 423 424 continue; 425 } 426 427 if (timercmp(&t2, &wtime, <)) 428 wtime = t2; 429 } 430 431 /* If we need a flash update, either do it now or 432 * set the delay to end when it is time. 433 * 434 * If we are within MIN_WAITTIME seconds of a full update, 435 * do not bother. 436 */ 437 if (need_flash 438 && supplier 439 && no_flash.tv_sec+MIN_WAITTIME < next_bcast.tv_sec) { 440 /* accurate to the millisecond */ 441 if (!timercmp(&no_flash, &now, >)) 442 rip_bcast(1); 443 timevalsub(&t2, &no_flash, &now); 444 if (timercmp(&t2, &wtime, <)) 445 wtime = t2; 446 } 447 448 /* trigger the main aging timer. 449 */ 450 timevalsub(&t2, &age_timer, &now); 451 if (t2.tv_sec <= 0) { 452 age(0); 453 continue; 454 } 455 if (timercmp(&t2, &wtime, <)) 456 wtime = t2; 457 458 /* update the kernel routing table 459 */ 460 timevalsub(&t2, &need_kern, &now); 461 if (t2.tv_sec <= 0) { 462 age(0); 463 continue; 464 } 465 if (timercmp(&t2, &wtime, <)) 466 wtime = t2; 467 468 /* take care of router discovery, 469 * but do it in the correct the millisecond 470 */ 471 if (!timercmp(&rdisc_timer, &now, >)) { 472 rdisc_age(0); 473 continue; 474 } 475 timevalsub(&t2, &rdisc_timer, &now); 476 if (timercmp(&t2, &wtime, <)) 477 wtime = t2; 478 479 480 /* wait for input or a timer to expire. 481 */ 482 trace_flush(); 483 ibits = fdbits; 484 n = select(sock_max, &ibits, 0, 0, &wtime); 485 if (n <= 0) { 486 if (n < 0 && errno != EINTR && errno != EAGAIN) 487 BADERR(1,"select"); 488 continue; 489 } 490 491 if (FD_ISSET(rt_sock, &ibits)) { 492 read_rt(); 493 n--; 494 } 495 if (rdisc_sock >= 0 && FD_ISSET(rdisc_sock, &ibits)) { 496 read_d(); 497 n--; 498 } 499 if (rip_sock >= 0 && FD_ISSET(rip_sock, &ibits)) { 500 read_rip(rip_sock, 0); 501 n--; 502 } 503 504 for (ifp = ifnet; n > 0 && 0 != ifp; ifp = ifp->int_next) { 505 if (ifp->int_rip_sock >= 0 506 && FD_ISSET(ifp->int_rip_sock, &ibits)) { 507 read_rip(ifp->int_rip_sock, ifp); 508 n--; 509 } 510 } 511 } 512 } 513 514 515 /* ARGSUSED */ 516 void 517 sigalrm(__unused int s) 518 { 519 /* Historically, SIGALRM would cause the daemon to check for 520 * new and broken interfaces. 521 */ 522 ifinit_timer.tv_sec = now.tv_sec; 523 trace_act("SIGALRM"); 524 } 525 526 527 /* watch for fatal signals */ 528 void 529 sigterm(int sig) 530 { 531 stopint = sig; 532 signal(sig, SIG_DFL); /* catch it only once */ 533 } 534 535 536 void 537 fix_select(void) 538 { 539 struct interface *ifp; 540 541 542 FD_ZERO(&fdbits); 543 sock_max = 0; 544 545 FD_SET(rt_sock, &fdbits); 546 if (sock_max <= rt_sock) 547 sock_max = rt_sock+1; 548 if (rip_sock >= 0) { 549 FD_SET(rip_sock, &fdbits); 550 if (sock_max <= rip_sock) 551 sock_max = rip_sock+1; 552 } 553 for (ifp = ifnet; NULL != ifp; ifp = ifp->int_next) { 554 if (ifp->int_rip_sock >= 0) { 555 FD_SET(ifp->int_rip_sock, &fdbits); 556 if (sock_max <= ifp->int_rip_sock) 557 sock_max = ifp->int_rip_sock+1; 558 } 559 } 560 if (rdisc_sock >= 0) { 561 FD_SET(rdisc_sock, &fdbits); 562 if (sock_max <= rdisc_sock) 563 sock_max = rdisc_sock+1; 564 } 565 } 566 567 568 void 569 fix_sock(int sock, 570 const char *name) 571 { 572 int on; 573 #define MIN_SOCKBUF (4*1024) 574 static int rbuf; 575 576 if (fcntl(sock, F_SETFL, O_NONBLOCK) == -1) 577 logbad(1, "fcntl(%s) O_NONBLOCK: %s", 578 name, strerror(errno)); 579 on = 1; 580 if (setsockopt(sock, SOL_SOCKET,SO_BROADCAST, &on,sizeof(on)) < 0) 581 msglog("setsockopt(%s,SO_BROADCAST): %s", 582 name, strerror(errno)); 583 #ifdef USE_PASSIFNAME 584 on = 1; 585 if (setsockopt(sock, SOL_SOCKET, SO_PASSIFNAME, &on,sizeof(on)) < 0) 586 msglog("setsockopt(%s,SO_PASSIFNAME): %s", 587 name, strerror(errno)); 588 #endif 589 590 if (rbuf >= MIN_SOCKBUF) { 591 if (setsockopt(sock, SOL_SOCKET, SO_RCVBUF, 592 &rbuf, sizeof(rbuf)) < 0) 593 msglog("setsockopt(%s,SO_RCVBUF=%d): %s", 594 name, rbuf, strerror(errno)); 595 } else { 596 for (rbuf = 60*1024; ; rbuf -= 4096) { 597 if (setsockopt(sock, SOL_SOCKET, SO_RCVBUF, 598 &rbuf, sizeof(rbuf)) == 0) { 599 trace_act("RCVBUF=%d", rbuf); 600 break; 601 } 602 if (rbuf < MIN_SOCKBUF) { 603 msglog("setsockopt(%s,SO_RCVBUF = %d): %s", 604 name, rbuf, strerror(errno)); 605 break; 606 } 607 } 608 } 609 } 610 611 612 /* get a rip socket 613 */ 614 static int /* <0 or file descriptor */ 615 get_rip_sock(naddr addr, 616 int serious) /* 1=failure to bind is serious */ 617 { 618 struct sockaddr_in in; 619 unsigned char ttl; 620 int s; 621 622 623 if ((s = socket(AF_INET, SOCK_DGRAM, 0)) < 0) 624 BADERR(1,"rip_sock = socket()"); 625 626 memset(&in, 0, sizeof(in)); 627 #ifdef _HAVE_SIN_LEN 628 in.sin_len = sizeof(in); 629 #endif 630 in.sin_family = AF_INET; 631 in.sin_port = htons(RIP_PORT); 632 in.sin_addr.s_addr = addr; 633 if (bind(s, (struct sockaddr *)&in, sizeof(in)) < 0) { 634 if (serious) 635 BADERR(errno != EADDRINUSE, "bind(rip_sock)"); 636 return -1; 637 } 638 fix_sock(s,"rip_sock"); 639 640 ttl = 1; 641 if (setsockopt(s, IPPROTO_IP, IP_MULTICAST_TTL, 642 &ttl, sizeof(ttl)) < 0) 643 DBGERR(1,"rip_sock setsockopt(IP_MULTICAST_TTL)"); 644 645 return s; 646 } 647 648 649 /* turn off main RIP socket */ 650 void 651 rip_off(void) 652 { 653 struct interface *ifp; 654 naddr addr; 655 656 657 if (rip_sock >= 0 && !mhome) { 658 trace_act("turn off RIP"); 659 660 close(rip_sock); 661 rip_sock = -1; 662 663 /* get non-broadcast sockets to listen to queries. 664 */ 665 for (ifp = ifnet; ifp != NULL; ifp = ifp->int_next) { 666 if (ifp->int_state & IS_REMOTE) 667 continue; 668 if (ifp->int_rip_sock < 0) { 669 addr = ((ifp->int_if_flags & IFF_POINTOPOINT) 670 ? ifp->int_dstaddr 671 : ifp->int_addr); 672 ifp->int_rip_sock = get_rip_sock(addr, 0); 673 } 674 } 675 676 fix_select(); 677 678 age(0); 679 } 680 } 681 682 683 /* turn on RIP multicast input via an interface 684 */ 685 static void 686 rip_mcast_on(struct interface *ifp) 687 { 688 struct ip_mreq m; 689 690 if (!IS_RIP_IN_OFF(ifp->int_state) 691 && (ifp->int_if_flags & IFF_MULTICAST) 692 #ifdef MCAST_PPP_BUG 693 && !(ifp->int_if_flags & IFF_POINTOPOINT) 694 #endif 695 && !(ifp->int_state & IS_ALIAS)) { 696 m.imr_multiaddr.s_addr = htonl(INADDR_RIP_GROUP); 697 m.imr_interface.s_addr = ((ifp->int_if_flags & IFF_POINTOPOINT) 698 ? ifp->int_dstaddr 699 : ifp->int_addr); 700 if (setsockopt(rip_sock,IPPROTO_IP, IP_ADD_MEMBERSHIP, 701 &m, sizeof(m)) < 0) 702 LOGERR("setsockopt(IP_ADD_MEMBERSHIP RIP)"); 703 } 704 } 705 706 707 /* Prepare socket used for RIP. 708 */ 709 void 710 rip_on(struct interface *ifp) 711 { 712 /* If the main RIP socket is already alive, only start receiving 713 * multicasts for this interface. 714 */ 715 if (rip_sock >= 0) { 716 if (ifp != NULL) 717 rip_mcast_on(ifp); 718 return; 719 } 720 721 /* If the main RIP socket is off and it makes sense to turn it on, 722 * then turn it on for all of the interfaces. 723 * It makes sense if either router discovery is off, or if 724 * router discover is on and at most one interface is doing RIP. 725 */ 726 if (rip_interfaces > 0 && (!rdisc_ok || rip_interfaces > 1)) { 727 trace_act("turn on RIP"); 728 729 /* Close all of the query sockets so that we can open 730 * the main socket. SO_REUSEPORT is not a solution, 731 * since that would let two daemons bind to the broadcast 732 * socket. 733 */ 734 for (ifp = ifnet; ifp != NULL; ifp = ifp->int_next) { 735 if (ifp->int_rip_sock >= 0) { 736 close(ifp->int_rip_sock); 737 ifp->int_rip_sock = -1; 738 } 739 } 740 741 rip_sock = get_rip_sock(INADDR_ANY, 1); 742 rip_sock_mcast = NULL; 743 744 /* Do not advertise anything until we have heard something 745 */ 746 if (next_bcast.tv_sec < now.tv_sec+MIN_WAITTIME) 747 next_bcast.tv_sec = now.tv_sec+MIN_WAITTIME; 748 749 for (ifp = ifnet; ifp != NULL; ifp = ifp->int_next) { 750 ifp->int_query_time = NEVER; 751 rip_mcast_on(ifp); 752 } 753 ifinit_timer.tv_sec = now.tv_sec; 754 755 } else if (ifp != NULL 756 && !(ifp->int_state & IS_REMOTE) 757 && ifp->int_rip_sock < 0) { 758 /* RIP is off, so ensure there are sockets on which 759 * to listen for queries. 760 */ 761 ifp->int_rip_sock = get_rip_sock(ifp->int_addr, 0); 762 } 763 764 fix_select(); 765 } 766 767 768 /* die if malloc(3) fails 769 */ 770 void * 771 rtmalloc(size_t size, 772 const char *msg) 773 { 774 void *p = malloc(size); 775 if (p == NULL) 776 logbad(1,"malloc(%lu) failed in %s", (u_long)size, msg); 777 return p; 778 } 779 780 781 /* get a random instant in an interval 782 */ 783 void 784 intvl_random(struct timeval *tp, /* put value here */ 785 u_long lo, /* value is after this second */ 786 u_long hi) /* and before this */ 787 { 788 tp->tv_sec = (time_t)(hi == lo 789 ? lo 790 : (lo + random() % ((hi - lo)))); 791 tp->tv_usec = random() % 1000000; 792 } 793 794 795 void 796 timevaladd(struct timeval *t1, 797 struct timeval *t2) 798 { 799 800 t1->tv_sec += t2->tv_sec; 801 if ((t1->tv_usec += t2->tv_usec) >= 1000000) { 802 t1->tv_sec++; 803 t1->tv_usec -= 1000000; 804 } 805 } 806 807 808 /* t1 = t2 - t3 809 */ 810 static void 811 timevalsub(struct timeval *t1, 812 struct timeval *t2, 813 struct timeval *t3) 814 { 815 t1->tv_sec = t2->tv_sec - t3->tv_sec; 816 if ((t1->tv_usec = t2->tv_usec - t3->tv_usec) < 0) { 817 t1->tv_sec--; 818 t1->tv_usec += 1000000; 819 } 820 } 821 822 823 /* put a message into the system log 824 */ 825 void 826 msglog(const char *p, ...) 827 { 828 va_list args; 829 830 trace_flush(); 831 832 va_start(args, p); 833 vsyslog(LOG_ERR, p, args); 834 835 if (ftrace != 0) { 836 if (ftrace == stdout) 837 fputs("routed: ", ftrace); 838 vfprintf(ftrace, p, args); 839 fputc('\n', ftrace); 840 } 841 } 842 843 844 /* Put a message about a bad system into the system log if 845 * we have not complained about it recently. 846 * 847 * It is desirable to complain about all bad systems, but not too often. 848 * In the worst case, it is not practical to keep track of all bad systems. 849 * For example, there can be many systems with the wrong password. 850 */ 851 void 852 msglim(struct msg_limit *lim, naddr addr, const char *p, ...) 853 { 854 va_list args; 855 int i; 856 struct msg_sub *ms1, *ms; 857 const char *p1; 858 859 va_start(args, p); 860 861 /* look for the oldest slot in the table 862 * or the slot for the bad router. 863 */ 864 ms = ms1 = lim->subs; 865 for (i = MSG_SUBJECT_N; ; i--, ms1++) { 866 if (i == 0) { 867 /* Reuse a slot at most once every 10 minutes. 868 */ 869 if (lim->reuse > now.tv_sec) { 870 ms = NULL; 871 } else { 872 ms = ms1; 873 lim->reuse = now.tv_sec + 10*60; 874 } 875 break; 876 } 877 if (ms->addr == addr) { 878 /* Repeat a complaint about a given system at 879 * most once an hour. 880 */ 881 if (ms->until > now.tv_sec) 882 ms = NULL; 883 break; 884 } 885 if (ms->until < ms1->until) 886 ms = ms1; 887 } 888 if (ms != NULL) { 889 ms->addr = addr; 890 ms->until = now.tv_sec + 60*60; /* 60 minutes */ 891 892 trace_flush(); 893 for (p1 = p; *p1 == ' '; p1++) 894 continue; 895 vsyslog(LOG_ERR, p1, args); 896 } 897 898 /* always display the message if tracing */ 899 if (ftrace != 0) { 900 vfprintf(ftrace, p, args); 901 fputc('\n', ftrace); 902 } 903 } 904 905 906 void 907 logbad(int dump, const char *p, ...) 908 { 909 va_list args; 910 911 trace_flush(); 912 913 va_start(args, p); 914 vsyslog(LOG_ERR, p, args); 915 916 fputs("routed: ", stderr); 917 vfprintf(stderr, p, args); 918 fputs("; giving up\n",stderr); 919 fflush(stderr); 920 921 if (dump) 922 abort(); 923 exit(1); 924 } 925