Annotation of embedaddon/mrouted/main.c, revision 1.1
1.1 ! misho 1: /*
! 2: * The mrouted program is covered by the license in the accompanying file
! 3: * named "LICENSE". Use of the mrouted program represents acceptance of
! 4: * the terms and conditions listed in that file.
! 5: *
! 6: * The mrouted program is COPYRIGHT 1989 by The Board of Trustees of
! 7: * Leland Stanford Junior University.
! 8: */
! 9:
! 10: /*
! 11: * Written by Steve Deering, Stanford University, February 1989.
! 12: *
! 13: * (An earlier version of DVMRP was implemented by David Waitzman of
! 14: * BBN STC by extending Berkeley's routed program. Some of Waitzman's
! 15: * extensions have been incorporated into mrouted, but none of the
! 16: * original routed code has been adopted.)
! 17: */
! 18:
! 19: #include "defs.h"
! 20: #include <err.h>
! 21: #include <getopt.h>
! 22: #include <paths.h>
! 23: #include <fcntl.h>
! 24: #include <stdarg.h>
! 25: #include <sys/stat.h>
! 26:
! 27: #ifdef SNMP
! 28: #include "snmp.h"
! 29: #endif
! 30:
! 31: extern char *configfilename;
! 32: char versionstring[MAX_VERSION_LEN];
! 33:
! 34: static const char dumpfilename[] = _PATH_MROUTED_DUMP;
! 35: static const char cachefilename[] = _PATH_MROUTED_CACHE;
! 36: static const char genidfilename[] = _PATH_MROUTED_GENID;
! 37:
! 38: static int haveterminal = 1;
! 39: int did_final_init = 0;
! 40:
! 41: static int sighandled = 0;
! 42: #define GOT_SIGINT 0x01
! 43: #define GOT_SIGHUP 0x02
! 44: #define GOT_SIGUSR1 0x04
! 45: #define GOT_SIGUSR2 0x08
! 46:
! 47: int cache_lifetime = DEFAULT_CACHE_LIFETIME;
! 48: int prune_lifetime = AVERAGE_PRUNE_LIFETIME;
! 49:
! 50: int debug = 0;
! 51: extern char *__progname;
! 52: time_t mrouted_init_time;
! 53:
! 54: #ifdef SNMP
! 55: #define NHANDLERS 34
! 56: #else
! 57: #define NHANDLERS 2
! 58: #endif
! 59:
! 60: static struct ihandler {
! 61: int fd; /* File descriptor */
! 62: ihfunc_t func; /* Function to call with &fd_set */
! 63: } ihandlers[NHANDLERS];
! 64: static int nhandlers = 0;
! 65:
! 66: static struct debugname {
! 67: char *name;
! 68: u_int32_t level;
! 69: size_t nchars;
! 70: } debugnames[] = {
! 71: { "packet", DEBUG_PKT, 2 },
! 72: { "pkt", DEBUG_PKT, 3 },
! 73: { "pruning", DEBUG_PRUNE, 1 },
! 74: { "prunes", DEBUG_PRUNE, 1 },
! 75: { "routing", DEBUG_ROUTE, 1 },
! 76: { "routes", DEBUG_ROUTE, 1 },
! 77: { "route_detail", DEBUG_RTDETAIL, 6 },
! 78: { "rtdetail", DEBUG_RTDETAIL, 2 },
! 79: { "peers", DEBUG_PEER, 2 },
! 80: { "neighbors", DEBUG_PEER, 1 },
! 81: { "cache", DEBUG_CACHE, 1 },
! 82: { "timeout", DEBUG_TIMEOUT, 1 },
! 83: { "callout", DEBUG_TIMEOUT, 2 },
! 84: { "interface", DEBUG_IF, 2 },
! 85: { "vif", DEBUG_IF, 1 },
! 86: { "membership", DEBUG_MEMBER, 1 },
! 87: { "groups", DEBUG_MEMBER, 1 },
! 88: { "traceroute", DEBUG_TRACE, 2 },
! 89: { "mtrace", DEBUG_TRACE, 2 },
! 90: { "igmp", DEBUG_IGMP, 1 },
! 91: { "icmp", DEBUG_ICMP, 2 },
! 92: { "rsrr", DEBUG_RSRR, 2 },
! 93: { "3", 0xffffffff, 1 } /* compat. */
! 94: };
! 95:
! 96: /*
! 97: * Forward declarations.
! 98: */
! 99: static void final_init(void *);
! 100: static void fasttimer(void*);
! 101: static void timer(void*);
! 102: #if UNUSED_CODE
! 103: static void dump(void);
! 104: #endif
! 105: static void dump_version(FILE *);
! 106: static void fdump(void);
! 107: static void cdump(void);
! 108: static void restart(void);
! 109: static void handler(int);
! 110: static void cleanup(void);
! 111: static void resetlogging(void *);
! 112:
! 113: int register_input_handler(int fd, ihfunc_t func)
! 114: {
! 115: if (nhandlers >= NHANDLERS)
! 116: return -1;
! 117:
! 118: ihandlers[nhandlers].fd = fd;
! 119: ihandlers[nhandlers++].func = func;
! 120:
! 121: return 0;
! 122: }
! 123:
! 124: static void do_randomize(void)
! 125: {
! 126: #define rol32(data,shift) ((data) >> (shift)) | ((data) << (32 - (shift)))
! 127: int fd;
! 128: unsigned int seed;
! 129:
! 130: /* Setup a fallback seed based on quasi random. */
! 131: #ifdef SYSV
! 132: seed = time(NULL);
! 133: #else
! 134: seed = time(NULL) ^ gethostid();
! 135: #endif
! 136: seed = rol32(seed, seed);
! 137:
! 138: fd = open("/dev/urandom", O_RDONLY);
! 139: if (fd >= 0) {
! 140: if (-1 == read(fd, &seed, sizeof(seed)))
! 141: warn("Failed reading entropy from /dev/urandom");
! 142: close(fd);
! 143: }
! 144:
! 145: #ifdef SYSV
! 146: srand48(seed);
! 147: #else
! 148: srandom(seed);
! 149: #endif
! 150: }
! 151:
! 152: /* Figure out the PID of a running daemon. */
! 153: static pid_t daemon_pid(void)
! 154: {
! 155: int result;
! 156: char *path = NULL;
! 157: FILE *fp;
! 158: pid_t pid = -1;
! 159:
! 160: result = asprintf(&path, "%s%s.pid", _PATH_VARRUN, __progname);
! 161: if (result == -1 || path == NULL)
! 162: return -1;
! 163:
! 164: fp = fopen(path, "r");
! 165: if (!fp) {
! 166: free(path);
! 167: return -1;
! 168: }
! 169:
! 170: result = fscanf(fp, "%d", &pid);
! 171: fclose(fp);
! 172: free(path);
! 173:
! 174: return pid;
! 175: }
! 176:
! 177: /* Send signal to running daemon and the show resulting file. */
! 178: static void killshow(int signo, char *file)
! 179: {
! 180: pid_t pid = daemon_pid();
! 181: char buf[100];
! 182:
! 183: if (pid > 0) {
! 184: if (file)
! 185: remove(file);
! 186: kill(pid, signo);
! 187: if (file) {
! 188: int result;
! 189:
! 190: usleep(200);
! 191: snprintf(buf, sizeof(buf), "cat %s", file);
! 192: result = system(buf);
! 193: }
! 194: }
! 195: }
! 196:
! 197: static void usage(void)
! 198: {
! 199: size_t i, j, k;
! 200: struct debugname *d;
! 201:
! 202: fprintf(stderr, "Usage: %s [-fhpv] [-c file] [-d [level[,level...]]]\n\n", __progname);
! 203: fputs(" -c, --config=FILE Configuration file to use, default /etc/mrouted.conf\n", stderr);
! 204: fputs(" -d, --debug[=LEVEL] Debug level, see below for valid levels\n", stderr);
! 205: fputs(" -f, --foreground Run in foreground, do not detach from calling terminal\n", stderr);
! 206: fputs(" -h, --help Show this help text\n", stderr);
! 207: fputs(" -p Disable pruning. Deprecated, compatibility option\n", stderr);
! 208: fputs(" -r, --show-routes Show state of VIFs and multicast routing tables\n", stderr);
! 209: fprintf(stderr, " -v, --version Show %s version\n", __progname);
! 210: fputs("\n", stderr);
! 211:
! 212: j = 0xffffffff;
! 213: k = 0;
! 214: fputs("Valid debug levels:\n ", stderr);
! 215: for (i = 0, d = debugnames; i < ARRAY_LEN(debugnames); i++, d++) {
! 216: if ((j & d->level) == d->level) {
! 217: if (k++)
! 218: fputs(", ", stderr);
! 219: if (!(k % 6))
! 220: fputs("\n ", stderr);
! 221:
! 222: fputs(d->name, stderr);
! 223: j &= ~d->level;
! 224: }
! 225: }
! 226: fputc('\n', stderr);
! 227:
! 228: exit(1);
! 229: }
! 230:
! 231: int main(int argc, char *argv[])
! 232: {
! 233: register int recvlen;
! 234: socklen_t dummy;
! 235: FILE *fp;
! 236: struct timeval tv, difftime, curtime, lasttime, *timeout;
! 237: u_int32 prev_genid;
! 238: int vers, foreground = 0;
! 239: fd_set rfds, readers;
! 240: int nfds, n, i, secs, ch;
! 241: extern char todaysversion[];
! 242: struct sigaction sa;
! 243: #ifdef SNMP
! 244: const char *errstr;
! 245: struct timeval timeout, *tvp = &timeout;
! 246: struct timeval sched, *svp = &sched, now, *nvp = &now;
! 247: int index, block;
! 248: #endif
! 249: struct option long_options[] = {
! 250: {"config", 1, 0, 'c'},
! 251: {"debug", 2, 0, 'd'},
! 252: {"foreground", 0, 0, 'f'},
! 253: {"help", 0, 0, 'h'},
! 254: {"version", 0, 0, 'v'},
! 255: {"show-routes", 0, 0, 'r'},
! 256: {0, 0, 0, 0}
! 257: };
! 258:
! 259: snprintf(versionstring, sizeof(versionstring), "mrouted version %s", todaysversion);
! 260:
! 261: while ((ch = getopt_long(argc, argv, "c:d::fhpP::rv", long_options, NULL)) != EOF) {
! 262: switch (ch) {
! 263: case 'c':
! 264: configfilename = optarg;
! 265: break;
! 266:
! 267: case 'd':
! 268: if (!optarg)
! 269: debug = DEFAULT_DEBUG;
! 270: else {
! 271: char *p,*q;
! 272: size_t i, len;
! 273: struct debugname *d;
! 274:
! 275: debug = 0;
! 276: p = optarg; q = NULL;
! 277: while (p) {
! 278: q = strchr(p, ',');
! 279: if (q)
! 280: *q++ = '\0';
! 281: len = strlen(p);
! 282: for (i = 0, d = debugnames; i < ARRAY_LEN(debugnames); i++, d++)
! 283: if (len >= d->nchars && strncmp(d->name, p, len) == 0)
! 284: break;
! 285:
! 286: if (i == ARRAY_LEN(debugnames))
! 287: usage();
! 288:
! 289: debug |= d->level;
! 290: p = q;
! 291: }
! 292: }
! 293: break;
! 294:
! 295: case 'f':
! 296: foreground = 1;
! 297: break;
! 298:
! 299: case 'h':
! 300: usage();
! 301: break;
! 302:
! 303: case 'p':
! 304: warnx("Disabling pruning is no longer supported.");
! 305: break;
! 306:
! 307: case 'P':
! 308: #ifdef SNMP
! 309: if (!optarg)
! 310: dest_port = DEFAULT_PORT;
! 311: else {
! 312: dest_port = strtonum(optarg, 1, 65535, &errstr);
! 313: if (errstr) {
! 314: warnx("destination port %s", errstr);
! 315: dest_port = DEFAULT_PORT;
! 316: }
! 317: }
! 318: #else
! 319: warnx("SNMP support missing, please feel free to submit a patch.");
! 320: #endif
! 321: break;
! 322:
! 323: case 'r':
! 324: killshow(SIGUSR1, _PATH_MROUTED_DUMP);
! 325: return 0;
! 326:
! 327: case 'v':
! 328: printf("%s\n", versionstring);
! 329: return 0;
! 330:
! 331: default:
! 332: usage();
! 333: }
! 334: }
! 335:
! 336: argc -= optind;
! 337: argv += optind;
! 338:
! 339: if (argc > 0)
! 340: usage();
! 341:
! 342: if (geteuid() != 0) {
! 343: fprintf(stderr, "%s: must be root\n", __progname);
! 344: exit(1);
! 345: }
! 346: setlinebuf(stderr);
! 347:
! 348: if (debug != 0) {
! 349: struct debugname *d;
! 350: char c;
! 351: int tmpd = debug;
! 352:
! 353: fprintf(stderr, "debug level 0x%x ", debug);
! 354: c = '(';
! 355: for (d = debugnames; d < debugnames + ARRAY_LEN(debugnames); d++) {
! 356: if ((tmpd & d->level) == d->level) {
! 357: tmpd &= ~d->level;
! 358: fprintf(stderr, "%c%s", c, d->name);
! 359: c = ',';
! 360: }
! 361: }
! 362: fprintf(stderr, ")\n");
! 363: }
! 364:
! 365: /*
! 366: * Create directory for runtime files
! 367: */
! 368: mkdir(_PATH_MROUTED_RUNDIR, 0755);
! 369:
! 370: /*
! 371: * Setup logging
! 372: */
! 373: #ifdef LOG_DAEMON
! 374: (void)openlog("mrouted", LOG_PID, LOG_DAEMON);
! 375: (void)setlogmask(LOG_UPTO(LOG_NOTICE));
! 376: #else
! 377: (void)openlog("mrouted", LOG_PID);
! 378: #endif
! 379:
! 380: logit(LOG_DEBUG, 0, "%s starting", versionstring);
! 381:
! 382: do_randomize();
! 383:
! 384: /*
! 385: * Get generation id
! 386: */
! 387: gettimeofday(&tv, 0);
! 388: dvmrp_genid = tv.tv_sec;
! 389:
! 390: fp = fopen(genidfilename, "r");
! 391: if (fp != NULL) {
! 392: int ret = fscanf(fp, "%u", &prev_genid);
! 393: if (ret == 1 && prev_genid == dvmrp_genid)
! 394: dvmrp_genid++;
! 395: (void) fclose(fp);
! 396: }
! 397:
! 398: fp = fopen(genidfilename, "w");
! 399: if (fp != NULL) {
! 400: fprintf(fp, "%d", dvmrp_genid);
! 401: (void) fclose(fp);
! 402: }
! 403:
! 404: /* Start up the log rate-limiter */
! 405: resetlogging(NULL);
! 406:
! 407: callout_init();
! 408: init_igmp();
! 409: init_icmp();
! 410: init_ipip();
! 411: init_routes();
! 412: init_ktable();
! 413: #ifndef OLD_KERNEL
! 414: /*
! 415: * Unfortunately, you can't k_get_version() unless you've
! 416: * k_init_dvmrp()'d. Now that we want to move the
! 417: * k_init_dvmrp() to later in the initialization sequence,
! 418: * we have to do the disgusting hack of initializing,
! 419: * getting the version, then stopping the kernel multicast
! 420: * forwarding.
! 421: */
! 422: k_init_dvmrp();
! 423: vers = k_get_version();
! 424: k_stop_dvmrp();
! 425: /*XXX
! 426: * This function must change whenever the kernel version changes
! 427: */
! 428: if ((((vers >> 8) & 0xff) != 3) ||
! 429: ((vers & 0xff) != 5))
! 430: logit(LOG_ERR, 0, "kernel (v%d.%d)/mrouted (v%d.%d) version mismatch",
! 431: (vers >> 8) & 0xff, vers & 0xff,
! 432: PROTOCOL_VERSION, MROUTED_VERSION);
! 433: #endif
! 434:
! 435: #ifdef SNMP
! 436: if (i = snmp_init())
! 437: return i;
! 438:
! 439: gettimeofday(nvp, 0);
! 440: if (nvp->tv_usec < 500000L){
! 441: svp->tv_usec = nvp->tv_usec + 500000L;
! 442: svp->tv_sec = nvp->tv_sec;
! 443: } else {
! 444: svp->tv_usec = nvp->tv_usec - 500000L;
! 445: svp->tv_sec = nvp->tv_sec + 1;
! 446: }
! 447: #endif /* SNMP */
! 448:
! 449: init_vifs();
! 450:
! 451: #ifdef RSRR
! 452: rsrr_init();
! 453: #endif /* RSRR */
! 454:
! 455: sa.sa_handler = handler;
! 456: sa.sa_flags = 0; /* Interrupt system calls */
! 457: sigemptyset(&sa.sa_mask);
! 458: sigaction(SIGHUP, &sa, NULL);
! 459: sigaction(SIGTERM, &sa, NULL);
! 460: sigaction(SIGINT, &sa, NULL);
! 461: sigaction(SIGUSR1, &sa, NULL);
! 462: sigaction(SIGUSR2, &sa, NULL);
! 463:
! 464: FD_ZERO(&readers);
! 465: if (igmp_socket >= (int)FD_SETSIZE)
! 466: logit(LOG_ERR, 0, "Descriptor too big");
! 467: FD_SET(igmp_socket, &readers);
! 468: nfds = igmp_socket + 1;
! 469: for (i = 0; i < nhandlers; i++) {
! 470: if (ihandlers[i].fd >= (int)FD_SETSIZE)
! 471: logit(LOG_ERR, 0, "Descriptor too big");
! 472: FD_SET(ihandlers[i].fd, &readers);
! 473: if (ihandlers[i].fd >= nfds)
! 474: nfds = ihandlers[i].fd + 1;
! 475: }
! 476:
! 477: IF_DEBUG(DEBUG_IF)
! 478: dump_vifs(stderr);
! 479: IF_DEBUG(DEBUG_ROUTE)
! 480: dump_routes(stderr);
! 481:
! 482: /* schedule first timer interrupt */
! 483: timer_setTimer(1, fasttimer, NULL);
! 484: timer_setTimer(TIMER_INTERVAL, timer, NULL);
! 485:
! 486: if (!debug && !foreground) {
! 487: /* Detach from the terminal */
! 488: haveterminal = 0;
! 489: if (fork())
! 490: exit(0);
! 491: (void)close(0);
! 492: (void)close(1);
! 493: (void)close(2);
! 494: (void)open("/", 0);
! 495: (void)dup2(0, 1);
! 496: (void)dup2(0, 2);
! 497: #ifdef SYSV
! 498: (void)setpgrp();
! 499: #else
! 500: #ifdef TIOCNOTTY
! 501: n = open("/dev/tty", 2);
! 502: if (n >= 0) {
! 503: (void)ioctl(n, TIOCNOTTY, (char *)0);
! 504: (void)close(n);
! 505: }
! 506: #else
! 507: if (setsid() < 0)
! 508: perror("setsid");
! 509: #endif
! 510: #endif
! 511: }
! 512:
! 513: if (pidfile(NULL)) {
! 514: warn("Cannot create pidfile");
! 515: }
! 516:
! 517: /* XXX HACK
! 518: * This will cause black holes for the first few seconds after startup,
! 519: * since we are exchanging routes but not actually forwarding.
! 520: * However, it eliminates much of the startup transient.
! 521: *
! 522: * It's possible that we can set a flag which says not to report any
! 523: * routes (just accept reports) until this timer fires, and then
! 524: * do a report_to_all_neighbors(ALL_ROUTES) immediately before
! 525: * turning on DVMRP.
! 526: */
! 527: timer_setTimer(10, final_init, NULL);
! 528:
! 529: /*
! 530: * Main receive loop.
! 531: */
! 532: dummy = 0;
! 533: difftime.tv_usec = 0;
! 534: gettimeofday(&curtime, NULL);
! 535: lasttime = curtime;
! 536: for(;;) {
! 537: memmove ((char *)&rfds, (char *)&readers, sizeof(rfds));
! 538: secs = timer_nextTimer();
! 539: if (secs == -1)
! 540: timeout = NULL;
! 541: else {
! 542: timeout = &tv;
! 543: timeout->tv_sec = secs;
! 544: timeout->tv_usec = 0;
! 545: }
! 546: #ifdef SNMP
! 547: THIS IS BROKEN
! 548: if (nvp->tv_sec > svp->tv_sec
! 549: || (nvp->tv_sec == svp->tv_sec && nvp->tv_usec > svp->tv_usec)){
! 550: alarmTimer(nvp);
! 551: eventTimer(nvp);
! 552: if (nvp->tv_usec < 500000L){
! 553: svp->tv_usec = nvp->tv_usec + 500000L;
! 554: svp->tv_sec = nvp->tv_sec;
! 555: } else {
! 556: svp->tv_usec = nvp->tv_usec - 500000L;
! 557: svp->tv_sec = nvp->tv_sec + 1;
! 558: }
! 559: }
! 560:
! 561: tvp = &timeout;
! 562: tvp->tv_sec = 0;
! 563: tvp->tv_usec = 500000L;
! 564:
! 565: block = 0;
! 566: snmp_select_info(&nfds, &rfds, tvp, &block);
! 567: if (block == 1)
! 568: tvp = NULL; /* block without timeout */
! 569: if ((n = select(nfds, &rfds, NULL, NULL, tvp)) < 0)
! 570: #endif
! 571: if (sighandled) {
! 572: if (sighandled & GOT_SIGINT) {
! 573: sighandled &= ~GOT_SIGINT;
! 574: break;
! 575: }
! 576: if (sighandled & GOT_SIGHUP) {
! 577: sighandled &= ~GOT_SIGHUP;
! 578: restart();
! 579: }
! 580: if (sighandled & GOT_SIGUSR1) {
! 581: sighandled &= ~GOT_SIGUSR1;
! 582: fdump();
! 583: }
! 584: if (sighandled & GOT_SIGUSR2) {
! 585: sighandled &= ~GOT_SIGUSR2;
! 586: cdump();
! 587: }
! 588: }
! 589: if ((n = select(nfds, &rfds, NULL, NULL, timeout)) < 0) {
! 590: if (errno != EINTR)
! 591: logit(LOG_WARNING, errno, "select failed");
! 592: continue;
! 593: }
! 594:
! 595: if (n > 0) {
! 596: if (FD_ISSET(igmp_socket, &rfds)) {
! 597: recvlen = recvfrom(igmp_socket, recv_buf, RECV_BUF_SIZE, 0, NULL, &dummy);
! 598: if (recvlen < 0) {
! 599: if (errno != EINTR) logit(LOG_ERR, errno, "recvfrom");
! 600: continue;
! 601: }
! 602: accept_igmp(recvlen);
! 603: }
! 604:
! 605: for (i = 0; i < nhandlers; i++) {
! 606: if (FD_ISSET(ihandlers[i].fd, &rfds)) {
! 607: (*ihandlers[i].func)(ihandlers[i].fd, &rfds);
! 608: }
! 609: }
! 610: }
! 611:
! 612: #ifdef SNMP
! 613: THIS IS BROKEN
! 614: snmp_read(&rfds);
! 615: snmp_timeout(); /* poll */
! 616: #endif
! 617: /*
! 618: * Handle timeout queue.
! 619: *
! 620: * If select + packet processing took more than 1 second,
! 621: * or if there is a timeout pending, age the timeout queue.
! 622: *
! 623: * If not, collect usec in difftime to make sure that the
! 624: * time doesn't drift too badly.
! 625: *
! 626: * If the timeout handlers took more than 1 second,
! 627: * age the timeout queue again. XXX This introduces the
! 628: * potential for infinite loops!
! 629: */
! 630: do {
! 631: /*
! 632: * If the select timed out, then there's no other
! 633: * activity to account for and we don't need to
! 634: * call gettimeofday.
! 635: */
! 636: if (n == 0) {
! 637: curtime.tv_sec = lasttime.tv_sec + secs;
! 638: curtime.tv_usec = lasttime.tv_usec;
! 639: n = -1; /* don't do this next time through the loop */
! 640: } else
! 641: gettimeofday(&curtime, NULL);
! 642: difftime.tv_sec = curtime.tv_sec - lasttime.tv_sec;
! 643: difftime.tv_usec += curtime.tv_usec - lasttime.tv_usec;
! 644: while (difftime.tv_usec > 1000000) {
! 645: difftime.tv_sec++;
! 646: difftime.tv_usec -= 1000000;
! 647: }
! 648: if (difftime.tv_usec < 0) {
! 649: difftime.tv_sec--;
! 650: difftime.tv_usec += 1000000;
! 651: }
! 652: lasttime = curtime;
! 653: if (secs == 0 || difftime.tv_sec > 0)
! 654: age_callout_queue(difftime.tv_sec);
! 655: secs = -1;
! 656: } while (difftime.tv_sec > 0);
! 657: }
! 658: logit(LOG_NOTICE, 0, "%s exiting", versionstring);
! 659: cleanup();
! 660: exit(0);
! 661: }
! 662:
! 663: static void final_init(void *i)
! 664: {
! 665: char *s = (char *)i;
! 666:
! 667: logit(LOG_NOTICE, 0, "%s%s", versionstring, s ? s : "");
! 668: if (s)
! 669: free(s);
! 670:
! 671: k_init_dvmrp(); /* enable DVMRP routing in kernel */
! 672:
! 673: /*
! 674: * Install the vifs in the kernel as late as possible in the
! 675: * initialization sequence.
! 676: */
! 677: init_installvifs();
! 678:
! 679: time(&mrouted_init_time);
! 680: did_final_init = 1;
! 681: }
! 682:
! 683: /*
! 684: * routine invoked every second. Its main goal is to cycle through
! 685: * the routing table and send partial updates to all neighbors at a
! 686: * rate that will cause the entire table to be sent in ROUTE_REPORT_INTERVAL
! 687: * seconds. Also, every TIMER_INTERVAL seconds it calls timer() to
! 688: * do all the other time-based processing.
! 689: */
! 690: static void fasttimer(void UNUSED *arg)
! 691: {
! 692: static unsigned int tlast;
! 693: static unsigned int nsent;
! 694: unsigned int t = tlast + 1;
! 695: int n;
! 696:
! 697: /*
! 698: * if we're in the last second, send everything that's left.
! 699: * otherwise send at least the fraction we should have sent by now.
! 700: */
! 701: if (t >= ROUTE_REPORT_INTERVAL) {
! 702: register int nleft = nroutes - nsent;
! 703: while (nleft > 0) {
! 704: if ((n = report_next_chunk()) <= 0)
! 705: break;
! 706: nleft -= n;
! 707: }
! 708: tlast = 0;
! 709: nsent = 0;
! 710: } else {
! 711: register unsigned int ncum = nroutes * t / ROUTE_REPORT_INTERVAL;
! 712: while (nsent < ncum) {
! 713: if ((n = report_next_chunk()) <= 0)
! 714: break;
! 715: nsent += n;
! 716: }
! 717: tlast = t;
! 718: }
! 719:
! 720: timer_setTimer(1, fasttimer, NULL);
! 721: }
! 722:
! 723: /*
! 724: * The 'virtual_time' variable is initialized to a value that will cause the
! 725: * first invocation of timer() to send a probe or route report to all vifs
! 726: * and send group membership queries to all subnets for which this router is
! 727: * querier. This first invocation occurs approximately TIMER_INTERVAL seconds
! 728: * after the router starts up. Note that probes for neighbors and queries
! 729: * for group memberships are also sent at start-up time, as part of initial-
! 730: * ization. This repetition after a short interval is desirable for quickly
! 731: * building up topology and membership information in the presence of possible
! 732: * packet loss.
! 733: *
! 734: * 'virtual_time' advances at a rate that is only a crude approximation of
! 735: * real time, because it does not take into account any time spent processing,
! 736: * and because the timer intervals are sometimes shrunk by a random amount to
! 737: * avoid unwanted synchronization with other routers.
! 738: */
! 739:
! 740: u_long virtual_time = 0;
! 741:
! 742:
! 743: /*
! 744: * Timer routine. Performs periodic neighbor probing, route reporting, and
! 745: * group querying duties, and drives various timers in routing entries and
! 746: * virtual interface data structures.
! 747: */
! 748: static void timer(void UNUSED *arg)
! 749: {
! 750: age_routes(); /* Advance the timers in the route entries */
! 751: age_vifs(); /* Advance the timers for neighbors */
! 752: age_table_entry(); /* Advance the timers for the cache entries */
! 753:
! 754: if (virtual_time % IGMP_QUERY_INTERVAL == 0) {
! 755: /*
! 756: * Time to query the local group memberships on all subnets
! 757: * for which this router is the elected querier.
! 758: */
! 759: query_groups();
! 760: }
! 761:
! 762: if (virtual_time % NEIGHBOR_PROBE_INTERVAL == 0) {
! 763: /*
! 764: * Time to send a probe on all vifs from which no neighbors have
! 765: * been heard. Also, check if any inoperative interfaces have now
! 766: * come up. (If they have, they will also be probed as part of
! 767: * their initialization.)
! 768: */
! 769: probe_for_neighbors();
! 770:
! 771: if (vifs_down)
! 772: check_vif_state();
! 773: }
! 774:
! 775: delay_change_reports = FALSE;
! 776: if (routes_changed) {
! 777: /*
! 778: * Some routes have changed since the last timer interrupt, but
! 779: * have not been reported yet. Report the changed routes to all
! 780: * neighbors.
! 781: */
! 782: report_to_all_neighbors(CHANGED_ROUTES);
! 783: }
! 784:
! 785: #ifdef SNMP
! 786: sync_timer();
! 787: #endif
! 788:
! 789: /*
! 790: * Advance virtual time
! 791: */
! 792: virtual_time += TIMER_INTERVAL;
! 793: timer_setTimer(TIMER_INTERVAL, timer, NULL);
! 794: }
! 795:
! 796:
! 797: static void cleanup(void)
! 798: {
! 799: static int in_cleanup = 0;
! 800:
! 801: if (!in_cleanup) {
! 802: in_cleanup++;
! 803: #ifdef RSRR
! 804: rsrr_clean();
! 805: #endif /* RSRR */
! 806: expire_all_routes();
! 807: report_to_all_neighbors(ALL_ROUTES);
! 808: if (did_final_init)
! 809: k_stop_dvmrp();
! 810: }
! 811: }
! 812:
! 813: /*
! 814: * Signal handler. Take note of the fact that the signal arrived
! 815: * so that the main loop can take care of it.
! 816: */
! 817: static void handler(int sig)
! 818: {
! 819: switch (sig) {
! 820: case SIGINT:
! 821: case SIGTERM:
! 822: sighandled |= GOT_SIGINT;
! 823: break;
! 824:
! 825: case SIGHUP:
! 826: sighandled |= GOT_SIGHUP;
! 827: break;
! 828:
! 829: case SIGUSR1:
! 830: sighandled |= GOT_SIGUSR1;
! 831: break;
! 832:
! 833: case SIGUSR2:
! 834: sighandled |= GOT_SIGUSR2;
! 835: break;
! 836: }
! 837: }
! 838:
! 839: #if UNUSED_CODE
! 840: /*
! 841: * Dump internal data structures to stderr.
! 842: */
! 843: static void dump(void)
! 844: {
! 845: dump_vifs(stderr);
! 846: dump_routes(stderr);
! 847: }
! 848: #endif
! 849:
! 850: static void dump_version(FILE *fp)
! 851: {
! 852: time_t t;
! 853:
! 854: time(&t);
! 855: fprintf(fp, "%s ", versionstring);
! 856: if (did_final_init)
! 857: fprintf(fp, "up %s",
! 858: scaletime(t - mrouted_init_time));
! 859: else
! 860: fprintf(fp, "(not yet initialized)");
! 861: fprintf(fp, " %s\n", ctime(&t));
! 862: }
! 863:
! 864: /*
! 865: * Dump internal data structures to a file.
! 866: */
! 867: static void fdump(void)
! 868: {
! 869: FILE *fp;
! 870:
! 871: fp = fopen(dumpfilename, "w");
! 872: if (fp != NULL) {
! 873: dump_version(fp);
! 874: dump_vifs(fp);
! 875: dump_routes(fp);
! 876: (void) fclose(fp);
! 877: }
! 878: }
! 879:
! 880:
! 881: /*
! 882: * Dump local cache contents to a file.
! 883: */
! 884: static void cdump(void)
! 885: {
! 886: FILE *fp;
! 887:
! 888: fp = fopen(cachefilename, "w");
! 889: if (fp != NULL) {
! 890: dump_version(fp);
! 891: dump_cache(fp);
! 892: (void) fclose(fp);
! 893: }
! 894: }
! 895:
! 896:
! 897: /*
! 898: * Restart mrouted
! 899: */
! 900: static void restart(void)
! 901: {
! 902: char *s;
! 903:
! 904: s = strdup (" restart");
! 905: if (s == NULL)
! 906: logit(LOG_ERR, 0, "out of memory");
! 907:
! 908: /*
! 909: * reset all the entries
! 910: */
! 911: free_all_prunes();
! 912: free_all_routes();
! 913: free_all_callouts();
! 914: stop_all_vifs();
! 915: k_stop_dvmrp();
! 916: close(igmp_socket);
! 917: close(udp_socket);
! 918: did_final_init = 0;
! 919:
! 920: /*
! 921: * start processing again
! 922: */
! 923: dvmrp_genid++;
! 924:
! 925: init_igmp();
! 926: init_routes();
! 927: init_ktable();
! 928: init_vifs();
! 929: /*XXX Schedule final_init() as main does? */
! 930: final_init(s);
! 931:
! 932: /* schedule timer interrupts */
! 933: timer_setTimer(1, fasttimer, NULL);
! 934: timer_setTimer(TIMER_INTERVAL, timer, NULL);
! 935: }
! 936:
! 937: #define LOG_MAX_MSGS 20 /* if > 20/minute then shut up for a while */
! 938: #define LOG_SHUT_UP 600 /* shut up for 10 minutes */
! 939: static int log_nmsgs = 0;
! 940:
! 941: static void resetlogging(void *arg)
! 942: {
! 943: int nxttime = 60;
! 944: void *narg = NULL;
! 945:
! 946: if (arg == NULL && log_nmsgs > LOG_MAX_MSGS) {
! 947: nxttime = LOG_SHUT_UP;
! 948: narg = (void *)&log_nmsgs; /* just need some valid void * */
! 949: syslog(LOG_WARNING, "logging too fast, shutting up for %d minutes",
! 950: LOG_SHUT_UP / 60);
! 951: } else {
! 952: log_nmsgs = 0;
! 953: }
! 954:
! 955: timer_setTimer(nxttime, resetlogging, narg);
! 956: }
! 957:
! 958: #define SCALETIMEBUFLEN 20
! 959: char *scaletime(u_long t)
! 960: {
! 961: static char buf1[SCALETIMEBUFLEN];
! 962: static char buf2[SCALETIMEBUFLEN];
! 963: static char *buf = buf1;
! 964: char *p;
! 965:
! 966: p = buf;
! 967: if (buf == buf1)
! 968: buf = buf2;
! 969: else
! 970: buf = buf1;
! 971:
! 972: snprintf(p, SCALETIMEBUFLEN, "%2ld:%02ld:%02ld", t / 3600, (t % 3600) / 60, t % 60);
! 973:
! 974: return p;
! 975: }
! 976:
! 977: #ifdef RINGBUFFER
! 978: #define NLOGMSGS 10000
! 979: #define LOGMSGSIZE 200
! 980: char *logmsg[NLOGMSGS];
! 981: static int logmsgno = 0;
! 982:
! 983: void printringbuf(void)
! 984: {
! 985: FILE *f;
! 986: int i;
! 987:
! 988: f = fopen("/var/tmp/mrouted.log", "a");
! 989: if (f == NULL) {
! 990: logit(LOG_ERR, errno, "Cannot open /var/tmp/mrouted.log");
! 991: /*NOTREACHED*/
! 992: }
! 993: fprintf(f, "--------------------------------------------\n");
! 994:
! 995: i = (logmsgno + 1) % NLOGMSGS;
! 996:
! 997: while (i != logmsgno) {
! 998: if (*logmsg[i]) {
! 999: fprintf(f, "%s\n", logmsg[i]);
! 1000: *logmsg[i] = '\0';
! 1001: }
! 1002: i = (i + 1) % NLOGMSGS;
! 1003: }
! 1004:
! 1005: fclose(f);
! 1006: }
! 1007: #endif
! 1008:
! 1009: /*
! 1010: * Log errors and other messages to the system log daemon and to stderr,
! 1011: * according to the severity of the message and the current debug level.
! 1012: * For errors of severity LOG_ERR or worse, terminate the program.
! 1013: */
! 1014: void logit(int severity, int syserr, const char *format, ...)
! 1015: {
! 1016: va_list ap;
! 1017: static char fmt[211] = "warning - ";
! 1018: char *msg;
! 1019: struct timeval now;
! 1020: time_t now_sec;
! 1021: struct tm *thyme;
! 1022: #ifdef RINGBUFFER
! 1023: static int ringbufinit = 0;
! 1024: #endif
! 1025:
! 1026: va_start(ap, format);
! 1027: vsnprintf(&fmt[10], sizeof(fmt) - 10, format, ap);
! 1028: va_end(ap);
! 1029: msg = (severity == LOG_WARNING) ? fmt : &fmt[10];
! 1030:
! 1031: #ifdef RINGBUFFER
! 1032: if (!ringbufinit) {
! 1033: int i;
! 1034:
! 1035: for (i = 0; i < NLOGMSGS; i++) {
! 1036: logmsg[i] = malloc(LOGMSGSIZE);
! 1037: if (logmsg[i] == 0) {
! 1038: syslog(LOG_ERR, "Out of memory");
! 1039: exit(1);
! 1040: }
! 1041: *logmsg[i] = 0;
! 1042: }
! 1043: ringbufinit = 1;
! 1044: }
! 1045: gettimeofday(&now,NULL);
! 1046: now_sec = now.tv_sec;
! 1047: thyme = localtime(&now_sec);
! 1048: snprintf(logmsg[logmsgno++], LOGMSGSIZE, "%02d:%02d:%02d.%03ld %s err %d",
! 1049: thyme->tm_hour, thyme->tm_min, thyme->tm_sec,
! 1050: now.tv_usec / 1000, msg, syserr);
! 1051: logmsgno %= NLOGMSGS;
! 1052: if (severity <= LOG_NOTICE)
! 1053: #endif
! 1054: /*
! 1055: * Log to stderr if we haven't forked yet and it's a warning or worse,
! 1056: * or if we're debugging.
! 1057: */
! 1058: if (haveterminal && (debug || severity <= LOG_WARNING)) {
! 1059: gettimeofday(&now,NULL);
! 1060: now_sec = now.tv_sec;
! 1061: thyme = localtime(&now_sec);
! 1062: if (!debug)
! 1063: fprintf(stderr, "%s: ", __progname);
! 1064: fprintf(stderr, "%02d:%02d:%02d.%03ld %s", thyme->tm_hour,
! 1065: thyme->tm_min, thyme->tm_sec, now.tv_usec / 1000, msg);
! 1066: if (syserr == 0)
! 1067: fprintf(stderr, "\n");
! 1068: else
! 1069: fprintf(stderr, ": %s\n", strerror(syserr));
! 1070: }
! 1071:
! 1072: /*
! 1073: * Always log things that are worse than warnings, no matter what
! 1074: * the log_nmsgs rate limiter says.
! 1075: * Only count things worse than debugging in the rate limiter
! 1076: * (since if you put daemon.debug in syslog.conf you probably
! 1077: * actually want to log the debugging messages so they shouldn't
! 1078: * be rate-limited)
! 1079: */
! 1080: if ((severity < LOG_WARNING) || (log_nmsgs < LOG_MAX_MSGS)) {
! 1081: if (severity < LOG_DEBUG)
! 1082: log_nmsgs++;
! 1083: if (syserr != 0) {
! 1084: errno = syserr;
! 1085: syslog(severity, "%s: %m", msg);
! 1086: } else
! 1087: syslog(severity, "%s", msg);
! 1088: }
! 1089:
! 1090: if (severity <= LOG_ERR) exit(1);
! 1091: }
! 1092:
! 1093: #ifdef DEBUG_MFC
! 1094: void md_log(int what, u_int32 origin, u_int32 mcastgrp)
! 1095: {
! 1096: static FILE *f = NULL;
! 1097: struct timeval tv;
! 1098: u_int32 buf[4];
! 1099:
! 1100: if (!f) {
! 1101: if ((f = fopen("/tmp/mrouted.clog", "w")) == NULL) {
! 1102: logit(LOG_ERR, errno, "open /tmp/mrouted.clog");
! 1103: }
! 1104: }
! 1105:
! 1106: gettimeofday(&tv, NULL);
! 1107: buf[0] = tv.tv_sec;
! 1108: buf[1] = what;
! 1109: buf[2] = origin;
! 1110: buf[3] = mcastgrp;
! 1111:
! 1112: fwrite(buf, sizeof(u_int32), 4, f);
! 1113: }
! 1114: #endif
! 1115:
! 1116: /**
! 1117: * Local Variables:
! 1118: * version-control: t
! 1119: * indent-tabs-mode: t
! 1120: * c-file-style: "ellemtel"
! 1121: * c-basic-offset: 4
! 1122: * End:
! 1123: */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to main.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / mrouted