1: /*
2: mtr -- a network diagnostic tool
3: Copyright (C) 1997,1998 Matt Kimball
4:
5: This program is free software; you can redistribute it and/or modify
6: it under the terms of the GNU General Public License version 2 as
7: published by the Free Software Foundation.
8:
9: This program is distributed in the hope that it will be useful,
10: but WITHOUT ANY WARRANTY; without even the implied warranty of
11: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12: GNU General Public License for more details.
13:
14: You should have received a copy of the GNU General Public License
15: along with this program; if not, write to the Free Software
16: Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
17: */
18:
19: #include "config.h"
20:
21: #include <sys/types.h>
22: #include <stdio.h>
23: #include <stdlib.h>
24: #include <string.h>
25: #include <unistd.h>
26: #include <errno.h>
27: #include <string.h>
28: #include <strings.h>
29: #ifdef HAVE_ERROR_H
30: #include <error.h>
31: #else
32: #include "portability/error.h"
33: #endif
34: #ifdef HAVE_VALUES_H
35: #include <values.h>
36: #endif
37: #ifdef HAVE_SYS_LIMITS_H
38: #include <sys/limits.h>
39: #endif
40:
41: #include <netdb.h>
42: #include <netinet/in.h>
43: #include <sys/socket.h>
44: #include <ctype.h>
45: #include <assert.h>
46: #include <fcntl.h>
47: #include <limits.h>
48: #include <sys/stat.h>
49: #include <sys/time.h>
50:
51: #include "mtr.h"
52: #include "mtr-curses.h"
53: #include "display.h"
54: #include "dns.h"
55: #include "report.h"
56: #include "net.h"
57: #include "asn.h"
58: #include "utils.h"
59:
60: #ifdef HAVE_GETOPT
61: #include <getopt.h>
62: #else
63: #include "portability/getopt.h"
64: #endif
65:
66: #ifdef ENABLE_IPV6
67: #define DEFAULT_AF AF_UNSPEC
68: #else
69: #define DEFAULT_AF AF_INET
70: #endif
71:
72:
73: const struct fields data_fields[MAXFLD] = {
74: /* key, Remark, Header, Format, Width, CallBackFunc */
75: {' ', "<sp>: Space between fields", " ", " ", 1, &net_drop},
76: {'L', "L: Loss Ratio", "Loss%", " %4.1f%%", 6, &net_loss},
77: {'D', "D: Dropped Packets", "Drop", " %4d", 5, &net_drop},
78: {'R', "R: Received Packets", "Rcv", " %5d", 6, &net_returned},
79: {'S', "S: Sent Packets", "Snt", " %5d", 6, &net_xmit},
80: {'N', "N: Newest RTT(ms)", "Last", " %5.1f", 6, &net_last},
81: {'B', "B: Min/Best RTT(ms)", "Best", " %5.1f", 6, &net_best},
82: {'A', "A: Average RTT(ms)", "Avg", " %5.1f", 6, &net_avg},
83: {'W', "W: Max/Worst RTT(ms)", "Wrst", " %5.1f", 6, &net_worst},
84: {'V', "V: Standard Deviation", "StDev", " %5.1f", 6, &net_stdev},
85: {'G', "G: Geometric Mean", "Gmean", " %5.1f", 6, &net_gmean},
86: {'J', "J: Current Jitter", "Jttr", " %4.1f", 5, &net_jitter},
87: {'M', "M: Jitter Mean/Avg.", "Javg", " %4.1f", 5, &net_javg},
88: {'X', "X: Worst Jitter", "Jmax", " %4.1f", 5, &net_jworst},
89: {'I', "I: Interarrival Jitter", "Jint", " %4.1f", 5, &net_jinta},
90: {'\0', NULL, NULL, NULL, 0, NULL}
91: };
92:
93: typedef struct names {
94: char *name;
95: struct names *next;
96: } names_t;
97:
98: static void __attribute__ ((__noreturn__)) usage(FILE * out)
99: {
100: fputs("\nUsage:\n", out);
101: fputs(" mtr [options] hostname\n", out);
102: fputs("\n", out);
103: fputs(" -F, --filename FILE read hostname(s) from a file\n",
104: out);
105: fputs(" -4 use IPv4 only\n", out);
106: #ifdef ENABLE_IPV6
107: fputs(" -6 use IPv6 only\n", out);
108: #endif
109: fputs(" -u, --udp use UDP instead of ICMP echo\n",
110: out);
111: fputs(" -T, --tcp use TCP instead of ICMP echo\n",
112: out);
113: fputs
114: (" -a, --address ADDRESS bind the outgoing socket to ADDRESS\n",
115: out);
116: fputs(" -f, --first-ttl NUMBER set what TTL to start\n", out);
117: fputs(" -m, --max-ttl NUMBER maximum number of hops\n", out);
118: fputs(" -U, --max-unknown NUMBER maximum unknown host\n", out);
119: fputs
120: (" -P, --port PORT target port number for TCP, SCTP, or UDP\n",
121: out);
122: fputs(" -L, --localport LOCALPORT source port number for UDP\n", out);
123: fputs
124: (" -s, --psize PACKETSIZE set the packet size used for probing\n",
125: out);
126: fputs
127: (" -B, --bitpattern NUMBER set bit pattern to use in payload\n",
128: out);
129: fputs(" -i, --interval SECONDS ICMP echo request interval\n", out);
130: fputs
131: (" -G, --gracetime SECONDS number of seconds to wait for responses\n",
132: out);
133: fputs
134: (" -Q, --tos NUMBER type of service field in IP header\n",
135: out);
136: fputs
137: (" -e, --mpls display information from ICMP extensions\n",
138: out);
139: fputs
140: (" -Z, --timeout SECONDS seconds to keep probe sockets open\n",
141: out);
142: #ifdef SO_MARK
143: fputs(" -M, --mark MARK mark each sent packet\n", out);
144: #endif
145: fputs(" -r, --report output using report mode\n", out);
146: fputs(" -w, --report-wide output wide report\n", out);
147: fputs(" -c, --report-cycles COUNT set the number of pings sent\n",
148: out);
149: fputs(" -j, --json output json\n", out);
150: fputs(" -x, --xml output xml\n", out);
151: fputs(" -C, --csv output comma separated values\n",
152: out);
153: fputs(" -l, --raw output raw format\n", out);
154: fputs(" -p, --split split output\n", out);
155: #ifdef HAVE_CURSES
156: fputs(" -t, --curses use curses terminal interface\n",
157: out);
158: #endif
159: fputs(" --displaymode MODE select initial display mode\n",
160: out);
161: #ifdef HAVE_GTK
162: fputs(" -g, --gtk use GTK+ xwindow interface\n", out);
163: #endif
164: fputs(" -n, --no-dns do not resove host names\n", out);
165: fputs(" -b, --show-ips show IP numbers and host names\n",
166: out);
167: fputs(" -o, --order FIELDS select output fields\n", out);
168: #ifdef HAVE_IPINFO
169: fputs(" -y, --ipinfo NUMBER select IP information in output\n",
170: out);
171: fputs(" -z, --aslookup display AS number\n", out);
172: #endif
173: fputs(" -h, --help display this help and exit\n", out);
174: fputs
175: (" -v, --version output version information and exit\n",
176: out);
177: fputs("\n", out);
178: fputs("See the 'man 8 mtr' for details.\n", out);
179: exit(out == stderr ? EXIT_FAILURE : EXIT_SUCCESS);
180: }
181:
182:
183: static void append_to_names(
184: names_t ** names_head,
185: const char *item)
186: {
187: names_t **name_tail = names_head;
188:
189: while (*name_tail) {
190: name_tail = &(*name_tail)->next;
191: }
192:
193: names_t *name = calloc(1, sizeof(names_t));
194: if (name == NULL) {
195: error(EXIT_FAILURE, errno, "memory allocation failure");
196: }
197: name->name = xstrdup(item);
198: name->next = NULL;
199:
200: *name_tail = name;
201: }
202:
203: static void read_from_file(
204: names_t ** names,
205: const char *filename)
206: {
207:
208: FILE *in;
209: char line[512];
210:
211: if (!filename || strcmp(filename, "-") == 0) {
212: clearerr(stdin);
213: in = stdin;
214: } else {
215: in = fopen(filename, "r");
216: if (!in) {
217: error(EXIT_FAILURE, errno, "open %s", filename);
218: }
219: }
220:
221: while (fgets(line, sizeof(line), in)) {
222: char *name = trim(line, '\0');
223: append_to_names(names, name);
224: }
225:
226: if (ferror(in)) {
227: error(EXIT_FAILURE, errno, "ferror %s", filename);
228: }
229:
230: if (in != stdin)
231: fclose(in);
232: }
233:
234: /*
235: * If the file stream is associated with a regular file, lock the file
236: * in order coordinate writes to a common file from multiple mtr
237: * instances. This is useful if, for example, multiple mtr instances
238: * try to append results to a common file.
239: */
240:
241: static void lock(
242: FILE * f)
243: {
244: int fd;
245: struct stat buf;
246: static struct flock lock;
247:
248: assert(f);
249:
250: lock.l_type = F_WRLCK;
251: lock.l_start = 0;
252: lock.l_whence = SEEK_END;
253: lock.l_len = 0;
254: lock.l_pid = getpid();
255:
256: fd = fileno(f);
257: if ((fstat(fd, &buf) == 0) && S_ISREG(buf.st_mode)) {
258: if (fcntl(fd, F_SETLKW, &lock) == -1) {
259: error(0, errno, "fcntl (ignored)");
260: }
261: }
262: }
263:
264: /*
265: * If the file stream is associated with a regular file, unlock the
266: * file (which presumably has previously been locked).
267: */
268:
269: static void unlock(
270: FILE * f)
271: {
272: int fd;
273: struct stat buf;
274: static struct flock lock;
275:
276: assert(f);
277:
278: lock.l_type = F_UNLCK;
279: lock.l_start = 0;
280: lock.l_whence = SEEK_END;
281: lock.l_len = 0;
282: lock.l_pid = getpid();
283:
284: fd = fileno(f);
285: if ((fstat(fd, &buf) == 0) && S_ISREG(buf.st_mode)) {
286: if (fcntl(fd, F_SETLKW, &lock) == -1) {
287: error(0, errno, "fcntl (ignored)");
288: }
289: }
290: }
291:
292:
293: static void init_fld_options(
294: struct mtr_ctl *ctl)
295: {
296: int i;
297:
298: memset(ctl->fld_index, -1, FLD_INDEX_SZ);
299:
300: for (i = 0; data_fields[i].key != 0; i++) {
301: ctl->available_options[i] = data_fields[i].key;
302: ctl->fld_index[data_fields[i].key] = i;
303: }
304: ctl->available_options[i] = 0;
305: }
306:
307:
308: static void parse_arg(
309: struct mtr_ctl *ctl,
310: names_t ** names,
311: int argc,
312: char **argv)
313: {
314: int opt;
315: int i;
316: /* IMPORTANT: when adding or modifying an option:
317: 0/ try to find a somewhat logical order;
318: 1/ add the long option name in "long_options" below;
319: 2/ update the man page (use the same order);
320: 3/ update the help message (see usage() function).
321: */
322: enum {
323: OPT_DISPLAYMODE = CHAR_MAX + 1
324: };
325: static const struct option long_options[] = {
326: /* option name, has argument, NULL, short name */
327: {"help", 0, NULL, 'h'},
328: {"version", 0, NULL, 'v'},
329:
330: {"inet", 0, NULL, '4'}, /* IPv4 only */
331: #ifdef ENABLE_IPV6
332: {"inet6", 0, NULL, '6'}, /* IPv6 only */
333: #endif
334: {"filename", 1, NULL, 'F'},
335:
336: {"report", 0, NULL, 'r'},
337: {"report-wide", 0, NULL, 'w'},
338: {"xml", 0, NULL, 'x'},
339: #ifdef HAVE_CURSES
340: {"curses", 0, NULL, 't'},
341: #endif
342: #ifdef HAVE_GTK
343: {"gtk", 0, NULL, 'g'},
344: #endif
345: {"raw", 0, NULL, 'l'},
346: {"csv", 0, NULL, 'C'},
347: {"json", 0, NULL, 'j'},
348: {"displaymode", 1, NULL, OPT_DISPLAYMODE},
349: {"split", 0, NULL, 'p'}, /* BL */
350: /* maybe above should change to -d 'x' */
351:
352: {"no-dns", 0, NULL, 'n'},
353: {"show-ips", 0, NULL, 'b'},
354: {"order", 1, NULL, 'o'}, /* fields to display & their order */
355: #ifdef HAVE_IPINFO
356: {"ipinfo", 1, NULL, 'y'}, /* IP info lookup */
357: {"aslookup", 0, NULL, 'z'}, /* Do AS lookup (--ipinfo 0) */
358: #endif
359:
360: {"interval", 1, NULL, 'i'},
361: {"report-cycles", 1, NULL, 'c'},
362: {"psize", 1, NULL, 's'}, /* overload psize<0, ->rand(min,max) */
363: {"bitpattern", 1, NULL, 'B'}, /* overload B>255, ->rand(0,255) */
364: {"tos", 1, NULL, 'Q'}, /* typeof service (0,255) */
365: {"mpls", 0, NULL, 'e'},
366: {"address", 1, NULL, 'a'},
367: {"first-ttl", 1, NULL, 'f'}, /* -f & -m are borrowed from traceroute */
368: {"max-ttl", 1, NULL, 'm'},
369: {"max-unknown", 1, NULL, 'U'},
370: {"udp", 0, NULL, 'u'}, /* UDP (default is ICMP) */
371: {"tcp", 0, NULL, 'T'}, /* TCP (default is ICMP) */
372: #ifdef HAS_SCTP
373: {"sctp", 0, NULL, 'S'}, /* SCTP (default is ICMP) */
374: #endif
375: {"port", 1, NULL, 'P'}, /* target port number for TCP/SCTP/UDP */
376: {"localport", 1, NULL, 'L'}, /* source port number for UDP */
377: {"timeout", 1, NULL, 'Z'}, /* timeout for probe sockets */
378: {"gracetime", 1, NULL, 'G'}, /* gracetime for replies after last probe */
379: #ifdef SO_MARK
380: {"mark", 1, NULL, 'M'}, /* use SO_MARK */
381: #endif
382: {NULL, 0, NULL, 0}
383: };
384: enum { num_options = sizeof(long_options) / sizeof(struct option) };
385: char short_options[num_options * 2];
386: size_t n, p;
387:
388: for (n = p = 0; n < num_options; n++) {
389: if (CHAR_MAX < long_options[n].val) {
390: continue;
391: }
392: short_options[p] = long_options[n].val;
393: p++;
394: if (long_options[n].has_arg == 1) {
395: short_options[p] = ':';
396: p++;
397: }
398: /* optional options need two ':', but ignore them now as they are not in use */
399: }
400:
401: opt = 0;
402: while (1) {
403: opt = getopt_long(argc, argv, short_options, long_options, NULL);
404: if (opt == -1)
405: break;
406:
407: switch (opt) {
408: case 'v':
409: printf("mtr " PACKAGE_VERSION "\n");
410: exit(EXIT_SUCCESS);
411: break;
412: case 'h':
413: usage(stdout);
414: break;
415:
416: case 'r':
417: ctl->DisplayMode = DisplayReport;
418: break;
419: case 'w':
420: ctl->reportwide = 1;
421: ctl->DisplayMode = DisplayReport;
422: break;
423: #ifdef HAVE_CURSES
424: case 't':
425: ctl->DisplayMode = DisplayCurses;
426: break;
427: #endif
428: #ifdef HAVE_GTK
429: case 'g':
430: ctl->DisplayMode = DisplayGTK;
431: break;
432: #endif
433: case 'p': /* BL */
434: ctl->DisplayMode = DisplaySplit;
435: break;
436: case 'l':
437: ctl->DisplayMode = DisplayRaw;
438: break;
439: case 'C':
440: ctl->DisplayMode = DisplayCSV;
441: break;
442: case 'j':
443: ctl->DisplayMode = DisplayJSON;
444: break;
445: case 'x':
446: ctl->DisplayMode = DisplayXML;
447: break;
448:
449: case OPT_DISPLAYMODE:
450: ctl->display_mode =
451: strtonum_or_err(optarg, "invalid argument", STRTO_INT);
452: if ((DisplayModeMAX - 1) < ctl->display_mode)
453: error(EXIT_FAILURE, 0, "value out of range (%d - %d): %s",
454: DisplayModeDefault, (DisplayModeMAX - 1), optarg);
455: break;
456: case 'c':
457: ctl->MaxPing =
458: strtonum_or_err(optarg, "invalid argument", STRTO_INT);
459: ctl->ForceMaxPing = 1;
460: break;
461: case 's':
462: ctl->cpacketsize =
463: strtonum_or_err(optarg, "invalid argument", STRTO_INT);
464: break;
465: case 'a':
466: ctl->InterfaceAddress = optarg;
467: break;
468: case 'e':
469: ctl->enablempls = 1;
470: break;
471: case 'n':
472: ctl->dns = 0;
473: break;
474: case 'i':
475: ctl->WaitTime = strtofloat_or_err(optarg, "invalid argument");
476: if (ctl->WaitTime <= 0.0) {
477: error(EXIT_FAILURE, 0, "wait time must be positive");
478: }
479: if (getuid() != 0 && ctl->WaitTime < 1.0) {
480: error(EXIT_FAILURE, 0,
481: "non-root users cannot request an interval < 1.0 seconds");
482: }
483: break;
484: case 'f':
485: ctl->fstTTL =
486: strtonum_or_err(optarg, "invalid argument", STRTO_INT);
487: if (ctl->fstTTL > ctl->maxTTL) {
488: ctl->fstTTL = ctl->maxTTL;
489: }
490: if (ctl->fstTTL < 1) { /* prevent 0 hop */
491: ctl->fstTTL = 1;
492: }
493: break;
494: case 'F':
495: read_from_file(names, optarg);
496: break;
497: case 'm':
498: ctl->maxTTL =
499: strtonum_or_err(optarg, "invalid argument", STRTO_INT);
500: if (ctl->maxTTL > (MaxHost - 1)) {
501: ctl->maxTTL = MaxHost - 1;
502: }
503: if (ctl->maxTTL < 1) { /* prevent 0 hop */
504: ctl->maxTTL = 1;
505: }
506: if (ctl->fstTTL > ctl->maxTTL) { /* don't know the pos of -m or -f */
507: ctl->fstTTL = ctl->maxTTL;
508: }
509: break;
510: case 'U':
511: ctl->maxUnknown =
512: strtonum_or_err(optarg, "invalid argument", STRTO_INT);
513: if (ctl->maxUnknown < 1) {
514: ctl->maxUnknown = 1;
515: }
516: break;
517: case 'o':
518: /* Check option before passing it on to fld_active. */
519: if (strlen(optarg) > MAXFLD) {
520: error(EXIT_FAILURE, 0, "Too many fields: %s", optarg);
521: }
522: for (i = 0; optarg[i]; i++) {
523: if (!strchr(ctl->available_options, optarg[i])) {
524: error(EXIT_FAILURE, 0, "Unknown field identifier: %c",
525: optarg[i]);
526: }
527: }
528: xstrncpy(ctl->fld_active, optarg, 2 * MAXFLD);
529: break;
530: case 'B':
531: ctl->bitpattern =
532: strtonum_or_err(optarg, "invalid argument", STRTO_INT);
533: if (ctl->bitpattern > 255)
534: ctl->bitpattern = -1;
535: break;
536: case 'G':
537: ctl->GraceTime = strtofloat_or_err(optarg, "invalid argument");
538: if (ctl->GraceTime <= 0.0) {
539: error(EXIT_FAILURE, 0, "wait time must be positive");
540: }
541: break;
542: case 'Q':
543: ctl->tos =
544: strtonum_or_err(optarg, "invalid argument", STRTO_INT);
545: if (ctl->tos > 255 || ctl->tos < 0) {
546: /* error message, should do more checking for valid values,
547: * details in rfc2474 */
548: ctl->tos = 0;
549: }
550: break;
551: case 'u':
552: if (ctl->mtrtype != IPPROTO_ICMP) {
553: error(EXIT_FAILURE, 0,
554: "-u , -T and -S are mutually exclusive");
555: }
556: ctl->mtrtype = IPPROTO_UDP;
557: break;
558: case 'T':
559: if (ctl->mtrtype != IPPROTO_ICMP) {
560: error(EXIT_FAILURE, 0,
561: "-u , -T and -S are mutually exclusive");
562: }
563: if (!ctl->remoteport) {
564: ctl->remoteport = 80;
565: }
566: ctl->mtrtype = IPPROTO_TCP;
567: break;
568: #ifdef HAS_SCTP
569: case 'S':
570: if (ctl->mtrtype != IPPROTO_ICMP) {
571: error(EXIT_FAILURE, 0,
572: "-u , -T and -S are mutually exclusive");
573: }
574: if (!ctl->remoteport) {
575: ctl->remoteport = 80;
576: }
577: ctl->mtrtype = IPPROTO_SCTP;
578: break;
579: #endif
580: case 'b':
581: ctl->show_ips = 1;
582: break;
583: case 'P':
584: ctl->remoteport =
585: strtonum_or_err(optarg, "invalid argument", STRTO_INT);
586: if (ctl->remoteport < 1 || MaxPort < ctl->remoteport) {
587: error(EXIT_FAILURE, 0, "Illegal port number: %d",
588: ctl->remoteport);
589: }
590: break;
591: case 'L':
592: ctl->localport =
593: strtonum_or_err(optarg, "invalid argument", STRTO_INT);
594: if (ctl->localport < MinPort || MaxPort < ctl->localport) {
595: error(EXIT_FAILURE, 0, "Illegal port number: %d",
596: ctl->localport);
597: }
598: break;
599: case 'Z':
600: ctl->probe_timeout =
601: strtonum_or_err(optarg, "invalid argument", STRTO_INT);
602: ctl->probe_timeout *= 1000000;
603: break;
604: case '4':
605: ctl->af = AF_INET;
606: break;
607: #ifdef ENABLE_IPV6
608: case '6':
609: ctl->af = AF_INET6;
610: break;
611: #endif
612: #ifdef HAVE_IPINFO
613: case 'y':
614: ctl->ipinfo_no =
615: strtonum_or_err(optarg, "invalid argument", STRTO_INT);
616: if (ctl->ipinfo_no < 0 || 4 < ctl->ipinfo_no) {
617: error(EXIT_FAILURE, 0, "value %d out of range (0 - 4)",
618: ctl->ipinfo_no);
619: }
620: break;
621: case 'z':
622: ctl->ipinfo_no = 0;
623: break;
624: #endif
625: #ifdef SO_MARK
626: case 'M':
627: ctl->mark =
628: strtonum_or_err(optarg, "invalid argument", STRTO_U32INT);
629: break;
630: #endif
631: default:
632: usage(stderr);
633: }
634: }
635:
636: if (ctl->DisplayMode == DisplayReport ||
637: ctl->DisplayMode == DisplayTXT ||
638: ctl->DisplayMode == DisplayJSON ||
639: ctl->DisplayMode == DisplayXML ||
640: ctl->DisplayMode == DisplayRaw || ctl->DisplayMode == DisplayCSV)
641: ctl->Interactive = 0;
642:
643: if (optind > argc - 1)
644: return;
645:
646: }
647:
648:
649: static void parse_mtr_options(
650: struct mtr_ctl *ctl,
651: names_t ** names,
652: char *string)
653: {
654: int argc = 1;
655: char *argv[128], *p;
656:
657: if (!string)
658: return;
659: argv[0] = xstrdup(PACKAGE_NAME);
660: argc = 1;
661: p = strtok(string, " \t");
662: while (p != NULL && ((size_t) argc < (sizeof(argv) / sizeof(argv[0])))) {
663: argv[argc++] = p;
664: p = strtok(NULL, " \t");
665: }
666: if (p != NULL) {
667: error(0, 0, "Warning: extra arguments ignored: %s", p);
668: }
669:
670: parse_arg(ctl, names, argc, argv);
671: free(argv[0]);
672: optind = 0;
673: }
674:
675: static void init_rand(
676: void)
677: {
678: struct timeval tv;
679:
680: gettimeofday(&tv, NULL);
681: srand((getpid() << 16) ^ getuid() ^ tv.tv_sec ^ tv.tv_usec);
682: }
683:
684: int main(
685: int argc,
686: char **argv)
687: {
688: struct hostent *host = NULL;
689: struct addrinfo hints, *res;
690: int gai_error;
691: struct hostent trhost;
692: char *alptr[2];
693: struct sockaddr_in *sa4;
694: #ifdef ENABLE_IPV6
695: struct sockaddr_in6 *sa6;
696: #endif
697: names_t *names_head = NULL;
698: names_t *names_walk;
699:
700: struct mtr_ctl ctl;
701: memset(&ctl, 0, sizeof(ctl));
702: /* initialize non-null values */
703: ctl.Interactive = 1;
704: ctl.MaxPing = 10;
705: ctl.WaitTime = 1.0;
706: ctl.GraceTime = 5.0;
707: ctl.dns = 1;
708: ctl.use_dns = 1;
709: ctl.cpacketsize = 64;
710: ctl.af = DEFAULT_AF;
711: ctl.mtrtype = IPPROTO_ICMP;
712: ctl.fstTTL = 1;
713: ctl.maxTTL = 30;
714: ctl.maxUnknown = 12;
715: ctl.probe_timeout = 10 * 1000000;
716: ctl.ipinfo_no = -1;
717: ctl.ipinfo_max = -1;
718: xstrncpy(ctl.fld_active, "LS NABWV", 2 * MAXFLD);
719:
720: /*
721: mtr used to be suid root. It should not be with this version.
722: We'll check so that we can notify people using installation
723: mechanisms with obsolete assumptions.
724: */
725: if ((geteuid() != getuid()) || (getegid() != getgid())) {
726: error(EXIT_FAILURE, errno, "mtr should not run suid");
727: }
728:
729: /* This will check if stdout/stderr writing is successful */
730: atexit(close_stdout);
731:
732: /* reset the random seed */
733: init_rand();
734:
735: display_detect(&ctl, &argc, &argv);
736: ctl.display_mode = DisplayModeDefault;
737:
738: /* The field options are now in a static array all together,
739: but that requires a run-time initialization. */
740: init_fld_options(&ctl);
741:
742: parse_mtr_options(&ctl, &names_head, getenv("MTR_OPTIONS"));
743:
744: parse_arg(&ctl, &names_head, argc, argv);
745:
746: while (optind < argc) {
747: char *name = argv[optind++];
748: append_to_names(&names_head, name);
749: }
750:
751: /* default: localhost. */
752: if (!names_head)
753: append_to_names(&names_head, "localhost");
754:
755: names_walk = names_head;
756: while (names_walk != NULL) {
757:
758: ctl.Hostname = names_walk->name;
759: if (gethostname(ctl.LocalHostname, sizeof(ctl.LocalHostname))) {
760: xstrncpy(ctl.LocalHostname, "UNKNOWNHOST",
761: sizeof(ctl.LocalHostname));
762: }
763:
764: /* gethostbyname2() is deprecated so we'll use getaddrinfo() instead. */
765: memset(&hints, 0, sizeof hints);
766: hints.ai_family = ctl.af;
767: hints.ai_socktype = SOCK_DGRAM;
768: gai_error = getaddrinfo(ctl.Hostname, NULL, &hints, &res);
769: if (gai_error) {
770: if (gai_error == EAI_SYSTEM)
771: error(0, 0, "Failed to resolve host: %s", ctl.Hostname);
772: else
773: error(0, 0, "Failed to resolve host: %s: %s", ctl.Hostname,
774: gai_strerror(gai_error));
775:
776: if (ctl.Interactive)
777: exit(EXIT_FAILURE);
778: else {
779: names_walk = names_walk->next;
780: continue;
781: }
782: }
783: /* Convert the first addrinfo into a hostent. */
784: host = &trhost;
785: memset(host, 0, sizeof trhost);
786: host->h_name = res->ai_canonname;
787: host->h_aliases = NULL;
788: host->h_addrtype = res->ai_family;
789: ctl.af = res->ai_family;
790: host->h_length = res->ai_addrlen;
791: host->h_addr_list = alptr;
792: switch (ctl.af) {
793: case AF_INET:
794: sa4 = (struct sockaddr_in *) res->ai_addr;
795: alptr[0] = (void *) &(sa4->sin_addr);
796: break;
797: #ifdef ENABLE_IPV6
798: case AF_INET6:
799: sa6 = (struct sockaddr_in6 *) res->ai_addr;
800: alptr[0] = (void *) &(sa6->sin6_addr);
801: break;
802: #endif
803: default:
804: error(0, 0, "unknown address type");
805: if (ctl.Interactive)
806: exit(EXIT_FAILURE);
807: else {
808: names_walk = names_walk->next;
809: continue;
810: }
811: }
812: alptr[1] = NULL;
813:
814: if (net_open(&ctl, host) != 0) {
815: error(0, 0, "Unable to start net module");
816: if (ctl.Interactive)
817: exit(EXIT_FAILURE);
818: else {
819: names_walk = names_walk->next;
820: continue;
821: }
822: }
823:
824: lock(stdout);
825: dns_open(&ctl);
826: display_open(&ctl);
827:
828: display_loop(&ctl);
829:
830: net_end_transit();
831: display_close(&ctl);
832: unlock(stdout);
833:
834: if (ctl.Interactive)
835: break;
836: else
837: names_walk = names_walk->next;
838:
839: }
840:
841: net_close();
842:
843: while (names_head != NULL) {
844: names_t *item = names_head;
845: free(item->name);
846: item->name = NULL;
847: names_head = item->next;
848: free(item);
849: item = NULL;
850: }
851:
852: return 0;
853: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to mtr.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / mtr / ui