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 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.
17: */
18:
19: #include "config.h"
20:
21: #include <sys/types.h>
22: #include <stdio.h>
23: #include <netdb.h>
24: #include <netinet/in.h>
25: #include <sys/socket.h>
26: #include <string.h>
27: #include <strings.h>
28: #include <time.h>
29: #ifdef HAVE_JANSSON
30: #include <jansson.h>
31: #endif
32: #ifdef HAVE_ERROR_H
33: #include <error.h>
34: #else
35: #include "portability/error.h"
36: #endif
37:
38: #include "mtr.h"
39: #include "report.h"
40: #include "net.h"
41: #include "dns.h"
42: #include "asn.h"
43: #include "utils.h"
44:
45: #define MAXLOADBAL 5
46: #define MAX_FORMAT_STR 320
47:
48:
49: void report_open(
50: void)
51: {
52: const time_t now = time(NULL);
53: const char *t = iso_time(&now);
54:
55: printf("Start: %s\n", t);
56: }
57:
58: static size_t snprint_addr(
59: struct mtr_ctl *ctl,
60: char *dst,
61: size_t dst_len,
62: ip_t * addr)
63: {
64: if (addrcmp((void *) addr, (void *) &ctl->unspec_addr, ctl->af)) {
65: struct hostent *host =
66: ctl->dns ? addr2host((void *) addr, ctl->af) : NULL;
67: if (!host)
68: return snprintf(dst, dst_len, "%s", strlongip(ctl->af, addr));
69: else if (ctl->dns && ctl->show_ips)
70: return snprintf(dst, dst_len, "%s (%s)", host->h_name,
71: strlongip(ctl->af, addr));
72: else
73: return snprintf(dst, dst_len, "%s", host->h_name);
74: } else
75: return snprintf(dst, dst_len, "%s", "???");
76: }
77:
78:
79: #ifdef HAVE_IPINFO
80: static void print_mpls(
81: struct mplslen *mpls)
82: {
83: int k;
84: for (k = 0; k < mpls->labels; k++)
85: printf(" [MPLS: Lbl %lu TC %u S %cu TTL %u]\n",
86: mpls->label[k], mpls->tc[k], mpls->s[k], mpls->ttl[k]);
87: }
88: #endif
89:
90: void report_close(
91: struct mtr_ctl *ctl)
92: {
93: int i, j, at, max, z, w;
94: struct mplslen *mpls, *mplss;
95: ip_t *addr;
96: ip_t *addr2 = NULL;
97: char name[MAX_FORMAT_STR];
98: char buf[1024];
99: char fmt[16];
100: size_t len = 0;
101: size_t len_hosts = 33;
102: #ifdef HAVE_IPINFO
103: int len_tmp;
104: const size_t iiwidth_len = get_iiwidth_len();
105: #endif
106:
107: if (ctl->reportwide) {
108: /* get the longest hostname */
109: len_hosts = strlen(ctl->LocalHostname);
110: max = net_max(ctl);
111: at = net_min(ctl);
112: for (; at < max; at++) {
113: size_t nlen;
114: addr = net_addr(at);
115: if ((nlen = snprint_addr(ctl, name, sizeof(name), addr)))
116: if (len_hosts < nlen)
117: len_hosts = nlen;
118: }
119: }
120: #ifdef HAVE_IPINFO
121: len_tmp = len_hosts;
122: if (ctl->ipinfo_no >= 0 && iiwidth_len) {
123: ctl->ipinfo_no %= iiwidth_len;
124: if (ctl->reportwide) {
125: len_hosts++; /* space */
126: len_tmp += get_iiwidth(ctl->ipinfo_no);
127: if (!ctl->ipinfo_no)
128: len_tmp += 2; /* align header: AS */
129: }
130: }
131: snprintf(fmt, sizeof(fmt), "HOST: %%-%ds", len_tmp);
132: #else
133: snprintf(fmt, sizeof(fmt), "HOST: %%-%zus", len_hosts);
134: #endif
135: snprintf(buf, sizeof(buf), fmt, ctl->LocalHostname);
136: len = ctl->reportwide ? strlen(buf) : len_hosts;
137: for (i = 0; i < MAXFLD; i++) {
138: j = ctl->fld_index[ctl->fld_active[i]];
139: if (j < 0)
140: continue;
141:
142: snprintf(fmt, sizeof(fmt), "%%%ds", data_fields[j].length);
143: snprintf(buf + len, sizeof(buf), fmt, data_fields[j].title);
144: len += data_fields[j].length;
145: }
146: printf("%s\n", buf);
147:
148: max = net_max(ctl);
149: at = net_min(ctl);
150: for (; at < max; at++) {
151: addr = net_addr(at);
152: mpls = net_mpls(at);
153: snprint_addr(ctl, name, sizeof(name), addr);
154:
155: #ifdef HAVE_IPINFO
156: if (is_printii(ctl)) {
157: snprintf(fmt, sizeof(fmt), " %%2d. %%s%%-%zus", len_hosts);
158: snprintf(buf, sizeof(buf), fmt, at + 1, fmt_ipinfo(ctl, addr),
159: name);
160: } else {
161: #endif
162: snprintf(fmt, sizeof(fmt), " %%2d.|-- %%-%zus", len_hosts);
163: snprintf(buf, sizeof(buf), fmt, at + 1, name);
164: #ifdef HAVE_IPINFO
165: }
166: #endif
167: len = ctl->reportwide ? strlen(buf) : len_hosts;
168: for (i = 0; i < MAXFLD; i++) {
169: j = ctl->fld_index[ctl->fld_active[i]];
170: if (j < 0)
171: continue;
172:
173: /* 1000.0 is a temporary hack for stats usec to ms, impacted net_loss. */
174: if (strchr(data_fields[j].format, 'f')) {
175: snprintf(buf + len, sizeof(buf), data_fields[j].format,
176: data_fields[j].net_xxx(at) / 1000.0);
177: } else {
178: snprintf(buf + len, sizeof(buf), data_fields[j].format,
179: data_fields[j].net_xxx(at));
180: }
181: len += data_fields[j].length;
182: }
183: printf("%s\n", buf);
184:
185: /* This feature shows 'loadbalances' on routes */
186:
187: /* Print list of all hosts that have responded from ttl = at + 1 away */
188: for (z = 0; z < MAX_PATH; z++) {
189: int found = 0;
190: addr2 = net_addrs(at, z);
191: mplss = net_mplss(at, z);
192: if ((addrcmp
193: ((void *) &ctl->unspec_addr, (void *) addr2,
194: ctl->af)) == 0) {
195: break;
196: } else if ((addrcmp
197: ((void *) addr, (void *) addr2,
198: ctl->af)) == 0) {
199: continue; /* Latest Host is already printed */
200: } else {
201: snprint_addr(ctl, name, sizeof(name), addr2);
202: snprintf(fmt, sizeof(fmt), " %%-%zus", len_hosts);
203: snprintf(buf, sizeof(buf), fmt, name);
204: printf("%s\n", buf);
205: }
206: for (w = 0; w < z; w++)
207: /* Ok... checking if there are ips repeated on same hop */
208: if ((addrcmp
209: ((void *) addr2, (void *) net_addrs(at, w),
210: ctl->af)) == 0) {
211: found = 1;
212: break;
213: }
214:
215: if (!found) {
216:
217: #ifdef HAVE_IPINFO
218: if (mpls->labels && z == 1 && ctl->enablempls)
219: print_mpls(mpls);
220: if (is_printii(ctl)) {
221: snprint_addr(ctl, name, sizeof(name), addr2);
222: printf(" %s%s\n", fmt_ipinfo(ctl, addr2), name);
223: }
224: if (ctl->enablempls)
225: print_mpls(mplss);
226: #else
227: int k;
228: if (mpls->labels && z == 1 && ctl->enablempls) {
229: for (k = 0; k < mpls->labels; k++) {
230: printf
231: (" | |+-- [MPLS: Lbl %lu TC %u S %u TTL %u]\n",
232: mpls->label[k], mpls->tc[k], mpls->s[k],
233: mpls->ttl[k]);
234: }
235: }
236:
237: if (z == 1) {
238: printf(" | `|-- %s\n", strlongip(ctl->af, addr2));
239: for (k = 0; k < mplss->labels && ctl->enablempls; k++) {
240: printf
241: (" | +-- [MPLS: Lbl %lu TC %u S %u TTL %u]\n",
242: mplss->label[k], mplss->tc[k], mplss->s[k],
243: mplss->ttl[k]);
244: }
245: } else {
246: printf(" | |-- %s\n", strlongip(ctl->af, addr2));
247: for (k = 0; k < mplss->labels && ctl->enablempls; k++) {
248: printf
249: (" | +-- [MPLS: Lbl %lu TC %u S %u TTL %u]\n",
250: mplss->label[k], mplss->tc[k], mplss->s[k],
251: mplss->ttl[k]);
252: }
253: }
254: #endif
255: }
256: }
257:
258: /* No multipath */
259: #ifdef HAVE_IPINFO
260: if (is_printii(ctl)) {
261: if (mpls->labels && z == 1 && ctl->enablempls)
262: print_mpls(mpls);
263: }
264: #else
265: if (mpls->labels && z == 1 && ctl->enablempls) {
266: int k;
267: for (k = 0; k < mpls->labels; k++) {
268: printf(" | +-- [MPLS: Lbl %lu TC %u S %u TTL %u]\n",
269: mpls->label[k], mpls->tc[k], mpls->s[k],
270: mpls->ttl[k]);
271: }
272: }
273: #endif
274: }
275: }
276:
277:
278: void txt_open(
279: void)
280: {
281: }
282:
283:
284: void txt_close(
285: struct mtr_ctl *ctl)
286: {
287: report_close(ctl);
288: }
289:
290: #ifdef HAVE_JANSSON
291: void json_open(
292: void)
293: {
294: }
295:
296: void json_close(struct mtr_ctl *ctl)
297: {
298: int i, j, at, max;
299: int ret;
300: char buf[128];
301: json_t *jreport, *jmtr, *jhubs, *jh;
302: ip_t *addr;
303: char name[MAX_FORMAT_STR];
304:
305: jmtr = json_pack("{ss ss si si}",
306: "src", ctl->LocalHostname,
307: "dst", ctl->Hostname,
308: "tos", ctl->tos,
309: "tests", ctl->MaxPing);
310: if (!jmtr)
311: goto on_error;
312:
313: if (ctl->cpacketsize >= 0) {
314: snprintf(buf, sizeof(buf), "%d", ctl->cpacketsize);
315: } else {
316: snprintf(buf, sizeof(buf), "rand(%d-%d)", MINPACKET, -ctl->cpacketsize);
317: }
318: ret = json_object_set_new(jmtr, "psize", json_string(buf));
319: if (ret == -1)
320: goto on_error;
321:
322: if (ctl->bitpattern >= 0) {
323: snprintf(buf, sizeof(buf), "0x%02X", (unsigned char)(ctl->bitpattern));
324: } else {
325: snprintf(buf, sizeof(buf), "rand(0x00-FF)");
326: }
327:
328: ret = json_object_set_new(jmtr, "bitpattern", json_string(buf));
329: if (ret == -1)
330: goto on_error;
331:
332: jhubs = json_array();
333: if (!jhubs)
334: goto on_error;
335:
336: max = net_max(ctl);
337: at = net_min(ctl);
338: for (; at < max; at++) {
339: addr = net_addr(at);
340: snprint_addr(ctl, name, sizeof(name), addr);
341:
342: jh = json_pack("{si ss}", "count", at + 1, "host", name);
343: if (!jh)
344: goto on_error;
345:
346: #ifdef HAVE_IPINFO
347: if (!ctl->ipinfo_no) {
348: char* fmtinfo = fmt_ipinfo(ctl, addr);
349: if (fmtinfo != NULL)
350: fmtinfo = trim(fmtinfo, '\0');
351:
352: ret = json_object_set_new(jh, "ASN", json_string(fmtinfo));
353: if (ret == -1)
354: goto on_error;
355: }
356: #endif
357:
358: for (i = 0; i < MAXFLD; i++) {
359: j = ctl->fld_index[ctl->fld_active[i]];
360:
361: if (j <= 0)
362: continue; /* Field nr 0, " " shouldn't be printed in this method. */
363:
364: if (strchr(data_fields[j].format, 'f')) {
365: ret = json_object_set_new(
366: jh, data_fields[j].title,
367: json_real(data_fields[j].net_xxx(at) / 1000.0));
368: } else {
369: ret = json_object_set_new(
370: jh, data_fields[j].title,
371: json_integer(data_fields[j].net_xxx(at)));
372: }
373: if (ret == -1)
374: goto on_error;
375: }
376:
377: ret = json_array_append_new(jhubs, jh);
378: if (ret == -1)
379: goto on_error;
380: }
381:
382: jreport = json_pack("{s{so so}}", "report", "mtr", jmtr, "hubs", jhubs);
383:
384: ret = json_dumpf(jreport, stdout, JSON_INDENT(4) | JSON_REAL_PRECISION(5));
385: if (ret == -1)
386: goto on_error;
387:
388: printf("\n"); // bash prompt should be on new line
389: json_decref(jreport);
390: return;
391: on_error:
392: error(EXIT_FAILURE, 0, "json_close failed");
393: }
394: #endif
395:
396:
397: void xml_open(
398: void)
399: {
400: }
401:
402:
403: void xml_close(
404: struct mtr_ctl *ctl)
405: {
406: int i, j, at, max;
407: ip_t *addr;
408: char name[MAX_FORMAT_STR];
409:
410: printf("<?xml version=\"1.0\"?>\n");
411: printf("<MTR SRC=\"%s\" DST=\"%s\"", ctl->LocalHostname,
412: ctl->Hostname);
413: printf(" TOS=\"0x%X\"", ctl->tos);
414: if (ctl->cpacketsize >= 0) {
415: printf(" PSIZE=\"%d\"", ctl->cpacketsize);
416: } else {
417: printf(" PSIZE=\"rand(%d-%d)\"", MINPACKET, -ctl->cpacketsize);
418: }
419: if (ctl->bitpattern >= 0) {
420: printf(" BITPATTERN=\"0x%02X\"",
421: (unsigned char) (ctl->bitpattern));
422: } else {
423: printf(" BITPATTERN=\"rand(0x00-FF)\"");
424: }
425: printf(" TESTS=\"%d\">\n", ctl->MaxPing);
426:
427: max = net_max(ctl);
428: at = net_min(ctl);
429: for (; at < max; at++) {
430: addr = net_addr(at);
431: snprint_addr(ctl, name, sizeof(name), addr);
432:
433: printf(" <HUB COUNT=\"%d\" HOST=\"%s\">\n", at + 1, name);
434: for (i = 0; i < MAXFLD; i++) {
435: const char *title;
436:
437: j = ctl->fld_index[ctl->fld_active[i]];
438: if (j <= 0)
439: continue; /* Field nr 0, " " shouldn't be printed in this method. */
440:
441: snprintf(name, sizeof(name), "%s%s%s", " <%s>",
442: data_fields[j].format, "</%s>\n");
443:
444: /* XML doesn't allow "%" in tag names, rename Loss% to just Loss */
445: title = data_fields[j].title;
446: if (strcmp(data_fields[j].title, "Loss%") == 0) {
447: title = "Loss";
448: }
449:
450: /* 1000.0 is a temporary hack for stats usec to ms, impacted net_loss. */
451: if (strchr(data_fields[j].format, 'f')) {
452: printf(name,
453: title, data_fields[j].net_xxx(at) / 1000.0, title);
454: } else {
455: printf(name, title, data_fields[j].net_xxx(at), title);
456: }
457: }
458: printf(" </HUB>\n");
459: }
460: printf("</MTR>\n");
461: }
462:
463:
464: void csv_open(
465: void)
466: {
467: }
468:
469: void csv_close(
470: struct mtr_ctl *ctl,
471: time_t now)
472: {
473: int i, j, at, max, z, w;
474: ip_t *addr;
475: ip_t *addr2 = NULL;
476: char name[MAX_FORMAT_STR];
477:
478: for (i = 0; i < MAXFLD; i++) {
479: j = ctl->fld_index[ctl->fld_active[i]];
480: if (j < 0)
481: continue;
482: }
483:
484: max = net_max(ctl);
485: at = net_min(ctl);
486: for (; at < max; at++) {
487: addr = net_addr(at);
488: snprint_addr(ctl, name, sizeof(name), addr);
489:
490: if (at == net_min(ctl)) {
491: printf("Mtr_Version,Start_Time,Status,Host,Hop,Ip,");
492: #ifdef HAVE_IPINFO
493: if (!ctl->ipinfo_no) {
494: printf("Asn,");
495: }
496: #endif
497: for (i = 0; i < MAXFLD; i++) {
498: j = ctl->fld_index[ctl->fld_active[i]];
499: if (j < 0)
500: continue;
501: printf("%s,", data_fields[j].title);
502: }
503: printf("\n");
504: }
505: #ifdef HAVE_IPINFO
506: if (!ctl->ipinfo_no) {
507: char *fmtinfo = fmt_ipinfo(ctl, addr);
508: fmtinfo = trim(fmtinfo, '\0');
509: printf("MTR.%s,%lld,%s,%s,%d,%s,%s", PACKAGE_VERSION,
510: (long long) now, "OK", ctl->Hostname, at + 1, name,
511: fmtinfo);
512: } else
513: #endif
514: printf("MTR.%s,%lld,%s,%s,%d,%s", PACKAGE_VERSION,
515: (long long) now, "OK", ctl->Hostname, at + 1, name);
516:
517: for (i = 0; i < MAXFLD; i++) {
518: j = ctl->fld_index[ctl->fld_active[i]];
519: if (j < 0)
520: continue;
521:
522: /* 1000.0 is a temporary hack for stats usec to ms, impacted net_loss. */
523: if (strchr(data_fields[j].format, 'f')) {
524: printf(",%.2f",
525: (double) (data_fields[j].net_xxx(at) / 1000.0));
526: } else {
527: printf(",%d", data_fields[j].net_xxx(at));
528: }
529: }
530: printf("\n");
531: if (ctl->reportwide == 0)
532: continue;
533:
534: for (z = 0; z < MAX_PATH; z++) {
535: int found = 0;
536: addr2 = net_addrs(at, z);
537: snprint_addr(ctl, name, sizeof(name), addr2);
538: if ((addrcmp
539: ((void *) &ctl->unspec_addr, (void *) addr2,
540: ctl->af)) == 0) {
541: break;
542: } else if ((addrcmp
543: ((void *) addr, (void *) addr2,
544: ctl->af)) == 0) {
545: continue; /* Latest Host is already printed */
546: } else {
547: for (w = 0; w < z; w++)
548: /* Ok... checking if there are ips repeated on same hop */
549: if ((addrcmp
550: ((void *) addr2, (void *) net_addrs(at, w),
551: ctl->af)) == 0) {
552: found = 1;
553: break;
554: }
555:
556: if (!found) {
557: #ifdef HAVE_IPINFO
558: if (!ctl->ipinfo_no) {
559: char *fmtinfo = fmt_ipinfo(ctl, addr2);
560: fmtinfo = trim(fmtinfo, '\0');
561: printf("MTR.%s,%lld,%s,%s,%d,%s,%s", PACKAGE_VERSION,
562: (long long) now, "OK", ctl->Hostname, at + 1, name,
563: fmtinfo);
564: } else
565: #endif
566: printf("MTR.%s,%lld,%s,%s,%d,%s", PACKAGE_VERSION,
567: (long long) now, "OK", ctl->Hostname, at + 1, name);
568:
569: /* Use values associated with the first ip discovered for this hop */
570: for (i = 0; i < MAXFLD; i++) {
571: j = ctl->fld_index[ctl->fld_active[i]];
572: if (j < 0)
573: continue;
574:
575: /* 1000.0 is a temporary hack for stats usec to ms, impacted net_loss. */
576: if (strchr(data_fields[j].format, 'f')) {
577: printf(",%.2f",
578: (double) (data_fields[j].net_xxx(at) / 1000.0));
579: } else {
580: printf(",%d", data_fields[j].net_xxx(at));
581: }
582: }
583: printf("\n");
584: }
585: }
586: }
587: }
588: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to report.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