Home | History | Annotate | Line # | Download | only in rtquery 
      1 /*	$NetBSD: rtquery.c,v 1.25 2014/03/23 05:36:58 dholland Exp $	*/
      2 
      3 /*-
      4  * Copyright (c) 1982, 1986, 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 #include <sys/cdefs.h>
     37 #include <sys/param.h>
     38 #include <sys/protosw.h>
     39 #include <sys/socket.h>
     40 #include <sys/time.h>
     41 #include <netinet/in.h>
     42 #define RIPVERSION RIPv2
     43 #include <protocols/routed.h>
     44 #include <arpa/inet.h>
     45 #include <netdb.h>
     46 #include <errno.h>
     47 #include <unistd.h>
     48 #include <stdio.h>
     49 #include <stdlib.h>
     50 #include <string.h>
     51 #ifdef sgi
     52 #include <strings.h>
     53 #include <bstring.h>
     54 #endif
     55 
     56 #define UNUSED __unused
     57 #ifndef __RCSID
     58 #define __RCSID(_s) static const char rcsid[] UNUSED = _s
     59 #endif
     60 #ifndef __COPYRIGHT
     61 #define __COPYRIGHT(_s) static const char copyright[] UNUSED = _s
     62 #endif
     63 __COPYRIGHT("@(#) Copyright (c) 1983, 1988, 1993\
     64  The Regents of the University of California.  All rights reserved.");
     65 #ifdef __NetBSD__
     66 __RCSID("$NetBSD: rtquery.c,v 1.25 2014/03/23 05:36:58 dholland Exp $");
     67 #elif defined(__FreeBSD__)
     68 __RCSID("$FreeBSD$");
     69 #else
     70 __RCSID("Revision: 2.26 ");
     71 #ident "Revision: 2.26 "
     72 #endif
     73 
     74 #ifndef sgi
     75 #define _HAVE_SIN_LEN
     76 #endif
     77 
     78 #ifdef __NetBSD__
     79 #include <md5.h>
     80 #else
     81 #define MD5_DIGEST_LEN 16
     82 typedef struct {
     83 	u_int32_t state[4];		/* state (ABCD) */
     84 	u_int32_t count[2];		/* # of bits, modulo 2^64 (LSB 1st) */
     85 	unsigned char buffer[64];	/* input buffer */
     86 } MD5_CTX;
     87 extern void MD5Init(MD5_CTX*);
     88 extern void MD5Update(MD5_CTX*, u_char*, u_int);
     89 extern void MD5Final(u_char[MD5_DIGEST_LEN], MD5_CTX*);
     90 #endif
     91 
     92 
     93 #define	WTIME	15		/* Time to wait for all responses */
     94 #define	STIME	(250*1000)	/* usec to wait for another response */
     95 
     96 int	soc;
     97 
     98 const char *pgmname;
     99 
    100 union {
    101 	struct rip rip;
    102 	char	packet[MAXPACKETSIZE+MAXPATHLEN];
    103 } omsg_buf;
    104 #define OMSG omsg_buf.rip
    105 int omsg_len = sizeof(struct rip);
    106 
    107 union {
    108 	struct	rip rip;
    109 	char	packet[MAXPACKETSIZE+1024];
    110 	} imsg_buf;
    111 #define IMSG imsg_buf.rip
    112 
    113 int	nflag;				/* numbers, no names */
    114 int	pflag;				/* play the `gated` game */
    115 int	ripv2 = 1;			/* use RIP version 2 */
    116 int	wtime = WTIME;
    117 int	rflag;				/* 1=ask about a particular route */
    118 int	trace, not_trace;		/* send trace command or not */
    119 int	auth_type = RIP_AUTH_NONE;
    120 char	passwd[RIP_AUTH_PW_LEN];
    121 u_long	keyid;
    122 
    123 struct timeval sent;			/* when query sent */
    124 
    125 static char localhost_str[] = "localhost";
    126 static char *default_argv[] = {localhost_str, 0};
    127 
    128 static void rip_input(struct sockaddr_in*, int);
    129 static int out(const char *);
    130 static void trace_loop(char *argv[]) __dead;
    131 static void query_loop(char *argv[], int) __dead;
    132 static int getnet(char *, struct netinfo *);
    133 static u_int std_mask(u_int);
    134 static int parse_quote(char **, const char *, char *, char *, int);
    135 __dead static void usage(void);
    136 
    137 
    138 int
    139 main(int argc,
    140      char *argv[])
    141 {
    142 	int ch, bsize;
    143 	char *p, *options, *value, delim;
    144 	const char *result;
    145 
    146 	delim = 0;	/* XXX gcc */
    147 
    148 	OMSG.rip_nets[0].n_dst = RIP_DEFAULT;
    149 	OMSG.rip_nets[0].n_family = RIP_AF_UNSPEC;
    150 	OMSG.rip_nets[0].n_metric = htonl(HOPCNT_INFINITY);
    151 
    152 	pgmname = argv[0];
    153 	while ((ch = getopt(argc, argv, "np1w:r:t:a:")) != -1)
    154 		switch (ch) {
    155 		case 'n':
    156 			not_trace = 1;
    157 			nflag = 1;
    158 			break;
    159 
    160 		case 'p':
    161 			not_trace = 1;
    162 			pflag = 1;
    163 			break;
    164 
    165 		case '1':
    166 			ripv2 = 0;
    167 			break;
    168 
    169 		case 'w':
    170 			not_trace = 1;
    171 			wtime = (int)strtoul(optarg, &p, 0);
    172 			if (*p != '\0'
    173 			    || wtime <= 0)
    174 				usage();
    175 			break;
    176 
    177 		case 'r':
    178 			not_trace = 1;
    179 			if (rflag)
    180 				usage();
    181 			rflag = getnet(optarg, &OMSG.rip_nets[0]);
    182 			if (!rflag) {
    183 				struct hostent *hp = gethostbyname(optarg);
    184 				if (hp == 0) {
    185 					fprintf(stderr, "%s: %s:",
    186 						pgmname, optarg);
    187 					herror(0);
    188 					exit(1);
    189 				}
    190 				memcpy(&OMSG.rip_nets[0].n_dst, hp->h_addr,
    191 				       sizeof(OMSG.rip_nets[0].n_dst));
    192 				OMSG.rip_nets[0].n_family = RIP_AF_INET;
    193 				OMSG.rip_nets[0].n_mask = -1;
    194 				rflag = 1;
    195 			}
    196 			break;
    197 
    198 		case 't':
    199 			trace = 1;
    200 			options = optarg;
    201 			while (*options != '\0') {
    202 				/* messy complications to make -W -Wall happy */
    203 				static char on_str[] = "on";
    204 				static char more_str[] = "more";
    205 				static char off_str[] = "off";
    206 				static char dump_str[] = "dump";
    207 				static char *traceopts[] = {
    208 #				    define TRACE_ON	0
    209 					on_str,
    210 #				    define TRACE_MORE	1
    211 					more_str,
    212 #				    define TRACE_OFF	2
    213 					off_str,
    214 #				    define TRACE_DUMP	3
    215 					dump_str,
    216 					0
    217 				};
    218 				result = "";
    219 				switch (getsubopt(&options,traceopts,&value)) {
    220 				case TRACE_ON:
    221 					OMSG.rip_cmd = RIPCMD_TRACEON;
    222 					if (!value
    223 					    || strlen(value) > MAXPATHLEN)
    224 					    usage();
    225 					result = value;
    226 					break;
    227 				case TRACE_MORE:
    228 					if (value)
    229 					    usage();
    230 					OMSG.rip_cmd = RIPCMD_TRACEON;
    231 					break;
    232 				case TRACE_OFF:
    233 					if (value)
    234 					    usage();
    235 					OMSG.rip_cmd = RIPCMD_TRACEOFF;
    236 					break;
    237 				case TRACE_DUMP:
    238 					if (value)
    239 					    usage();
    240 					OMSG.rip_cmd = RIPCMD_TRACEON;
    241 					result = "dump/../table";
    242 					break;
    243 				default:
    244 					usage();
    245 				}
    246 				strcpy((char*)OMSG.rip_tracefile, result);
    247 				omsg_len += strlen(result) - sizeof(OMSG.ripun);
    248 			}
    249 			break;
    250 
    251 		case 'a':
    252 			not_trace = 1;
    253 			p = strchr(optarg,'=');
    254 			if (!p)
    255 				usage();
    256 			*p++ = '\0';
    257 			if (!strcasecmp("passwd",optarg))
    258 				auth_type = RIP_AUTH_PW;
    259 			else if (!strcasecmp("md5_passwd",optarg))
    260 				auth_type = RIP_AUTH_MD5;
    261 			else
    262 				usage();
    263 			if (0 > parse_quote(&p,"|",&delim,
    264 					    passwd, sizeof(passwd)))
    265 				usage();
    266 			if (auth_type == RIP_AUTH_MD5
    267 			    && delim == '|') {
    268 				keyid = strtoul(p+1,&p,0);
    269 				if (keyid > 255 || *p != '\0')
    270 					usage();
    271 			} else if (delim != '\0') {
    272 				usage();
    273 			}
    274 			break;
    275 
    276 		default:
    277 			usage();
    278 	}
    279 	argv += optind;
    280 	argc -= optind;
    281 	if (not_trace && trace)
    282 		usage();
    283 	if (argc == 0) {
    284 		argc = 1;
    285 		argv = default_argv;
    286 	}
    287 
    288 	soc = socket(AF_INET, SOCK_DGRAM, 0);
    289 	if (soc < 0) {
    290 		perror("socket");
    291 		exit(2);
    292 	}
    293 
    294 	/* be prepared to receive a lot of routes */
    295 	for (bsize = 127*1024; ; bsize -= 1024) {
    296 		if (setsockopt(soc, SOL_SOCKET, SO_RCVBUF,
    297 			       &bsize, sizeof(bsize)) == 0)
    298 			break;
    299 		if (bsize <= 4*1024) {
    300 			perror("setsockopt SO_RCVBUF");
    301 			break;
    302 		}
    303 	}
    304 
    305 	if (trace)
    306 		trace_loop(argv);
    307 	else
    308 		query_loop(argv, argc);
    309 	/* NOTREACHED */
    310 	return 0;
    311 }
    312 
    313 
    314 static void
    315 usage(void)
    316 {
    317 	fprintf(stderr,
    318 		"usage:  rtquery [-np1] [-r tgt_rt] [-w wtime]"
    319 		" [-a type=passwd] host1 [host2 ...]\n"
    320 		"\trtquery -t {on=filename|more|off|dump}"
    321 				" host1 [host2 ...]\n");
    322 	exit(1);
    323 }
    324 
    325 
    326 /* tell the target hosts about tracing
    327  */
    328 static void
    329 trace_loop(char *argv[])
    330 {
    331 	struct sockaddr_in myaddr;
    332 	int res;
    333 
    334 	if (geteuid() != 0) {
    335 		(void)fprintf(stderr, "-t requires UID 0\n");
    336 		exit(1);
    337 	}
    338 
    339 	if (ripv2) {
    340 		OMSG.rip_vers = RIPv2;
    341 	} else {
    342 		OMSG.rip_vers = RIPv1;
    343 	}
    344 
    345 	memset(&myaddr, 0, sizeof(myaddr));
    346 	myaddr.sin_family = AF_INET;
    347 #ifdef _HAVE_SIN_LEN
    348 	myaddr.sin_len = sizeof(myaddr);
    349 #endif
    350 	myaddr.sin_port = htons(IPPORT_RESERVED-1);
    351 	while (bind(soc, (struct sockaddr *)&myaddr, sizeof(myaddr)) < 0) {
    352 		if (errno != EADDRINUSE
    353 		    || myaddr.sin_port == 0) {
    354 			perror("bind");
    355 			exit(2);
    356 		}
    357 		myaddr.sin_port = ntohs(myaddr.sin_port)-1;
    358 		myaddr.sin_port = htons(myaddr.sin_port);
    359 	}
    360 
    361 	res = 1;
    362 	while (*argv != 0) {
    363 		if (out(*argv++) <= 0)
    364 			res = 0;
    365 	}
    366 	exit(res);
    367 }
    368 
    369 
    370 /* query all of the listed hosts
    371  */
    372 static void
    373 query_loop(char *argv[], int argc)
    374 {
    375 	struct netauth *na = OMSG.rip_auths;
    376 #	define NA0 (na[0])
    377 #	define NA2 (na[2])
    378 	struct seen {
    379 		struct seen *next;
    380 		struct in_addr addr;
    381 	} *seen, *sp;
    382 	int answered = 0;
    383 	int cc;
    384 	fd_set bits;
    385 	struct timeval now, delay;
    386 	struct sockaddr_in from;
    387 	socklen_t fromlen;
    388 	MD5_CTX md5_ctx;
    389 
    390 
    391 	OMSG.rip_cmd = (pflag) ? RIPCMD_POLL : RIPCMD_REQUEST;
    392 	if (ripv2) {
    393 		OMSG.rip_vers = RIPv2;
    394 		if (auth_type == RIP_AUTH_PW) {
    395 			na[1] = na[0];
    396 			NA0.a_family = RIP_AF_AUTH;
    397 			NA0.a_type = RIP_AUTH_PW;
    398 			memcpy(NA0.au.au_pw, passwd, RIP_AUTH_PW_LEN);
    399 			omsg_len += sizeof(OMSG.rip_nets[0]);
    400 
    401 		} else if (auth_type == RIP_AUTH_MD5) {
    402 			na[1] = na[0];
    403 			NA0.a_family = RIP_AF_AUTH;
    404 			NA0.a_type = RIP_AUTH_MD5;
    405 			NA0.au.a_md5.md5_keyid = (int8_t)keyid;
    406 			NA0.au.a_md5.md5_auth_len = RIP_AUTH_MD5_KEY_LEN;
    407 			NA0.au.a_md5.md5_seqno = 0;
    408 			cc = (char *)&NA2-(char *)&OMSG;
    409 			NA0.au.a_md5.md5_pkt_len = htons(cc);
    410 			NA2.a_family = RIP_AF_AUTH;
    411 			NA2.a_type = htons(1);
    412 			MD5Init(&md5_ctx);
    413 			MD5Update(&md5_ctx,
    414 				  (u_char *)&OMSG, cc);
    415 			MD5Update(&md5_ctx,
    416 				  (u_char *)passwd, RIP_AUTH_MD5_HASH_LEN);
    417 			MD5Final(NA2.au.au_pw, &md5_ctx);
    418 			omsg_len += 2*sizeof(OMSG.rip_nets[0]);
    419 		}
    420 
    421 	} else {
    422 		OMSG.rip_vers = RIPv1;
    423 		OMSG.rip_nets[0].n_mask = 0;
    424 	}
    425 
    426 	/* ask the first (valid) host */
    427 	seen = 0;
    428 	while (0 > out(*argv++)) {
    429 		if (*argv == 0)
    430 			exit(1);
    431 		answered++;
    432 	}
    433 
    434 	FD_ZERO(&bits);
    435 	for (;;) {
    436 		FD_SET(soc, &bits);
    437 		delay.tv_sec = 0;
    438 		delay.tv_usec = STIME;
    439 		cc = select(soc+1, &bits, 0,0, &delay);
    440 		if (cc > 0) {
    441 			fromlen = sizeof(from);
    442 			cc = recvfrom(soc, imsg_buf.packet,
    443 				      sizeof(imsg_buf.packet), 0,
    444 				      (struct sockaddr *)&from, &fromlen);
    445 			if (cc < 0) {
    446 				perror("recvfrom");
    447 				exit(1);
    448 			}
    449 			/* count the distinct responding hosts.
    450 			 * You cannot match responding hosts with
    451 			 * addresses to which queries were transmitted,
    452 			 * because a router might respond with a
    453 			 * different source address.
    454 			 */
    455 			for (sp = seen; sp != 0; sp = sp->next) {
    456 				if (sp->addr.s_addr == from.sin_addr.s_addr)
    457 					break;
    458 			}
    459 			if (sp == 0) {
    460 				sp = malloc(sizeof(*sp));
    461 				if (sp == 0) {
    462 					fprintf(stderr,
    463 						"rtquery: malloc failed\n");
    464 					exit(1);
    465 				}
    466 				sp->addr = from.sin_addr;
    467 				sp->next = seen;
    468 				seen = sp;
    469 				answered++;
    470 			}
    471 
    472 			rip_input(&from, cc);
    473 			continue;
    474 		}
    475 
    476 		if (cc < 0) {
    477 			if (errno == EINTR)
    478 				continue;
    479 			perror("select");
    480 			exit(1);
    481 		}
    482 
    483 		/* After a pause in responses, probe another host.
    484 		 * This reduces the intermingling of answers.
    485 		 */
    486 		while (*argv != 0 && 0 > out(*argv++))
    487 			answered++;
    488 
    489 		/* continue until no more packets arrive
    490 		 * or we have heard from all hosts
    491 		 */
    492 		if (answered >= argc)
    493 			break;
    494 
    495 		/* or until we have waited a long time
    496 		 */
    497 		if (gettimeofday(&now, 0) < 0) {
    498 			perror("gettimeofday(now)");
    499 			exit(1);
    500 		}
    501 		if (sent.tv_sec + wtime <= now.tv_sec)
    502 			break;
    503 	}
    504 
    505 	/* fail if there was no answer */
    506 	exit (answered >= argc ? 0 : 1);
    507 }
    508 
    509 
    510 /* send to one host
    511  */
    512 static int
    513 out(const char *host)
    514 {
    515 	struct sockaddr_in router;
    516 	struct hostent *hp;
    517 
    518 	if (gettimeofday(&sent, 0) < 0) {
    519 		perror("gettimeofday(sent)");
    520 		return -1;
    521 	}
    522 
    523 	memset(&router, 0, sizeof(router));
    524 	router.sin_family = AF_INET;
    525 #ifdef _HAVE_SIN_LEN
    526 	router.sin_len = sizeof(router);
    527 #endif
    528 	if (!inet_aton(host, &router.sin_addr)) {
    529 		hp = gethostbyname(host);
    530 		if (hp == 0) {
    531 			herror(host);
    532 			return -1;
    533 		}
    534 		memcpy(&router.sin_addr, hp->h_addr, sizeof(router.sin_addr));
    535 	}
    536 	router.sin_port = htons(RIP_PORT);
    537 
    538 	if (sendto(soc, &omsg_buf, omsg_len, 0,
    539 		   (struct sockaddr *)&router, sizeof(router)) < 0) {
    540 		perror(host);
    541 		return -1;
    542 	}
    543 
    544 	return 0;
    545 }
    546 
    547 
    548 /*
    549  * Convert string to printable characters
    550  */
    551 static char *
    552 qstring(u_char *s, int len)
    553 {
    554 	static char buf[8*20+1];
    555 	size_t bufpos;
    556 	u_char *s2, c;
    557 
    558 
    559 	for (bufpos = 0; len != 0 && bufpos < sizeof(buf) - 1; len--) {
    560 		c = *s++;
    561 		if (c == '\0') {
    562 			for (s2 = s+1; s2 < &s[len]; s2++) {
    563 				if (*s2 != '\0')
    564 					break;
    565 			}
    566 			if (s2 >= &s[len])
    567 			    goto exit;
    568 		}
    569 
    570 		if (c >= ' ' && c < 0x7f && c != '\\') {
    571 			buf[bufpos++] = c;
    572 			continue;
    573 		}
    574 		if (bufpos >= sizeof(buf) - 2) {
    575 			/* too long */
    576 			break;
    577 		}
    578 		buf[bufpos++] = '\\';
    579 		switch (c) {
    580 		case '\\':
    581 			buf[bufpos++] = '\\';
    582 			break;
    583 		case '\n':
    584 			buf[bufpos++] = 'n';
    585 			break;
    586 		case '\r':
    587 			buf[bufpos++] = 'r';
    588 			break;
    589 		case '\t':
    590 			buf[bufpos++] = 't';
    591 			break;
    592 		case '\b':
    593 			buf[bufpos++] = 'b';
    594 			break;
    595 		default:
    596 			bufpos += snprintf(buf + bufpos, sizeof(buf) - bufpos,
    597 					   "%o", c);
    598 			break;
    599 		}
    600 	}
    601 exit:
    602 	buf[bufpos] = '\0';
    603 	return buf;
    604 }
    605 
    606 
    607 /*
    608  * Handle an incoming RIP packet.
    609  */
    610 static void
    611 rip_input(struct sockaddr_in *from,
    612 	  int size)
    613 {
    614 	struct netinfo *n, *lim;
    615 	struct in_addr in;
    616 	const char *name;
    617 	char net_buf[80];
    618 	u_char hash[RIP_AUTH_MD5_KEY_LEN];
    619 	MD5_CTX md5_ctx;
    620 	u_char md5_authed = 0;
    621 	u_int mask, dmask;
    622 	size_t spos;
    623 	int i;
    624 	struct hostent *hp;
    625 	struct netent *np;
    626 	struct netauth *na;
    627 
    628 
    629 	if (nflag) {
    630 		printf("%s:", inet_ntoa(from->sin_addr));
    631 	} else {
    632 		hp = gethostbyaddr((char*)&from->sin_addr,
    633 				   sizeof(struct in_addr), AF_INET);
    634 		if (hp == 0) {
    635 			printf("%s:",
    636 			       inet_ntoa(from->sin_addr));
    637 		} else {
    638 			printf("%s (%s):", hp->h_name,
    639 			       inet_ntoa(from->sin_addr));
    640 		}
    641 	}
    642 	if (IMSG.rip_cmd != RIPCMD_RESPONSE) {
    643 		printf("\n    unexpected response type %d\n", IMSG.rip_cmd);
    644 		return;
    645 	}
    646 	printf(" RIPv%d%s %d bytes\n", IMSG.rip_vers,
    647 	       (IMSG.rip_vers != RIPv1 && IMSG.rip_vers != RIPv2) ? " ?" : "",
    648 	       size);
    649 	if (size > MAXPACKETSIZE) {
    650 		if (size > (int)sizeof(imsg_buf) - (int)sizeof(*n)) {
    651 			printf("       at least %d bytes too long\n",
    652 			       size-MAXPACKETSIZE);
    653 			size = (int)sizeof(imsg_buf) - (int)sizeof(*n);
    654 		} else {
    655 			printf("       %d bytes too long\n",
    656 			       size-MAXPACKETSIZE);
    657 		}
    658 	} else if (size%sizeof(*n) != sizeof(struct rip)%sizeof(*n)) {
    659 		printf("    response of bad length=%d\n", size);
    660 	}
    661 
    662 	n = IMSG.rip_nets;
    663 	lim = (struct netinfo *)((char*)n + size) - 1;
    664 	for (; n <= lim; n++) {
    665 		name = "";
    666 		if (n->n_family == RIP_AF_INET) {
    667 			in.s_addr = n->n_dst;
    668 			(void)strcpy(net_buf, inet_ntoa(in));
    669 
    670 			mask = ntohl(n->n_mask);
    671 			dmask = mask & -mask;
    672 			if (mask != 0) {
    673 				spos = strlen(net_buf);
    674 				if (IMSG.rip_vers == RIPv1) {
    675 					(void)snprintf(net_buf + spos,
    676 						       sizeof(net_buf) - spos,
    677 						       " mask=%#x ? ", mask);
    678 					mask = 0;
    679 				} else if (mask + dmask == 0) {
    680 					for (i = 0;
    681 					     (i != 32
    682 					      && ((1<<i)&mask) == 0);
    683 					     i++)
    684 						continue;
    685 					(void)snprintf(net_buf + spos,
    686 						      sizeof(net_buf) - spos,
    687 						      "/%d", 32-i);
    688 				} else {
    689 					(void)snprintf(net_buf + spos,
    690 						       sizeof(net_buf) - spos,
    691 						       " (mask %#x)", mask);
    692 				}
    693 			}
    694 
    695 			if (!nflag) {
    696 				if (mask == 0) {
    697 					mask = std_mask(in.s_addr);
    698 					if ((ntohl(in.s_addr) & ~mask) != 0)
    699 						mask = 0;
    700 				}
    701 				/* Without a netmask, do not worry about
    702 				 * whether the destination is a host or a
    703 				 * network. Try both and use the first name
    704 				 * we get.
    705 				 *
    706 				 * If we have a netmask we can make a
    707 				 * good guess.
    708 				 */
    709 				if ((in.s_addr & ~mask) == 0) {
    710 					np = getnetbyaddr((long)in.s_addr,
    711 							  AF_INET);
    712 					if (np != 0)
    713 						name = np->n_name;
    714 					else if (in.s_addr == 0)
    715 						name = "default";
    716 				}
    717 				if (name[0] == '\0'
    718 				    && ((in.s_addr & ~mask) != 0
    719 					|| mask == 0xffffffff)) {
    720 					hp = gethostbyaddr((char*)&in,
    721 							   sizeof(in),
    722 							   AF_INET);
    723 					if (hp != 0)
    724 						name = hp->h_name;
    725 				}
    726 			}
    727 
    728 		} else if (n->n_family == RIP_AF_AUTH) {
    729 			na = (struct netauth*)n;
    730 			if (na->a_type == RIP_AUTH_PW
    731 			    && n == IMSG.rip_nets) {
    732 				(void)printf("  Password Authentication:"
    733 					     " \"%s\"\n",
    734 					     qstring(na->au.au_pw,
    735 						     RIP_AUTH_PW_LEN));
    736 				continue;
    737 			}
    738 
    739 			if (na->a_type == RIP_AUTH_MD5
    740 			    && n == IMSG.rip_nets) {
    741 				(void)printf("  MD5 Auth"
    742 					     " len=%d KeyID=%d"
    743 					     " auth_len=%d"
    744 					     " seqno=%#x"
    745 					     " rsvd=%#x,%#x\n",
    746 					     ntohs(na->au.a_md5.md5_pkt_len),
    747 					     na->au.a_md5.md5_keyid,
    748 					     na->au.a_md5.md5_auth_len,
    749 					     (int)ntohl(na->au.a_md5.md5_seqno),
    750 					     na->au.a_md5.rsvd[0],
    751 					     na->au.a_md5.rsvd[1]);
    752 				md5_authed = 1;
    753 				continue;
    754 			}
    755 			(void)printf("  Authentication type %d: ",
    756 				     ntohs(na->a_type));
    757 			for (i = 0; i < (int)sizeof(na->au.au_pw); i++)
    758 				(void)printf("%02x ", na->au.au_pw[i]);
    759 			putc('\n', stdout);
    760 			if (md5_authed && n+1 > lim
    761 			    && na->a_type == ntohs(1)) {
    762 				MD5Init(&md5_ctx);
    763 				MD5Update(&md5_ctx, (u_char *)&IMSG,
    764 					  (char *)na-(char *)&IMSG
    765 					  +RIP_AUTH_MD5_HASH_XTRA);
    766 				MD5Update(&md5_ctx, (u_char *)passwd,
    767 					  RIP_AUTH_MD5_KEY_LEN);
    768 				MD5Final(hash, &md5_ctx);
    769 				(void)printf("    %s hash\n",
    770 					     memcmp(hash, na->au.au_pw,
    771 						    sizeof(hash))
    772 					     ? "WRONG" : "correct");
    773 			}
    774 			continue;
    775 
    776 		} else {
    777 			(void)snprintf(net_buf, sizeof(net_buf),
    778 				      "(af %#x) %d.%d.%d.%d",
    779 				      ntohs(n->n_family),
    780 				      (u_char)(n->n_dst >> 24),
    781 				      (u_char)(n->n_dst >> 16),
    782 				      (u_char)(n->n_dst >> 8),
    783 				      (u_char)n->n_dst);
    784 		}
    785 
    786 		(void)printf("  %-18s metric %2d %-10s",
    787 			     net_buf, (int)ntohl(n->n_metric), name);
    788 
    789 		if (n->n_nhop != 0) {
    790 			in.s_addr = n->n_nhop;
    791 			if (nflag)
    792 				hp = 0;
    793 			else
    794 				hp = gethostbyaddr((char*)&in, sizeof(in),
    795 						   AF_INET);
    796 			(void)printf(" nhop=%-15s%s",
    797 				     (hp != 0) ? hp->h_name : inet_ntoa(in),
    798 				     (IMSG.rip_vers == RIPv1) ? " ?" : "");
    799 		}
    800 		if (n->n_tag != 0)
    801 			(void)printf(" tag=%#x%s", n->n_tag,
    802 				     (IMSG.rip_vers == RIPv1) ? " ?" : "");
    803 		putc('\n', stdout);
    804 	}
    805 }
    806 
    807 
    808 /* Return the classical netmask for an IP address.
    809  */
    810 static u_int
    811 std_mask(u_int addr)			/* in network order */
    812 {
    813 	addr = ntohl(addr);			/* was a host, not a network */
    814 
    815 	if (addr == 0)			/* default route has mask 0 */
    816 		return 0;
    817 	if (IN_CLASSA(addr))
    818 		return IN_CLASSA_NET;
    819 	if (IN_CLASSB(addr))
    820 		return IN_CLASSB_NET;
    821 	return IN_CLASSC_NET;
    822 }
    823 
    824 
    825 /* get a network number as a name or a number, with an optional "/xx"
    826  * netmask.
    827  */
    828 static int				/* 0=bad */
    829 getnet(char *name,
    830        struct netinfo *rt)
    831 {
    832 	int i;
    833 	struct netent *nentp;
    834 	u_int mask;
    835 	struct in_addr in;
    836 	char hname[MAXHOSTNAMELEN+1];
    837 	char *mname, *p;
    838 
    839 
    840 	/* Detect and separate "1.2.3.4/24"
    841 	 */
    842 	if (0 != (mname = strrchr(name,'/'))) {
    843 		i = (int)(mname - name);
    844 		if (i > (int)sizeof(hname)-1)	/* name too long */
    845 			return 0;
    846 		memmove(hname, name, i);
    847 		hname[i] = '\0';
    848 		mname++;
    849 		name = hname;
    850 	}
    851 
    852 	nentp = getnetbyname(name);
    853 	if (nentp != 0) {
    854 		in.s_addr = nentp->n_net;
    855 	} else if (inet_aton(name, &in) == 1) {
    856 		in.s_addr = ntohl(in.s_addr);
    857 	} else {
    858 		return 0;
    859 	}
    860 
    861 	if (mname == 0) {
    862 		mask = std_mask(in.s_addr);
    863 		if ((~mask & in.s_addr) != 0)
    864 			mask = 0xffffffff;
    865 	} else {
    866 		mask = (u_int)strtoul(mname, &p, 0);
    867 		if (*p != '\0' || mask > 32)
    868 			return 0;
    869 		mask = 0xffffffff << (32-mask);
    870 	}
    871 
    872 	rt->n_dst = htonl(in.s_addr);
    873 	rt->n_family = RIP_AF_INET;
    874 	rt->n_mask = htonl(mask);
    875 	return 1;
    876 }
    877 
    878 
    879 /* strtok(), but honoring backslash
    880  */
    881 static int				/* -1=bad */
    882 parse_quote(char **linep,
    883 	    const char *delims,
    884 	    char *delimp,
    885 	    char *buf,
    886 	    int	lim)
    887 {
    888 	char c, *pc;
    889 	const char *p;
    890 
    891 
    892 	pc = *linep;
    893 	if (*pc == '\0')
    894 		return -1;
    895 
    896 	for (;;) {
    897 		if (lim == 0)
    898 			return -1;
    899 		c = *pc++;
    900 		if (c == '\0')
    901 			break;
    902 
    903 		if (c == '\\' && *pc != '\0') {
    904 			if ((c = *pc++) == 'n') {
    905 				c = '\n';
    906 			} else if (c == 'r') {
    907 				c = '\r';
    908 			} else if (c == 't') {
    909 				c = '\t';
    910 			} else if (c == 'b') {
    911 				c = '\b';
    912 			} else if (c >= '0' && c <= '7') {
    913 				c -= '0';
    914 				if (*pc >= '0' && *pc <= '7') {
    915 					c = (c<<3)+(*pc++ - '0');
    916 					if (*pc >= '0' && *pc <= '7')
    917 					    c = (c<<3)+(*pc++ - '0');
    918 				}
    919 			}
    920 
    921 		} else {
    922 			for (p = delims; *p != '\0'; ++p) {
    923 				if (*p == c)
    924 					goto exit;
    925 			}
    926 		}
    927 
    928 		*buf++ = c;
    929 		--lim;
    930 	}
    931 exit:
    932 	if (delimp != 0)
    933 		*delimp = c;
    934 	*linep = pc-1;
    935 	if (lim != 0)
    936 		*buf = '\0';
    937 	return 0;
    938 }
    939