1 /*
2 * Copyright 2001-2003 Sun Microsystems, Inc. All rights reserved.
3 * Use is subject to license terms.
4 *
5 * Copyright (c) 1982, 1986, 1993
6 * The Regents of the University of California. All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 * 3. All advertising materials mentioning features or use of this software
17 * must display the following acknowledgment:
18 * This product includes software developed by the University of
19 * California, Berkeley and its contributors.
20 * 4. Neither the name of the University nor the names of its contributors
21 * may be used to endorse or promote products derived from this software
22 * without specific prior written permission.
23 *
24 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34 * SUCH DAMAGE.
35 *
36 * $FreeBSD: src/sbin/routed/rtquery/rtquery.c,v 1.14 2000/08/11 08:24:39
37 * sheldonh Exp $
38 * char copyright[] = "@(#) Copyright (c) 1982, 1986, 1993\n"
39 * "The Regents of the University of California. All rights reserved.\n";
40 */
41
42 #pragma ident "%Z%%M% %I% %E% SMI"
43
44 #include "defs.h"
45 #include <sys/types.h>
46 #include <sys/param.h>
47 #include <sys/protosw.h>
48 #include <sys/socket.h>
49 #include <sys/time.h>
50 #include <netinet/in.h>
51 #define RIPVERSION RIPv2
52 #include <protocols/routed.h>
53 #include <arpa/inet.h>
54 #include <netdb.h>
55 #include <errno.h>
56 #include <unistd.h>
57 #include <stdio.h>
58 #include <stdlib.h>
59 #include <string.h>
60 #include <md5.h>
61 #include <libintl.h>
62 #include <locale.h>
63 #include <net/if.h>
64 #include <netinet/udp.h>
65
66 #ident "$Revision: 1.12 $"
67
68 #define WTIME 15 /* Time to wait for all responses */
69 #define STIME (250*1000) /* usec to wait for another response */
70
71 /*
72 * The size of the control buffer passed to recvmsg() used to receive
73 * ancillary data.
74 */
75 #define CONTROL_BUFSIZE 1024
76
77 static const char *pgmname;
78
79 static union {
80 struct rip rip;
81 char packet[MAXPACKETSIZE+MAXPATHLEN];
82 } omsg_buf;
83 #define OMSG omsg_buf.rip
84 static int omsg_len = sizeof (struct rip);
85
86 static union {
87 struct rip rip;
88 char packet[MAXPACKETSIZE+1024];
89 } imsg_buf;
90 #define IMSG imsg_buf.rip
91
92 static int wtime = WTIME;
93 static int auth_type = RIP_AUTH_NONE;
94 char passwd[RIP_AUTH_PW_LEN+1];
95 static ulong_t keyid;
96 static boolean_t ripv2 = _B_TRUE; /* use RIP version 2 */
97 static boolean_t trace, not_trace; /* send trace command or not */
98 static boolean_t nflag; /* numbers, no names */
99 static boolean_t pflag; /* play the `gated` game */
100 static boolean_t rflag; /* 1=ask about a particular route */
101
102 static struct timeval sent; /* when query sent */
103
104 static char *default_argv[] = {"localhost", 0};
105
106 static void rip_input(struct sockaddr_in *, int, uint_t);
107 static int out(const char *, int);
108 static void trace_loop(char *argv[], int);
109 static void query_loop(char *argv[], int, int);
110 static uint_t incoming_interface(struct msghdr *);
111 static void usage(void);
112
113
114 int
main(int argc,char * argv[])115 main(int argc, char *argv[])
116 {
117 #define MAX_RCVBUF 127*1024
118 #define MIN_RCVBUF 4*1024
119
120 int ch, bsize, soc;
121 char *p, *tmp_ptr, *options, *value, delim;
122 const char *result;
123 in_addr_t netaddr, netmask;
124 int on;
125
126 (void) setlocale(LC_ALL, "");
127 #if !defined(TEXT_DOMAIN) /* Should be defined by cc -D */
128 #define TEXT_DOMAIN "SYS_TEXT"
129 #endif /* ! TEXT_DOMAIN */
130
131 (void) textdomain(TEXT_DOMAIN);
132
133 OMSG.rip_nets[0].n_dst = RIP_DEFAULT;
134 OMSG.rip_nets[0].n_family = RIP_AF_UNSPEC;
135 OMSG.rip_nets[0].n_metric = htonl(HOPCNT_INFINITY);
136
137 if ((pgmname = argv[0]) == NULL)
138 pgmname = "rtquery";
139 while ((ch = getopt(argc, argv, "np1w:r:t:a:")) != -1)
140 switch (ch) {
141 case 'n':
142 not_trace = _B_TRUE;
143 nflag = _B_TRUE;
144 break;
145
146 case 'p':
147 not_trace = _B_TRUE;
148 pflag = _B_TRUE;
149 break;
150
151 case '1':
152 ripv2 = _B_FALSE;
153 break;
154
155 case 'w':
156 not_trace = _B_TRUE;
157 wtime = (int)strtoul(optarg, &p, 0);
158 if (*p != '\0' || wtime <= 0 || p == optarg)
159 usage();
160 break;
161
162 case 'r':
163 not_trace = _B_TRUE;
164 if (rflag)
165 usage();
166 rflag = getnet(optarg, &netaddr, &netmask);
167 if (rflag) {
168 OMSG.rip_nets[0].n_dst = htonl(netaddr);
169 OMSG.rip_nets[0].n_family = RIP_AF_INET;
170 OMSG.rip_nets[0].n_mask = htonl(netmask);
171 } else {
172 struct hostent *hp = gethostbyname(optarg);
173 if (hp == NULL) {
174 (void) fprintf(stderr, "%s: %s: %s\n",
175 pgmname, optarg,
176 hstrerror(h_errno));
177 exit(EXIT_FAILURE);
178 }
179 (void) memcpy(&OMSG.rip_nets[0].n_dst,
180 hp->h_addr,
181 sizeof (OMSG.rip_nets[0].n_dst));
182 OMSG.rip_nets[0].n_family = RIP_AF_INET;
183 OMSG.rip_nets[0].n_mask = INADDR_BROADCAST;
184 rflag = _B_TRUE;
185 }
186 break;
187
188 case 't':
189 trace = _B_TRUE;
190 options = optarg;
191 while (*options != '\0') {
192 /* messy complications to make -W -Wall happy */
193 static char on_str[] = "on";
194 static char more_str[] = "more";
195 static char off_str[] = "off";
196 static char dump_str[] = "dump";
197 static char *traceopts[] = {
198 #define TRACE_ON 0
199 on_str,
200 #define TRACE_MORE 1
201 more_str,
202 #define TRACE_OFF 2
203 off_str,
204 #define TRACE_DUMP 3
205 dump_str,
206 0
207 };
208 result = "";
209 switch (getsubopt(&options, traceopts,
210 &value)) {
211 case TRACE_ON:
212 OMSG.rip_cmd = RIPCMD_TRACEON;
213 if (value == NULL ||
214 strlen(value) > MAXPATHLEN)
215 usage();
216 result = value;
217 break;
218 case TRACE_MORE:
219 if (value != NULL)
220 usage();
221 OMSG.rip_cmd = RIPCMD_TRACEON;
222 break;
223 case TRACE_OFF:
224 if (value != NULL)
225 usage();
226 OMSG.rip_cmd = RIPCMD_TRACEOFF;
227 break;
228 case TRACE_DUMP:
229 if (value != NULL)
230 usage();
231 OMSG.rip_cmd = RIPCMD_TRACEON;
232 result = "dump/../table";
233 break;
234 default:
235 usage();
236 }
237 (void) strlcpy((char *)OMSG.rip_tracefile,
238 result, MAXPATHLEN);
239 omsg_len += strlen(result) -
240 sizeof (OMSG.ripun);
241 }
242 break;
243
244 case 'a':
245 not_trace = _B_TRUE;
246 p = strchr(optarg, '=');
247 if (p == NULL)
248 usage();
249 *p++ = '\0';
250 if (0 == strcasecmp("passwd", optarg))
251 auth_type = RIP_AUTH_PW;
252 else if (0 == strcasecmp("md5_passwd", optarg))
253 auth_type = RIP_AUTH_MD5;
254 else
255 usage();
256 if (0 > parse_quote(&p, "|", &delim,
257 passwd, sizeof (passwd)))
258 usage();
259 if (auth_type == RIP_AUTH_MD5 &&
260 delim == '|') {
261 tmp_ptr = p+1;
262 keyid = strtoul(p+1, &p, 0);
263 if (keyid > 255 || *p != '\0' ||
264 p == tmp_ptr)
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(PF_INET, SOCK_DGRAM, 0);
284 if (soc < 0) {
285 perror("rtquery: socket");
286 exit(EXIT_FAILURE);
287 }
288
289 on = 1;
290 if (setsockopt(soc, IPPROTO_IP, IP_RECVIF, &on, sizeof (on)))
291 perror("rtquery: setsockopt IP_RECVIF");
292
293 /* be prepared to receive a lot of routes */
294 for (bsize = MAX_RCVBUF; ; bsize -= 1024) {
295 if (setsockopt(soc, SOL_SOCKET, SO_RCVBUF,
296 &bsize, sizeof (bsize)) == 0)
297 break;
298 if (bsize <= MIN_RCVBUF) {
299 perror("rtquery: setsockopt SO_RCVBUF");
300 break;
301 }
302 }
303
304 if (trace)
305 trace_loop(argv, soc);
306 else
307 query_loop(argv, argc, soc);
308 /* NOTREACHED */
309 return (0);
310 }
311
312
313 static void
usage(void)314 usage(void)
315 {
316 (void) fprintf(stderr,
317 gettext("usage: %s [-np1] [-r tgt_rt] [-w wtime]"
318 " [-a type=passwd] [host1 ...]\n"),
319 pgmname);
320 (void) fprintf(stderr,
321 gettext("\t%s -t {on=filename|more|off|dump} [host1 ...]\n"),
322 pgmname);
323 exit(EXIT_FAILURE);
324 }
325
326
327 /* Tell the target hosts about tracing */
328 static void
trace_loop(char * argv[],int soc)329 trace_loop(char *argv[], int soc)
330 {
331 struct sockaddr_in myaddr;
332 int res;
333 int optval = 1;
334
335 if (ripv2) {
336 OMSG.rip_vers = RIPv2;
337 } else {
338 OMSG.rip_vers = RIPv1;
339 }
340
341 (void) memset(&myaddr, 0, sizeof (myaddr));
342 myaddr.sin_family = AF_INET;
343 if (setsockopt(soc, IPPROTO_UDP, UDP_ANONPRIVBIND,
344 &optval, sizeof (optval)) < 0) {
345 perror("rtquery: setsockopt UDP_ANONPRIVBIND");
346 exit(EXIT_FAILURE);
347 }
348
349 if (bind(soc, (struct sockaddr *)&myaddr, sizeof (myaddr)) < 0) {
350 perror("rtquery: bind");
351 exit(EXIT_FAILURE);
352 }
353
354 res = EXIT_FAILURE;
355 while (*argv != NULL) {
356 if (out(*argv++, soc) == 0)
357 res = EXIT_SUCCESS;
358 }
359 exit(res);
360 }
361
362
363 /* Query all of the listed hosts */
364 static void
query_loop(char * argv[],int argc,int soc)365 query_loop(char *argv[], int argc, int soc)
366 {
367 #define NA0 (OMSG.rip_auths[0])
368 #define NA2 (OMSG.rip_auths[2])
369 struct seen {
370 struct seen *next;
371 struct in_addr addr;
372 } *seen, *sp;
373 int answered = 0;
374 int cc;
375 fd_set bits;
376 struct timeval now, delay;
377 struct sockaddr_in from;
378 MD5_CTX md5_ctx;
379 struct msghdr msg;
380 uint_t ifindex;
381 struct iovec iov;
382 uint8_t ancillary_data[CONTROL_BUFSIZE];
383
384
385 OMSG.rip_cmd = (pflag) ? RIPCMD_POLL : RIPCMD_REQUEST;
386 if (ripv2) {
387 OMSG.rip_vers = RIPv2;
388 if (auth_type == RIP_AUTH_PW) {
389 OMSG.rip_nets[1] = OMSG.rip_nets[0];
390 NA0.a_family = RIP_AF_AUTH;
391 NA0.a_type = RIP_AUTH_PW;
392 (void) memcpy(NA0.au.au_pw, passwd, RIP_AUTH_PW_LEN);
393 omsg_len += sizeof (OMSG.rip_nets[0]);
394
395 } else if (auth_type == RIP_AUTH_MD5) {
396 OMSG.rip_nets[1] = OMSG.rip_nets[0];
397 NA0.a_family = RIP_AF_AUTH;
398 NA0.a_type = RIP_AUTH_MD5;
399 NA0.au.a_md5.md5_keyid = (int8_t)keyid;
400 NA0.au.a_md5.md5_auth_len = RIP_AUTH_MD5_LEN;
401 NA0.au.a_md5.md5_seqno = 0;
402 cc = (char *)&NA2-(char *)&OMSG;
403 NA0.au.a_md5.md5_pkt_len = htons(cc);
404 NA2.a_family = RIP_AF_AUTH;
405 NA2.a_type = RIP_AUTH_TRAILER;
406 MD5Init(&md5_ctx);
407 MD5Update(&md5_ctx, (uchar_t *)&OMSG, cc+4);
408 MD5Update(&md5_ctx,
409 (uchar_t *)passwd, RIP_AUTH_MD5_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++, soc)) {
422 if (*argv == NULL)
423 exit(EXIT_FAILURE);
424 answered++;
425 }
426
427 iov.iov_base = &imsg_buf;
428 iov.iov_len = sizeof (imsg_buf);
429 msg.msg_iov = &iov;
430 msg.msg_iovlen = 1;
431 msg.msg_name = &from;
432 msg.msg_control = &ancillary_data;
433
434 (void) FD_ZERO(&bits);
435 FD_SET(soc, &bits);
436 for (;;) {
437 delay.tv_sec = 0;
438 delay.tv_usec = STIME;
439 cc = select(soc+1, &bits, 0, 0, &delay);
440 if (cc > 0) {
441 msg.msg_namelen = sizeof (from);
442 msg.msg_controllen = sizeof (ancillary_data);
443 cc = recvmsg(soc, &msg, 0);
444 if (cc < 0) {
445 perror("rtquery: recvmsg");
446 exit(EXIT_FAILURE);
447 }
448
449 /* avoid looping on high traffic */
450 if (answered > argc + 200)
451 break;
452
453 /*
454 * count the distinct responding hosts.
455 * You cannot match responding hosts with
456 * addresses to which queries were transmitted,
457 * because a router might respond with a
458 * different source address.
459 */
460 for (sp = seen; sp != NULL; sp = sp->next) {
461 if (sp->addr.s_addr == from.sin_addr.s_addr)
462 break;
463 }
464 if (sp == NULL) {
465 sp = malloc(sizeof (*sp));
466 if (sp != NULL) {
467 sp->addr = from.sin_addr;
468 sp->next = seen;
469 seen = sp;
470 } else {
471 perror("rtquery: malloc");
472 }
473 answered++;
474 }
475
476 ifindex = incoming_interface(&msg);
477 rip_input(&from, cc, ifindex);
478 continue;
479 }
480
481 if (cc < 0) {
482 if (errno == EINTR)
483 continue;
484 perror("rtquery: select");
485 exit(EXIT_FAILURE);
486 }
487
488 /*
489 * After a pause in responses, probe another host.
490 * This reduces the intermingling of answers.
491 */
492 while (*argv != NULL && 0 > out(*argv++, soc))
493 answered++;
494
495 /*
496 * continue until no more packets arrive
497 * or we have heard from all hosts
498 */
499 if (answered >= argc)
500 break;
501
502 /* or until we have waited a long time */
503 if (gettimeofday(&now, 0) < 0) {
504 perror("rtquery: gettimeofday");
505 exit(EXIT_FAILURE);
506 }
507 if (sent.tv_sec + wtime <= now.tv_sec)
508 break;
509 }
510
511 /* fail if there was no answer */
512 exit(answered >= argc ? EXIT_SUCCESS : EXIT_FAILURE);
513 }
514
515
516 /* Send to one host */
517 static int
out(const char * host,int soc)518 out(const char *host, int soc)
519 {
520
521 struct addrinfo hints, *res;
522 int ret;
523
524 if (gettimeofday(&sent, 0) < 0) {
525 perror("rtquery: gettimeofday");
526 return (-1);
527 }
528
529 (void) memset(&hints, 0, sizeof (hints));
530 hints.ai_family = PF_INET;
531 hints.ai_socktype = SOCK_DGRAM;
532 if ((ret = getaddrinfo(host, "route", &hints, &res)) != 0) {
533 (void) fprintf(stderr, "%s: getaddrinfo: %s: %s\n", pgmname,
534 host, gai_strerror(ret));
535 return (-1);
536 }
537
538 if (sendto(soc, &omsg_buf, omsg_len, 0, res->ai_addr,
539 res->ai_addrlen) < 0) {
540 perror("rtquery: sendto");
541 return (-1);
542 }
543
544 freeaddrinfo(res);
545 return (0);
546 }
547
548 /*
549 * Handle an incoming RIP packet.
550 */
551 static void
rip_input(struct sockaddr_in * from,int size,uint_t ifindex)552 rip_input(struct sockaddr_in *from, int size, uint_t ifindex)
553 {
554 struct netinfo *n, *lim;
555 struct in_addr in;
556 const char *name;
557 char net_buf[80];
558 uchar_t hash[RIP_AUTH_MD5_LEN];
559 MD5_CTX md5_ctx;
560 uchar_t md5_authed = 0;
561 in_addr_t mask, dmask;
562 struct in_addr tmp_addr;
563 char *sp;
564 char ifname[IF_NAMESIZE+1];
565 int i;
566 struct hostent *hp;
567 struct netent *np;
568 struct netauth *na;
569 char srcaddr[MAXHOSTNAMELEN + sizeof (" (123.123.123.123)") + 1];
570 char ifstring[IF_NAMESIZE + 3*sizeof (ifindex) + sizeof (" ()") + 1];
571
572 if (!nflag && (hp = gethostbyaddr((char *)&from->sin_addr,
573 sizeof (struct in_addr), AF_INET)) != NULL) {
574 (void) snprintf(srcaddr, sizeof (srcaddr), "%s (%s)",
575 hp->h_name, inet_ntoa(from->sin_addr));
576 } else {
577 /* safe; cannot overflow destination */
578 (void) strcpy(srcaddr, inet_ntoa(from->sin_addr));
579 }
580 if (ifindex == 0) {
581 (void) printf("%s:", srcaddr);
582 } else {
583 if (if_indextoname(ifindex, ifname) != NULL)
584 (void) snprintf(ifstring, sizeof (ifstring), "%s (%d)",
585 ifname, ifindex);
586 else
587 (void) snprintf(ifstring, sizeof (ifstring), "%d",
588 ifindex);
589 (void) printf(gettext("%1$s received on interface %2$s:"),
590 srcaddr, ifstring);
591 }
592
593 if (IMSG.rip_cmd != RIPCMD_RESPONSE) {
594 (void) printf(gettext("\n unexpected response type %d\n"),
595 IMSG.rip_cmd);
596 return;
597 }
598 (void) printf(gettext(" RIPv%1$d%2$s %3$d bytes\n"), IMSG.rip_vers,
599 (IMSG.rip_vers != RIPv1 && IMSG.rip_vers != RIPv2) ? " ?" : "",
600 size);
601 if (size > MAXPACKETSIZE) {
602 if (size > sizeof (imsg_buf) - sizeof (*n)) {
603 (void) printf(
604 gettext(" at least %d bytes too long\n"),
605 size-MAXPACKETSIZE);
606 size = sizeof (imsg_buf) - sizeof (*n);
607 } else {
608 (void) printf(gettext(" %d bytes too long\n"),
609 size-MAXPACKETSIZE);
610 }
611 } else if (size%sizeof (*n) != sizeof (struct rip)%sizeof (*n)) {
612 (void) printf(gettext(" response of bad length=%d\n"), size);
613 }
614
615 n = IMSG.rip_nets;
616 lim = n + (size - 4) / sizeof (struct netinfo);
617 for (; n < lim; n++) {
618 name = "";
619 if (n->n_family == RIP_AF_INET) {
620 in.s_addr = n->n_dst;
621 (void) strlcpy(net_buf, inet_ntoa(in),
622 sizeof (net_buf));
623
624 tmp_addr.s_addr = (n->n_mask);
625 mask = ntohl(n->n_mask);
626 dmask = mask & -mask;
627 if (mask != 0) {
628 sp = &net_buf[strlen(net_buf)];
629 if (IMSG.rip_vers == RIPv1) {
630 (void) snprintf(sp,
631 (sizeof (net_buf) -
632 strlen(net_buf)),
633 gettext(" mask=%s ? "),
634 inet_ntoa(tmp_addr));
635 mask = 0;
636 } else if (mask + dmask == 0) {
637 i = ffs(mask) - 1;
638 (void) snprintf(sp,
639 (sizeof (net_buf) -
640 strlen(net_buf)), "/%d", 32-i);
641 } else {
642 (void) snprintf(sp,
643 (sizeof (net_buf) -
644 strlen(net_buf)),
645 gettext(" (mask %s)"),
646 inet_ntoa(tmp_addr));
647 }
648 }
649
650 if (!nflag) {
651 if (mask == 0) {
652 mask = std_mask(in.s_addr);
653 if ((ntohl(in.s_addr) & ~mask) != 0)
654 mask = 0;
655 }
656 /*
657 * Without a netmask, do not worry about
658 * whether the destination is a host or a
659 * network. Try both and use the first name
660 * we get.
661 *
662 * If we have a netmask we can make a
663 * good guess.
664 */
665 if ((in.s_addr & ~mask) == 0) {
666 np = getnetbyaddr((long)in.s_addr,
667 AF_INET);
668 if (np != NULL)
669 name = np->n_name;
670 else if (in.s_addr == 0)
671 name = "default";
672 }
673 if (name[0] == '\0' &&
674 ((in.s_addr & ~mask) != 0 ||
675 mask == 0xffffffff)) {
676 hp = gethostbyaddr((char *)&in,
677 sizeof (in), AF_INET);
678 if (hp != NULL)
679 name = hp->h_name;
680 }
681 }
682
683 } else if (n->n_family == RIP_AF_AUTH) {
684 na = (struct netauth *)n;
685 if (na->a_type == RIP_AUTH_PW &&
686 n == IMSG.rip_nets) {
687 (void) printf(
688 gettext(" Password Authentication:"
689 " \"%s\"\n"),
690 qstring(na->au.au_pw,
691 RIP_AUTH_PW_LEN));
692 continue;
693 }
694
695 if (na->a_type == RIP_AUTH_MD5 &&
696 n == IMSG.rip_nets) {
697 (void) printf(gettext(" MD5 Auth"
698 " len=%1$d KeyID=%2$d"
699 " auth_len=%3$d"
700 " seqno=%4$#x"
701 " rsvd=%5$#x,%6$#x\n"),
702 ntohs(na->au.a_md5.md5_pkt_len),
703 na->au.a_md5.md5_keyid,
704 na->au.a_md5.md5_auth_len,
705 (int)ntohl(na->au.a_md5.md5_seqno),
706 na->au.a_md5.rsvd[0],
707 na->au.a_md5.rsvd[1]);
708 md5_authed = 1;
709 continue;
710 }
711 (void) printf(gettext(" Authentication type %d: "),
712 ntohs(na->a_type));
713 for (i = 0; i < sizeof (na->au.au_pw); i++)
714 (void) printf("%02x ",
715 na->au.au_pw[i]);
716 (void) putchar('\n');
717 if (md5_authed && n+1 > lim &&
718 na->a_type == RIP_AUTH_TRAILER) {
719 MD5Init(&md5_ctx);
720 MD5Update(&md5_ctx, (uchar_t *)&IMSG,
721 (char *)na-(char *)&IMSG);
722 MD5Update(&md5_ctx,
723 (uchar_t *)passwd, RIP_AUTH_MD5_LEN);
724 MD5Final(hash, &md5_ctx);
725 (void) printf(gettext(" %s hash\n"),
726 memcmp(hash, na->au.au_pw, sizeof (hash)) ?
727 gettext("WRONG") : gettext("correct"));
728 } else if (md5_authed && n+1 > lim &&
729 na->a_type != RIP_AUTH_TRAILER) {
730 (void) printf(gettext("Error -"
731 "authentication entry missing hash\n"));
732 }
733 continue;
734
735 } else {
736 tmp_addr.s_addr = n->n_dst;
737 (void) snprintf(net_buf, sizeof (net_buf),
738 gettext("(address family %1$u) %2$s"),
739 ntohs(n->n_family), inet_ntoa(tmp_addr));
740 }
741
742 (void) printf(gettext(" %1$-18s metric %2$2lu %3$-10s"),
743 net_buf, ntohl(n->n_metric), name);
744
745 if (n->n_nhop != 0) {
746 in.s_addr = n->n_nhop;
747 if (nflag)
748 hp = NULL;
749 else
750 hp = gethostbyaddr((char *)&in, sizeof (in),
751 AF_INET);
752 (void) printf(gettext(" nhop=%1$-15s%2$s"),
753 (hp != NULL) ? hp->h_name : inet_ntoa(in),
754 (IMSG.rip_vers == RIPv1) ? " ?" : "");
755 }
756 if (n->n_tag != 0)
757 (void) printf(gettext(" tag=%1$#x%2$s"), n->n_tag,
758 (IMSG.rip_vers == RIPv1) ? " ?" : "");
759 (void) putchar('\n');
760 }
761 }
762
763 /*
764 * Find the interface which received the given message.
765 */
766 static uint_t
incoming_interface(struct msghdr * msg)767 incoming_interface(struct msghdr *msg)
768 {
769 void *opt;
770 uint_t ifindex = 0;
771
772 /*
773 * Determine which physical interface this packet was received on by
774 * processing the message's ancillary data to find the
775 * IP_RECVIF option we requested.
776 */
777 if ((opt = find_ancillary(msg, IP_RECVIF)) == NULL)
778 (void) fprintf(stderr,
779 gettext("%s: unable to retrieve input interface\n"),
780 pgmname);
781 else
782 ifindex = *(uint_t *)opt;
783 return (ifindex);
784 }
785