1: /*
2: * mtrace.c
3: *
4: * This tool traces the branch of a multicast tree from a source to a
5: * receiver for a particular multicast group and gives statistics
6: * about packet rate and loss for each hop along the path. It can
7: * usually be invoked just as
8: *
9: * mtrace source
10: *
11: * to trace the route from that source to the local host for a default
12: * group when only the route is desired and not group-specific packet
13: * counts. See the usage line for more complex forms.
14: *
15: *
16: * Released 4 Apr 1995. This program was adapted by Steve Casner
17: * (USC/ISI) from a prototype written by Ajit Thyagarajan (UDel and
18: * Xerox PARC). It attempts to parallel in command syntax and output
19: * format the unicast traceroute program written by Van Jacobson (LBL)
20: * for the parts where that makes sense.
21: *
22: * Copyright (c) 1998-2001.
23: * The University of Southern California/Information Sciences Institute.
24: * All rights reserved.
25: *
26: * Redistribution and use in source and binary forms, with or without
27: * modification, are permitted provided that the following conditions
28: * are met:
29: * 1. Redistributions of source code must retain the above copyright
30: * notice, this list of conditions and the following disclaimer.
31: * 2. Redistributions in binary form must reproduce the above copyright
32: * notice, this list of conditions and the following disclaimer in the
33: * documentation and/or other materials provided with the distribution.
34: * 3. Neither the name of the project nor the names of its contributors
35: * may be used to endorse or promote products derived from this software
36: * without specific prior written permission.
37: *
38: * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
39: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
40: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
41: * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
42: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
43: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
44: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
45: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
46: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
47: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
48: * SUCH DAMAGE.
49: */
50:
51: #include "defs.h"
52: #include <arpa/inet.h>
53: #include <ctype.h>
54: #include <err.h>
55: #include <ifaddrs.h>
56: #include <memory.h>
57: #include <netdb.h>
58: #include <poll.h>
59: #include <stdarg.h>
60: #include <string.h>
61: #include <sys/ioctl.h>
62: #ifdef SUNOS5
63: #include <sys/systeminfo.h>
64: #endif
65: #include <sys/time.h>
66:
67: #define DEFAULT_TIMEOUT 3 /* How long to wait before retrying requests */
68: #define DEFAULT_RETRIES 3 /* How many times to try */
69: #define MAXHOPS UNREACHABLE /* Don't need more hops than max metric */
70: #define UNICAST_TTL 255 /* TTL for unicast response */
71: #define MULTICAST_TTL1 64 /* Default TTL for multicast query/response */
72: #define MULTICAST_TTL_INC 32 /* TTL increment for increase after timeout */
73: #define MULTICAST_TTL_MAX 192 /* Maximum TTL allowed (protect low-BW links */
74:
75: struct resp_buf {
76: u_long qtime; /* Time query was issued */
77: u_long rtime; /* Time response was received */
78: int len; /* Number of reports or length of data */
79: struct igmp igmp; /* IGMP header */
80: union {
81: struct {
82: struct tr_query q; /* Query/response header */
83: struct tr_resp r[MAXHOPS]; /* Per-hop reports */
84: } t;
85: char d[MAX_DVMRP_DATA_LEN]; /* Neighbor data */
86: } u;
87: } base, incr[2];
88:
89: #define qhdr u.t.q
90: #define resps u.t.r
91: #define ndata u.d
92:
93: char names[MAXHOPS][40];
94: int reset[MAXHOPS]; /* To get around 3.4 bug, ... */
95: int swaps[MAXHOPS]; /* To get around 3.6 bug, ... */
96:
97: int timeout = DEFAULT_TIMEOUT;
98: int nqueries = DEFAULT_RETRIES;
99: int numeric = FALSE;
100: int debug = 0;
101: int passive = FALSE;
102: int multicast = FALSE;
103: int statint = 10;
104: int verbose = 0;
105:
106: u_int32_t defgrp; /* Default group if not specified */
107: u_int32_t query_cast; /* All routers multicast addr */
108: u_int32_t resp_cast; /* Mtrace response multicast addr */
109:
110: u_int32_t lcl_addr = 0; /* This host address, in NET order */
111: u_int32_t dst_netmask; /* netmask to go with qdst */
112:
113: /*
114: * Query/response parameters, all initialized to zero and set later
115: * to default values or from options.
116: */
117: u_int32_t qsrc = 0; /* Source address in the query */
118: u_int32_t qgrp = 0; /* Group address in the query */
119: u_int32_t qdst = 0; /* Destination (receiver) address in query */
120: u_char qno = 0; /* Max number of hops to query */
121: u_int32_t raddr = 0; /* Address where response should be sent */
122: int qttl = 0; /* TTL for the query packet */
123: u_char rttl = 0; /* TTL for the response packet */
124: u_int32_t gwy = 0; /* User-supplied last-hop router address */
125: u_int32_t tdst = 0; /* Address where trace is sent (last-hop) */
126:
127: vifi_t numvifs; /* to keep loader happy */
128: /* (see kern.c) */
129:
130: char * inet_name(u_int32_t addr);
131: u_int32_t host_addr(char *name);
132: /* u_int is promoted u_char */
133: char * proto_type(u_int type);
134: char * flag_type(u_int type);
135:
136: u_int32_t get_netmask(int s, u_int32_t dst);
137: int get_ttl(struct resp_buf *buf);
138: int t_diff(u_long a, u_long b);
139: u_long fixtime(u_long time);
140: int send_recv(u_int32_t dst, int type, int code,
141: int tries, struct resp_buf *save);
142: char * print_host(u_int32_t addr);
143: char * print_host2(u_int32_t addr1, u_int32_t addr2);
144: void print_trace(int index, struct resp_buf *buf);
145: int what_kind(struct resp_buf *buf, char *why);
146: char * scale(int *hop);
147: void stat_line(struct tr_resp *r, struct tr_resp *s,
148: int have_next, int *res);
149: void fixup_stats(struct resp_buf *base,
150: struct resp_buf *prev, struct resp_buf *new);
151: int print_stats(struct resp_buf *base,
152: struct resp_buf *prev, struct resp_buf *new);
153: void check_vif_state(void);
154: u_long byteswap(u_long v);
155:
156:
157: char *inet_name(u_int32_t addr)
158: {
159: struct hostent *e;
160:
161: e = gethostbyaddr((char *)&addr, sizeof(addr), AF_INET);
162:
163: return e ? e->h_name : "?";
164: }
165:
166: u_int32_t host_addr(char *name)
167: {
168: struct hostent *e = (struct hostent *)0;
169: u_int32_t addr;
170: int i, dots = 3;
171: char buf[40];
172: char *ip = name;
173: char *op = buf;
174:
175: /*
176: * Undo BSD's favor -- take fewer than 4 octets as net/subnet address
177: * if the name is all numeric.
178: */
179: for (i = sizeof(buf) - 7; i > 0; --i) {
180: if (*ip == '.') --dots;
181: else if (*ip == '\0') break;
182: else if (!isdigit((int)*ip)) dots = 0; /* Not numeric, don't add zeroes */
183: *op++ = *ip++;
184: }
185: for (i = 0; i < dots; ++i) {
186: *op++ = '.';
187: *op++ = '0';
188: }
189: *op = '\0';
190:
191: if (dots <= 0) e = gethostbyname(name);
192: if (e) memcpy((char *)&addr, e->h_addr_list[0], e->h_length);
193: else {
194: addr = inet_addr(buf);
195: if (addr == INADDR_NONE) {
196: addr = 0;
197: printf("Could not parse %s as host name or address\n", name);
198: }
199: }
200: return addr;
201: }
202:
203:
204: char *proto_type(u_int type)
205: {
206: static char buf[80];
207:
208: switch (type) {
209: case PROTO_DVMRP:
210: return ("DVMRP");
211: case PROTO_MOSPF:
212: return ("MOSPF");
213: case PROTO_PIM:
214: return ("PIM");
215: case PROTO_CBT:
216: return ("CBT");
217: default:
218: (void) snprintf(buf, sizeof buf, "Unknown protocol code %d", type);
219: return (buf);
220: }
221: }
222:
223:
224: char *flag_type(u_int type)
225: {
226: static char buf[80];
227:
228: switch (type) {
229: case TR_NO_ERR:
230: return ("");
231: case TR_WRONG_IF:
232: return ("Wrong interface");
233: case TR_PRUNED:
234: return ("Prune sent upstream");
235: case TR_OPRUNED:
236: return ("Output pruned");
237: case TR_SCOPED:
238: return ("Hit scope boundary");
239: case TR_NO_RTE:
240: return ("No route");
241: case TR_OLD_ROUTER:
242: return ("Next router no mtrace");
243: case TR_NO_FWD:
244: return ("Not forwarding");
245: case TR_NO_SPACE:
246: return ("No space in packet");
247: default:
248: (void) snprintf(buf, sizeof buf, "Unknown error code %d", type);
249: return (buf);
250: }
251: }
252:
253: /*
254: * If destination is on a local net, get the netmask, else set the
255: * netmask to all ones. There are two side effects: if the local
256: * address was not explicitly set, and if the destination is on a
257: * local net, use that one; in either case, verify that the local
258: * address is valid.
259: */
260: u_int32_t get_netmask(int UNUSED s, u_int32_t dst)
261: {
262: u_int32_t if_addr, if_mask;
263: u_int32_t retval = 0xFFFFFFFF;
264: int found = FALSE;
265: struct ifaddrs *ifap, *ifa;
266:
267: if (getifaddrs(&ifap) != 0) {
268: perror("getifaddrs");
269: return (retval);
270: }
271: for (ifa = ifap; ifa; ifa = ifa->ifa_next) {
272: if (!ifa->ifa_addr || ifa->ifa_addr->sa_family != AF_INET)
273: continue;
274: if_addr = ((struct sockaddr_in *)ifa->ifa_addr)->sin_addr.s_addr;
275: if_mask = ((struct sockaddr_in *)ifa->ifa_netmask)->sin_addr.s_addr;
276: if ((dst & if_mask) == (if_addr & if_mask)) {
277: retval = if_mask;
278: if (lcl_addr == 0)
279: lcl_addr = if_addr;
280: }
281: if (lcl_addr == if_addr)
282: found = TRUE;
283: }
284: if (!found && lcl_addr != 0) {
285: printf("Interface address is not valid\n");
286: exit(1);
287: }
288: freeifaddrs(ifap);
289: return (retval);
290: }
291:
292:
293: int get_ttl(struct resp_buf *buf)
294: {
295: int rno;
296: struct tr_resp *b;
297: u_int ttl;
298:
299: if (buf && (rno = buf->len) > 0) {
300: b = buf->resps + rno - 1;
301: ttl = b->tr_fttl;
302:
303: while (--rno > 0) {
304: --b;
305: if (ttl < b->tr_fttl) ttl = b->tr_fttl;
306: else ++ttl;
307: }
308: ttl += MULTICAST_TTL_INC;
309: if (ttl < MULTICAST_TTL1) ttl = MULTICAST_TTL1;
310: if (ttl > MULTICAST_TTL_MAX) ttl = MULTICAST_TTL_MAX;
311: return (ttl);
312: } else return(MULTICAST_TTL1);
313: }
314:
315: /*
316: * Calculate the difference between two 32-bit NTP timestamps and return
317: * the result in milliseconds.
318: */
319: int t_diff(u_long a, u_long b)
320: {
321: int d = a - b;
322:
323: return ((d * 125) >> 13);
324: }
325:
326: /*
327: * Fixup for incorrect time format in 3.3 mrouted.
328: * This is possible because (JAN_1970 mod 64K) is quite close to 32K,
329: * so correct and incorrect times will be far apart.
330: */
331: u_long fixtime(u_long time)
332: {
333: if (abs((int)(time-base.qtime)) > 0x3FFFFFFF)
334: time = ((time & 0xFFFF0000) + (JAN_1970 << 16)) +
335: ((time & 0xFFFF) << 14) / 15625;
336: return (time);
337: }
338:
339: /*
340: * Swap bytes for poor little-endian machines that don't byte-swap
341: */
342: u_long byteswap(u_long v)
343: {
344: return ((v << 24) | ((v & 0xff00) << 8) |
345: ((v >> 8) & 0xff00) | (v >> 24));
346: }
347:
348: int send_recv(u_int32_t dst, int type, int code, int tries, struct resp_buf *save)
349: {
350: struct timeval tq, tr, tv;
351: struct ip *ip;
352: struct igmp *igmp;
353: struct tr_query *query, *rquery;
354: size_t ipdatalen, iphdrlen;
355: u_int32_t local, group;
356: int datalen;
357: struct pollfd pfd[1];
358: int count, len, i;
359: size_t igmpdatalen;
360: ssize_t recvlen;
361: socklen_t dummy = 0;
362:
363: if (type == IGMP_MTRACE) {
364: group = qgrp;
365: datalen = sizeof(struct tr_query);
366: } else {
367: group = htonl(MROUTED_LEVEL);
368: datalen = 0;
369: }
370: if (IN_MULTICAST(ntohl(dst))) local = lcl_addr;
371: else local = INADDR_ANY;
372:
373: /*
374: * If the reply address was not explicitly specified, start off
375: * with the unicast address of this host. Then, if there is no
376: * response after trying half the tries with unicast, switch to
377: * the standard multicast reply address. If the TTL was also not
378: * specified, set a multicast TTL and if needed increase it for the
379: * last quarter of the tries.
380: */
381: query = (struct tr_query *)(send_buf + MIN_IP_HEADER_LEN + IGMP_MINLEN);
382: query->tr_raddr = raddr ? raddr : multicast ? resp_cast : lcl_addr;
383: query->tr_rttl = rttl ? rttl :
384: IN_MULTICAST(ntohl(query->tr_raddr)) ? get_ttl(save) : UNICAST_TTL;
385: query->tr_src = qsrc;
386: query->tr_dst = qdst;
387:
388: for (i = tries ; i > 0; --i) {
389: if (tries == nqueries && raddr == 0) {
390: if (i == ((nqueries + 1) >> 1)) {
391: query->tr_raddr = resp_cast;
392: if (rttl == 0) query->tr_rttl = get_ttl(save);
393: }
394: if (i <= ((nqueries + 3) >> 2) && rttl == 0) {
395: query->tr_rttl += MULTICAST_TTL_INC;
396: if (query->tr_rttl > MULTICAST_TTL_MAX)
397: query->tr_rttl = MULTICAST_TTL_MAX;
398: }
399: }
400:
401: /*
402: * Change the qid for each request sent to avoid being confused
403: * by duplicate responses
404: */
405: #ifdef SYSV
406: query->tr_qid = ((u_int32_t)lrand48() >> 8);
407: #else
408: query->tr_qid = ((u_int32_t)random() >> 8);
409: #endif
410:
411: /*
412: * Set timer to calculate delays, then send query
413: */
414: gettimeofday(&tq, 0);
415: send_igmp(local, dst, type, code, group, datalen);
416:
417: /*
418: * Wait for response, discarding false alarms
419: */
420: pfd[0].fd = igmp_socket;
421: pfd[0].events = POLLIN;
422: while (TRUE) {
423: gettimeofday(&tv, 0);
424: tv.tv_sec = tq.tv_sec + timeout - tv.tv_sec;
425: tv.tv_usec = tq.tv_usec - tv.tv_usec;
426: if (tv.tv_usec < 0) tv.tv_usec += 1000000L, --tv.tv_sec;
427: if (tv.tv_sec < 0) tv.tv_sec = tv.tv_usec = 0;
428:
429: count = poll(pfd, 1, tv.tv_sec * 1000);
430:
431: if (count < 0) {
432: if (errno != EINTR) perror("poll");
433: continue;
434: } else if (count == 0) {
435: printf("* ");
436: fflush(stdout);
437: break;
438: }
439:
440: gettimeofday(&tr, 0);
441: recvlen = recvfrom(igmp_socket, recv_buf, RECV_BUF_SIZE,
442: 0, (struct sockaddr *)0, &dummy);
443:
444: if (recvlen <= 0) {
445: if (recvlen && errno != EINTR) perror("recvfrom");
446: continue;
447: }
448:
449: if ((size_t)recvlen < sizeof(struct ip)) {
450: fprintf(stderr, "packet too short (%zd bytes) for IP header", recvlen);
451: continue;
452: }
453: ip = (struct ip *) recv_buf;
454: if (ip->ip_p == 0) /* ignore cache creation requests */
455: continue;
456:
457: iphdrlen = ip->ip_hl << 2;
458: ipdatalen = ntohs(ip->ip_len) - iphdrlen;
459: if (iphdrlen + ipdatalen != (size_t)recvlen) {
460: fprintf(stderr, "packet shorter (%zd bytes) than hdr+data len (%zu+%zu)\n",
461: recvlen, iphdrlen, ipdatalen);
462: continue;
463: }
464:
465: igmp = (struct igmp *) (recv_buf + iphdrlen);
466: if (ipdatalen < IGMP_MINLEN) {
467: fprintf(stderr,
468: "IP data field too short (%zu bytes) for IGMP from %s\n",
469: ipdatalen, inet_fmt(ip->ip_src.s_addr, s1, sizeof(s1)));
470: continue;
471: }
472: igmpdatalen = ipdatalen - IGMP_MINLEN;
473:
474: switch (igmp->igmp_type) {
475:
476: case IGMP_DVMRP:
477: if (igmp->igmp_code != DVMRP_NEIGHBORS2) continue;
478: len = igmpdatalen;
479: /*
480: * Accept DVMRP_NEIGHBORS2 response if it comes from the
481: * address queried or if that address is one of the local
482: * addresses in the response.
483: */
484: if (ip->ip_src.s_addr != dst) {
485: u_int32_t *p = (u_int32_t *)(igmp + 1);
486: u_int32_t *ep = p + (len >> 2);
487: while (p < ep) {
488: u_int32_t laddr = *p++;
489: int n = ntohl(*p++) & 0xFF;
490: if (laddr == dst) {
491: ep = p + 1; /* ensure p < ep after loop */
492: break;
493: }
494: p += n;
495: }
496: if (p >= ep) continue;
497: }
498: break;
499:
500: case IGMP_MTRACE: /* For backward compatibility with 3.3 */
501: case IGMP_MTRACE_RESP:
502: if (igmpdatalen <= QLEN) continue;
503: if ((igmpdatalen - QLEN) % RLEN) {
504: printf("packet with incorrect datalen\n");
505: continue;
506: }
507:
508: /*
509: * Ignore responses that don't match query.
510: */
511: rquery = (struct tr_query *)(igmp + 1);
512: if (rquery->tr_qid != query->tr_qid) continue;
513: if (rquery->tr_src != qsrc) continue;
514: if (rquery->tr_dst != qdst) continue;
515: len = (igmpdatalen - QLEN) / RLEN;
516:
517: /*
518: * Ignore trace queries passing through this node when
519: * mtrace is run on an mrouter that is in the path
520: * (needed only because IGMP_MTRACE is accepted above
521: * for backward compatibility with multicast release 3.3).
522: */
523: if (igmp->igmp_type == IGMP_MTRACE) {
524: struct tr_resp *r = (struct tr_resp *)(rquery+1) + len - 1;
525: u_int32_t smask;
526:
527: VAL_TO_MASK(smask, r->tr_smask);
528: if (len < code && (r->tr_inaddr & smask) != (qsrc & smask)
529: && r->tr_rmtaddr != 0 && !(r->tr_rflags & 0x80))
530: continue;
531: }
532:
533: /*
534: * A match, we'll keep this one.
535: */
536: if (len > code) {
537: fprintf(stderr,
538: "Num hops received (%d) exceeds request (%d)\n",
539: len, code);
540: }
541: rquery->tr_raddr = query->tr_raddr; /* Insure these are */
542: rquery->tr_rttl = query->tr_rttl; /* as we sent them */
543: break;
544:
545: default:
546: continue;
547: }
548:
549: /*
550: * Most of the sanity checking done at this point.
551: * Return this packet we have been waiting for.
552: */
553: if (save) {
554: save->qtime = ((tq.tv_sec + JAN_1970) << 16) +
555: (tq.tv_usec << 10) / 15625;
556: save->rtime = ((tr.tv_sec + JAN_1970) << 16) +
557: (tr.tv_usec << 10) / 15625;
558: save->len = len;
559: bcopy((char *)igmp, (char *)&save->igmp, ipdatalen);
560: }
561: return recvlen;
562: }
563: }
564: return 0;
565: }
566:
567: /*
568: * Most of this code is duplicated elsewhere. I'm not sure if
569: * the duplication is absolutely required or not.
570: *
571: * Ideally, this would keep track of ongoing statistics
572: * collection and print out statistics. (& keep track
573: * of h-b-h traces and only print the longest) For now,
574: * it just snoops on what traces it can.
575: */
576: void passive_mode(void)
577: {
578: struct timeval tr;
579: struct ip *ip;
580: struct igmp *igmp;
581: struct tr_resp *r;
582: size_t ipdatalen, iphdrlen, igmpdatalen;
583: size_t len;
584: ssize_t recvlen;
585: socklen_t dummy = 0;
586: u_int32_t smask;
587:
588: if (raddr) {
589: if (IN_MULTICAST(ntohl(raddr))) k_join(raddr, INADDR_ANY);
590: } else k_join(htonl(0xE0000120), INADDR_ANY);
591:
592: while (1) {
593: recvlen = recvfrom(igmp_socket, recv_buf, RECV_BUF_SIZE,
594: 0, (struct sockaddr *)0, &dummy);
595: gettimeofday(&tr,0);
596:
597: if (recvlen <= 0) {
598: if (recvlen && errno != EINTR) perror("recvfrom");
599: continue;
600: }
601:
602: if ((size_t)recvlen < sizeof(struct ip)) {
603: fprintf(stderr, "packet too short (%zd bytes) for IP header", recvlen);
604: continue;
605: }
606: ip = (struct ip *) recv_buf;
607: if (ip->ip_p == 0) /* ignore cache creation requests */
608: continue;
609:
610: iphdrlen = ip->ip_hl << 2;
611: ipdatalen = ntohs(ip->ip_len) - iphdrlen;
612: if (iphdrlen + ipdatalen != (size_t)recvlen) {
613: fprintf(stderr, "packet shorter (%zd bytes) than hdr+data len (%zu+%zu)\n",
614: recvlen, iphdrlen, ipdatalen);
615: continue;
616: }
617:
618: igmp = (struct igmp *) (recv_buf + iphdrlen);
619: if (ipdatalen < IGMP_MINLEN) {
620: fprintf(stderr, "IP data field too short (%zu bytes) for IGMP from %s\n",
621: ipdatalen, inet_fmt(ip->ip_src.s_addr, s1, sizeof(s1)));
622: continue;
623: }
624: igmpdatalen = ipdatalen - IGMP_MINLEN;
625:
626: switch (igmp->igmp_type) {
627:
628: case IGMP_MTRACE: /* For backward compatibility with 3.3 */
629: case IGMP_MTRACE_RESP:
630: if (igmpdatalen < QLEN) continue;
631: if ((igmpdatalen - QLEN) % RLEN) {
632: printf("packet with incorrect datalen\n");
633: continue;
634: }
635:
636: len = (igmpdatalen - QLEN)/RLEN;
637:
638: break;
639:
640: default:
641: continue;
642: }
643:
644: base.qtime = ((tr.tv_sec + JAN_1970) << 16) +
645: (tr.tv_usec << 10) / 15625;
646: base.rtime = ((tr.tv_sec + JAN_1970) << 16) +
647: (tr.tv_usec << 10) / 15625;
648: base.len = len;
649: bcopy((char *)igmp, (char *)&base.igmp, ipdatalen);
650: /*
651: * If the user specified which traces to monitor,
652: * only accept traces that correspond to the
653: * request
654: */
655: if ((qsrc != 0 && qsrc != base.qhdr.tr_src) ||
656: (qdst != 0 && qdst != base.qhdr.tr_dst) ||
657: (qgrp != 0 && qgrp != igmp->igmp_group.s_addr))
658: continue;
659:
660: printf("Mtrace from %s to %s via group %s (mxhop=%d)\n",
661: inet_fmt(base.qhdr.tr_dst, s1, sizeof(s1)), inet_fmt(base.qhdr.tr_src, s2, sizeof(s2)),
662: inet_fmt(igmp->igmp_group.s_addr, s3, sizeof(s3)), igmp->igmp_code);
663: if (len == 0)
664: continue;
665: printf(" 0 ");
666: print_host(base.qhdr.tr_dst);
667: printf("\n");
668: print_trace(1, &base);
669: r = base.resps + base.len - 1;
670: VAL_TO_MASK(smask, r->tr_smask);
671: if ((r->tr_inaddr & smask) == (base.qhdr.tr_src & smask)) {
672: printf("%3d ", -(base.len+1));
673: print_host(base.qhdr.tr_src);
674: printf("\n");
675: } else if (r->tr_rmtaddr != 0) {
676: printf("%3d ", -(base.len+1));
677: what_kind(&base, r->tr_rflags == TR_OLD_ROUTER ?
678: "doesn't support mtrace"
679: : "is the next hop");
680: }
681: printf("\n");
682: }
683: }
684:
685: char *print_host(u_int32_t addr)
686: {
687: return print_host2(addr, 0);
688: }
689:
690: /*
691: * On some routers, one interface has a name and the other doesn't.
692: * We always print the address of the outgoing interface, but can
693: * sometimes get the name from the incoming interface. This might be
694: * confusing but should be slightly more helpful than just a "?".
695: */
696: char *print_host2(u_int32_t addr1, u_int32_t addr2)
697: {
698: char *name;
699:
700: if (numeric) {
701: printf("%s", inet_fmt(addr1, s1, sizeof(s1)));
702: return ("");
703: }
704: name = inet_name(addr1);
705: if (*name == '?' && *(name + 1) == '\0' && addr2 != 0)
706: name = inet_name(addr2);
707: printf("%s (%s)", name, inet_fmt(addr1, s1, sizeof(s1)));
708: return (name);
709: }
710:
711: /*
712: * Print responses as received (reverse path from dst to src)
713: */
714: void print_trace(int index, struct resp_buf *buf)
715: {
716: struct tr_resp *r;
717: char *name;
718: int i;
719: int hop;
720: char *ms;
721:
722: i = abs(index);
723: r = buf->resps + i - 1;
724:
725: for (; i <= buf->len; ++i, ++r) {
726: if (index > 0) printf("%3d ", -i);
727: name = print_host2(r->tr_outaddr, r->tr_inaddr);
728: printf(" %s thresh^ %d", proto_type(r->tr_rproto), r->tr_fttl);
729: if (verbose) {
730: hop = t_diff(fixtime(ntohl(r->tr_qarr)), buf->qtime);
731: ms = scale(&hop);
732: printf(" %d%s", hop, ms);
733: }
734: printf(" %s\n", flag_type(r->tr_rflags));
735: memcpy(names[i-1], name, sizeof(names[0]) - 1);
736: names[i-1][sizeof(names[0])-1] = '\0';
737: }
738: }
739:
740: /*
741: * See what kind of router is the next hop
742: */
743: int what_kind(struct resp_buf *buf, char *why)
744: {
745: u_int32_t smask;
746: int retval;
747: int hops = buf->len;
748: struct tr_resp *r = buf->resps + hops - 1;
749: u_int32_t next = r->tr_rmtaddr;
750:
751: retval = send_recv(next, IGMP_DVMRP, DVMRP_ASK_NEIGHBORS2, 1, &incr[0]);
752: print_host(next);
753: if (retval) {
754: u_int32_t version = ntohl(incr[0].igmp.igmp_group.s_addr);
755: u_int32_t *p = (u_int32_t *)incr[0].ndata;
756: u_int32_t *ep = p + (incr[0].len >> 2);
757: char *type = "";
758: retval = 0;
759: switch (version & 0xFF) {
760: case 1:
761: type = "proteon/mrouted ";
762: retval = 1;
763: break;
764:
765: case 2:
766: case 3:
767: if (((version >> 8) & 0xFF) < 3) retval = 1;
768: /* Fall through */
769: case 4:
770: type = "mrouted ";
771: break;
772:
773: case 10:
774: type = "cisco ";
775: }
776: printf(" [%s%d.%d] %s\n",
777: type, version & 0xFF, (version >> 8) & 0xFF,
778: why);
779: VAL_TO_MASK(smask, r->tr_smask);
780: while (p < ep) {
781: u_int32_t laddr = *p++;
782: int flags = (ntohl(*p) & 0xFF00) >> 8;
783: int n = ntohl(*p++) & 0xFF;
784: if (!(flags & (DVMRP_NF_DOWN | DVMRP_NF_DISABLED)) &&
785: (laddr & smask) == (qsrc & smask)) {
786: printf("%3d ", -(hops+2));
787: print_host(qsrc);
788: printf("\n");
789: return 1;
790: }
791: p += n;
792: }
793: return retval;
794: }
795: printf(" %s\n", why);
796: return 0;
797: }
798:
799:
800: char *scale(int *hop)
801: {
802: if (*hop > -1000 && *hop < 10000) return (" ms");
803: *hop /= 1000;
804: if (*hop > -1000 && *hop < 10000) return (" s ");
805: return ("s ");
806: }
807:
808: /*
809: * Calculate and print one line of packet loss and packet rate statistics.
810: * Checks for count of all ones from mrouted 2.3 that doesn't have counters.
811: */
812: #define NEITHER 0
813: #define INS 1
814: #define OUTS 2
815: #define BOTH 3
816: void stat_line(struct tr_resp *r, struct tr_resp *s, int have_next, int *rst)
817: {
818: int timediff = (fixtime(ntohl(s->tr_qarr)) -
819: fixtime(ntohl(r->tr_qarr))) >> 16;
820: int v_lost, v_pct;
821: int g_lost, g_pct;
822: int v_out = ntohl(s->tr_vifout) - ntohl(r->tr_vifout);
823: int g_out = ntohl(s->tr_pktcnt) - ntohl(r->tr_pktcnt);
824: int v_pps, g_pps;
825: char v_str[8], g_str[8];
826: int have = NEITHER;
827: int res = *rst;
828:
829: if (timediff == 0) timediff = 1;
830: v_pps = v_out / timediff;
831: g_pps = g_out / timediff;
832:
833: if (v_out && ((s->tr_vifout != 0xFFFFFFFF && s->tr_vifout != 0) ||
834: (r->tr_vifout != 0xFFFFFFFF && r->tr_vifout != 0)))
835: have |= OUTS;
836:
837: if (have_next) {
838: --r, --s, --rst;
839: if ((s->tr_vifin != 0xFFFFFFFF && s->tr_vifin != 0) ||
840: (r->tr_vifin != 0xFFFFFFFF && r->tr_vifin != 0))
841: have |= INS;
842: if (*rst)
843: res = 1;
844: }
845:
846: switch (have) {
847: case BOTH:
848: v_lost = v_out - (ntohl(s->tr_vifin) - ntohl(r->tr_vifin));
849: if (v_out) v_pct = (v_lost * 100 + (v_out >> 1)) / v_out;
850: else v_pct = 0;
851: if (-100 < v_pct && v_pct < 101 && v_out > 10)
852: snprintf(v_str, sizeof v_str, "%3d", v_pct);
853: else memcpy(v_str, " --", 4);
854:
855: g_lost = g_out - (ntohl(s->tr_pktcnt) - ntohl(r->tr_pktcnt));
856: if (g_out) g_pct = (g_lost * 100 + (g_out >> 1))/ g_out;
857: else g_pct = 0;
858: if (-100 < g_pct && g_pct < 101 && g_out > 10)
859: snprintf(g_str, sizeof g_str, "%3d", g_pct);
860: else memcpy(g_str, " --", 4);
861:
862: printf("%6d/%-5d=%s%%%4d pps",
863: v_lost, v_out, v_str, v_pps);
864: if (res)
865: printf("\n");
866: else
867: printf("%6d/%-5d=%s%%%4d pps\n",
868: g_lost, g_out, g_str, g_pps);
869: break;
870:
871: case INS:
872: v_out = ntohl(s->tr_vifin) - ntohl(r->tr_vifin);
873: v_pps = v_out / timediff;
874: /* Fall through */
875:
876: case OUTS:
877: printf(" %-5d %4d pps",
878: v_out, v_pps);
879: if (res)
880: printf("\n");
881: else
882: printf(" %-5d %4d pps\n",
883: g_out, g_pps);
884: break;
885:
886: case NEITHER:
887: printf("\n");
888: break;
889: }
890:
891: if (debug > 2) {
892: printf("\t\t\t\tv_in: %u ", ntohl(s->tr_vifin));
893: printf("v_out: %u ", ntohl(s->tr_vifout));
894: printf("pkts: %u\n", ntohl(s->tr_pktcnt));
895: printf("\t\t\t\tv_in: %u ", ntohl(r->tr_vifin));
896: printf("v_out: %u ", ntohl(r->tr_vifout));
897: printf("pkts: %u\n", ntohl(r->tr_pktcnt));
898: printf("\t\t\t\tv_in: %u ", ntohl(s->tr_vifin)-ntohl(r->tr_vifin));
899: printf("v_out: %u ", ntohl(s->tr_vifout) - ntohl(r->tr_vifout));
900: printf("pkts: %u ", ntohl(s->tr_pktcnt) - ntohl(r->tr_pktcnt));
901: printf("time: %d\n", timediff);
902: printf("\t\t\t\tres: %d\n", res);
903: }
904: }
905:
906: /*
907: * A fixup to check if any pktcnt has been reset, and to fix the
908: * byteorder bugs in mrouted 3.6 on little-endian machines.
909: */
910: void fixup_stats(struct resp_buf *base, struct resp_buf *prev, struct resp_buf *new)
911: {
912: int rno = base->len;
913: struct tr_resp *b = base->resps + rno;
914: struct tr_resp *p = prev->resps + rno;
915: struct tr_resp *n = new->resps + rno;
916: int *r = reset + rno;
917: int *s = swaps + rno;
918: int res;
919:
920: /* Check for byte-swappers */
921: while (--rno >= 0) {
922: --n; --p; --b; --s;
923: if (*s || abs(ntohl(n->tr_vifout) - ntohl(p->tr_vifout)) > 100000) {
924: /* This host sends byteswapped reports; swap 'em */
925: if (!*s) {
926: *s = 1;
927: b->tr_qarr = byteswap(b->tr_qarr);
928: b->tr_vifin = byteswap(b->tr_vifin);
929: b->tr_vifout = byteswap(b->tr_vifout);
930: b->tr_pktcnt = byteswap(b->tr_pktcnt);
931: }
932:
933: n->tr_qarr = byteswap(n->tr_qarr);
934: n->tr_vifin = byteswap(n->tr_vifin);
935: n->tr_vifout = byteswap(n->tr_vifout);
936: n->tr_pktcnt = byteswap(n->tr_pktcnt);
937: }
938: }
939:
940: rno = base->len;
941: b = base->resps + rno;
942: p = prev->resps + rno;
943: n = new->resps + rno;
944:
945: while (--rno >= 0) {
946: --n; --p; --b; --r;
947: res = ((ntohl(n->tr_pktcnt) < ntohl(b->tr_pktcnt)) ||
948: (ntohl(n->tr_pktcnt) < ntohl(p->tr_pktcnt)));
949: if (debug > 2)
950: printf("\t\tr=%d, res=%d\n", *r, res);
951: if (*r) {
952: if (res || *r > 1) {
953: /*
954: * This router appears to be a 3.4 with that nasty ol'
955: * neighbor version bug, which causes it to constantly
956: * reset. Just nuke the statistics for this node, and
957: * don't even bother giving it the benefit of the
958: * doubt from now on.
959: */
960: p->tr_pktcnt = b->tr_pktcnt = n->tr_pktcnt;
961: r++;
962: } else {
963: /*
964: * This is simply the situation that the original
965: * fixup_stats was meant to deal with -- that a
966: * 3.3 or 3.4 router deleted a cache entry while
967: * traffic was still active.
968: */
969: *r = 0;
970: break;
971: }
972: } else
973: *r = res;
974: }
975:
976: if (rno < 0) return;
977:
978: rno = base->len;
979: b = base->resps + rno;
980: p = prev->resps + rno;
981:
982: while (--rno >= 0) (--b)->tr_pktcnt = (--p)->tr_pktcnt;
983: }
984:
985: /*
986: * Print responses with statistics for forward path (from src to dst)
987: */
988: int print_stats(struct resp_buf *base, struct resp_buf *prev, struct resp_buf *new)
989: {
990: int rtt, hop;
991: char *ms;
992: u_int32_t smask;
993: int rno = base->len - 1;
994: struct tr_resp *b = base->resps + rno;
995: struct tr_resp *p = prev->resps + rno;
996: struct tr_resp *n = new->resps + rno;
997: int *r = reset + rno;
998: u_long resptime = new->rtime;
999: u_long qarrtime = fixtime(ntohl(n->tr_qarr));
1000: u_int ttl = n->tr_fttl;
1001: int first = (base == prev);
1002:
1003: VAL_TO_MASK(smask, b->tr_smask);
1004: printf(" Source Response Dest");
1005: printf(" Packet Statistics For Only For Traffic\n");
1006: printf("%-15s %-15s All Multicast Traffic From %s\n",
1007: ((b->tr_inaddr & smask) == (qsrc & smask)) ? s1 : " * * * ",
1008: inet_fmt(base->qhdr.tr_raddr, s2, sizeof(s2)), inet_fmt(qsrc, s1, sizeof(s1)));
1009: rtt = t_diff(resptime, new->qtime);
1010: ms = scale(&rtt);
1011: printf(" %c __/ rtt%5d%s Lost/Sent = Pct Rate To %s\n",
1012: first ? 'v' : '|', rtt, ms, inet_fmt(qgrp, s2, sizeof(s2)));
1013: if (!first) {
1014: hop = t_diff(resptime, qarrtime);
1015: ms = scale(&hop);
1016: printf(" v / hop%5d%s", hop, ms);
1017: printf(" --------------------- --------------------\n");
1018: }
1019: if (debug > 2) {
1020: printf("\t\t\t\tv_in: %u ", ntohl(n->tr_vifin));
1021: printf("v_out: %u ", ntohl(n->tr_vifout));
1022: printf("pkts: %u\n", ntohl(n->tr_pktcnt));
1023: printf("\t\t\t\tv_in: %u ", ntohl(b->tr_vifin));
1024: printf("v_out: %u ", ntohl(b->tr_vifout));
1025: printf("pkts: %u\n", ntohl(b->tr_pktcnt));
1026: printf("\t\t\t\tv_in: %u ", ntohl(n->tr_vifin) - ntohl(b->tr_vifin));
1027: printf("v_out: %u ", ntohl(n->tr_vifout) - ntohl(b->tr_vifout));
1028: printf("pkts: %u\n", ntohl(n->tr_pktcnt) - ntohl(b->tr_pktcnt));
1029: printf("\t\t\t\treset: %d\n", *r);
1030: }
1031:
1032: while (TRUE) {
1033: if ((n->tr_inaddr != b->tr_inaddr) || (n->tr_inaddr != b->tr_inaddr))
1034: return 1; /* Route changed */
1035:
1036: if ((n->tr_inaddr != n->tr_outaddr))
1037: printf("%-15s\n", inet_fmt(n->tr_inaddr, s1, sizeof(s1)));
1038: printf("%-15s %-14s %s\n", inet_fmt(n->tr_outaddr, s1, sizeof(s1)), names[rno],
1039: flag_type(n->tr_rflags));
1040:
1041: if (rno-- < 1) break;
1042:
1043: printf(" %c ^ ttl%5d ", first ? 'v' : '|', ttl);
1044: stat_line(p, n, TRUE, r);
1045: if (!first) {
1046: resptime = qarrtime;
1047: qarrtime = fixtime(ntohl((n-1)->tr_qarr));
1048: hop = t_diff(resptime, qarrtime);
1049: ms = scale(&hop);
1050: printf(" v | hop%5d%s", hop, ms);
1051: stat_line(b, n, TRUE, r);
1052: }
1053:
1054: --b, --p, --n, --r;
1055: if (ttl < n->tr_fttl) ttl = n->tr_fttl;
1056: else ++ttl;
1057: }
1058:
1059: printf(" %c \\__ ttl%5d ", first ? 'v' : '|', ttl);
1060: stat_line(p, n, FALSE, r);
1061: if (!first) {
1062: hop = t_diff(qarrtime, new->qtime);
1063: ms = scale(&hop);
1064: printf(" v \\ hop%5d%s", hop, ms);
1065: stat_line(b, n, FALSE, r);
1066: }
1067: printf("%-15s %s\n", inet_fmt(qdst, s1, sizeof(s1)), inet_fmt(lcl_addr, s2, sizeof(s2)));
1068: printf(" Receiver Query Source\n\n");
1069: return 0;
1070: }
1071:
1072:
1073: void usage(void)
1074: {
1075: fprintf(stderr, "Usage: mtrace [-lMnpsv] [-g gateway] [-i if_addr] [-m max_hops] [-q nqueries]\n"
1076: " [-r host] [-S stat_int] [-t ttl] [-w waittime] source [receiver]\n"
1077: " [group]\n");
1078: exit(1);
1079: }
1080:
1081: int main(int argc, char *argv[])
1082: {
1083: int udp;
1084: struct sockaddr_in addr;
1085: socklen_t addrlen = sizeof(addr);
1086: ssize_t recvlen;
1087: struct timeval tv;
1088: struct resp_buf *prev, *new;
1089: struct tr_resp *r;
1090: u_int32_t smask;
1091: int rno;
1092: int hops, nexthop, tries;
1093: u_int32_t lastout = 0;
1094: int numstats = 1;
1095: int waittime;
1096: int seed, ch;
1097: uid_t uid;
1098: const char *errstr;
1099:
1100: while ((ch = getopt(argc, argv, "d:g:i:lm:Mnpq:r:sS:t:vw:")) != -1) {
1101: switch (ch) {
1102: case 'd': /* Unlisted debug print option */
1103: debug = strtonum(optarg, 0, 3, &errstr);
1104: if (errstr) {
1105: warnx("debug level %s", errstr);
1106: debug = 0;
1107: }
1108: break;
1109:
1110: case 'g': /* Last-hop gateway (dest of query) */
1111: gwy = host_addr(optarg);
1112: break;
1113:
1114: case 'l': /* Loop updating stats indefinitely */
1115: numstats = 3153600;
1116: break;
1117:
1118: case 'm': /* Max number of hops to trace */
1119: qno = strtonum(optarg, 1, MAXHOPS, &errstr);
1120: if (errstr) {
1121: warnx("max hops %s", errstr);
1122: qno = 0;
1123: }
1124: break;
1125:
1126: case 'M': /* Use multicast for response */
1127: multicast = TRUE;
1128: break;
1129:
1130: case 'n': /* Don't reverse map host addresses */
1131: numeric = TRUE;
1132: break;
1133:
1134: case 'p': /* Passive listen for traces */
1135: passive = TRUE;
1136: break;
1137:
1138: case 'q': /* Number of query retries */
1139: nqueries = strtonum(optarg, 1, 65535, &errstr);
1140: if (errstr) {
1141: warnx("query retries %s", errstr);
1142: qno = 0;
1143: }
1144: break;
1145:
1146: case 'r': /* Dest for response packet */
1147: raddr = host_addr(optarg);
1148: break;
1149:
1150: case 's': /* Short form, don't wait for stats */
1151: numstats = 0;
1152: break;
1153:
1154: case 'S': /* Stat accumulation interval */
1155: statint = strtonum(optarg, 1, 65535, &errstr);
1156: if (errstr) {
1157: warnx("stat accumulation interval %s", errstr);
1158: statint = 10;
1159: }
1160: break;
1161:
1162: case 't': /* TTL for query packet */
1163: qttl = strtonum(optarg, 1, 32767, &errstr);
1164: if (errstr) {
1165: warnx("TTL for query packet %s", errstr);
1166: qttl = 0;
1167: }
1168: rttl = qttl;
1169: break;
1170:
1171: case 'v': /* Verbosity */
1172: verbose = TRUE;
1173: break;
1174:
1175: case 'w': /* Time to wait for packet arrival */
1176: timeout = strtonum(optarg, 1, 65535, &errstr);
1177: if (errstr) {
1178: warnx("TTL for query packet %s", errstr);
1179: timeout = DEFAULT_TIMEOUT;
1180: }
1181: break;
1182:
1183: case 'i': /* Local interface address */
1184: lcl_addr = host_addr(optarg);
1185: break;
1186:
1187: default:
1188: usage();
1189: }
1190: }
1191: argc -= optind;
1192: argv += optind;
1193:
1194: if (geteuid() != 0) {
1195: fprintf(stderr, "mtrace: must be root\n");
1196: exit(1);
1197: }
1198:
1199: init_igmp();
1200:
1201: uid = getuid();
1202: if (setuid(uid) == -1)
1203: err(1, "setuid");
1204:
1205: if (argc > 0 && (qsrc = host_addr(argv[0]))) { /* Source of path */
1206: if (IN_MULTICAST(ntohl(qsrc))) usage();
1207: argv++, argc--;
1208: if (argc > 0 && (qdst = host_addr(argv[0]))) { /* Dest of path */
1209: argv++, argc--;
1210: if (argc > 0 && (qgrp = host_addr(argv[0]))) { /* Path via group */
1211: argv++, argc--;
1212: }
1213: if (IN_MULTICAST(ntohl(qdst))) {
1214: u_int32_t temp = qdst;
1215: qdst = qgrp;
1216: qgrp = temp;
1217: if (IN_MULTICAST(ntohl(qdst))) usage();
1218: } else if (qgrp && !IN_MULTICAST(ntohl(qgrp))) usage();
1219: }
1220: }
1221:
1222: if (passive) {
1223: passive_mode();
1224: return(0);
1225: }
1226:
1227: if (argc > 0 || qsrc == 0) {
1228: usage();
1229: }
1230:
1231: /*
1232: * Set useful defaults for as many parameters as possible.
1233: */
1234:
1235: defgrp = htonl(0xE0020001); /* MBone Audio (224.2.0.1) */
1236: query_cast = htonl(0xE0000002); /* All routers multicast addr */
1237: resp_cast = htonl(0xE0000120); /* Mtrace response multicast addr */
1238: if (qgrp == 0) qgrp = defgrp;
1239:
1240: /*
1241: * Get default local address for multicasts to use in setting defaults.
1242: */
1243: memset(&addr, 0, sizeof addr);
1244: addr.sin_family = AF_INET;
1245: #ifdef HAVE_SA_LEN
1246: addr.sin_len = sizeof(addr);
1247: #endif
1248: addr.sin_addr.s_addr = qgrp;
1249: addr.sin_port = htons(2000); /* Any port above 1024 will do */
1250:
1251: if (((udp = socket(AF_INET, SOCK_DGRAM, 0)) < 0) ||
1252: (connect(udp, (struct sockaddr *) &addr, sizeof(addr)) < 0) ||
1253: getsockname(udp, (struct sockaddr *) &addr, &addrlen) < 0) {
1254: perror("Determining local address");
1255: exit(1);
1256: }
1257:
1258: #ifdef SUNOS5
1259: /*
1260: * SunOS 5.X prior to SunOS 2.6, getsockname returns 0 for udp socket.
1261: * This call to sysinfo will return the hostname.
1262: * If the default multicast interface (set with the route
1263: * for 224.0.0.0) is not the same as the hostname,
1264: * mtrace -i [if_addr] will have to be used.
1265: */
1266: if (addr.sin_addr.s_addr == 0) {
1267: char myhostname[MAXHOSTNAMELEN];
1268: struct hostent *hp;
1269: int error;
1270:
1271: error = sysinfo(SI_HOSTNAME, myhostname, sizeof(myhostname));
1272: if (error == -1) {
1273: perror("Getting my hostname");
1274: exit(1);
1275: }
1276:
1277: hp = gethostbyname(myhostname);
1278: if (hp == NULL || hp->h_addrtype != AF_INET ||
1279: hp->h_length != sizeof(addr.sin_addr)) {
1280: perror("Finding IP address for my hostname");
1281: exit(1);
1282: }
1283:
1284: memcpy((char *)&addr.sin_addr.s_addr, hp->h_addr, hp->h_length);
1285: }
1286: #endif
1287:
1288: /*
1289: * Default destination for path to be queried is the local host.
1290: */
1291: if (qdst == 0) qdst = lcl_addr ? lcl_addr : addr.sin_addr.s_addr;
1292: dst_netmask = get_netmask(udp, qdst);
1293: close(udp);
1294: if (lcl_addr == 0) lcl_addr = addr.sin_addr.s_addr;
1295:
1296: /*
1297: * Initialize the seed for random query identifiers.
1298: */
1299: gettimeofday(&tv, 0);
1300: seed = tv.tv_usec ^ lcl_addr;
1301: #ifdef SYSV
1302: srand48(seed);
1303: #else
1304: srandom(seed);
1305: #endif
1306:
1307: /*
1308: * Protect against unicast queries to mrouted versions that might crash.
1309: */
1310: if (gwy && !IN_MULTICAST(ntohl(gwy)))
1311: if (send_recv(gwy, IGMP_DVMRP, DVMRP_ASK_NEIGHBORS2, 1, &incr[0])) {
1312: int version = ntohl(incr[0].igmp.igmp_group.s_addr) & 0xFFFF;
1313: if (version == 0x0303 || version == 0x0503) {
1314: printf("Don't use -g to address an mrouted 3.%d, it might crash\n",
1315: (version >> 8) & 0xFF);
1316: exit(0);
1317: }
1318: }
1319:
1320: printf("Mtrace from %s to %s via group %s\n",
1321: inet_fmt(qsrc, s1, sizeof(s1)), inet_fmt(qdst, s2, sizeof(s2)), inet_fmt(qgrp, s3, sizeof(s3)));
1322:
1323: if ((qdst & dst_netmask) == (qsrc & dst_netmask)) {
1324: printf("Source & receiver are directly connected, no path to trace\n");
1325: exit(0);
1326: }
1327:
1328: /*
1329: * If the response is to be a multicast address, make sure we
1330: * are listening on that multicast address.
1331: */
1332: if (raddr) {
1333: if (IN_MULTICAST(ntohl(raddr))) k_join(raddr, lcl_addr);
1334: } else k_join(resp_cast, lcl_addr);
1335:
1336: /*
1337: * If the destination is on the local net, the last-hop router can
1338: * be found by multicast to the all-routers multicast group.
1339: * Otherwise, use the group address that is the subject of the
1340: * query since by definition the last-hop router will be a member.
1341: * Set default TTLs for local remote multicasts.
1342: */
1343: restart:
1344:
1345: if (gwy == 0) {
1346: if ((qdst & dst_netmask) == (lcl_addr & dst_netmask))
1347: tdst = query_cast;
1348: else
1349: tdst = qgrp;
1350: } else {
1351: tdst = gwy;
1352: }
1353:
1354: if (IN_MULTICAST(ntohl(tdst))) {
1355: k_set_loop(1); /* If I am running on a router, I need to hear this */
1356: if (tdst == query_cast) k_set_ttl(qttl ? qttl : 1);
1357: else k_set_ttl(qttl ? qttl : MULTICAST_TTL1);
1358: }
1359:
1360: /*
1361: * Try a query at the requested number of hops or MAXHOPS if unspecified.
1362: */
1363: if (qno == 0) {
1364: hops = MAXHOPS;
1365: tries = 1;
1366: printf("Querying full reverse path... ");
1367: fflush(stdout);
1368: } else {
1369: hops = qno;
1370: tries = nqueries;
1371: printf("Querying reverse path, maximum %d hops... ", qno);
1372: fflush(stdout);
1373: }
1374: base.rtime = 0;
1375: base.len = 0;
1376:
1377: recvlen = send_recv(tdst, IGMP_MTRACE, hops, tries, &base);
1378:
1379: /*
1380: * If the initial query was successful, print it. Otherwise, if
1381: * the query max hop count is the default of zero, loop starting
1382: * from one until there is no response for four hops. The extra
1383: * hops allow getting past an mtrace-capable mrouter that can't
1384: * send multicast packets because all phyints are disabled.
1385: */
1386: if (recvlen) {
1387: printf("\n 0 ");
1388: print_host(qdst);
1389: printf("\n");
1390: print_trace(1, &base);
1391: r = base.resps + base.len - 1;
1392: if (r->tr_rflags == TR_OLD_ROUTER || r->tr_rflags == TR_NO_SPACE ||
1393: qno != 0) {
1394: printf("%3d ", -(base.len+1));
1395: what_kind(&base, r->tr_rflags == TR_OLD_ROUTER ?
1396: "doesn't support mtrace"
1397: : "is the next hop");
1398: } else {
1399: VAL_TO_MASK(smask, r->tr_smask);
1400: if ((r->tr_inaddr & smask) == (qsrc & smask)) {
1401: printf("%3d ", -(base.len+1));
1402: print_host(qsrc);
1403: printf("\n");
1404: }
1405: }
1406: } else if (qno == 0) {
1407: printf("switching to hop-by-hop:\n 0 ");
1408: print_host(qdst);
1409: printf("\n");
1410:
1411: for (hops = 1, nexthop = 1; hops <= MAXHOPS; ++hops) {
1412: printf("%3d ", -hops);
1413: fflush(stdout);
1414:
1415: /*
1416: * After a successful first hop, try switching to the unicast
1417: * address of the last-hop router instead of multicasting the
1418: * trace query. This should be safe for mrouted versions 3.3
1419: * and 3.5 because there is a long route timeout with metric
1420: * infinity before a route disappears. Switching to unicast
1421: * reduces the amount of multicast traffic and avoids a bug
1422: * with duplicate suppression in mrouted 3.5.
1423: */
1424: if (hops == 2 && gwy == 0 &&
1425: (recvlen = send_recv(lastout, IGMP_MTRACE, hops, 1, &base)))
1426: tdst = lastout;
1427: else recvlen = send_recv(tdst, IGMP_MTRACE, hops, nqueries, &base);
1428:
1429: if (recvlen == 0) {
1430: if (hops == 1) break;
1431: if (hops == nexthop) {
1432: if (what_kind(&base, "didn't respond")) {
1433: /* the ask_neighbors determined that the
1434: * not-responding router is the first-hop. */
1435: break;
1436: }
1437: } else if (hops < nexthop + 3) {
1438: printf("\n");
1439: } else {
1440: printf("...giving up\n");
1441: break;
1442: }
1443: continue;
1444: }
1445: r = base.resps + base.len - 1;
1446: if (base.len == hops &&
1447: (hops == 1 || (base.resps+nexthop-2)->tr_outaddr == lastout)) {
1448: if (hops == nexthop) {
1449: print_trace(-hops, &base);
1450: } else {
1451: printf("\nResuming...\n");
1452: print_trace(nexthop, &base);
1453: }
1454: } else {
1455: if (base.len < hops) {
1456: /*
1457: * A shorter trace than requested means a fatal error
1458: * occurred along the path, or that the route changed
1459: * to a shorter one.
1460: *
1461: * If the trace is longer than the last one we received,
1462: * then we are resuming from a skipped router (but there
1463: * is still probably a problem).
1464: *
1465: * If the trace is shorter than the last one we
1466: * received, then the route must have changed (and
1467: * there is still probably a problem).
1468: */
1469: if (nexthop <= base.len) {
1470: printf("\nResuming...\n");
1471: print_trace(nexthop, &base);
1472: } else if (nexthop > base.len + 1) {
1473: hops = base.len;
1474: printf("\nRoute must have changed...\n");
1475: print_trace(1, &base);
1476: }
1477: } else {
1478: /*
1479: * The last hop address is not the same as it was;
1480: * the route probably changed underneath us.
1481: */
1482: hops = base.len;
1483: printf("\nRoute must have changed...\n");
1484: print_trace(1, &base);
1485: }
1486: }
1487: lastout = r->tr_outaddr;
1488:
1489: if (base.len < hops ||
1490: r->tr_rmtaddr == 0 ||
1491: (r->tr_rflags & 0x80)) {
1492: VAL_TO_MASK(smask, r->tr_smask);
1493: if (r->tr_rmtaddr) {
1494: if (hops != nexthop) {
1495: printf("\n%3d ", -(base.len+1));
1496: }
1497: what_kind(&base, r->tr_rflags == TR_OLD_ROUTER ?
1498: "doesn't support mtrace" :
1499: "would be the next hop");
1500: /* XXX could do segmented trace if TR_NO_SPACE */
1501: } else if (r->tr_rflags == TR_NO_ERR &&
1502: (r->tr_inaddr & smask) == (qsrc & smask)) {
1503: printf("%3d ", -(hops + 1));
1504: print_host(qsrc);
1505: printf("\n");
1506: }
1507: break;
1508: }
1509:
1510: nexthop = hops + 1;
1511: }
1512: }
1513:
1514: if (base.rtime == 0) {
1515: printf("Timed out receiving responses\n");
1516: if (IN_MULTICAST(ntohl(tdst))) {
1517: if (tdst == query_cast)
1518: printf("Perhaps no local router has a route for source %s\n",
1519: inet_fmt(qsrc, s1, sizeof(s1)));
1520: else
1521: printf("Perhaps receiver %s is not a member of group %s,\n"
1522: "or no router local to it has a route for source %s,\n"
1523: "or multicast at ttl %d doesn't reach its last-hop router for that source\n",
1524: inet_fmt(qdst, s2, sizeof(s2)), inet_fmt(qgrp, s3, sizeof(s3)), inet_fmt(qsrc, s1, sizeof(s1)),
1525: qttl ? qttl : MULTICAST_TTL1);
1526: }
1527: exit(1);
1528: }
1529:
1530: printf("Round trip time %d ms\n\n", t_diff(base.rtime, base.qtime));
1531:
1532: /*
1533: * Use the saved response which was the longest one received,
1534: * and make additional probes after delay to measure loss.
1535: */
1536: raddr = base.qhdr.tr_raddr;
1537: rttl = base.qhdr.tr_rttl;
1538: gettimeofday(&tv, 0);
1539: waittime = statint - (((tv.tv_sec + JAN_1970) & 0xFFFF) - (base.qtime >> 16));
1540: prev = &base;
1541: new = &incr[numstats&1];
1542:
1543: while (numstats--) {
1544: if (waittime < 1) printf("\n");
1545: else {
1546: printf("Waiting to accumulate statistics... ");
1547: fflush(stdout);
1548: sleep((unsigned)waittime);
1549: }
1550: rno = base.len;
1551: recvlen = send_recv(tdst, IGMP_MTRACE, rno, nqueries, new);
1552:
1553: if (recvlen == 0) {
1554: printf("Timed out.\n");
1555: exit(1);
1556: }
1557:
1558: if (rno != new->len) {
1559: printf("Trace length doesn't match:\n");
1560: /*
1561: * XXX Should this trace result be printed, or is that
1562: * too verbose? Perhaps it should just say restarting.
1563: * But if the path is changing quickly, this may be the
1564: * only snapshot of the current path. But, if the path
1565: * is changing that quickly, does the current path really
1566: * matter?
1567: */
1568: print_trace(1, new);
1569: printf("Restarting.\n\n");
1570: numstats++;
1571: goto restart;
1572: }
1573:
1574: printf("Results after %d seconds:\n\n",
1575: (int)((new->qtime - base.qtime) >> 16));
1576: fixup_stats(&base, prev, new);
1577: if (print_stats(&base, prev, new)) {
1578: printf("Route changed:\n");
1579: print_trace(1, new);
1580: printf("Restarting.\n\n");
1581: goto restart;
1582: }
1583: prev = new;
1584: new = &incr[numstats&1];
1585: waittime = statint;
1586: }
1587:
1588: /*
1589: * If the response was multicast back, leave the group
1590: */
1591: if (raddr) {
1592: if (IN_MULTICAST(ntohl(raddr))) k_leave(raddr, lcl_addr);
1593: } else k_leave(resp_cast, lcl_addr);
1594:
1595: return (0);
1596: }
1597:
1598: void check_vif_state(void)
1599: {
1600: logit(LOG_WARNING, errno, "sendto");
1601: }
1602:
1603: /*
1604: * Log errors and other messages to stderr, according to the severity
1605: * of the message and the current debug level. For errors of severity
1606: * LOG_ERR or worse, terminate the program.
1607: */
1608: void logit(int severity, int syserr, const char *format, ...)
1609: {
1610: va_list ap;
1611:
1612: switch (debug) {
1613: case 0:
1614: if (severity > LOG_WARNING)
1615: return;
1616: case 1:
1617: if (severity > LOG_NOTICE)
1618: return;
1619: case 2:
1620: if (severity > LOG_INFO)
1621: return;
1622: default:
1623: if (severity == LOG_WARNING)
1624: fprintf(stderr, "warning - ");
1625: va_start(ap, format);
1626: vfprintf(stderr, format, ap);
1627: va_end(ap);
1628: if (syserr == 0)
1629: fprintf(stderr, "\n");
1630: else
1631: fprintf(stderr, ": %s\n", strerror(syserr));
1632: }
1633:
1634: if (severity <= LOG_ERR)
1635: exit(1);
1636: }
1637:
1638: /* dummies */
1639: void accept_probe(u_int32_t UNUSED src, u_int32_t UNUSED dst, char UNUSED *p, size_t UNUSED datalen, u_int32_t UNUSED level)
1640: {
1641: }
1642:
1643: void accept_group_report(u_int32_t UNUSED src, u_int32_t UNUSED dst, u_int32_t UNUSED group, int UNUSED r_type)
1644: {
1645: }
1646:
1647: void accept_neighbor_request2(u_int32_t UNUSED src, u_int32_t UNUSED dst)
1648: {
1649: }
1650:
1651: void accept_report(u_int32_t UNUSED src, u_int32_t UNUSED dst, char UNUSED *p, size_t UNUSED datalen, u_int32_t UNUSED level)
1652: {
1653: }
1654:
1655: void accept_neighbor_request(u_int32_t UNUSED src, u_int32_t UNUSED dst)
1656: {
1657: }
1658:
1659: void accept_prune(u_int32_t UNUSED src, u_int32_t UNUSED dst, char UNUSED *p, size_t UNUSED datalen)
1660: {
1661: }
1662:
1663: void accept_graft(u_int32_t UNUSED src, u_int32_t UNUSED dst, char UNUSED *p, size_t UNUSED datalen)
1664: {
1665: }
1666:
1667: void accept_g_ack(u_int32_t UNUSED src, u_int32_t UNUSED dst, char UNUSED *p, size_t UNUSED datalen)
1668: {
1669: }
1670:
1671: void add_table_entry(u_int32_t UNUSED origin, u_int32_t UNUSED mcastgrp)
1672: {
1673: }
1674:
1675: void accept_leave_message(u_int32_t UNUSED src, u_int32_t UNUSED dst, u_int32_t UNUSED group)
1676: {
1677: }
1678:
1679: void accept_mtrace(u_int32_t UNUSED src, u_int32_t UNUSED dst, u_int32_t UNUSED group, char UNUSED *data, u_int8_t UNUSED no, size_t UNUSED datalen)
1680: {
1681: }
1682:
1683: void accept_membership_query(u_int32_t UNUSED src, u_int32_t UNUSED dst, u_int32_t UNUSED group, int UNUSED tmo)
1684: {
1685: }
1686:
1687: void accept_neighbors(u_int32_t UNUSED src, u_int32_t UNUSED dst, u_char UNUSED *p, size_t UNUSED datalen, u_int32_t UNUSED level)
1688: {
1689: }
1690:
1691: void accept_neighbors2(u_int32_t UNUSED src, u_int32_t UNUSED dst, u_char UNUSED *p, size_t UNUSED datalen, u_int32_t UNUSED level)
1692: {
1693: }
1694:
1695: void accept_info_request(u_int32_t UNUSED src, u_int32_t UNUSED dst, u_char UNUSED *p, size_t UNUSED datalen)
1696: {
1697: }
1698:
1699: void accept_info_reply(u_int32_t UNUSED src, u_int32_t UNUSED dst, u_char UNUSED *p, size_t UNUSED datalen)
1700: {
1701: }
1702:
1703: /**
1704: * Local Variables:
1705: * version-control: t
1706: * indent-tabs-mode: t
1707: * c-file-style: "ellemtel"
1708: * c-basic-offset: 4
1709: * End:
1710: */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to mtrace.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / mrouted