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