Home | History | Annotate | Line # | Download | only in routed
trace.c revision 1.25 
      1 /*	$NetBSD: trace.c,v 1.25 2001/03/10 23:52:47 christos Exp $	*/
      2 
      3 /*
      4  * Copyright (c) 1983, 1988, 1993
      5  *	The Regents of the University of California.  All rights reserved.
      6  *
      7  * Redistribution and use in source and binary forms, with or without
      8  * modification, are permitted provided that the following conditions
      9  * are met:
     10  * 1. Redistributions of source code must retain the above copyright
     11  *    notice, this list of conditions and the following disclaimer.
     12  * 2. Redistributions in binary form must reproduce the above copyright
     13  *    notice, this list of conditions and the following disclaimer in the
     14  *    documentation and/or other materials provided with the distribution.
     15  * 3. All advertising materials mentioning features or use of this software
     16  *    must display the following acknowledgment:
     17  *	This product includes software developed by the University of
     18  *	California, Berkeley and its contributors.
     19  * 4. Neither the name of the University nor the names of its contributors
     20  *    may be used to endorse or promote products derived from this software
     21  *    without specific prior written permission.
     22  *
     23  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     33  * SUCH DAMAGE.
     34  */
     35 
     36 #define	RIPCMDS
     37 #include "defs.h"
     38 #include "pathnames.h"
     39 #include <sys/stat.h>
     40 #include <sys/signal.h>
     41 #include <fcntl.h>
     42 
     43 #ifdef __NetBSD__
     44 __RCSID("$NetBSD: trace.c,v 1.25 2001/03/10 23:52:47 christos Exp $");
     45 #elif defined(__FreeBSD__)
     46 __RCSID("$FreeBSD$");
     47 #else
     48 __RCSID("Revision: 2.23 ");
     49 #ident "Revision: 2.23 "
     50 #endif
     51 
     52 #ifdef sgi
     53 /* use *stat64 for files on large filesystems */
     54 #define stat	stat64
     55 #endif
     56 
     57 #define	NRECORDS	50		/* size of circular trace buffer */
     58 
     59 int	tracelevel, new_tracelevel;
     60 FILE	*ftrace = stdout;		/* output trace file */
     61 static const char *sigtrace_pat = "%s";
     62 static char savetracename[MAXPATHLEN+1];
     63 char	inittracename[MAXPATHLEN+1];
     64 int	file_trace;			/* 1=tracing to file, not stdout */
     65 
     66 static void trace_dump(void);
     67 static void tmsg(const char *, ...) PATTRIB(1,2);
     68 
     69 
     70 /* convert string to printable characters
     71  */
     72 static char *
     73 qstring(u_char *s, int len)
     74 {
     75 	static char buf[8*20+1];
     76 	char *p;
     77 	u_char *s2, c;
     78 
     79 
     80 	for (p = buf; len != 0 && p < &buf[sizeof(buf)-1]; len--) {
     81 		c = *s++;
     82 		if (c == '\0') {
     83 			for (s2 = s+1; s2 < &s[len]; s2++) {
     84 				if (*s2 != '\0')
     85 					break;
     86 			}
     87 			if (s2 >= &s[len])
     88 			    goto exit;
     89 		}
     90 
     91 		if (c >= ' ' && c < 0x7f && c != '\\') {
     92 			*p++ = c;
     93 			continue;
     94 		}
     95 		*p++ = '\\';
     96 		switch (c) {
     97 		case '\\':
     98 			*p++ = '\\';
     99 			break;
    100 		case '\n':
    101 			*p++= 'n';
    102 			break;
    103 		case '\r':
    104 			*p++= 'r';
    105 			break;
    106 		case '\t':
    107 			*p++ = 't';
    108 			break;
    109 		case '\b':
    110 			*p++ = 'b';
    111 			break;
    112 		default:
    113 			p += sprintf(p,"%o",c);
    114 			break;
    115 		}
    116 	}
    117 exit:
    118 	*p = '\0';
    119 	return buf;
    120 }
    121 
    122 
    123 /* convert IP address to a string, but not into a single buffer
    124  */
    125 char *
    126 naddr_ntoa(naddr a)
    127 {
    128 #define NUM_BUFS 4
    129 	static int bufno;
    130 	static struct {
    131 	    char    str[16];		/* xxx.xxx.xxx.xxx\0 */
    132 	} bufs[NUM_BUFS];
    133 	char *s;
    134 	struct in_addr addr;
    135 
    136 	addr.s_addr = a;
    137 	s = strcpy(bufs[bufno].str, inet_ntoa(addr));
    138 	bufno = (bufno+1) % NUM_BUFS;
    139 	return s;
    140 #undef NUM_BUFS
    141 }
    142 
    143 
    144 const char *
    145 saddr_ntoa(struct sockaddr *sa)
    146 {
    147 	return (sa == 0) ? "?" : naddr_ntoa(S_ADDR(sa));
    148 }
    149 
    150 
    151 static char *
    152 ts(time_t secs) {
    153 	static char s[20];
    154 
    155 	secs += epoch.tv_sec;
    156 #ifdef sgi
    157 	(void)cftime(s, "%T", &secs);
    158 #else
    159 	memcpy(s, ctime(&secs)+11, 8);
    160 	s[8] = '\0';
    161 #endif
    162 	return s;
    163 }
    164 
    165 
    166 /* On each event, display a time stamp.
    167  * This assumes that 'now' is update once for each event, and
    168  * that at least now.tv_usec changes.
    169  */
    170 static struct timeval lastlog_time;
    171 
    172 void
    173 lastlog(void)
    174 {
    175 	if (lastlog_time.tv_sec != now.tv_sec
    176 	    || lastlog_time.tv_usec != now.tv_usec) {
    177 		(void)fprintf(ftrace, "-- %s --\n", ts(now.tv_sec));
    178 		lastlog_time = now;
    179 	}
    180 }
    181 
    182 
    183 static void
    184 tmsg(const char *p, ...)
    185 {
    186 	va_list args;
    187 
    188 	if (ftrace != 0) {
    189 		lastlog();
    190 		va_start(args, p);
    191 		vfprintf(ftrace, p, args);
    192 		(void)fputc('\n',ftrace);
    193 		fflush(ftrace);
    194 	}
    195 }
    196 
    197 
    198 void
    199 trace_close(int zap_stdio)
    200 {
    201 	int fd;
    202 
    203 
    204 	fflush(stdout);
    205 	fflush(stderr);
    206 
    207 	if (ftrace != 0 && zap_stdio) {
    208 		if (ftrace != stdout)
    209 			fclose(ftrace);
    210 		ftrace = 0;
    211 		fd = open(_PATH_DEVNULL, O_RDWR);
    212 		if (isatty(STDIN_FILENO))
    213 			(void)dup2(fd, STDIN_FILENO);
    214 		if (isatty(STDOUT_FILENO))
    215 			(void)dup2(fd, STDOUT_FILENO);
    216 		if (isatty(STDERR_FILENO))
    217 			(void)dup2(fd, STDERR_FILENO);
    218 		(void)close(fd);
    219 	}
    220 	lastlog_time.tv_sec = 0;
    221 }
    222 
    223 
    224 void
    225 trace_flush(void)
    226 {
    227 	if (ftrace != 0) {
    228 		fflush(ftrace);
    229 		if (ferror(ftrace))
    230 			trace_off("tracing off: %s", strerror(ferror(ftrace)));
    231 	}
    232 }
    233 
    234 
    235 void
    236 trace_off(const char *p, ...)
    237 {
    238 	va_list args;
    239 
    240 
    241 	if (ftrace != 0) {
    242 		lastlog();
    243 		va_start(args, p);
    244 		vfprintf(ftrace, p, args);
    245 		(void)fputc('\n',ftrace);
    246 	}
    247 	trace_close(file_trace);
    248 
    249 	new_tracelevel = tracelevel = 0;
    250 }
    251 
    252 
    253 /* log a change in tracing
    254  */
    255 void
    256 tracelevel_msg(const char *pat,
    257 	       int dump)		/* -1=no dump, 0=default, 1=force */
    258 {
    259 	static const char *off_msgs[MAX_TRACELEVEL] = {
    260 		"Tracing actions stopped",
    261 		"Tracing packets stopped",
    262 		"Tracing packet contents stopped",
    263 		"Tracing kernel changes stopped",
    264 	};
    265 	static const char *on_msgs[MAX_TRACELEVEL] = {
    266 		"Tracing actions started",
    267 		"Tracing packets started",
    268 		"Tracing packet contents started",
    269 		"Tracing kernel changes started",
    270 	};
    271 	u_int old_tracelevel = tracelevel;
    272 
    273 
    274 	if (new_tracelevel < 0)
    275 		new_tracelevel = 0;
    276 	else if (new_tracelevel > MAX_TRACELEVEL)
    277 		new_tracelevel = MAX_TRACELEVEL;
    278 
    279 	if (new_tracelevel < tracelevel) {
    280 		if (new_tracelevel <= 0) {
    281 			trace_off(pat, off_msgs[0]);
    282 		} else do {
    283 			tmsg(pat, off_msgs[tracelevel]);
    284 		}
    285 		while (--tracelevel != new_tracelevel);
    286 
    287 	} else if (new_tracelevel > tracelevel) {
    288 		do {
    289 			tmsg(pat, on_msgs[tracelevel++]);
    290 		} while (tracelevel != new_tracelevel);
    291 	}
    292 
    293 	if (dump > 0
    294 	    || (dump == 0 && old_tracelevel == 0 && tracelevel != 0))
    295 		trace_dump();
    296 }
    297 
    298 
    299 void
    300 set_tracefile(const char *filename,
    301 	      const char *pat,
    302 	      int dump)			/* -1=no dump, 0=default, 1=force */
    303 {
    304 	struct stat stbuf;
    305 	FILE *n_ftrace;
    306 	const char *fn;
    307 
    308 
    309 	/* Allow a null filename to increase the level if the trace file
    310 	 * is already open or if coming from a trusted source, such as
    311 	 * a signal or the command line.
    312 	 */
    313 	if (filename == 0 || filename[0] == '\0') {
    314 		filename = 0;
    315 		if (ftrace == 0) {
    316 			if (inittracename[0] == '\0') {
    317 				msglog("missing trace file name");
    318 				return;
    319 			}
    320 			fn = inittracename;
    321 		} else {
    322 			fn = 0;
    323 		}
    324 
    325 	} else if (!strcmp(filename,"dump/../table")) {
    326 		trace_dump();
    327 		return;
    328 
    329 	} else {
    330 		/* Allow the file specified with "-T file" to be reopened,
    331 		 * but require all other names specified over the net to
    332 		 * match the official path.  The path can specify a directory
    333 		 * in which the file is to be created.
    334 		 */
    335 		if (strcmp(filename, inittracename)
    336 #ifdef _PATH_TRACE
    337 		    && (strncmp(filename, _PATH_TRACE, sizeof(_PATH_TRACE)-1)
    338 			|| strstr(filename,"../")
    339 			|| 0 > stat(_PATH_TRACE, &stbuf))
    340 #endif
    341 		    ) {
    342 			msglog("wrong trace file \"%s\"", filename);
    343 			return;
    344 		}
    345 
    346 		/* If the new tracefile exists, it must be a regular file.
    347 		 */
    348 		if (stat(filename, &stbuf) >= 0 && !S_ISREG(stbuf.st_mode)) {
    349 			msglog("wrong type (%#x) of trace file \"%s\"",
    350 			       stbuf.st_mode, filename);
    351 			return;
    352 		}
    353 
    354 		fn = filename;
    355 	}
    356 
    357 	if (fn != 0) {
    358 		n_ftrace = fopen(fn, "a");
    359 		if (n_ftrace == 0) {
    360 			msglog("failed to open trace file \"%s\" %s",
    361 			       fn, strerror(errno));
    362 			if (fn == inittracename)
    363 				inittracename[0] = '\0';
    364 			return;
    365 		}
    366 
    367 		tmsg("switch to trace file %s", fn);
    368 
    369 		trace_close(file_trace = 1);
    370 
    371 		if (fn != savetracename)
    372 			strncpy(savetracename, fn, sizeof(savetracename)-1);
    373 		ftrace = n_ftrace;
    374 
    375 		fflush(stdout);
    376 		fflush(stderr);
    377 		dup2(fileno(ftrace), STDOUT_FILENO);
    378 		dup2(fileno(ftrace), STDERR_FILENO);
    379 	}
    380 
    381 	if (new_tracelevel == 0 || filename == 0)
    382 		new_tracelevel++;
    383 	tracelevel_msg(pat, dump != 0 ? dump : (filename != 0));
    384 }
    385 
    386 
    387 /* ARGSUSED */
    388 void
    389 sigtrace_on(int s UNUSED)
    390 {
    391 	new_tracelevel++;
    392 	sigtrace_pat = "SIGUSR1: %s";
    393 }
    394 
    395 
    396 /* ARGSUSED */
    397 void
    398 sigtrace_off(int s UNUSED)
    399 {
    400 	new_tracelevel--;
    401 	sigtrace_pat = "SIGUSR2: %s";
    402 }
    403 
    404 
    405 /* Set tracing after a signal.
    406  */
    407 void
    408 set_tracelevel(void)
    409 {
    410 	if (new_tracelevel == tracelevel)
    411 		return;
    412 
    413 	/* If tracing entirely off, and there was no tracefile specified
    414 	 * on the command line, then leave it off.
    415 	 */
    416 	if (new_tracelevel > tracelevel && ftrace == 0) {
    417 		if (savetracename[0] != '\0') {
    418 			set_tracefile(savetracename,sigtrace_pat,0);
    419 		} else if (inittracename[0] != '\0') {
    420 				set_tracefile(inittracename,sigtrace_pat,0);
    421 		} else {
    422 			new_tracelevel = 0;
    423 			return;
    424 		}
    425 	} else {
    426 		tracelevel_msg(sigtrace_pat, 0);
    427 	}
    428 }
    429 
    430 
    431 /* display an address
    432  */
    433 char *
    434 addrname(naddr	addr,			/* in network byte order */
    435 	 naddr	mask,
    436 	 int	force)			/* 0=show mask if nonstandard, */
    437 {					/*	1=always show mask, 2=never */
    438 #define NUM_BUFS 4
    439 	static int bufno;
    440 	static struct {
    441 	    char    str[15+20];
    442 	} bufs[NUM_BUFS];
    443 	char *s, *sp;
    444 	naddr dmask;
    445 	int i;
    446 
    447 	s = strcpy(bufs[bufno].str, naddr_ntoa(addr));
    448 	bufno = (bufno+1) % NUM_BUFS;
    449 
    450 	if (force == 1 || (force == 0 && mask != std_mask(addr))) {
    451 		sp = &s[strlen(s)];
    452 
    453 		dmask = mask & -mask;
    454 		if (mask + dmask == 0) {
    455 			for (i = 0; i != 32 && ((1<<i) & mask) == 0; i++)
    456 				continue;
    457 			(void)sprintf(sp, "/%d", 32-i);
    458 
    459 		} else {
    460 			(void)sprintf(sp, " (mask %#x)", (u_int)mask);
    461 		}
    462 	}
    463 
    464 	return s;
    465 #undef NUM_BUFS
    466 }
    467 
    468 
    469 /* display a bit-field
    470  */
    471 struct bits {
    472 	u_int	bits_mask;
    473 	u_int	bits_clear;
    474 	const char *bits_name;
    475 };
    476 
    477 static struct bits if_bits[] = {
    478 	{ IFF_LOOPBACK,		0,		"LOOPBACK" },
    479 	{ IFF_POINTOPOINT,	0,		"PT-TO-PT" },
    480 	{ 0,			0,		0}
    481 };
    482 
    483 static struct bits is_bits[] = {
    484 	{ IS_ALIAS,		0,		"ALIAS" },
    485 	{ IS_SUBNET,		0,		"" },
    486 	{ IS_REMOTE,		(IS_NO_RDISC
    487 				 | IS_BCAST_RDISC), "REMOTE" },
    488 	{ IS_PASSIVE,		(IS_NO_RDISC
    489 				 | IS_NO_RIP
    490 				 | IS_NO_SUPER_AG
    491 				 | IS_PM_RDISC
    492 				 | IS_NO_AG),	"PASSIVE" },
    493 	{ IS_EXTERNAL,		0,		"EXTERNAL" },
    494 	{ IS_CHECKED,		0,		"" },
    495 	{ IS_ALL_HOSTS,		0,		"" },
    496 	{ IS_ALL_ROUTERS,	0,		"" },
    497 	{ IS_DISTRUST,		0,		"DISTRUST" },
    498 	{ IS_BROKE,		IS_SICK,	"BROKEN" },
    499 	{ IS_SICK,		0,		"SICK" },
    500 	{ IS_DUP,		0,		"DUPLICATE" },
    501 	{ IS_REDIRECT_OK,	0,		"REDIRECT_OK" },
    502 	{ IS_NEED_NET_SYN,	0,		"" },
    503 	{ IS_NO_AG,		IS_NO_SUPER_AG,	"NO_AG" },
    504 	{ IS_NO_SUPER_AG,	0,		"NO_SUPER_AG" },
    505 	{ (IS_NO_RIPV1_IN
    506 	   | IS_NO_RIPV2_IN
    507 	   | IS_NO_RIPV1_OUT
    508 	   | IS_NO_RIPV2_OUT),	0,		"NO_RIP" },
    509 	{ (IS_NO_RIPV1_IN
    510 	   | IS_NO_RIPV1_OUT),	0,		"RIPV2" },
    511 	{ IS_NO_RIPV1_IN,	0,		"NO_RIPV1_IN" },
    512 	{ IS_NO_RIPV2_IN,	0,		"NO_RIPV2_IN" },
    513 	{ IS_NO_RIPV1_OUT,	0,		"NO_RIPV1_OUT" },
    514 	{ IS_NO_RIPV2_OUT,	0,		"NO_RIPV2_OUT" },
    515 	{ (IS_NO_ADV_IN
    516 	   | IS_NO_SOL_OUT
    517 	   | IS_NO_ADV_OUT),	IS_BCAST_RDISC,	"NO_RDISC" },
    518 	{ IS_NO_SOL_OUT,	0,		"NO_SOLICIT" },
    519 	{ IS_SOL_OUT,		0,		"SEND_SOLICIT" },
    520 	{ IS_NO_ADV_OUT,	IS_BCAST_RDISC,	"NO_RDISC_ADV" },
    521 	{ IS_ADV_OUT,		0,		"RDISC_ADV" },
    522 	{ IS_BCAST_RDISC,	0,		"BCAST_RDISC" },
    523 	{ IS_PM_RDISC,		0,		"" },
    524 	{ 0,			0,		"%#x"}
    525 };
    526 
    527 static struct bits rs_bits[] = {
    528 	{ RS_IF,		0,		"IF" },
    529 	{ RS_NET_INT,		RS_NET_SYN,	"NET_INT" },
    530 	{ RS_NET_SYN,		0,		"NET_SYN" },
    531 	{ RS_SUBNET,		0,		"" },
    532 	{ RS_LOCAL,		0,		"LOCAL" },
    533 	{ RS_MHOME,		0,		"MHOME" },
    534 	{ RS_STATIC,		0,		"STATIC" },
    535 	{ RS_RDISC,		0,		"RDISC" },
    536 	{ 0,			0,		"%#x"}
    537 };
    538 
    539 
    540 static void
    541 trace_bits(const struct bits *tbl,
    542 	   u_int field,
    543 	   int force)
    544 {
    545 	u_int b;
    546 	char c;
    547 
    548 	if (force) {
    549 		(void)putc('<', ftrace);
    550 		c = 0;
    551 	} else {
    552 		c = '<';
    553 	}
    554 
    555 	while (field != 0
    556 	       && (b = tbl->bits_mask) != 0) {
    557 		if ((b & field) == b) {
    558 			if (tbl->bits_name[0] != '\0') {
    559 				if (c)
    560 					(void)putc(c, ftrace);
    561 				(void)fprintf(ftrace, "%s", tbl->bits_name);
    562 				c = '|';
    563 			}
    564 			if (0 == (field &= ~(b | tbl->bits_clear)))
    565 				break;
    566 		}
    567 		tbl++;
    568 	}
    569 	if (field != 0 && tbl->bits_name != 0) {
    570 		if (c)
    571 			(void)putc(c, ftrace);
    572 		(void)fprintf(ftrace, tbl->bits_name, field);
    573 		c = '|';
    574 	}
    575 
    576 	if (c != '<' || force)
    577 		(void)fputs("> ", ftrace);
    578 }
    579 
    580 
    581 char *
    582 rtname(naddr dst,
    583        naddr mask,
    584        naddr gate)
    585 {
    586 	static char buf[3*4+3+1+2+3	/* "xxx.xxx.xxx.xxx/xx-->" */
    587 			+3*4+3+1];	/* "xxx.xxx.xxx.xxx" */
    588 	int i;
    589 
    590 	i = sprintf(buf, "%-16s-->", addrname(dst, mask, 0));
    591 	(void)sprintf(&buf[i], "%-*s", 15+20-MAX(20,i), naddr_ntoa(gate));
    592 	return buf;
    593 }
    594 
    595 
    596 static void
    597 print_rts(struct rt_spare *rts,
    598 	  int force_metric,		/* -1=suppress, 0=default */
    599 	  int force_ifp,		/* -1=suppress, 0=default */
    600 	  int force_router,		/* -1=suppress, 0=default, 1=display */
    601 	  int force_tag,		/* -1=suppress, 0=default, 1=display */
    602 	  int force_time)		/* 0=suppress, 1=display */
    603 {
    604 	int i;
    605 
    606 
    607 	if (force_metric >= 0)
    608 		(void)fprintf(ftrace, "metric=%-2d ", rts->rts_metric);
    609 	if (force_ifp >= 0)
    610 		(void)fprintf(ftrace, "%s ", (rts->rts_ifp == 0 ?
    611 					      "if?" : rts->rts_ifp->int_name));
    612 	if (force_router > 0
    613 	    || (force_router == 0 && rts->rts_router != rts->rts_gate))
    614 		(void)fprintf(ftrace, "router=%s ",
    615 			      naddr_ntoa(rts->rts_router));
    616 	if (force_time > 0)
    617 		(void)fprintf(ftrace, "%s ", ts(rts->rts_time));
    618 	if (force_tag > 0
    619 	    || (force_tag == 0 && rts->rts_tag != 0))
    620 		(void)fprintf(ftrace, "tag=%#x ", ntohs(rts->rts_tag));
    621 	if (rts->rts_de_ag != 0) {
    622 		for (i = 1; (u_int)(1 << i) <= rts->rts_de_ag; i++)
    623 			continue;
    624 		(void)fprintf(ftrace, "de_ag=%d ", i);
    625 	}
    626 
    627 }
    628 
    629 
    630 void
    631 trace_if(const char *act,
    632 	 struct interface *ifp)
    633 {
    634 	if (!TRACEACTIONS || ftrace == 0)
    635 		return;
    636 
    637 	lastlog();
    638 	(void)fprintf(ftrace, "%-3s interface %-4s ", act, ifp->int_name);
    639 	(void)fprintf(ftrace, "%-15s-->%-15s ",
    640 		      naddr_ntoa(ifp->int_addr),
    641 		      addrname(((ifp->int_if_flags & IFF_POINTOPOINT)
    642 				? ifp->int_dstaddr
    643 				: htonl(ifp->int_net)),
    644 			       ifp->int_mask, 1));
    645 	if (ifp->int_metric != 0)
    646 		(void)fprintf(ftrace, "metric=%d ", ifp->int_metric);
    647 	if (!IS_RIP_OUT_OFF(ifp->int_state)
    648 	    && ifp->int_d_metric != 0)
    649 		(void)fprintf(ftrace, "fake_default=%d ", ifp->int_d_metric);
    650 	trace_bits(if_bits, ifp->int_if_flags, 0);
    651 	trace_bits(is_bits, ifp->int_state, 0);
    652 	(void)fputc('\n',ftrace);
    653 }
    654 
    655 
    656 void
    657 trace_upslot(struct rt_entry *rt,
    658 	     struct rt_spare *rts,
    659 	     struct rt_spare *new)
    660 {
    661 	if (!TRACEACTIONS || ftrace == 0)
    662 		return;
    663 
    664 	if (rts->rts_gate == new->rts_gate
    665 	    && rts->rts_router == new->rts_router
    666 	    && rts->rts_metric == new->rts_metric
    667 	    && rts->rts_tag == new->rts_tag
    668 	    && rts->rts_de_ag == new->rts_de_ag)
    669 		return;
    670 
    671 	lastlog();
    672 	if (new->rts_gate == 0) {
    673 		(void)fprintf(ftrace, "Del #%d %-35s ",
    674 			      (int)(rts - rt->rt_spares),
    675 			      rtname(rt->rt_dst, rt->rt_mask, rts->rts_gate));
    676 		print_rts(rts, 0,0,0,0,
    677 			  (rts != rt->rt_spares
    678 			   || AGE_RT(rt->rt_state,new->rts_ifp)));
    679 
    680 	} else if (rts->rts_gate != RIP_DEFAULT) {
    681 		(void)fprintf(ftrace, "Chg #%d %-35s ",
    682 			      (int)(rts - rt->rt_spares),
    683 			      rtname(rt->rt_dst, rt->rt_mask, rts->rts_gate));
    684 		print_rts(rts, 0,0,
    685 			  rts->rts_gate != new->rts_gate,
    686 			  rts->rts_tag != new->rts_tag,
    687 			  rts != rt->rt_spares || AGE_RT(rt->rt_state,
    688 							rt->rt_ifp));
    689 
    690 		(void)fprintf(ftrace, "\n       %19s%-16s ", "",
    691 			      (new->rts_gate != rts->rts_gate
    692 			       ? naddr_ntoa(new->rts_gate) : ""));
    693 		print_rts(new,
    694 			  -(new->rts_metric == rts->rts_metric),
    695 			  -(new->rts_ifp == rts->rts_ifp),
    696 			  0,
    697 			  rts->rts_tag != new->rts_tag,
    698 			  (new->rts_time != rts->rts_time
    699 			   && (rts != rt->rt_spares
    700 			       || AGE_RT(rt->rt_state, new->rts_ifp))));
    701 
    702 	} else {
    703 		(void)fprintf(ftrace, "Add #%d %-35s ",
    704 			      (int)(rts - rt->rt_spares),
    705 			      rtname(rt->rt_dst, rt->rt_mask, new->rts_gate));
    706 		print_rts(new, 0,0,0,0,
    707 			  (rts != rt->rt_spares
    708 			   || AGE_RT(rt->rt_state,new->rts_ifp)));
    709 	}
    710 	(void)fputc('\n',ftrace);
    711 }
    712 
    713 
    714 /* miscellaneous message checked by the caller
    715  */
    716 void
    717 trace_misc(const char *p, ...)
    718 {
    719 	va_list args;
    720 
    721 	if (ftrace == 0)
    722 		return;
    723 
    724 	lastlog();
    725 	va_start(args, p);
    726 	vfprintf(ftrace, p, args);
    727 	(void)fputc('\n',ftrace);
    728 }
    729 
    730 
    731 /* display a message if tracing actions
    732  */
    733 void
    734 trace_act(const char *p, ...)
    735 {
    736 	va_list args;
    737 
    738 	if (!TRACEACTIONS || ftrace == 0)
    739 		return;
    740 
    741 	lastlog();
    742 	va_start(args, p);
    743 	vfprintf(ftrace, p, args);
    744 	(void)fputc('\n',ftrace);
    745 }
    746 
    747 
    748 /* display a message if tracing packets
    749  */
    750 void
    751 trace_pkt(const char *p, ...)
    752 {
    753 	va_list args;
    754 
    755 	if (!TRACEPACKETS || ftrace == 0)
    756 		return;
    757 
    758 	lastlog();
    759 	va_start(args, p);
    760 	vfprintf(ftrace, p, args);
    761 	(void)fputc('\n',ftrace);
    762 }
    763 
    764 
    765 void
    766 trace_change(struct rt_entry *rt,
    767 	     u_int	state,
    768 	     struct	rt_spare *new,
    769 	     const char	*label)
    770 {
    771 	if (ftrace == 0)
    772 		return;
    773 
    774 	if (rt->rt_metric == new->rts_metric
    775 	    && rt->rt_gate == new->rts_gate
    776 	    && rt->rt_router == new->rts_router
    777 	    && rt->rt_state == state
    778 	    && rt->rt_tag == new->rts_tag
    779 	    && rt->rt_de_ag == new->rts_de_ag)
    780 		return;
    781 
    782 	lastlog();
    783 	(void)fprintf(ftrace, "%s %-35s ",
    784 		      label,
    785 		      rtname(rt->rt_dst, rt->rt_mask, rt->rt_gate));
    786 	print_rts(rt->rt_spares,
    787 		  0,0,0,0, AGE_RT(rt->rt_state, rt->rt_ifp));
    788 	trace_bits(rs_bits, rt->rt_state, rt->rt_state != state);
    789 
    790 	(void)fprintf(ftrace, "\n%*s %19s%-16s ",
    791 		      (int)strlen(label), "", "",
    792 		      (rt->rt_gate != new->rts_gate
    793 		       ? naddr_ntoa(new->rts_gate) : ""));
    794 	print_rts(new,
    795 		  -(new->rts_metric == rt->rt_metric),
    796 		  -(new->rts_ifp == rt->rt_ifp),
    797 		  0,
    798 		  rt->rt_tag != new->rts_tag,
    799 		  (rt->rt_time != new->rts_time
    800 		   && AGE_RT(rt->rt_state,new->rts_ifp)));
    801 	if (rt->rt_state != state)
    802 		trace_bits(rs_bits, state, 1);
    803 	(void)fputc('\n',ftrace);
    804 }
    805 
    806 
    807 void
    808 trace_add_del(const char * action, struct rt_entry *rt)
    809 {
    810 	if (ftrace == 0)
    811 		return;
    812 
    813 	lastlog();
    814 	(void)fprintf(ftrace, "%s    %-35s ",
    815 		      action,
    816 		      rtname(rt->rt_dst, rt->rt_mask, rt->rt_gate));
    817 	print_rts(rt->rt_spares, 0,0,0,0,AGE_RT(rt->rt_state,rt->rt_ifp));
    818 	trace_bits(rs_bits, rt->rt_state, 0);
    819 	(void)fputc('\n',ftrace);
    820 }
    821 
    822 
    823 /* ARGSUSED */
    824 static int
    825 walk_trace(struct radix_node *rn,
    826 	   struct walkarg *w UNUSED)
    827 {
    828 #define RT ((struct rt_entry *)rn)
    829 	struct rt_spare *rts;
    830 	int i;
    831 
    832 	(void)fprintf(ftrace, "  %-35s ",
    833 		      rtname(RT->rt_dst, RT->rt_mask, RT->rt_gate));
    834 	print_rts(&RT->rt_spares[0], 0,0,0,0, AGE_RT(RT->rt_state, RT->rt_ifp));
    835 	trace_bits(rs_bits, RT->rt_state, 0);
    836 	if (RT->rt_poison_time >= now_garbage
    837 	    && RT->rt_poison_metric < RT->rt_metric)
    838 		(void)fprintf(ftrace, "pm=%d@%s",
    839 			      RT->rt_poison_metric, ts(RT->rt_poison_time));
    840 
    841 	rts = &RT->rt_spares[1];
    842 	for (i = 1; i < NUM_SPARES; i++, rts++) {
    843 		if (rts->rts_gate != RIP_DEFAULT) {
    844 			(void)fprintf(ftrace,"\n    #%d%15s%-16s ",
    845 				      i, "", naddr_ntoa(rts->rts_gate));
    846 			print_rts(rts, 0,0,0,0,1);
    847 		}
    848 	}
    849 	(void)fputc('\n',ftrace);
    850 
    851 	return 0;
    852 }
    853 
    854 
    855 static void
    856 trace_dump(void)
    857 {
    858 	struct interface *ifp;
    859 
    860 	if (ftrace == 0)
    861 		return;
    862 	lastlog();
    863 
    864 	(void)fputs("current daemon state:\n", ftrace);
    865 	for (ifp = ifnet; ifp != 0; ifp = ifp->int_next)
    866 		trace_if("", ifp);
    867 	(void)rn_walktree(rhead, walk_trace, 0);
    868 }
    869 
    870 
    871 void
    872 trace_rip(const char *dir1, const char *dir2,
    873 	  struct sockaddr_in *who,
    874 	  struct interface *ifp,
    875 	  struct rip *msg,
    876 	  int size)			/* total size of message */
    877 {
    878 	struct netinfo *n, *lim;
    879 #	define NA ((struct netauth*)n)
    880 	int i, seen_route;
    881 
    882 	if (!TRACEPACKETS || ftrace == 0)
    883 		return;
    884 
    885 	lastlog();
    886 	if (msg->rip_cmd >= RIPCMD_MAX
    887 	    || msg->rip_vers == 0) {
    888 		(void)fprintf(ftrace, "%s bad RIPv%d cmd=%d %s"
    889 			      " %s.%d size=%d\n",
    890 			      dir1, msg->rip_vers, msg->rip_cmd, dir2,
    891 			      naddr_ntoa(who->sin_addr.s_addr),
    892 			      ntohs(who->sin_port),
    893 			      size);
    894 		return;
    895 	}
    896 
    897 	(void)fprintf(ftrace, "%s RIPv%d %s %s %s.%d%s%s\n",
    898 		      dir1, msg->rip_vers, ripcmds[msg->rip_cmd], dir2,
    899 		      naddr_ntoa(who->sin_addr.s_addr), ntohs(who->sin_port),
    900 		      ifp ? " via " : "", ifp ? ifp->int_name : "");
    901 	if (!TRACECONTENTS)
    902 		return;
    903 
    904 	seen_route = 0;
    905 	switch (msg->rip_cmd) {
    906 	case RIPCMD_REQUEST:
    907 	case RIPCMD_RESPONSE:
    908 		n = msg->rip_nets;
    909 		lim = (struct netinfo *)((char*)msg + size);
    910 		for (; n < lim; n++) {
    911 			if (!seen_route
    912 			    && n->n_family == RIP_AF_UNSPEC
    913 			    && ntohl(n->n_metric) == HOPCNT_INFINITY
    914 			    && msg->rip_cmd == RIPCMD_REQUEST
    915 			    && (n+1 == lim
    916 				|| (n+2 == lim
    917 				    && (n+1)->n_family == RIP_AF_AUTH))) {
    918 				(void)fputs("\tQUERY ", ftrace);
    919 				if (n->n_dst != 0)
    920 					(void)fprintf(ftrace, "%s ",
    921 						      naddr_ntoa(n->n_dst));
    922 				if (n->n_mask != 0)
    923 					(void)fprintf(ftrace, "mask=%#x ",
    924 						      (u_int)ntohl(n->n_mask));
    925 				if (n->n_nhop != 0)
    926 					(void)fprintf(ftrace, "nhop=%s ",
    927 						      naddr_ntoa(n->n_nhop));
    928 				if (n->n_tag != 0)
    929 					(void)fprintf(ftrace, "tag=%#x ",
    930 						      ntohs(n->n_tag));
    931 				(void)fputc('\n',ftrace);
    932 				continue;
    933 			}
    934 
    935 			if (n->n_family == RIP_AF_AUTH) {
    936 				if (NA->a_type == RIP_AUTH_PW
    937 				    && n == msg->rip_nets) {
    938 					(void)fprintf(ftrace, "\tPassword"
    939 						      " Authentication:"
    940 						      " \"%s\"\n",
    941 						      qstring(NA->au.au_pw,
    942 							  RIP_AUTH_PW_LEN));
    943 					continue;
    944 				}
    945 
    946 				if (NA->a_type == RIP_AUTH_MD5
    947 				    && n == msg->rip_nets) {
    948 					(void)fprintf(ftrace,
    949 						      "\tMD5 Auth"
    950 						      " pkt_len=%d KeyID=%u"
    951 						      " auth_len=%d"
    952 						      " seqno=%#x"
    953 						      " rsvd=%#x,%#x\n",
    954 					    ntohs(NA->au.a_md5.md5_pkt_len),
    955 					    NA->au.a_md5.md5_keyid,
    956 					    NA->au.a_md5.md5_auth_len,
    957 					    (int)ntohl(NA->au.a_md5.md5_seqno),
    958 					    (int)ntohs(NA->au.a_md5.rsvd[0]),
    959 					    (int)ntohs(NA->au.a_md5.rsvd[1]));
    960 					continue;
    961 				}
    962 				(void)fprintf(ftrace,
    963 					      "\tAuthentication type %d: ",
    964 					      ntohs(NA->a_type));
    965 				for (i = 0;
    966 				     i < (int)sizeof(NA->au.au_pw);
    967 				     i++)
    968 					(void)fprintf(ftrace, "%02x ",
    969 						      NA->au.au_pw[i]);
    970 				(void)fputc('\n',ftrace);
    971 				continue;
    972 			}
    973 
    974 			seen_route = 1;
    975 			if (n->n_family != RIP_AF_INET) {
    976 				(void)fprintf(ftrace,
    977 					      "\t(af %d) %-18s mask=%#x ",
    978 					      ntohs(n->n_family),
    979 					      naddr_ntoa(n->n_dst),
    980 					      (u_int)ntohl(n->n_mask));
    981 			} else if (msg->rip_vers == RIPv1) {
    982 				(void)fprintf(ftrace, "\t%-18s ",
    983 					      addrname(n->n_dst,
    984 						       ntohl(n->n_mask),
    985 						       n->n_mask==0 ? 2 : 1));
    986 			} else {
    987 				(void)fprintf(ftrace, "\t%-18s ",
    988 					      addrname(n->n_dst,
    989 						       ntohl(n->n_mask),
    990 						       n->n_mask==0 ? 2 : 0));
    991 			}
    992 			(void)fprintf(ftrace, "metric=%-2d ",
    993 				      (u_int)ntohl(n->n_metric));
    994 			if (n->n_nhop != 0)
    995 				(void)fprintf(ftrace, " nhop=%s ",
    996 					      naddr_ntoa(n->n_nhop));
    997 			if (n->n_tag != 0)
    998 				(void)fprintf(ftrace, "tag=%#x",
    999 					      ntohs(n->n_tag));
   1000 			(void)fputc('\n',ftrace);
   1001 		}
   1002 		if (size != (char *)n - (char *)msg)
   1003 			(void)fprintf(ftrace, "truncated record, len %d\n",
   1004 				size);
   1005 		break;
   1006 
   1007 	case RIPCMD_TRACEON:
   1008 		fprintf(ftrace, "\tfile=\"%.*s\"\n", size-4,
   1009 			msg->rip_tracefile);
   1010 		break;
   1011 
   1012 	case RIPCMD_TRACEOFF:
   1013 		break;
   1014 	}
   1015 }
   1016