Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.sbin/mrouted/main.c	Lines:	0	216	0.0 %
Date:	2017-11-07	Branches:	0	106	0.0 %


/*	$NetBSD: main.c,v 1.6 1995/12/10 10:07:05 mycroft Exp $	*/

/*
 * The mrouted program is covered by the license in the accompanying file
 * named "LICENSE".  Use of the mrouted program represents acceptance of
 * the terms and conditions listed in that file.
 *
 * The mrouted program is COPYRIGHT 1989 by The Board of Trustees of
 * Leland Stanford Junior University.
 */

/*
 * Written by Steve Deering, Stanford University, February 1989.
 *
 * (An earlier version of DVMRP was implemented by David Waitzman of
 *  BBN STC by extending Berkeley's routed program.  Some of Waitzman's
 *  extensions have been incorporated into mrouted, but none of the
 *  original routed code has been adopted.)
 */


#include "defs.h"
#include <stdarg.h>
#include <fcntl.h>
#include <poll.h>
#include <err.h>

extern char *configfilename;
char versionstring[100];

static char dumpfilename[] = _PATH_MROUTED_DUMP;
static char cachefilename[] = _PATH_MROUTED_CACHE;
static char genidfilename[] = _PATH_MROUTED_GENID;

int cache_lifetime	= DEFAULT_CACHE_LIFETIME;
int max_prune_lifetime	= DEFAULT_CACHE_LIFETIME * 2;

int debug = 0;
u_char pruning = 1;	/* Enable pruning by default */

#define NHANDLERS	2

static struct ihandler {
    int fd;			/* File descriptor		*/
    ihfunc_t func;		/* Function to call		*/
} ihandlers[NHANDLERS];
static int nhandlers = 0;

/*
 * Forward declarations.
 */
static void fasttimer(int);
static void done(int);
static void dump(int);
static void fdump(int);
static void cdump(int);
static void restart(int);
static void timer(void);
static void cleanup(void);
static void resetlogging(void *);

int
register_input_handler(int fd, ihfunc_t func)
{
    if (nhandlers >= NHANDLERS)
	return -1;

    ihandlers[nhandlers].fd = fd;
    ihandlers[nhandlers++].func = func;

    return 0;
}

int
main(int argc, char *argv[])
{
    int recvlen;
    int dummy;
    FILE *fp;
    struct timeval now;
    u_int32_t prev_genid;
    struct pollfd *pfd;
    int vers, n, i, ch;
    sigset_t mask, omask;
    const char *errstr;

    if (geteuid() != 0) {
	fprintf(stderr, "must be root\n");
	exit(1);
    }
    setvbuf(stderr, NULL, _IOLBF, 0);

    while ((ch = getopt(argc, argv, "c:d::p")) != -1) {
	    switch (ch) {
	    case 'c':
		    configfilename = optarg;
		    break;
	    case 'd':
		    if (!optarg)
			    debug = DEFAULT_DEBUG;
		    else {
			    debug = strtonum(optarg, 0, 3, &errstr);
			    if (errstr) {
				    warnx("debug level %s", errstr);
				    debug = DEFAULT_DEBUG;
			    }
		    }
		    break;
	    case 'p':
		    pruning = 0;
		    break;
	    default:
		    goto usage;
	    }
    }
    argc -= optind;
    argv += optind;

    if (argc > 0) {
usage:	fprintf(stderr,
		"usage: mrouted [-p] [-c config_file] [-d [debug_level]]\n");
	exit(1);
    }

    if (debug == 0) {
	/*
	 * Detach from the terminal
	 */
	int t;

	if (fork()) exit(0);
	(void)close(0);
	(void)close(1);
	(void)close(2);
	(void)open("/dev/null", O_RDONLY);
	(void)dup2(0, 1);
	(void)dup2(0, 2);
#ifdef SYSV
	(void)setpgrp();
#else
#ifdef TIOCNOTTY
	t = open("/dev/tty", O_RDWR);
	if (t >= 0) {
	    (void)ioctl(t, TIOCNOTTY, (char *)0);
	    (void)close(t);
	}
#else
	if (setsid() < 0)
	    perror("setsid");
#endif
#endif
    }
    else
	fprintf(stderr, "debug level %u\n", debug);

#ifdef LOG_DAEMON
    (void)openlog("mrouted", LOG_PID, LOG_DAEMON);
    (void)setlogmask(LOG_UPTO(LOG_NOTICE));
#else
    (void)openlog("mrouted", LOG_PID);
#endif
    snprintf(versionstring, sizeof versionstring, "mrouted version %d.%d",
			PROTOCOL_VERSION, MROUTED_VERSION);

    logit(LOG_NOTICE, 0, "%s", versionstring);

    /*
     * Get generation id
     */
    gettimeofday(&now, NULL);
    dvmrp_genid = (u_int32_t)now.tv_sec;	/* for a while after 2038 */

    fp = fopen(genidfilename, "r");
    if (fp != NULL) {
	fscanf(fp, "%d", &prev_genid);
	if (prev_genid == dvmrp_genid)
	    dvmrp_genid++;
	(void) fclose(fp);
    }

    fp = fopen(genidfilename, "w");
    if (fp != NULL) {
	fprintf(fp, "%d", dvmrp_genid);
	(void) fclose(fp);
    }

    callout_init();
    init_igmp();
    init_routes();
    init_ktable();
    k_init_dvmrp();		/* enable DVMRP routing in kernel */

#ifndef OLD_KERNEL
    vers = k_get_version();
    /*XXX
     * This function must change whenever the kernel version changes
     */
    if ((((vers >> 8) & 0xff) != 3) ||
	 ((vers & 0xff) != 5))
	logit(LOG_ERR, 0, "kernel (v%d.%d)/mrouted (v%d.%d) version mismatch",
		(vers >> 8) & 0xff, vers & 0xff,
		PROTOCOL_VERSION, MROUTED_VERSION);
#endif

    init_vifs();

#ifdef RSRR
    rsrr_init();
#endif /* RSRR */

    /*
     * Allow cleanup if unexpected exit.  Apparently some architectures
     * have a kernel bug where closing the socket doesn't do an
     * ip_mrouter_done(), so we attempt to do it on exit.
     */
    atexit(cleanup);

    if (debug)
	fprintf(stderr, "pruning %s\n", pruning ? "on" : "off");

    (void)signal(SIGALRM, fasttimer);

    (void)signal(SIGHUP,  restart);
    (void)signal(SIGTERM, done);
    (void)signal(SIGINT,  done);
    (void)signal(SIGUSR1, fdump);
    (void)signal(SIGUSR2, cdump);
    if (debug != 0)
	(void)signal(SIGQUIT, dump);

    pfd = calloc(sizeof(struct pollfd), 1 + nhandlers);
    pfd[0].fd = igmp_socket;
    pfd[0].events = POLLIN;
    for (i = 0; i < nhandlers; i++) {
	pfd[i + 1].fd = ihandlers[i].fd;
	pfd[i + 1].events = POLLIN;
    }

    /*
     * Install the vifs in the kernel as late as possible in the
     * initialization sequence.
     */
    init_installvifs();

    if (debug >= 2) dump(0);

    /* Start up the log rate-limiter */
    resetlogging(NULL);

    (void)alarm(1);	 /* schedule first timer interrupt */

    /*
     * Main receive loop.
     */
    dummy = 0;
    for(;;) {
	if ((n = poll(pfd, nhandlers + 1, -1)) < 0) {
            if (errno != EINTR) /* SIGALRM is expected */
                logit(LOG_WARNING, errno, "poll failed");
            continue;
        }

	if (pfd[0].revents & POLLIN) {
	    recvlen = recvfrom(igmp_socket, recv_buf, RECV_BUF_SIZE,
			       0, NULL, &dummy);
	    if (recvlen < 0) {
		if (errno != EINTR) logit(LOG_ERR, errno, "recvfrom");
		continue;
	    }
	    (void)sigemptyset(&mask);
	    (void)sigaddset(&mask, SIGALRM);
	    if (sigprocmask(SIG_BLOCK, &mask, &omask) < 0)
		    logit(LOG_ERR, errno, "sigprocmask");
	    accept_igmp(recvlen);
	    (void)sigprocmask(SIG_SETMASK, &omask, NULL);
        }

	for (i = 0; i < nhandlers; i++) {
	    if (pfd[i + 1].revents & POLLIN) {
		(*ihandlers[i].func)(ihandlers[i].fd);
	    }
	}
    }
}


/*
 * routine invoked every second.  Its main goal is to cycle through
 * the routing table and send partial updates to all neighbors at a
 * rate that will cause the entire table to be sent in ROUTE_REPORT_INTERVAL
 * seconds.  Also, every TIMER_INTERVAL seconds it calls timer() to
 * do all the other time-based processing.
 */
/* XXX signal race */
static void
fasttimer(int i)
{
    static unsigned int tlast;
    static unsigned int nsent;
    unsigned int t = tlast + 1;
    int n;

    /*
     * if we're in the last second, send everything that's left.
     * otherwise send at least the fraction we should have sent by now.
     */
    if (t >= ROUTE_REPORT_INTERVAL) {
	int nleft = nroutes - nsent;
	while (nleft > 0) {
	    if ((n = report_next_chunk()) <= 0)
		break;
	    nleft -= n;
	}
	tlast = 0;
	nsent = 0;
    } else {
	unsigned int ncum = nroutes * t / ROUTE_REPORT_INTERVAL;
	while (nsent < ncum) {
	    if ((n = report_next_chunk()) <= 0)
		break;
	    nsent += n;
	}
	tlast = t;
    }
    if ((t % TIMER_INTERVAL) == 0)
	timer();

    age_callout_queue();/* Advance the timer for the callout queue
				for groups */
    alarm(1);
}

/*
 * The 'virtual_time' variable is initialized to a value that will cause the
 * first invocation of timer() to send a probe or route report to all vifs
 * and send group membership queries to all subnets for which this router is
 * querier.  This first invocation occurs approximately TIMER_INTERVAL seconds
 * after the router starts up.   Note that probes for neighbors and queries
 * for group memberships are also sent at start-up time, as part of initial-
 * ization.  This repetition after a short interval is desirable for quickly
 * building up topology and membership information in the presence of possible
 * packet loss.
 *
 * 'virtual_time' advances at a rate that is only a crude approximation of
 * real time, because it does not take into account any time spent processing,
 * and because the timer intervals are sometimes shrunk by a random amount to
 * avoid unwanted synchronization with other routers.
 */

static u_long virtual_time = 0;


/*
 * Timer routine.  Performs periodic neighbor probing, route reporting, and
 * group querying duties, and drives various timers in routing entries and
 * virtual interface data structures.
 */
static void
timer(void)
{
    age_routes();	/* Advance the timers in the route entries     */
    age_vifs();		/* Advance the timers for neighbors */
    age_table_entry();	/* Advance the timers for the cache entries */

    if (virtual_time % GROUP_QUERY_INTERVAL == 0) {
	/*
	 * Time to query the local group memberships on all subnets
	 * for which this router is the elected querier.
	 */
	query_groups();
    }

    if (virtual_time % NEIGHBOR_PROBE_INTERVAL == 0) {
	/*
	 * Time to send a probe on all vifs from which no neighbors have
	 * been heard.  Also, check if any inoperative interfaces have now
	 * come up.  (If they have, they will also be probed as part of
	 * their initialization.)
	 */
	probe_for_neighbors();

	if (vifs_down)
	    check_vif_state();
    }

    delay_change_reports = FALSE;
    if (routes_changed) {
	/*
	 * Some routes have changed since the last timer interrupt, but
	 * have not been reported yet.  Report the changed routes to all
	 * neighbors.
	 */
	report_to_all_neighbors(CHANGED_ROUTES);
    }

    /*
     * Advance virtual time
     */
    virtual_time += TIMER_INTERVAL;
}


/*
 * On termination, let everyone know we're going away.
 */
/* XXX signal race */
static void
done(int i)
{
    logit(LOG_NOTICE, 0, "%s exiting", versionstring);
    cleanup();
    _exit(1);
}

/* XXX signal race, atexit race */
static void
cleanup(void)
{
    static int in_cleanup = 0;

    if (!in_cleanup) {
	in_cleanup++;
#ifdef RSRR
	rsrr_clean();
#endif /* RSRR */
	expire_all_routes();
	report_to_all_neighbors(ALL_ROUTES);
	k_stop_dvmrp();
    }
}


/*
 * Dump internal data structures to stderr.
 */
/* XXX signal race */
static void
dump(int i)
{
    dump_vifs(stderr);
    dump_routes(stderr);
}


/*
 * Dump internal data structures to a file.
 */
static void
fdump(int i)
{
    FILE *fp;

    fp = fopen(dumpfilename, "w");
    if (fp != NULL) {
	dump_vifs(fp);
	dump_routes(fp);
	(void) fclose(fp);
    }
}


/*
 * Dump local cache contents to a file.
 */
/* XXX signal race */
static void
cdump(int i)
{
    FILE *fp;

    fp = fopen(cachefilename, "w");
    if (fp != NULL) {
	dump_cache(fp);
	(void) fclose(fp);
    }
}


/*
 * Restart mrouted
 */
/* XXX signal race */
static void
restart(int i)
{
    sigset_t mask, omask;

    logit(LOG_NOTICE, 0, "%s restart", versionstring);

    /*
     * reset all the entries
     */
    (void)sigemptyset(&mask);
    (void)sigaddset(&mask, SIGALRM);
    if (sigprocmask(SIG_BLOCK, &mask, &omask) < 0)
	logit(LOG_ERR, errno, "sigprocmask");
    free_all_prunes();
    free_all_routes();
    stop_all_vifs();
    k_stop_dvmrp();
    close(igmp_socket);
    close(udp_socket);

    /*
     * start processing again
     */
    dvmrp_genid++;
    pruning = 1;

    init_igmp();
    init_routes();
    init_ktable();
    init_vifs();
    k_init_dvmrp();		/* enable DVMRP routing in kernel */
    init_installvifs();

    (void)sigprocmask(SIG_SETMASK, &omask, NULL);
}

#define LOG_MAX_MSGS	20	/* if > 20/minute then shut up for a while */
#define LOG_SHUT_UP	600	/* shut up for 10 minutes */
static int log_nmsgs = 0;

static void
resetlogging(void *arg)
{
    int nxttime = 60;
    void *narg = NULL;

    if (arg == NULL && log_nmsgs > LOG_MAX_MSGS) {
	nxttime = LOG_SHUT_UP;
	narg = (void *)&log_nmsgs;	/* just need some valid void * */
	syslog(LOG_WARNING, "logging too fast, shutting up for %d minutes",
			LOG_SHUT_UP / 60);
    } else {
	log_nmsgs = 0;
    }

    timer_setTimer(nxttime, resetlogging, narg);
}

/*
 * Log errors and other messages to the system log daemon and to stderr,
 * according to the severity of the message and the current debug level.
 * For errors of severity LOG_ERR or worse, terminate the program.
 */
void
logit(int severity, int syserr, char *format, ...)
{
    va_list ap;
    static char fmt[211] = "warning - ";
    char *msg;
    char tbuf[20];
    struct timeval now;
    struct tm *thyme;
    time_t t;

    va_start(ap, format);
    vsnprintf(&fmt[10], sizeof fmt - 10, format, ap);
    va_end(ap);
    msg = (severity == LOG_WARNING) ? fmt : &fmt[10];

    switch (debug) {
	case 0: break;
	case 1: if (severity > LOG_NOTICE) break;
	case 2: if (severity > LOG_INFO  ) break;
	default:
	    gettimeofday(&now,NULL);
	    t = now.tv_sec;
	    thyme = localtime(&t);
	    strftime(tbuf, sizeof(tbuf), "%X.%%03d ", thyme);
	    fprintf(stderr, tbuf, now.tv_usec / 1000);
	    fprintf(stderr, "%s", msg);
	    if (syserr == 0)
		fprintf(stderr, "\n");
	    else if (syserr < sys_nerr)
		fprintf(stderr, ": %s\n", sys_errlist[syserr]);
	    else
		fprintf(stderr, ": errno %d\n", syserr);
    }

    if (severity <= LOG_NOTICE) {
	if (log_nmsgs++ < LOG_MAX_MSGS) {
	    if (syserr != 0) {
		errno = syserr;
		syslog(severity, "%s: %m", msg);
	    } else
		syslog(severity, "%s", msg);
	}

	if (severity <= LOG_ERR) exit(1);
    }
}

#ifdef DEBUG_MFC
void
md_logit(int what, u_int32_t origin, u_int32_t mcastgrp)
{
    static FILE *f = NULL;
    struct timeval tv;
    u_int32_t buf[4];

    if (!f) {
	if ((f = fopen("/tmp/mrouted.clog", "w")) == NULL) {
	    logit(LOG_ERR, errno, "open /tmp/mrouted.clog");
	}
    }

    gettimeofday(&tv, NULL);
    buf[0] = tv.tv_sec;
    buf[1] = what;
    buf[2] = origin;
    buf[3] = mcastgrp;

    fwrite(buf, sizeof(u_int32_t), 4, f);
}
#endif


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $NetBSD: main.c,v 1.6 1995/12/10 10:07:05 mycroft Exp $ */
2
3			/*
4			* The mrouted program is covered by the license in the accompanying file
5			* named "LICENSE". Use of the mrouted program represents acceptance of
6			* the terms and conditions listed in that file.
7			*
8			* The mrouted program is COPYRIGHT 1989 by The Board of Trustees of
9			* Leland Stanford Junior University.
10			*/
11
12			/*
13			* Written by Steve Deering, Stanford University, February 1989.
14			*
15			* (An earlier version of DVMRP was implemented by David Waitzman of
16			* BBN STC by extending Berkeley's routed program. Some of Waitzman's
17			* extensions have been incorporated into mrouted, but none of the
18			* original routed code has been adopted.)
19			*/
20
21
22			#include "defs.h"
23			#include <stdarg.h>
24			#include <fcntl.h>
25			#include <poll.h>
26			#include <err.h>
27
28			extern char *configfilename;
29			char versionstring[100];
30
31			static char dumpfilename[] = _PATH_MROUTED_DUMP;
32			static char cachefilename[] = _PATH_MROUTED_CACHE;
33			static char genidfilename[] = _PATH_MROUTED_GENID;
34
35			int cache_lifetime = DEFAULT_CACHE_LIFETIME;
36			int max_prune_lifetime = DEFAULT_CACHE_LIFETIME * 2;
37
38			int debug = 0;
39			u_char pruning = 1; /* Enable pruning by default */
40
41			#define NHANDLERS 2
42
43			static struct ihandler {
44			int fd; /* File descriptor */
45			ihfunc_t func; /* Function to call */
46			} ihandlers[NHANDLERS];
47			static int nhandlers = 0;
48
49			/*
50			* Forward declarations.
51			*/
52			static void fasttimer(int);
53			static void done(int);
54			static void dump(int);
55			static void fdump(int);
56			static void cdump(int);
57			static void restart(int);
58			static void timer(void);
59			static void cleanup(void);
60			static void resetlogging(void *);
61
62			int
63			register_input_handler(int fd, ihfunc_t func)
64			{
65			if (nhandlers >= NHANDLERS)
66			return -1;
67
68			ihandlers[nhandlers].fd = fd;
69			ihandlers[nhandlers++].func = func;
70
71			return 0;
72			}
73
74			int
75			main(int argc, char *argv[])
76			{
77			int recvlen;
78			int dummy;
79			FILE *fp;
80			struct timeval now;
81			u_int32_t prev_genid;
82			struct pollfd *pfd;
83			int vers, n, i, ch;
84			sigset_t mask, omask;
85			const char *errstr;
86
87			if (geteuid() != 0) {
88			fprintf(stderr, "must be root\n");
89			exit(1);
90			}
91			setvbuf(stderr, NULL, _IOLBF, 0);
92
93			while ((ch = getopt(argc, argv, "c:d::p")) != -1) {
94			switch (ch) {
95			case 'c':
96			configfilename = optarg;
97			break;
98			case 'd':
99			if (!optarg)
100			debug = DEFAULT_DEBUG;
101			else {
102			debug = strtonum(optarg, 0, 3, &errstr);
103			if (errstr) {
104			warnx("debug level %s", errstr);
105			debug = DEFAULT_DEBUG;
106			}
107			}
108			break;
109			case 'p':
110			pruning = 0;
111			break;
112			default:
113			goto usage;
114			}
115			}
116			argc -= optind;
117			argv += optind;
118
119			if (argc > 0) {
120			usage: fprintf(stderr,
121			"usage: mrouted [-p] [-c config_file] [-d [debug_level]]\n");
122			exit(1);
123			}
124
125			if (debug == 0) {
126			/*
127			* Detach from the terminal
128			*/
129			int t;
130
131			if (fork()) exit(0);
132			(void)close(0);
133			(void)close(1);
134			(void)close(2);
135			(void)open("/dev/null", O_RDONLY);
136			(void)dup2(0, 1);
137			(void)dup2(0, 2);
138			#ifdef SYSV
139			(void)setpgrp();
140			#else
141			#ifdef TIOCNOTTY
142			t = open("/dev/tty", O_RDWR);
143			if (t >= 0) {
144			(void)ioctl(t, TIOCNOTTY, (char *)0);
145			(void)close(t);
146			}
147			#else
148			if (setsid() < 0)
149			perror("setsid");
150			#endif
151			#endif
152			}
153			else
154			fprintf(stderr, "debug level %u\n", debug);
155
156			#ifdef LOG_DAEMON
157			(void)openlog("mrouted", LOG_PID, LOG_DAEMON);
158			(void)setlogmask(LOG_UPTO(LOG_NOTICE));
159			#else
160			(void)openlog("mrouted", LOG_PID);
161			#endif
162			snprintf(versionstring, sizeof versionstring, "mrouted version %d.%d",
163			PROTOCOL_VERSION, MROUTED_VERSION);
164
165			logit(LOG_NOTICE, 0, "%s", versionstring);
166
167			/*
168			* Get generation id
169			*/
170			gettimeofday(&now, NULL);
171			dvmrp_genid = (u_int32_t)now.tv_sec; /* for a while after 2038 */
172
173			fp = fopen(genidfilename, "r");
174			if (fp != NULL) {
175			fscanf(fp, "%d", &prev_genid);
176			if (prev_genid == dvmrp_genid)
177			dvmrp_genid++;
178			(void) fclose(fp);
179			}
180
181			fp = fopen(genidfilename, "w");
182			if (fp != NULL) {
183			fprintf(fp, "%d", dvmrp_genid);
184			(void) fclose(fp);
185			}
186
187			callout_init();
188			init_igmp();
189			init_routes();
190			init_ktable();
191			k_init_dvmrp(); /* enable DVMRP routing in kernel */
192
193			#ifndef OLD_KERNEL
194			vers = k_get_version();
195			/*XXX
196			* This function must change whenever the kernel version changes
197			*/
198			if ((((vers >> 8) & 0xff) != 3) \|\|
199			((vers & 0xff) != 5))
200			logit(LOG_ERR, 0, "kernel (v%d.%d)/mrouted (v%d.%d) version mismatch",
201			(vers >> 8) & 0xff, vers & 0xff,
202			PROTOCOL_VERSION, MROUTED_VERSION);
203			#endif
204
205			init_vifs();
206
207			#ifdef RSRR
208			rsrr_init();
209			#endif /* RSRR */
210
211			/*
212			* Allow cleanup if unexpected exit. Apparently some architectures
213			* have a kernel bug where closing the socket doesn't do an
214			* ip_mrouter_done(), so we attempt to do it on exit.
215			*/
216			atexit(cleanup);
217
218			if (debug)
219			fprintf(stderr, "pruning %s\n", pruning ? "on" : "off");
220
221			(void)signal(SIGALRM, fasttimer);
222
223			(void)signal(SIGHUP, restart);
224			(void)signal(SIGTERM, done);
225			(void)signal(SIGINT, done);
226			(void)signal(SIGUSR1, fdump);
227			(void)signal(SIGUSR2, cdump);
228			if (debug != 0)
229			(void)signal(SIGQUIT, dump);
230
231			pfd = calloc(sizeof(struct pollfd), 1 + nhandlers);
232			pfd[0].fd = igmp_socket;
233			pfd[0].events = POLLIN;
234			for (i = 0; i < nhandlers; i++) {
235			pfd[i + 1].fd = ihandlers[i].fd;
236			pfd[i + 1].events = POLLIN;
237			}
238
239			/*
240			* Install the vifs in the kernel as late as possible in the
241			* initialization sequence.
242			*/
243			init_installvifs();
244
245			if (debug >= 2) dump(0);
246
247			/* Start up the log rate-limiter */
248			resetlogging(NULL);
249
250			(void)alarm(1); /* schedule first timer interrupt */
251
252			/*
253			* Main receive loop.
254			*/
255			dummy = 0;
256			for(;;) {
257			if ((n = poll(pfd, nhandlers + 1, -1)) < 0) {
258			if (errno != EINTR) /* SIGALRM is expected */
259			logit(LOG_WARNING, errno, "poll failed");
260			continue;
261			}
262
263			if (pfd[0].revents & POLLIN) {
264			recvlen = recvfrom(igmp_socket, recv_buf, RECV_BUF_SIZE,
265			0, NULL, &dummy);
266			if (recvlen < 0) {
267			if (errno != EINTR) logit(LOG_ERR, errno, "recvfrom");
268			continue;
269			}
270			(void)sigemptyset(&mask);
271			(void)sigaddset(&mask, SIGALRM);
272			if (sigprocmask(SIG_BLOCK, &mask, &omask) < 0)
273			logit(LOG_ERR, errno, "sigprocmask");
274			accept_igmp(recvlen);
275			(void)sigprocmask(SIG_SETMASK, &omask, NULL);
276			}
277
278			for (i = 0; i < nhandlers; i++) {
279			if (pfd[i + 1].revents & POLLIN) {
280			(*ihandlers[i].func)(ihandlers[i].fd);
281			}
282			}
283			}
284			}
285
286
287			/*
288			* routine invoked every second. Its main goal is to cycle through
289			* the routing table and send partial updates to all neighbors at a
290			* rate that will cause the entire table to be sent in ROUTE_REPORT_INTERVAL
291			* seconds. Also, every TIMER_INTERVAL seconds it calls timer() to
292			* do all the other time-based processing.
293			*/
294			/* XXX signal race */
295			static void
296			fasttimer(int i)
297			{
298			static unsigned int tlast;
299			static unsigned int nsent;
300			unsigned int t = tlast + 1;
301			int n;
302
303			/*
304			* if we're in the last second, send everything that's left.
305			* otherwise send at least the fraction we should have sent by now.
306			*/
307			if (t >= ROUTE_REPORT_INTERVAL) {
308			int nleft = nroutes - nsent;
309			while (nleft > 0) {
310			if ((n = report_next_chunk()) <= 0)
311			break;
312			nleft -= n;
313			}
314			tlast = 0;
315			nsent = 0;
316			} else {
317			unsigned int ncum = nroutes * t / ROUTE_REPORT_INTERVAL;
318			while (nsent < ncum) {
319			if ((n = report_next_chunk()) <= 0)
320			break;
321			nsent += n;
322			}
323			tlast = t;
324			}
325			if ((t % TIMER_INTERVAL) == 0)
326			timer();
327
328			age_callout_queue();/* Advance the timer for the callout queue
329			for groups */
330			alarm(1);
331			}
332
333			/*
334			* The 'virtual_time' variable is initialized to a value that will cause the
335			* first invocation of timer() to send a probe or route report to all vifs
336			* and send group membership queries to all subnets for which this router is
337			* querier. This first invocation occurs approximately TIMER_INTERVAL seconds
338			* after the router starts up. Note that probes for neighbors and queries
339			* for group memberships are also sent at start-up time, as part of initial-
340			* ization. This repetition after a short interval is desirable for quickly
341			* building up topology and membership information in the presence of possible
342			* packet loss.
343			*
344			* 'virtual_time' advances at a rate that is only a crude approximation of
345			* real time, because it does not take into account any time spent processing,
346			* and because the timer intervals are sometimes shrunk by a random amount to
347			* avoid unwanted synchronization with other routers.
348			*/
349
350			static u_long virtual_time = 0;
351
352
353			/*
354			* Timer routine. Performs periodic neighbor probing, route reporting, and
355			* group querying duties, and drives various timers in routing entries and
356			* virtual interface data structures.
357			*/
358			static void
359			timer(void)
360			{
361			age_routes(); /* Advance the timers in the route entries */
362			age_vifs(); /* Advance the timers for neighbors */
363			age_table_entry(); /* Advance the timers for the cache entries */
364
365			if (virtual_time % GROUP_QUERY_INTERVAL == 0) {
366			/*
367			* Time to query the local group memberships on all subnets
368			* for which this router is the elected querier.
369			*/
370			query_groups();
371			}
372
373			if (virtual_time % NEIGHBOR_PROBE_INTERVAL == 0) {
374			/*
375			* Time to send a probe on all vifs from which no neighbors have
376			* been heard. Also, check if any inoperative interfaces have now
377			* come up. (If they have, they will also be probed as part of
378			* their initialization.)
379			*/
380			probe_for_neighbors();
381
382			if (vifs_down)
383			check_vif_state();
384			}
385
386			delay_change_reports = FALSE;
387			if (routes_changed) {
388			/*
389			* Some routes have changed since the last timer interrupt, but
390			* have not been reported yet. Report the changed routes to all
391			* neighbors.
392			*/
393			report_to_all_neighbors(CHANGED_ROUTES);
394			}
395
396			/*
397			* Advance virtual time
398			*/
399			virtual_time += TIMER_INTERVAL;
400			}
401
402
403			/*
404			* On termination, let everyone know we're going away.
405			*/
406			/* XXX signal race */
407			static void
408			done(int i)
409			{
410			logit(LOG_NOTICE, 0, "%s exiting", versionstring);
411			cleanup();
412			_exit(1);
413			}
414
415			/* XXX signal race, atexit race */
416			static void
417			cleanup(void)
418			{
419			static int in_cleanup = 0;
420
421			if (!in_cleanup) {
422			in_cleanup++;
423			#ifdef RSRR
424			rsrr_clean();
425			#endif /* RSRR */
426			expire_all_routes();
427			report_to_all_neighbors(ALL_ROUTES);
428			k_stop_dvmrp();
429			}
430			}
431
432
433			/*
434			* Dump internal data structures to stderr.
435			*/
436			/* XXX signal race */
437			static void
438			dump(int i)
439			{
440			dump_vifs(stderr);
441			dump_routes(stderr);
442			}
443
444
445			/*
446			* Dump internal data structures to a file.
447			*/
448			static void
449			fdump(int i)
450			{
451			FILE *fp;
452
453			fp = fopen(dumpfilename, "w");
454			if (fp != NULL) {
455			dump_vifs(fp);
456			dump_routes(fp);
457			(void) fclose(fp);
458			}
459			}
460
461
462			/*
463			* Dump local cache contents to a file.
464			*/
465			/* XXX signal race */
466			static void
467			cdump(int i)
468			{
469			FILE *fp;
470
471			fp = fopen(cachefilename, "w");
472			if (fp != NULL) {
473			dump_cache(fp);
474			(void) fclose(fp);
475			}
476			}
477
478
479			/*
480			* Restart mrouted
481			*/
482			/* XXX signal race */
483			static void
484			restart(int i)
485			{
486			sigset_t mask, omask;
487
488			logit(LOG_NOTICE, 0, "%s restart", versionstring);
489
490			/*
491			* reset all the entries
492			*/
493			(void)sigemptyset(&mask);
494			(void)sigaddset(&mask, SIGALRM);
495			if (sigprocmask(SIG_BLOCK, &mask, &omask) < 0)
496			logit(LOG_ERR, errno, "sigprocmask");
497			free_all_prunes();
498			free_all_routes();
499			stop_all_vifs();
500			k_stop_dvmrp();
501			close(igmp_socket);
502			close(udp_socket);
503
504			/*
505			* start processing again
506			*/
507			dvmrp_genid++;
508			pruning = 1;
509
510			init_igmp();
511			init_routes();
512			init_ktable();
513			init_vifs();
514			k_init_dvmrp(); /* enable DVMRP routing in kernel */
515			init_installvifs();
516
517			(void)sigprocmask(SIG_SETMASK, &omask, NULL);
518			}
519
520			#define LOG_MAX_MSGS 20 /* if > 20/minute then shut up for a while */
521			#define LOG_SHUT_UP 600 /* shut up for 10 minutes */
522			static int log_nmsgs = 0;
523
524			static void
525			resetlogging(void *arg)
526			{
527			int nxttime = 60;
528			void *narg = NULL;
529
530			if (arg == NULL && log_nmsgs > LOG_MAX_MSGS) {
531			nxttime = LOG_SHUT_UP;
532			narg = (void )&log_nmsgs; / just need some valid void * */
533			syslog(LOG_WARNING, "logging too fast, shutting up for %d minutes",
534			LOG_SHUT_UP / 60);
535			} else {
536			log_nmsgs = 0;
537			}
538
539			timer_setTimer(nxttime, resetlogging, narg);
540			}
541
542			/*
543			* Log errors and other messages to the system log daemon and to stderr,
544			* according to the severity of the message and the current debug level.
545			* For errors of severity LOG_ERR or worse, terminate the program.
546			*/
547			void
548			logit(int severity, int syserr, char *format, ...)
549			{
550			va_list ap;
551			static char fmt[211] = "warning - ";
552			char *msg;
553			char tbuf[20];
554			struct timeval now;
555			struct tm *thyme;
556			time_t t;
557
558			va_start(ap, format);
559			vsnprintf(&fmt[10], sizeof fmt - 10, format, ap);
560			va_end(ap);
561			msg = (severity == LOG_WARNING) ? fmt : &fmt[10];
562
563			switch (debug) {
564			case 0: break;
565			case 1: if (severity > LOG_NOTICE) break;
566			case 2: if (severity > LOG_INFO ) break;
567			default:
568			gettimeofday(&now,NULL);
569			t = now.tv_sec;
570			thyme = localtime(&t);
571			strftime(tbuf, sizeof(tbuf), "%X.%%03d ", thyme);
572			fprintf(stderr, tbuf, now.tv_usec / 1000);
573			fprintf(stderr, "%s", msg);
574			if (syserr == 0)
575			fprintf(stderr, "\n");
576			else if (syserr < sys_nerr)
577			fprintf(stderr, ": %s\n", sys_errlist[syserr]);
578			else
579			fprintf(stderr, ": errno %d\n", syserr);
580			}
581
582			if (severity <= LOG_NOTICE) {
583			if (log_nmsgs++ < LOG_MAX_MSGS) {
584			if (syserr != 0) {
585			errno = syserr;
586			syslog(severity, "%s: %m", msg);
587			} else
588			syslog(severity, "%s", msg);
589			}
590
591			if (severity <= LOG_ERR) exit(1);
592			}
593			}
594
595			#ifdef DEBUG_MFC
596			void
597			md_logit(int what, u_int32_t origin, u_int32_t mcastgrp)
598			{
599			static FILE *f = NULL;
600			struct timeval tv;
601			u_int32_t buf[4];
602
603			if (!f) {
604			if ((f = fopen("/tmp/mrouted.clog", "w")) == NULL) {
605			logit(LOG_ERR, errno, "open /tmp/mrouted.clog");
606			}
607			}
608
609			gettimeofday(&tv, NULL);
610			buf[0] = tv.tv_sec;
611			buf[1] = what;
612			buf[2] = origin;
613			buf[3] = mcastgrp;
614
615			fwrite(buf, sizeof(u_int32_t), 4, f);
616			}
617			#endif