Home | History | Annotate | Line # | Download | only in routed
trace.c revision 1.26 
      1 /*	$NetBSD: trace.c,v 1.26 2001/09/24 13:22:32 wiz 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.26 2001/09/24 13:22:32 wiz 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 		va_end(args);
    193 		(void)fputc('\n',ftrace);
    194 		fflush(ftrace);
    195 	}
    196 }
    197 
    198 
    199 void
    200 trace_close(int zap_stdio)
    201 {
    202 	int fd;
    203 
    204 
    205 	fflush(stdout);
    206 	fflush(stderr);
    207 
    208 	if (ftrace != 0 && zap_stdio) {
    209 		if (ftrace != stdout)
    210 			fclose(ftrace);
    211 		ftrace = 0;
    212 		fd = open(_PATH_DEVNULL, O_RDWR);
    213 		if (isatty(STDIN_FILENO))
    214 			(void)dup2(fd, STDIN_FILENO);
    215 		if (isatty(STDOUT_FILENO))
    216 			(void)dup2(fd, STDOUT_FILENO);
    217 		if (isatty(STDERR_FILENO))
    218 			(void)dup2(fd, STDERR_FILENO);
    219 		(void)close(fd);
    220 	}
    221 	lastlog_time.tv_sec = 0;
    222 }
    223 
    224 
    225 void
    226 trace_flush(void)
    227 {
    228 	if (ftrace != 0) {
    229 		fflush(ftrace);
    230 		if (ferror(ftrace))
    231 			trace_off("tracing off: %s", strerror(ferror(ftrace)));
    232 	}
    233 }
    234 
    235 
    236 void
    237 trace_off(const char *p, ...)
    238 {
    239 	va_list args;
    240 
    241 
    242 	if (ftrace != 0) {
    243 		lastlog();
    244 		va_start(args, p);
    245 		vfprintf(ftrace, p, args);
    246 		va_end(args);
    247 		(void)fputc('\n',ftrace);
    248 	}
    249 	trace_close(file_trace);
    250 
    251 	new_tracelevel = tracelevel = 0;
    252 }
    253 
    254 
    255 /* log a change in tracing
    256  */
    257 void
    258 tracelevel_msg(const char *pat,
    259 	       int dump)		/* -1=no dump, 0=default, 1=force */
    260 {
    261 	static const char *off_msgs[MAX_TRACELEVEL] = {
    262 		"Tracing actions stopped",
    263 		"Tracing packets stopped",
    264 		"Tracing packet contents stopped",
    265 		"Tracing kernel changes stopped",
    266 	};
    267 	static const char *on_msgs[MAX_TRACELEVEL] = {
    268 		"Tracing actions started",
    269 		"Tracing packets started",
    270 		"Tracing packet contents started",
    271 		"Tracing kernel changes started",
    272 	};
    273 	u_int old_tracelevel = tracelevel;
    274 
    275 
    276 	if (new_tracelevel < 0)
    277 		new_tracelevel = 0;
    278 	else if (new_tracelevel > MAX_TRACELEVEL)
    279 		new_tracelevel = MAX_TRACELEVEL;
    280 
    281 	if (new_tracelevel < tracelevel) {
    282 		if (new_tracelevel <= 0) {
    283 			trace_off(pat, off_msgs[0]);
    284 		} else do {
    285 			tmsg(pat, off_msgs[tracelevel]);
    286 		}
    287 		while (--tracelevel != new_tracelevel);
    288 
    289 	} else if (new_tracelevel > tracelevel) {
    290 		do {
    291 			tmsg(pat, on_msgs[tracelevel++]);
    292 		} while (tracelevel != new_tracelevel);
    293 	}
    294 
    295 	if (dump > 0
    296 	    || (dump == 0 && old_tracelevel == 0 && tracelevel != 0))
    297 		trace_dump();
    298 }
    299 
    300 
    301 void
    302 set_tracefile(const char *filename,
    303 	      const char *pat,
    304 	      int dump)			/* -1=no dump, 0=default, 1=force */
    305 {
    306 	struct stat stbuf;
    307 	FILE *n_ftrace;
    308 	const char *fn;
    309 
    310 
    311 	/* Allow a null filename to increase the level if the trace file
    312 	 * is already open or if coming from a trusted source, such as
    313 	 * a signal or the command line.
    314 	 */
    315 	if (filename == 0 || filename[0] == '\0') {
    316 		filename = 0;
    317 		if (ftrace == 0) {
    318 			if (inittracename[0] == '\0') {
    319 				msglog("missing trace file name");
    320 				return;
    321 			}
    322 			fn = inittracename;
    323 		} else {
    324 			fn = 0;
    325 		}
    326 
    327 	} else if (!strcmp(filename,"dump/../table")) {
    328 		trace_dump();
    329 		return;
    330 
    331 	} else {
    332 		/* Allow the file specified with "-T file" to be reopened,
    333 		 * but require all other names specified over the net to
    334 		 * match the official path.  The path can specify a directory
    335 		 * in which the file is to be created.
    336 		 */
    337 		if (strcmp(filename, inittracename)
    338 #ifdef _PATH_TRACE
    339 		    && (strncmp(filename, _PATH_TRACE, sizeof(_PATH_TRACE)-1)
    340 			|| strstr(filename,"../")
    341 			|| 0 > stat(_PATH_TRACE, &stbuf))
    342 #endif
    343 		    ) {
    344 			msglog("wrong trace file \"%s\"", filename);
    345 			return;
    346 		}
    347 
    348 		/* If the new tracefile exists, it must be a regular file.
    349 		 */
    350 		if (stat(filename, &stbuf) >= 0 && !S_ISREG(stbuf.st_mode)) {
    351 			msglog("wrong type (%#x) of trace file \"%s\"",
    352 			       stbuf.st_mode, filename);
    353 			return;
    354 		}
    355 
    356 		fn = filename;
    357 	}
    358 
    359 	if (fn != 0) {
    360 		n_ftrace = fopen(fn, "a");
    361 		if (n_ftrace == 0) {
    362 			msglog("failed to open trace file \"%s\" %s",
    363 			       fn, strerror(errno));
    364 			if (fn == inittracename)
    365 				inittracename[0] = '\0';
    366 			return;
    367 		}
    368 
    369 		tmsg("switch to trace file %s", fn);
    370 
    371 		trace_close(file_trace = 1);
    372 
    373 		if (fn != savetracename)
    374 			strncpy(savetracename, fn, sizeof(savetracename)-1);
    375 		ftrace = n_ftrace;
    376 
    377 		fflush(stdout);
    378 		fflush(stderr);
    379 		dup2(fileno(ftrace), STDOUT_FILENO);
    380 		dup2(fileno(ftrace), STDERR_FILENO);
    381 	}
    382 
    383 	if (new_tracelevel == 0 || filename == 0)
    384 		new_tracelevel++;
    385 	tracelevel_msg(pat, dump != 0 ? dump : (filename != 0));
    386 }
    387 
    388 
    389 /* ARGSUSED */
    390 void
    391 sigtrace_on(int s UNUSED)
    392 {
    393 	new_tracelevel++;
    394 	sigtrace_pat = "SIGUSR1: %s";
    395 }
    396 
    397 
    398 /* ARGSUSED */
    399 void
    400 sigtrace_off(int s UNUSED)
    401 {
    402 	new_tracelevel--;
    403 	sigtrace_pat = "SIGUSR2: %s";
    404 }
    405 
    406 
    407 /* Set tracing after a signal.
    408  */
    409 void
    410 set_tracelevel(void)
    411 {
    412 	if (new_tracelevel == tracelevel)
    413 		return;
    414 
    415 	/* If tracing entirely off, and there was no tracefile specified
    416 	 * on the command line, then leave it off.
    417 	 */
    418 	if (new_tracelevel > tracelevel && ftrace == 0) {
    419 		if (savetracename[0] != '\0') {
    420 			set_tracefile(savetracename,sigtrace_pat,0);
    421 		} else if (inittracename[0] != '\0') {
    422 				set_tracefile(inittracename,sigtrace_pat,0);
    423 		} else {
    424 			new_tracelevel = 0;
    425 			return;
    426 		}
    427 	} else {
    428 		tracelevel_msg(sigtrace_pat, 0);
    429 	}
    430 }
    431 
    432 
    433 /* display an address
    434  */
    435 char *
    436 addrname(naddr	addr,			/* in network byte order */
    437 	 naddr	mask,
    438 	 int	force)			/* 0=show mask if nonstandard, */
    439 {					/*	1=always show mask, 2=never */
    440 #define NUM_BUFS 4
    441 	static int bufno;
    442 	static struct {
    443 	    char    str[15+20];
    444 	} bufs[NUM_BUFS];
    445 	char *s, *sp;
    446 	naddr dmask;
    447 	int i;
    448 
    449 	s = strcpy(bufs[bufno].str, naddr_ntoa(addr));
    450 	bufno = (bufno+1) % NUM_BUFS;
    451 
    452 	if (force == 1 || (force == 0 && mask != std_mask(addr))) {
    453 		sp = &s[strlen(s)];
    454 
    455 		dmask = mask & -mask;
    456 		if (mask + dmask == 0) {
    457 			for (i = 0; i != 32 && ((1<<i) & mask) == 0; i++)
    458 				continue;
    459 			(void)sprintf(sp, "/%d", 32-i);
    460 
    461 		} else {
    462 			(void)sprintf(sp, " (mask %#x)", (u_int)mask);
    463 		}
    464 	}
    465 
    466 	return s;
    467 #undef NUM_BUFS
    468 }
    469 
    470 
    471 /* display a bit-field
    472  */
    473 struct bits {
    474 	u_int	bits_mask;
    475 	u_int	bits_clear;
    476 	const char *bits_name;
    477 };
    478 
    479 static struct bits if_bits[] = {
    480 	{ IFF_LOOPBACK,		0,		"LOOPBACK" },
    481 	{ IFF_POINTOPOINT,	0,		"PT-TO-PT" },
    482 	{ 0,			0,		0}
    483 };
    484 
    485 static struct bits is_bits[] = {
    486 	{ IS_ALIAS,		0,		"ALIAS" },
    487 	{ IS_SUBNET,		0,		"" },
    488 	{ IS_REMOTE,		(IS_NO_RDISC
    489 				 | IS_BCAST_RDISC), "REMOTE" },
    490 	{ IS_PASSIVE,		(IS_NO_RDISC
    491 				 | IS_NO_RIP
    492 				 | IS_NO_SUPER_AG
    493 				 | IS_PM_RDISC
    494 				 | IS_NO_AG),	"PASSIVE" },
    495 	{ IS_EXTERNAL,		0,		"EXTERNAL" },
    496 	{ IS_CHECKED,		0,		"" },
    497 	{ IS_ALL_HOSTS,		0,		"" },
    498 	{ IS_ALL_ROUTERS,	0,		"" },
    499 	{ IS_DISTRUST,		0,		"DISTRUST" },
    500 	{ IS_BROKE,		IS_SICK,	"BROKEN" },
    501 	{ IS_SICK,		0,		"SICK" },
    502 	{ IS_DUP,		0,		"DUPLICATE" },
    503 	{ IS_REDIRECT_OK,	0,		"REDIRECT_OK" },
    504 	{ IS_NEED_NET_SYN,	0,		"" },
    505 	{ IS_NO_AG,		IS_NO_SUPER_AG,	"NO_AG" },
    506 	{ IS_NO_SUPER_AG,	0,		"NO_SUPER_AG" },
    507 	{ (IS_NO_RIPV1_IN
    508 	   | IS_NO_RIPV2_IN
    509 	   | IS_NO_RIPV1_OUT
    510 	   | IS_NO_RIPV2_OUT),	0,		"NO_RIP" },
    511 	{ (IS_NO_RIPV1_IN
    512 	   | IS_NO_RIPV1_OUT),	0,		"RIPV2" },
    513 	{ IS_NO_RIPV1_IN,	0,		"NO_RIPV1_IN" },
    514 	{ IS_NO_RIPV2_IN,	0,		"NO_RIPV2_IN" },
    515 	{ IS_NO_RIPV1_OUT,	0,		"NO_RIPV1_OUT" },
    516 	{ IS_NO_RIPV2_OUT,	0,		"NO_RIPV2_OUT" },
    517 	{ (IS_NO_ADV_IN
    518 	   | IS_NO_SOL_OUT
    519 	   | IS_NO_ADV_OUT),	IS_BCAST_RDISC,	"NO_RDISC" },
    520 	{ IS_NO_SOL_OUT,	0,		"NO_SOLICIT" },
    521 	{ IS_SOL_OUT,		0,		"SEND_SOLICIT" },
    522 	{ IS_NO_ADV_OUT,	IS_BCAST_RDISC,	"NO_RDISC_ADV" },
    523 	{ IS_ADV_OUT,		0,		"RDISC_ADV" },
    524 	{ IS_BCAST_RDISC,	0,		"BCAST_RDISC" },
    525 	{ IS_PM_RDISC,		0,		"" },
    526 	{ 0,			0,		"%#x"}
    527 };
    528 
    529 static struct bits rs_bits[] = {
    530 	{ RS_IF,		0,		"IF" },
    531 	{ RS_NET_INT,		RS_NET_SYN,	"NET_INT" },
    532 	{ RS_NET_SYN,		0,		"NET_SYN" },
    533 	{ RS_SUBNET,		0,		"" },
    534 	{ RS_LOCAL,		0,		"LOCAL" },
    535 	{ RS_MHOME,		0,		"MHOME" },
    536 	{ RS_STATIC,		0,		"STATIC" },
    537 	{ RS_RDISC,		0,		"RDISC" },
    538 	{ 0,			0,		"%#x"}
    539 };
    540 
    541 
    542 static void
    543 trace_bits(const struct bits *tbl,
    544 	   u_int field,
    545 	   int force)
    546 {
    547 	u_int b;
    548 	char c;
    549 
    550 	if (force) {
    551 		(void)putc('<', ftrace);
    552 		c = 0;
    553 	} else {
    554 		c = '<';
    555 	}
    556 
    557 	while (field != 0
    558 	       && (b = tbl->bits_mask) != 0) {
    559 		if ((b & field) == b) {
    560 			if (tbl->bits_name[0] != '\0') {
    561 				if (c)
    562 					(void)putc(c, ftrace);
    563 				(void)fprintf(ftrace, "%s", tbl->bits_name);
    564 				c = '|';
    565 			}
    566 			if (0 == (field &= ~(b | tbl->bits_clear)))
    567 				break;
    568 		}
    569 		tbl++;
    570 	}
    571 	if (field != 0 && tbl->bits_name != 0) {
    572 		if (c)
    573 			(void)putc(c, ftrace);
    574 		(void)fprintf(ftrace, tbl->bits_name, field);
    575 		c = '|';
    576 	}
    577 
    578 	if (c != '<' || force)
    579 		(void)fputs("> ", ftrace);
    580 }
    581 
    582 
    583 char *
    584 rtname(naddr dst,
    585        naddr mask,
    586        naddr gate)
    587 {
    588 	static char buf[3*4+3+1+2+3	/* "xxx.xxx.xxx.xxx/xx-->" */
    589 			+3*4+3+1];	/* "xxx.xxx.xxx.xxx" */
    590 	int i;
    591 
    592 	i = sprintf(buf, "%-16s-->", addrname(dst, mask, 0));
    593 	(void)sprintf(&buf[i], "%-*s", 15+20-MAX(20,i), naddr_ntoa(gate));
    594 	return buf;
    595 }
    596 
    597 
    598 static void
    599 print_rts(struct rt_spare *rts,
    600 	  int force_metric,		/* -1=suppress, 0=default */
    601 	  int force_ifp,		/* -1=suppress, 0=default */
    602 	  int force_router,		/* -1=suppress, 0=default, 1=display */
    603 	  int force_tag,		/* -1=suppress, 0=default, 1=display */
    604 	  int force_time)		/* 0=suppress, 1=display */
    605 {
    606 	int i;
    607 
    608 
    609 	if (force_metric >= 0)
    610 		(void)fprintf(ftrace, "metric=%-2d ", rts->rts_metric);
    611 	if (force_ifp >= 0)
    612 		(void)fprintf(ftrace, "%s ", (rts->rts_ifp == 0 ?
    613 					      "if?" : rts->rts_ifp->int_name));
    614 	if (force_router > 0
    615 	    || (force_router == 0 && rts->rts_router != rts->rts_gate))
    616 		(void)fprintf(ftrace, "router=%s ",
    617 			      naddr_ntoa(rts->rts_router));
    618 	if (force_time > 0)
    619 		(void)fprintf(ftrace, "%s ", ts(rts->rts_time));
    620 	if (force_tag > 0
    621 	    || (force_tag == 0 && rts->rts_tag != 0))
    622 		(void)fprintf(ftrace, "tag=%#x ", ntohs(rts->rts_tag));
    623 	if (rts->rts_de_ag != 0) {
    624 		for (i = 1; (u_int)(1 << i) <= rts->rts_de_ag; i++)
    625 			continue;
    626 		(void)fprintf(ftrace, "de_ag=%d ", i);
    627 	}
    628 
    629 }
    630 
    631 
    632 void
    633 trace_if(const char *act,
    634 	 struct interface *ifp)
    635 {
    636 	if (!TRACEACTIONS || ftrace == 0)
    637 		return;
    638 
    639 	lastlog();
    640 	(void)fprintf(ftrace, "%-3s interface %-4s ", act, ifp->int_name);
    641 	(void)fprintf(ftrace, "%-15s-->%-15s ",
    642 		      naddr_ntoa(ifp->int_addr),
    643 		      addrname(((ifp->int_if_flags & IFF_POINTOPOINT)
    644 				? ifp->int_dstaddr
    645 				: htonl(ifp->int_net)),
    646 			       ifp->int_mask, 1));
    647 	if (ifp->int_metric != 0)
    648 		(void)fprintf(ftrace, "metric=%d ", ifp->int_metric);
    649 	if (!IS_RIP_OUT_OFF(ifp->int_state)
    650 	    && ifp->int_d_metric != 0)
    651 		(void)fprintf(ftrace, "fake_default=%d ", ifp->int_d_metric);
    652 	trace_bits(if_bits, ifp->int_if_flags, 0);
    653 	trace_bits(is_bits, ifp->int_state, 0);
    654 	(void)fputc('\n',ftrace);
    655 }
    656 
    657 
    658 void
    659 trace_upslot(struct rt_entry *rt,
    660 	     struct rt_spare *rts,
    661 	     struct rt_spare *new)
    662 {
    663 	if (!TRACEACTIONS || ftrace == 0)
    664 		return;
    665 
    666 	if (rts->rts_gate == new->rts_gate
    667 	    && rts->rts_router == new->rts_router
    668 	    && rts->rts_metric == new->rts_metric
    669 	    && rts->rts_tag == new->rts_tag
    670 	    && rts->rts_de_ag == new->rts_de_ag)
    671 		return;
    672 
    673 	lastlog();
    674 	if (new->rts_gate == 0) {
    675 		(void)fprintf(ftrace, "Del #%d %-35s ",
    676 			      (int)(rts - rt->rt_spares),
    677 			      rtname(rt->rt_dst, rt->rt_mask, rts->rts_gate));
    678 		print_rts(rts, 0,0,0,0,
    679 			  (rts != rt->rt_spares
    680 			   || AGE_RT(rt->rt_state,new->rts_ifp)));
    681 
    682 	} else if (rts->rts_gate != RIP_DEFAULT) {
    683 		(void)fprintf(ftrace, "Chg #%d %-35s ",
    684 			      (int)(rts - rt->rt_spares),
    685 			      rtname(rt->rt_dst, rt->rt_mask, rts->rts_gate));
    686 		print_rts(rts, 0,0,
    687 			  rts->rts_gate != new->rts_gate,
    688 			  rts->rts_tag != new->rts_tag,
    689 			  rts != rt->rt_spares || AGE_RT(rt->rt_state,
    690 							rt->rt_ifp));
    691 
    692 		(void)fprintf(ftrace, "\n       %19s%-16s ", "",
    693 			      (new->rts_gate != rts->rts_gate
    694 			       ? naddr_ntoa(new->rts_gate) : ""));
    695 		print_rts(new,
    696 			  -(new->rts_metric == rts->rts_metric),
    697 			  -(new->rts_ifp == rts->rts_ifp),
    698 			  0,
    699 			  rts->rts_tag != new->rts_tag,
    700 			  (new->rts_time != rts->rts_time
    701 			   && (rts != rt->rt_spares
    702 			       || AGE_RT(rt->rt_state, new->rts_ifp))));
    703 
    704 	} else {
    705 		(void)fprintf(ftrace, "Add #%d %-35s ",
    706 			      (int)(rts - rt->rt_spares),
    707 			      rtname(rt->rt_dst, rt->rt_mask, new->rts_gate));
    708 		print_rts(new, 0,0,0,0,
    709 			  (rts != rt->rt_spares
    710 			   || AGE_RT(rt->rt_state,new->rts_ifp)));
    711 	}
    712 	(void)fputc('\n',ftrace);
    713 }
    714 
    715 
    716 /* miscellaneous message checked by the caller
    717  */
    718 void
    719 trace_misc(const char *p, ...)
    720 {
    721 	va_list args;
    722 
    723 	if (ftrace == 0)
    724 		return;
    725 
    726 	lastlog();
    727 	va_start(args, p);
    728 	vfprintf(ftrace, p, args);
    729 	va_end(args);
    730 	(void)fputc('\n',ftrace);
    731 }
    732 
    733 
    734 /* display a message if tracing actions
    735  */
    736 void
    737 trace_act(const char *p, ...)
    738 {
    739 	va_list args;
    740 
    741 	if (!TRACEACTIONS || ftrace == 0)
    742 		return;
    743 
    744 	lastlog();
    745 	va_start(args, p);
    746 	vfprintf(ftrace, p, args);
    747 	va_end(args);
    748 	(void)fputc('\n',ftrace);
    749 }
    750 
    751 
    752 /* display a message if tracing packets
    753  */
    754 void
    755 trace_pkt(const char *p, ...)
    756 {
    757 	va_list args;
    758 
    759 	if (!TRACEPACKETS || ftrace == 0)
    760 		return;
    761 
    762 	lastlog();
    763 	va_start(args, p);
    764 	vfprintf(ftrace, p, args);
    765 	va_end(args);
    766 	(void)fputc('\n',ftrace);
    767 }
    768 
    769 
    770 void
    771 trace_change(struct rt_entry *rt,
    772 	     u_int	state,
    773 	     struct	rt_spare *new,
    774 	     const char	*label)
    775 {
    776 	if (ftrace == 0)
    777 		return;
    778 
    779 	if (rt->rt_metric == new->rts_metric
    780 	    && rt->rt_gate == new->rts_gate
    781 	    && rt->rt_router == new->rts_router
    782 	    && rt->rt_state == state
    783 	    && rt->rt_tag == new->rts_tag
    784 	    && rt->rt_de_ag == new->rts_de_ag)
    785 		return;
    786 
    787 	lastlog();
    788 	(void)fprintf(ftrace, "%s %-35s ",
    789 		      label,
    790 		      rtname(rt->rt_dst, rt->rt_mask, rt->rt_gate));
    791 	print_rts(rt->rt_spares,
    792 		  0,0,0,0, AGE_RT(rt->rt_state, rt->rt_ifp));
    793 	trace_bits(rs_bits, rt->rt_state, rt->rt_state != state);
    794 
    795 	(void)fprintf(ftrace, "\n%*s %19s%-16s ",
    796 		      (int)strlen(label), "", "",
    797 		      (rt->rt_gate != new->rts_gate
    798 		       ? naddr_ntoa(new->rts_gate) : ""));
    799 	print_rts(new,
    800 		  -(new->rts_metric == rt->rt_metric),
    801 		  -(new->rts_ifp == rt->rt_ifp),
    802 		  0,
    803 		  rt->rt_tag != new->rts_tag,
    804 		  (rt->rt_time != new->rts_time
    805 		   && AGE_RT(rt->rt_state,new->rts_ifp)));
    806 	if (rt->rt_state != state)
    807 		trace_bits(rs_bits, state, 1);
    808 	(void)fputc('\n',ftrace);
    809 }
    810 
    811 
    812 void
    813 trace_add_del(const char * action, struct rt_entry *rt)
    814 {
    815 	if (ftrace == 0)
    816 		return;
    817 
    818 	lastlog();
    819 	(void)fprintf(ftrace, "%s    %-35s ",
    820 		      action,
    821 		      rtname(rt->rt_dst, rt->rt_mask, rt->rt_gate));
    822 	print_rts(rt->rt_spares, 0,0,0,0,AGE_RT(rt->rt_state,rt->rt_ifp));
    823 	trace_bits(rs_bits, rt->rt_state, 0);
    824 	(void)fputc('\n',ftrace);
    825 }
    826 
    827 
    828 /* ARGSUSED */
    829 static int
    830 walk_trace(struct radix_node *rn,
    831 	   struct walkarg *w UNUSED)
    832 {
    833 #define RT ((struct rt_entry *)rn)
    834 	struct rt_spare *rts;
    835 	int i;
    836 
    837 	(void)fprintf(ftrace, "  %-35s ",
    838 		      rtname(RT->rt_dst, RT->rt_mask, RT->rt_gate));
    839 	print_rts(&RT->rt_spares[0], 0,0,0,0, AGE_RT(RT->rt_state, RT->rt_ifp));
    840 	trace_bits(rs_bits, RT->rt_state, 0);
    841 	if (RT->rt_poison_time >= now_garbage
    842 	    && RT->rt_poison_metric < RT->rt_metric)
    843 		(void)fprintf(ftrace, "pm=%d@%s",
    844 			      RT->rt_poison_metric, ts(RT->rt_poison_time));
    845 
    846 	rts = &RT->rt_spares[1];
    847 	for (i = 1; i < NUM_SPARES; i++, rts++) {
    848 		if (rts->rts_gate != RIP_DEFAULT) {
    849 			(void)fprintf(ftrace,"\n    #%d%15s%-16s ",
    850 				      i, "", naddr_ntoa(rts->rts_gate));
    851 			print_rts(rts, 0,0,0,0,1);
    852 		}
    853 	}
    854 	(void)fputc('\n',ftrace);
    855 
    856 	return 0;
    857 }
    858 
    859 
    860 static void
    861 trace_dump(void)
    862 {
    863 	struct interface *ifp;
    864 
    865 	if (ftrace == 0)
    866 		return;
    867 	lastlog();
    868 
    869 	(void)fputs("current daemon state:\n", ftrace);
    870 	for (ifp = ifnet; ifp != 0; ifp = ifp->int_next)
    871 		trace_if("", ifp);
    872 	(void)rn_walktree(rhead, walk_trace, 0);
    873 }
    874 
    875 
    876 void
    877 trace_rip(const char *dir1, const char *dir2,
    878 	  struct sockaddr_in *who,
    879 	  struct interface *ifp,
    880 	  struct rip *msg,
    881 	  int size)			/* total size of message */
    882 {
    883 	struct netinfo *n, *lim;
    884 #	define NA ((struct netauth*)n)
    885 	int i, seen_route;
    886 
    887 	if (!TRACEPACKETS || ftrace == 0)
    888 		return;
    889 
    890 	lastlog();
    891 	if (msg->rip_cmd >= RIPCMD_MAX
    892 	    || msg->rip_vers == 0) {
    893 		(void)fprintf(ftrace, "%s bad RIPv%d cmd=%d %s"
    894 			      " %s.%d size=%d\n",
    895 			      dir1, msg->rip_vers, msg->rip_cmd, dir2,
    896 			      naddr_ntoa(who->sin_addr.s_addr),
    897 			      ntohs(who->sin_port),
    898 			      size);
    899 		return;
    900 	}
    901 
    902 	(void)fprintf(ftrace, "%s RIPv%d %s %s %s.%d%s%s\n",
    903 		      dir1, msg->rip_vers, ripcmds[msg->rip_cmd], dir2,
    904 		      naddr_ntoa(who->sin_addr.s_addr), ntohs(who->sin_port),
    905 		      ifp ? " via " : "", ifp ? ifp->int_name : "");
    906 	if (!TRACECONTENTS)
    907 		return;
    908 
    909 	seen_route = 0;
    910 	switch (msg->rip_cmd) {
    911 	case RIPCMD_REQUEST:
    912 	case RIPCMD_RESPONSE:
    913 		n = msg->rip_nets;
    914 		lim = (struct netinfo *)((char*)msg + size);
    915 		for (; n < lim; n++) {
    916 			if (!seen_route
    917 			    && n->n_family == RIP_AF_UNSPEC
    918 			    && ntohl(n->n_metric) == HOPCNT_INFINITY
    919 			    && msg->rip_cmd == RIPCMD_REQUEST
    920 			    && (n+1 == lim
    921 				|| (n+2 == lim
    922 				    && (n+1)->n_family == RIP_AF_AUTH))) {
    923 				(void)fputs("\tQUERY ", ftrace);
    924 				if (n->n_dst != 0)
    925 					(void)fprintf(ftrace, "%s ",
    926 						      naddr_ntoa(n->n_dst));
    927 				if (n->n_mask != 0)
    928 					(void)fprintf(ftrace, "mask=%#x ",
    929 						      (u_int)ntohl(n->n_mask));
    930 				if (n->n_nhop != 0)
    931 					(void)fprintf(ftrace, "nhop=%s ",
    932 						      naddr_ntoa(n->n_nhop));
    933 				if (n->n_tag != 0)
    934 					(void)fprintf(ftrace, "tag=%#x ",
    935 						      ntohs(n->n_tag));
    936 				(void)fputc('\n',ftrace);
    937 				continue;
    938 			}
    939 
    940 			if (n->n_family == RIP_AF_AUTH) {
    941 				if (NA->a_type == RIP_AUTH_PW
    942 				    && n == msg->rip_nets) {
    943 					(void)fprintf(ftrace, "\tPassword"
    944 						      " Authentication:"
    945 						      " \"%s\"\n",
    946 						      qstring(NA->au.au_pw,
    947 							  RIP_AUTH_PW_LEN));
    948 					continue;
    949 				}
    950 
    951 				if (NA->a_type == RIP_AUTH_MD5
    952 				    && n == msg->rip_nets) {
    953 					(void)fprintf(ftrace,
    954 						      "\tMD5 Auth"
    955 						      " pkt_len=%d KeyID=%u"
    956 						      " auth_len=%d"
    957 						      " seqno=%#x"
    958 						      " rsvd=%#x,%#x\n",
    959 					    ntohs(NA->au.a_md5.md5_pkt_len),
    960 					    NA->au.a_md5.md5_keyid,
    961 					    NA->au.a_md5.md5_auth_len,
    962 					    (int)ntohl(NA->au.a_md5.md5_seqno),
    963 					    (int)ntohs(NA->au.a_md5.rsvd[0]),
    964 					    (int)ntohs(NA->au.a_md5.rsvd[1]));
    965 					continue;
    966 				}
    967 				(void)fprintf(ftrace,
    968 					      "\tAuthentication type %d: ",
    969 					      ntohs(NA->a_type));
    970 				for (i = 0;
    971 				     i < (int)sizeof(NA->au.au_pw);
    972 				     i++)
    973 					(void)fprintf(ftrace, "%02x ",
    974 						      NA->au.au_pw[i]);
    975 				(void)fputc('\n',ftrace);
    976 				continue;
    977 			}
    978 
    979 			seen_route = 1;
    980 			if (n->n_family != RIP_AF_INET) {
    981 				(void)fprintf(ftrace,
    982 					      "\t(af %d) %-18s mask=%#x ",
    983 					      ntohs(n->n_family),
    984 					      naddr_ntoa(n->n_dst),
    985 					      (u_int)ntohl(n->n_mask));
    986 			} else if (msg->rip_vers == RIPv1) {
    987 				(void)fprintf(ftrace, "\t%-18s ",
    988 					      addrname(n->n_dst,
    989 						       ntohl(n->n_mask),
    990 						       n->n_mask==0 ? 2 : 1));
    991 			} else {
    992 				(void)fprintf(ftrace, "\t%-18s ",
    993 					      addrname(n->n_dst,
    994 						       ntohl(n->n_mask),
    995 						       n->n_mask==0 ? 2 : 0));
    996 			}
    997 			(void)fprintf(ftrace, "metric=%-2d ",
    998 				      (u_int)ntohl(n->n_metric));
    999 			if (n->n_nhop != 0)
   1000 				(void)fprintf(ftrace, " nhop=%s ",
   1001 					      naddr_ntoa(n->n_nhop));
   1002 			if (n->n_tag != 0)
   1003 				(void)fprintf(ftrace, "tag=%#x",
   1004 					      ntohs(n->n_tag));
   1005 			(void)fputc('\n',ftrace);
   1006 		}
   1007 		if (size != (char *)n - (char *)msg)
   1008 			(void)fprintf(ftrace, "truncated record, len %d\n",
   1009 				size);
   1010 		break;
   1011 
   1012 	case RIPCMD_TRACEON:
   1013 		fprintf(ftrace, "\tfile=\"%.*s\"\n", size-4,
   1014 			msg->rip_tracefile);
   1015 		break;
   1016 
   1017 	case RIPCMD_TRACEOFF:
   1018 		break;
   1019 	}
   1020 }
   1021