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