![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to curses.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|
Return to curses.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / mtr / ui |
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:
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 "mtr.h"
22:
23: #include <strings.h>
24: #include <unistd.h>
25:
26: #include <ctype.h>
27: #include <stdlib.h>
28: #include <string.h>
29: #include <time.h>
30:
31: /* MacOSX may need this before socket.h...*/
32: #if defined(HAVE_SYS_TYPES_H)
33: #include <sys/types.h>
34: #endif
35:
36: #include <sys/socket.h>
37: #include <netinet/in.h>
38: #include <arpa/inet.h>
39:
40: #if defined(HAVE_NCURSES_H)
41: #include <ncurses.h>
42: #elif defined(HAVE_NCURSES_CURSES_H)
43: #include <ncurses/curses.h>
44: #elif defined(HAVE_CURSES_H)
45: #include <curses.h>
46: #elif defined(HAVE_CURSESX_H)
47: #include <cursesX.h>
48: #else
49: #error No curses header file available
50: #endif
51:
52: /* This go-around is needed only when compiling with antique version of curses.
53: getmaxyx is part of Technical Standard X/Open Curses Issue 4, Version 2 (1996).
54: http://pubs.opengroup.org/onlinepubs/9693989999/toc.pdf see page 106 */
55: #ifndef getmaxyx
56: #define getmaxyx(win,y,x) ((y) = (win)->_maxy + 1, (x) = (win)->_maxx + 1)
57: #endif
58:
59: #include "mtr.h"
60: #include "mtr-curses.h"
61: #include "net.h"
62: #include "dns.h"
63: #include "asn.h"
64: #include "display.h"
65: #include "utils.h"
66:
67:
68: enum { NUM_FACTORS = 8 };
69: static double factors[NUM_FACTORS];
70: static int scale[NUM_FACTORS];
71: static char block_map[NUM_FACTORS];
72:
73: enum { black = 1, red, green, yellow, blue, magenta, cyan, white };
74: static const int block_col[NUM_FACTORS + 1] = {
75: COLOR_PAIR(red) | A_BOLD,
76: A_NORMAL,
77: COLOR_PAIR(green),
78: COLOR_PAIR(green) | A_BOLD,
79: COLOR_PAIR(yellow) | A_BOLD,
80: COLOR_PAIR(magenta) | A_BOLD,
81: COLOR_PAIR(magenta),
82: COLOR_PAIR(red),
83: COLOR_PAIR(red) | A_BOLD
84: };
85:
86: static void pwcenter(
87: char *str)
88: {
89: int maxx;
90: size_t cx;
91: int __unused_int ATTRIBUTE_UNUSED;
92:
93: getmaxyx(stdscr, __unused_int, maxx);
94: cx = (size_t) (maxx - strlen(str)) / 2;
95: printw("%*s%s", (int) cx, "", str);
96: }
97:
98:
99: static char *format_number(
100: int n,
101: int w,
102: char *buf)
103: {
104: if (w != 5)
105: /* XXX todo: implement w != 5.. */
106: snprintf(buf, w + 1, "%s", "unimpl");
107: else if (n < 100000)
108: /* buf is good as-is */ ;
109: else if (n < 1000000)
110: snprintf(buf, w + 1, "%3dk%1d", n / 1000, (n % 1000) / 100);
111: else if (n < 10000000)
112: snprintf(buf, w + 1, "%1dM%03d", n / 1000000,
113: (n % 1000000) / 1000);
114: else if (n < 100000000)
115: snprintf(buf, w + 1, "%2dM%02d", n / 1000000,
116: (n % 1000000) / 10000);
117: else if (n < 1000000000)
118: snprintf(buf, w + 1, "%3dM%01d", n / 1000000,
119: (n % 1000000) / 100000);
120: else /* if (n < 10000000000) */
121: snprintf(buf, w + 1, "%1dG%03d", n / 1000000000,
122: (n % 1000000000) / 1000000);
123:
124: return buf;
125: }
126:
127:
128: int mtr_curses_keyaction(
129: struct mtr_ctl *ctl)
130: {
131: int c = getch();
132: int i = 0;
133: float f = 0.0;
134: char buf[MAXFLD + 1];
135:
136: if (c == 'Q') { /* must be checked before c = tolower(c) */
137: mvprintw(2, 0, "Type of Service(tos): %d\n", ctl->tos);
138: mvprintw(3, 0,
139: "default 0x00, min cost 0x02, rel 0x04,, thr 0x08, low del 0x10...\n");
140: move(2, 22);
141: refresh();
142: while ((c = getch()) != '\n' && i < MAXFLD) {
143: attron(A_BOLD);
144: printw("%c", c);
145: attroff(A_BOLD);
146: refresh();
147: buf[i++] = c; /* need more checking on 'c' */
148: }
149: buf[i] = '\0';
150: ctl->tos = atoi(buf);
151: if (ctl->tos > 255 || ctl->tos < 0)
152: ctl->tos = 0;
153: return ActionNone;
154: }
155:
156: c = tolower(c);
157:
158: switch (c) {
159: case 'q':
160: case 3:
161: return ActionQuit;
162: case 12:
163: return ActionClear;
164: case 19:
165: case 'p':
166: return ActionPause;
167: case 17:
168: case ' ':
169: return ActionResume;
170: case 'r':
171: return ActionReset;
172: case 'd':
173: return ActionDisplay;
174: case 'e':
175: return ActionMPLS;
176: case 'n':
177: return ActionDNS;
178: #ifdef HAVE_IPINFO
179: case 'y':
180: return ActionII;
181: case 'z':
182: return ActionAS;
183: #endif
184: case '+':
185: return ActionScrollDown;
186: case '-':
187: return ActionScrollUp;
188: case 's':
189: mvprintw(2, 0, "Change Packet Size: %d\n", ctl->cpacketsize);
190: mvprintw(3, 0, "Size Range: %d-%d, < 0:random.\n", MINPACKET,
191: MAXPACKET);
192: move(2, 20);
193: refresh();
194: while ((c = getch()) != '\n' && i < MAXFLD) {
195: attron(A_BOLD);
196: printw("%c", c);
197: attroff(A_BOLD);
198: refresh();
199: buf[i++] = c; /* need more checking on 'c' */
200: }
201: buf[i] = '\0';
202: ctl->cpacketsize = atoi(buf);
203: return ActionNone;
204: case 'b':
205: mvprintw(2, 0, "Ping Bit Pattern: %d\n", ctl->bitpattern);
206: mvprintw(3, 0, "Pattern Range: 0(0x00)-255(0xff), <0 random.\n");
207: move(2, 18);
208: refresh();
209: while ((c = getch()) != '\n' && i < MAXFLD) {
210: attron(A_BOLD);
211: printw("%c", c);
212: attroff(A_BOLD);
213: refresh();
214: buf[i++] = c; /* need more checking on 'c' */
215: }
216: buf[i] = '\0';
217: ctl->bitpattern = atoi(buf);
218: if (ctl->bitpattern > 255)
219: ctl->bitpattern = -1;
220: return ActionNone;
221: case 'i':
222: mvprintw(2, 0, "Interval : %0.0f\n\n", ctl->WaitTime);
223: move(2, 11);
224: refresh();
225: while ((c = getch()) != '\n' && i < MAXFLD) {
226: attron(A_BOLD);
227: printw("%c", c);
228: attroff(A_BOLD);
229: refresh();
230: buf[i++] = c; /* need more checking on 'c' */
231: }
232: buf[i] = '\0';
233:
234: f = atof(buf);
235:
236: if (f <= 0.0)
237: return ActionNone;
238: if (getuid() != 0 && f < 1.0)
239: return ActionNone;
240: ctl->WaitTime = f;
241:
242: return ActionNone;
243: case 'f':
244: mvprintw(2, 0, "First TTL: %d\n\n", ctl->fstTTL);
245: move(2, 11);
246: refresh();
247: while ((c = getch()) != '\n' && i < MAXFLD) {
248: attron(A_BOLD);
249: printw("%c", c);
250: attroff(A_BOLD);
251: refresh();
252: buf[i++] = c; /* need more checking on 'c' */
253: }
254: buf[i] = '\0';
255: i = atoi(buf);
256:
257: if (i < 1 || i > ctl->maxTTL)
258: return ActionNone;
259: ctl->fstTTL = i;
260:
261: return ActionNone;
262: case 'm':
263: mvprintw(2, 0, "Max TTL: %d\n\n", ctl->maxTTL);
264: move(2, 9);
265: refresh();
266: while ((c = getch()) != '\n' && i < MAXFLD) {
267: attron(A_BOLD);
268: printw("%c", c);
269: attroff(A_BOLD);
270: refresh();
271: buf[i++] = c; /* need more checking on 'c' */
272: }
273: buf[i] = '\0';
274: i = atoi(buf);
275:
276: if (i < ctl->fstTTL || i > (MaxHost - 1))
277: return ActionNone;
278: ctl->maxTTL = i;
279:
280: return ActionNone;
281: /* fields to display & their ordering */
282: case 'o':
283: mvprintw(2, 0, "Fields: %s\n\n", ctl->fld_active);
284:
285: for (i = 0; i < MAXFLD; i++) {
286: if (data_fields[i].descr != NULL)
287: printw(" %s\n", data_fields[i].descr);
288: }
289: printw("\n");
290: move(2, 8); /* length of "Fields: " */
291: refresh();
292:
293: i = 0;
294: while ((c = getch()) != '\n' && i < MAXFLD) {
295: if (strchr(ctl->available_options, c)) {
296: attron(A_BOLD);
297: printw("%c", c);
298: attroff(A_BOLD);
299: refresh();
300: buf[i++] = c; /* Only permit values in "available_options" be entered */
301: } else {
302: printf("\a"); /* Illegal character. Beep, ring the bell. */
303: }
304: }
305: buf[i] = '\0';
306: if (strlen(buf) > 0)
307: xstrncpy(ctl->fld_active, buf, 2 * MAXFLD);
308:
309: return ActionNone;
310: case 'j':
311: if (strchr(ctl->fld_active, 'N'))
312: /* GeoMean and jitter */
313: xstrncpy(ctl->fld_active, "DR AGJMXI", 2 * MAXFLD);
314: else
315: /* default */
316: xstrncpy(ctl->fld_active, "LS NABWV", 2 * MAXFLD);
317: return ActionNone;
318: case 'u':
319: switch (ctl->mtrtype) {
320: case IPPROTO_ICMP:
321: case IPPROTO_TCP:
322: ctl->mtrtype = IPPROTO_UDP;
323: break;
324: case IPPROTO_UDP:
325: ctl->mtrtype = IPPROTO_ICMP;
326: break;
327: }
328: return ActionNone;
329: case 't':
330: switch (ctl->mtrtype) {
331: case IPPROTO_ICMP:
332: case IPPROTO_UDP:
333: ctl->mtrtype = IPPROTO_TCP;
334: break;
335: case IPPROTO_TCP:
336: ctl->mtrtype = IPPROTO_ICMP;
337: break;
338: }
339: return ActionNone;
340: /* reserve to display help message -Min */
341: case '?':
342: case 'h':
343: mvprintw(2, 0, "Command:\n");
344: printw(" ?|h help\n");
345: printw(" p pause (SPACE to resume)\n");
346: printw(" d switching display mode\n");
347: printw(" e toggle MPLS information on/off\n");
348: printw(" n toggle DNS on/off\n");
349: printw(" r reset all counters\n");
350: printw
351: (" o str set the columns to display, default str='LRS N BAWV'\n");
352: printw
353: (" j toggle latency(LS NABWV)/jitter(DR AGJMXI) stats\n");
354: printw(" c <n> report cycle n, default n=infinite\n");
355: printw
356: (" i <n> set the ping interval to n seconds, default n=1\n");
357: printw
358: (" f <n> set the initial time-to-live(ttl), default n=1\n");
359: printw
360: (" m <n> set the max time-to-live, default n= # of hops\n");
361: printw(" s <n> set the packet size to n or random(n<0)\n");
362: printw
363: (" b <c> set ping bit pattern to c(0..255) or random(c<0)\n");
364: printw(" Q <t> set ping packet's TOS to t\n");
365: printw(" u switch between ICMP ECHO and UDP datagrams\n");
366: #ifdef HAVE_IPINFO
367: printw(" y switching IP info\n");
368: printw(" z toggle ASN info on/off\n");
369: #endif
370: printw("\n");
371: printw(" press any key to go back...");
372: getch(); /* read and ignore 'any key' */
373: return ActionNone;
374: default: /* ignore unknown input */
375: return ActionNone;
376: }
377: }
378:
379:
380: static void format_field(
381: char *dst,
382: int dst_length,
383: const char *format,
384: int n)
385: {
386: if (index(format, 'N')) {
387: *dst++ = ' ';
388: format_number(n, 5, dst);
389: } else if (strchr(format, 'f')) {
390: /* this is for fields where we measure integer microseconds but
391: display floating point miliseconds. Convert to float here. */
392: snprintf(dst, dst_length, format, n / 1000.0);
393: /* this was marked as a temporary hack over 10 years ago. -- REW */
394: } else {
395: snprintf(dst, dst_length, format, n);
396: }
397: }
398:
399: static void mtr_curses_hosts(
400: struct mtr_ctl *ctl,
401: int startstat)
402: {
403: int max;
404: int at;
405: struct mplslen *mpls, *mplss;
406: ip_t *addr, *addrs;
407: int y;
408: char *name;
409:
410: int i, j, k;
411: int hd_len;
412: char buf[1024];
413: int __unused_int ATTRIBUTE_UNUSED;
414:
415: max = net_max(ctl);
416:
417: for (at = net_min(ctl) + ctl->display_offset; at < max; at++) {
418: printw("%2d. ", at + 1);
419: addr = net_addr(at);
420: mpls = net_mpls(at);
421:
422: if (addrcmp((void *) addr, (void *) &ctl->unspec_addr, ctl->af) !=
423: 0) {
424: name = dns_lookup(ctl, addr);
425: if (!net_up(at))
426: attron(A_BOLD);
427: #ifdef HAVE_IPINFO
428: if (is_printii(ctl))
429: printw(fmt_ipinfo(ctl, addr));
430: #endif
431: if (name != NULL) {
432: if (ctl->show_ips)
433: printw("%s (%s)", name, strlongip(ctl, addr));
434: else
435: printw("%s", name);
436: } else {
437: printw("%s", strlongip(ctl, addr));
438: }
439: attroff(A_BOLD);
440:
441: getyx(stdscr, y, __unused_int);
442: move(y, startstat);
443:
444: /* net_xxx returns times in usecs. Just display millisecs */
445: hd_len = 0;
446: for (i = 0; i < MAXFLD; i++) {
447: /* Ignore options that don't exist */
448: /* On the other hand, we now check the input side. Shouldn't happen,
449: can't be careful enough. */
450: j = ctl->fld_index[ctl->fld_active[i]];
451: if (j == -1)
452: continue;
453: format_field(buf + hd_len, sizeof(buf) - hd_len,
454: data_fields[j].format,
455: data_fields[j].net_xxx(at));
456: hd_len += data_fields[j].length;
457: }
458: buf[hd_len] = 0;
459: printw("%s", buf);
460:
461: for (k = 0; k < mpls->labels && ctl->enablempls; k++) {
462: printw("\n [MPLS: Lbl %lu Exp %u S %u TTL %u]",
463: mpls->label[k], mpls->exp[k], mpls->s[k],
464: mpls->ttl[k]);
465: }
466:
467: /* Multi path */
468: for (i = 0; i < MAXPATH; i++) {
469: addrs = net_addrs(at, i);
470: mplss = net_mplss(at, i);
471: if (addrcmp((void *) addrs, (void *) addr, ctl->af) == 0)
472: continue;
473: if (addrcmp
474: ((void *) addrs, (void *) &ctl->unspec_addr,
475: ctl->af) == 0)
476: break;
477:
478: name = dns_lookup(ctl, addrs);
479: if (!net_up(at))
480: attron(A_BOLD);
481: printw("\n ");
482: #ifdef HAVE_IPINFO
483: if (is_printii(ctl))
484: printw(fmt_ipinfo(ctl, addrs));
485: #endif
486: if (name != NULL) {
487: if (ctl->show_ips)
488: printw("%s (%s)", name, strlongip(ctl, addrs));
489: else
490: printw("%s", name);
491: } else {
492: printw("%s", strlongip(ctl, addrs));
493: }
494: for (k = 0; k < mplss->labels && ctl->enablempls; k++) {
495: printw("\n [MPLS: Lbl %lu Exp %u S %u TTL %u]",
496: mplss->label[k], mplss->exp[k], mplss->s[k],
497: mplss->ttl[k]);
498: }
499: attroff(A_BOLD);
500: }
501:
502: } else {
503: printw("???");
504: }
505:
506: printw("\n");
507: }
508: move(2, 0);
509: }
510:
511: static void mtr_gen_scale(
512: struct mtr_ctl *ctl)
513: {
514: int *saved, i, max, at;
515: int range;
516: static int low_ms, high_ms;
517:
518: low_ms = 1000000;
519: high_ms = -1;
520:
521: for (i = 0; i < NUM_FACTORS; i++) {
522: scale[i] = 0;
523: }
524: max = net_max(ctl);
525: for (at = ctl->display_offset; at < max; at++) {
526: saved = net_saved_pings(at);
527: for (i = 0; i < SAVED_PINGS; i++) {
528: if (saved[i] < 0)
529: continue;
530: if (saved[i] < low_ms) {
531: low_ms = saved[i];
532: }
533: if (saved[i] > high_ms) {
534: high_ms = saved[i];
535: }
536: }
537: }
538: range = high_ms - low_ms;
539: for (i = 0; i < NUM_FACTORS; i++) {
540: scale[i] = low_ms + ((double) range * factors[i]);
541: }
542: }
543:
544: static void mtr_curses_init(
545: void)
546: {
547: int i;
548: int block_split;
549:
550: /* Initialize factors to a log scale. */
551: for (i = 0; i < NUM_FACTORS; i++) {
552: factors[i] = ((double) 1 / NUM_FACTORS) * (i + 1);
553: factors[i] *= factors[i]; /* Squared. */
554: }
555:
556: /* Initialize block_map. The block_split is always smaller than 9 */
557: block_split = (NUM_FACTORS - 2) / 2;
558: for (i = 1; i <= block_split; i++) {
559: block_map[i] = '0' + i;
560: }
561: for (i = block_split + 1; i < NUM_FACTORS - 1; i++) {
562: block_map[i] = 'a' + i - block_split - 1;
563: }
564: block_map[0] = '.';
565: block_map[NUM_FACTORS - 1] = '>';
566: }
567:
568: static void mtr_print_scaled(
569: int ms)
570: {
571: int i;
572:
573: for (i = 0; i < NUM_FACTORS; i++) {
574: if (ms <= scale[i]) {
575: attrset(block_col[i + 1]);
576: printw("%c", block_map[i]);
577: attrset(A_NORMAL);
578: return;
579: }
580: }
581: printw(">");
582: }
583:
584:
585: static void mtr_fill_graph(
586: struct mtr_ctl *ctl,
587: int at,
588: int cols)
589: {
590: int *saved;
591: int i;
592:
593: saved = net_saved_pings(at);
594: for (i = SAVED_PINGS - cols; i < SAVED_PINGS; i++) {
595: if (saved[i] == -2) {
596: printw(" ");
597: } else if (saved[i] == -1) {
598: attrset(block_col[0]);
599: printw("%c", '?');
600: attrset(A_NORMAL);
601: } else {
602: if (ctl->display_mode == DisplayModeBlockmap) {
603: if (saved[i] > scale[6]) {
604: printw("%c", block_map[NUM_FACTORS - 1]);
605: } else {
606: printw(".");
607: }
608: } else {
609: mtr_print_scaled(saved[i]);
610: }
611: }
612: }
613: }
614:
615:
616: static void mtr_curses_graph(
617: struct mtr_ctl *ctl,
618: int startstat,
619: int cols)
620: {
621: int max, at, y;
622: ip_t *addr;
623: char *name;
624: int __unused_int ATTRIBUTE_UNUSED;
625:
626: max = net_max(ctl);
627:
628: for (at = ctl->display_offset; at < max; at++) {
629: printw("%2d. ", at + 1);
630:
631: addr = net_addr(at);
632: if (!addr) {
633: printw("???\n");
634: continue;
635: }
636:
637: if (!net_up(at))
638: attron(A_BOLD);
639: if (addrcmp((void *) addr, (void *) &ctl->unspec_addr, ctl->af)) {
640: #ifdef HAVE_IPINFO
641: if (is_printii(ctl))
642: printw(fmt_ipinfo(ctl, addr));
643: #endif
644: name = dns_lookup(ctl, addr);
645: printw("%s", name ? name : strlongip(ctl, addr));
646: } else
647: printw("???");
648: attroff(A_BOLD);
649:
650: getyx(stdscr, y, __unused_int);
651: move(y, startstat);
652:
653: printw(" ");
654: mtr_fill_graph(ctl, at, cols);
655: printw("\n");
656: }
657: }
658:
659:
660: void mtr_curses_redraw(
661: struct mtr_ctl *ctl)
662: {
663: int maxx;
664: int startstat;
665: int rowstat;
666: time_t t;
667: int __unused_int ATTRIBUTE_UNUSED;
668:
669: int i, j;
670: int hd_len = 0;
671: char buf[1024];
672: char fmt[16];
673:
674:
675: erase();
676: getmaxyx(stdscr, __unused_int, maxx);
677:
678: rowstat = 5;
679:
680: move(0, 0);
681: attron(A_BOLD);
682: snprintf(buf, sizeof(buf), "%s%s%s", "My traceroute [v",
683: PACKAGE_VERSION, "]");
684: pwcenter(buf);
685: attroff(A_BOLD);
686:
687: mvprintw(1, 0, "%s (%s)", ctl->LocalHostname, net_localaddr());
688: t = time(NULL);
689: mvprintw(1, maxx - 25, iso_time(&t));
690: printw("\n");
691:
692: printw("Keys: ");
693: attron(A_BOLD);
694: printw("H");
695: attroff(A_BOLD);
696: printw("elp ");
697: attron(A_BOLD);
698: printw("D");
699: attroff(A_BOLD);
700: printw("isplay mode ");
701: attron(A_BOLD);
702: printw("R");
703: attroff(A_BOLD);
704: printw("estart statistics ");
705: attron(A_BOLD);
706: printw("O");
707: attroff(A_BOLD);
708: printw("rder of fields ");
709: attron(A_BOLD);
710: printw("q");
711: attroff(A_BOLD);
712: printw("uit\n");
713:
714: if (ctl->display_mode == DisplayModeDefault) {
715: for (i = 0; i < MAXFLD; i++) {
716: j = ctl->fld_index[ctl->fld_active[i]];
717: if (j < 0)
718: continue;
719:
720: snprintf(fmt, sizeof(fmt), "%%%ds", data_fields[j].length);
721: snprintf(buf + hd_len, sizeof(buf) - hd_len, fmt,
722: data_fields[j].title);
723: hd_len += data_fields[j].length;
724: }
725: attron(A_BOLD);
726: mvprintw(rowstat - 1, 0, " Host");
727: mvprintw(rowstat - 1, maxx - hd_len - 1, "%s", buf);
728: mvprintw(rowstat - 2, maxx - hd_len - 1,
729: " Packets Pings");
730: attroff(A_BOLD);
731:
732: move(rowstat, 0);
733: mtr_curses_hosts(ctl, maxx - hd_len - 1);
734:
735: } else {
736: char msg[80];
737: int padding = 30;
738: int max_cols;
739:
740: #ifdef HAVE_IPINFO
741: if (is_printii(ctl))
742: padding += get_iiwidth(ctl->ipinfo_no);
743: #endif
744: max_cols =
745: maxx <= SAVED_PINGS + padding ? maxx - padding : SAVED_PINGS;
746: startstat = padding - 2;
747:
748: snprintf(msg, sizeof(msg), " Last %3d pings", max_cols);
749: mvprintw(rowstat - 1, startstat, msg);
750:
751: attroff(A_BOLD);
752: move(rowstat, 0);
753:
754: mtr_gen_scale(ctl);
755: mtr_curses_graph(ctl, startstat, max_cols);
756:
757: printw("\n");
758: attron(A_BOLD);
759: printw("Scale:");
760: attroff(A_BOLD);
761:
762: for (i = 0; i < NUM_FACTORS - 1; i++) {
763: printw(" ");
764: attrset(block_col[i + 1]);
765: printw("%c", block_map[i]);
766: attrset(A_NORMAL);
767: printw(":%d ms", scale[i] / 1000);
768: }
769: printw(" ");
770: attrset(block_col[NUM_FACTORS]);
771: printw("%c", block_map[NUM_FACTORS - 1]);
772: attrset(A_NORMAL);
773: }
774:
775: refresh();
776: }
777:
778:
779: void mtr_curses_open(
780: struct mtr_ctl *ctl)
781: {
782: int bg_col = 0;
783: int i;
784:
785: initscr();
786: raw();
787: noecho();
788: start_color();
789: if (use_default_colors() == OK)
790: bg_col = -1;
791: for (i = 0; i < NUM_FACTORS; i++)
792: init_pair(i + 1, i, bg_col);
793:
794: mtr_curses_init();
795: mtr_curses_redraw(ctl);
796: }
797:
798:
799: void mtr_curses_close(
800: void)
801: {
802: printw("\n");
803: endwin();
804: }
805:
806:
807: void mtr_curses_clear(
808: struct mtr_ctl *ctl)
809: {
810: mtr_curses_close();
811: mtr_curses_open(ctl);
812: }