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