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