![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to show_stat.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / trafshow|
Return to show_stat.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / trafshow |
1.1 misho 1: /*
2: * Copyright (c) 1998,2004 Rinet Corp., Novosibirsk, Russia
3: *
4: * Redistribution and use in source forms, with and without modification,
5: * are permitted provided that this entire comment appears intact.
6: *
7: * THIS SOURCE CODE IS PROVIDED ``AS IS'' WITHOUT ANY WARRANTIES OF ANY KIND.
8: */
9:
10: #ifdef HAVE_CONFIG_H
11: #include <config.h>
12: #endif
13:
14: #include <sys/param.h>
15: #include <sys/types.h>
16: #include <sys/socket.h>
17: #include <netinet/in.h>
18: #include <arpa/inet.h>
19: #include <stdio.h>
20: #include <stdlib.h>
21: #include <string.h>
22:
23: #include "show_stat.h"
24: #include "trafshow.h"
25: #include "screen.h"
26: #include "selector.h"
27: #include "netstat.h"
28: #include "getkey.h"
29: #include "addrtoname.h"
30:
31: ShowStatMode show_stat_mode = Size;
32: static int find_backflow(NETSTAT **list, int items, NETSTAT *at);
33: static void sort_backflow(NETSTAT **list, int items);
34:
35: static void
36: scale_size(addr, prot, data, rate)
37: int *addr, *prot, *data, *rate;
38: {
39: *addr = line_factor * (double)SHOW_STAT_ADDR;
40: *prot = line_factor * (double)SHOW_STAT_PROT;
41: *data = line_factor * (double)SHOW_STAT_DATA;
42: *rate = line_factor * (double)SHOW_STAT_RATE;
43: }
44:
45: static int
46: compare_pkt_len(p1, p2)
47: register const NETSTAT **p1, **p2;
48: {
49: if ((*p1)->pkt_len > (*p2)->pkt_len) return -1;
50: if ((*p1)->pkt_len < (*p2)->pkt_len) return 1;
51: return 0;
52: }
53:
54: static int
55: compare_data_len(p1, p2)
56: register const NETSTAT **p1, **p2;
57: {
58: if ((*p1)->data_len > (*p2)->data_len) return -1;
59: if ((*p1)->data_len < (*p2)->data_len) return 1;
60: return 0;
61: }
62:
63: static int
64: compare_pkt_cnt(p1, p2)
65: register const NETSTAT **p1, **p2;
66: {
67: if ((*p1)->pkt_cnt > (*p2)->pkt_cnt) return -1;
68: if ((*p1)->pkt_cnt < (*p2)->pkt_cnt) return 1;
69: return 0;
70: }
71:
72: static int
73: find_backflow(list, items, at)
74: NETSTAT **list;
75: int items;
76: NETSTAT *at;
77: {
78: int i;
79:
80: /* sanity check */
81: if (!list || items < 1 || !at)
82: return -1;
83:
84: for (i = 0; i < items; i++) {
85: if (netstat_bidir(at, list[i]))
86: return i;
87: }
88: return -1;
89: }
90:
91: /* too bad implementation -- it take alot of CPU cycles like deadloop. XXX */
92: static void
93: sort_backflow(list, items)
94: NETSTAT **list;
95: int items;
96: {
97: int i = 0, at;
98: NETSTAT *ns;
99:
100: while (i < items-1) {
101: ns = list[i++];
102: if ((at = find_backflow(&list[i], items - i, ns)) < 0)
103: continue;
104: if (at) {
105: ns = list[i + at];
106: memmove(&list[i + 1], &list[i], at * sizeof(NETSTAT *));
107: list[i] = ns;
108: }
109: i++;
110: }
111: }
112:
113: /*
114: * Pretty print an Internet address (net address + port).
115: */
116: static char *
117: ip_print(ver, proto, addr, dst, size)
118: int ver;
119: int proto;
120: const struct ip_address *addr;
121: char *dst;
122: int size;
123: {
124: const char *cp = 0;
125: char buf[100];
126:
127: if (ver == 4 && addr->ip_addr.s_addr) {
128: /*cp = intoa(addr->ip_addr.s_addr);*/
129: cp = ipaddr_string(&addr->ip_addr);
130: }
131: #ifdef INET6
132: else if (ver == 6 && !IN6_IS_ADDR_UNSPECIFIED(&addr->ip6_addr)) {
133: /*cp = inet_ntop(AF_INET6, &addr->ip6_addr, buf, sizeof(buf));*/
134: cp = ip6addr_string(&addr->ip6_addr);
135: }
136: #endif
137:
138: if (cp) {
139: (void)strncpy(dst, cp, size);
140: dst[size-1] = '\0';
141: } else snprintf(dst, size, "IPv%d", ver);
142:
143: if (addr->ip_port) {
144: char pb[20];
145: int len;
146: switch (proto) {
147: case IPPROTO_TCP:
148: if (nflag) {
149: sprintf(pb, "%d", ntohs(addr->ip_port));
150: cp = pb;
151: } else cp = tcpport_string(ntohs(addr->ip_port));
152: break;
153: case IPPROTO_UDP:
154: if (nflag) {
155: sprintf(pb, "%d", ntohs(addr->ip_port));
156: cp = pb;
157: } else cp = udpport_string(ntohs(addr->ip_port));
158: break;
159: case IPPROTO_ICMP:
160: if (nflag) {
161: sprintf(pb, "%04x", addr->ip_port - 1);
162: cp = pb;
163: } else cp = icmp_string(addr->ip_port - 1);
164: break;
165: #ifdef INET6
166: case IPPROTO_ICMPV6:
167: if (nflag) {
168: sprintf(pb, "%04x", addr->ip_port - 1);
169: cp = pb;
170: } else cp = icmpv6_string(addr->ip_port - 1);
171: break;
172: #endif
173: default: /* nonsense, but be strong */
174: sprintf(pb, "%d", ntohs(addr->ip_port));
175: cp = pb;
176: }
177: buf[0] = ',';
178: (void)strncpy(&buf[1], cp, 10);
179: buf[11] = '\0';
180: len = strlen(buf);
181: if (strlen(dst) + len < size)
182: (void)strcat(dst, buf);
183: else (void)strcpy(&dst[size - len - 1], buf);
184: }
185: return dst;
186: }
187:
188: static char *
189: sap_print(addr, sap, dst, size)
190: const u_char *addr;
191: u_char sap;
192: char *dst;
193: int size;
194: {
195: char buf[20];
196: int len;
197:
198: (void)strncpy(dst, etheraddr_string(addr), size);
199: dst[size-1] = '\0';
200:
201: buf[0] = '/';
202: if (nflag)
203: sprintf(&buf[1], "sap-%02x", sap & 0xff);
204: else (void)strncpy(&buf[1], llcsap_string(sap), 10);
205: buf[11] = '\0';
206: len = strlen(buf);
207: if (strlen(dst) + len < size)
208: (void)strcat(dst, buf);
209: else (void)strcpy(&dst[size - len - 1], buf);
210: return dst;
211: }
212:
213: void
214: hdr2str(nh, src_buf, src_len, dst_buf, dst_len, proto_buf, proto_len)
215: const struct netstat_header *nh;
216: char *src_buf, *dst_buf, *proto_buf;
217: int src_len, dst_len, proto_len;
218: {
219: const NETSTAT *ns;
220:
221: if (src_buf) *src_buf = '\0';
222: if (dst_buf) *dst_buf = '\0';
223: if (proto_buf) *proto_buf = '\0';
224:
225: /* sanity check */
226: if (!nh) return;
227:
228: ns = (NETSTAT *)nh;
229:
230: if (ns->ip_ver) {
231: if (src_buf && src_len > 1) {
232: ip_print(ns->ip_ver, ns->ip_proto, &ns->ip_src_addr,
233: src_buf, src_len);
234: }
235: if (dst_buf && dst_len > 1) {
236: ip_print(ns->ip_ver, ns->ip_proto, &ns->ip_dst_addr,
237: dst_buf, dst_len);
238: }
239: if (proto_buf && proto_len > 1) {
240: if (nflag)
241: snprintf(proto_buf, proto_len, "%d", (int)ns->ip_proto);
242: else (void)strncpy(proto_buf, ipproto_string(ns->ip_proto),
243: proto_len);
244: proto_buf[proto_len-1] = '\0';
245: }
246: } else if (ntohs(ns->eth_type) > 1500) { /* Ethernet II (DIX) */
247: if (src_buf && src_len > 1) {
248: (void)strncpy(src_buf, etheraddr_string(ns->eth_src_addr),
249: src_len);
250: src_buf[src_len-1] = '\0';
251: }
252: if (dst_buf && dst_len > 1) {
253: (void)strncpy(dst_buf, etheraddr_string(ns->eth_dst_addr),
254: dst_len);
255: dst_buf[dst_len-1] = '\0';
256: }
257: if (proto_buf && proto_len > 1) {
258: if (nflag)
259: snprintf(proto_buf, proto_len, "%04x", ntohs(ns->eth_type));
260: else (void)strncpy(proto_buf, ethertype_string(ns->eth_type),
261: proto_len);
262: proto_buf[proto_len-1] = '\0';
263: }
264: } else if (ns->eth_ssap == ns->eth_dsap) {
265: if (src_buf && src_len > 1) {
266: (void)strncpy(src_buf, etheraddr_string(ns->eth_src_addr),
267: src_len);
268: src_buf[src_len-1] = '\0';
269: }
270: if (dst_buf && dst_len > 1) {
271: (void)strncpy(dst_buf, etheraddr_string(ns->eth_dst_addr),
272: dst_len);
273: dst_buf[dst_len-1] = '\0';
274: }
275: if (proto_buf && proto_len > 1) {
276: if (nflag)
277: snprintf(proto_buf, proto_len, "sap-%02x",
278: (int)(ns->eth_ssap & 0xff));
279: else (void)strncpy(proto_buf, llcsap_string(ns->eth_ssap),
280: proto_len);
281: proto_buf[proto_len-1] = '\0';
282: }
283: } else {
284: if (src_buf && src_len > 1) {
285: sap_print(ns->eth_src_addr, ns->eth_ssap,
286: src_buf, src_len);
287: }
288: if (dst_buf && dst_len > 1) {
289: sap_print(ns->eth_dst_addr, ns->eth_dsap,
290: dst_buf, dst_len);
291: }
292: if (proto_buf && proto_len > 1) {
293: (void)strncpy(proto_buf, "802.3", proto_len);
294: proto_buf[proto_len-1] = '\0';
295: }
296: }
297: }
298:
299: static int
300: show_stat_header(dst, size, ph)
301: char *dst;
302: int size;
303: const PCAP_HANDLER *ph;
304: {
305: int addr_sz, prot_sz, data_sz, rate_sz;
306: char src_buf[100], dst_buf[100];
307: const char *data_ptr, *rate_ptr;
308:
309: /* sanity check */
310: if (!dst || size < 1 || !ph)
311: return 0;
312:
313: scale_size(&addr_sz, &prot_sz, &data_sz, &rate_sz);
314:
315: (void)strcpy(src_buf, "Source");
316: (void)strcpy(dst_buf, "Destination");
317: if (ph->masklen >= 0) {
318: sprintf(src_buf + strlen(src_buf), "/%d", ph->masklen);
319: sprintf(dst_buf + strlen(dst_buf), "/%d", ph->masklen);
320: }
321:
322: data_ptr = rate_ptr = "?";
323: switch (show_stat_mode) {
324: case Size:
325: data_ptr = "Size";
326: rate_ptr = "CPS";
327: break;
328: case Data:
329: data_ptr = "Data";
330: rate_ptr = "CPS";
331: break;
332: case Packets:
333: data_ptr = "Packets";
334: rate_ptr = "PPS";
335: break;
336: }
337: snprintf(dst, size,
338: "%-*.*s %-*.*s %-*.*s %-*.*s %-*.*s",
339: addr_sz, addr_sz, src_buf,
340: addr_sz, addr_sz, dst_buf,
341: prot_sz, prot_sz, "Protocol",
342: data_sz, data_sz, data_ptr,
343: rate_sz, rate_sz, rate_ptr);
344: return 0;
345: }
346:
347: static int
348: show_stat_line(dst, size, ns_list, idx)
349: char *dst;
350: int size;
351: const NETSTAT **ns_list;
352: int idx;
353: {
354: int addr_sz, prot_sz, data_sz, rate_sz;
355: const NETSTAT *ns;
356: char src_buf[100], dst_buf[100], proto_buf[20], data_buf[20], rate_buf[20];
357:
358: /* sanity check */
359: if (!dst || size < 1 || !ns_list)
360: return 0;
361:
362: ns = ns_list[idx];
363:
364: scale_size(&addr_sz, &prot_sz, &data_sz, &rate_sz);
365:
366: hdr2str(&ns->ns_hdr,
367: src_buf, MIN(sizeof(src_buf), addr_sz + 1),
368: dst_buf, MIN(sizeof(dst_buf), addr_sz + 1),
369: proto_buf, MIN(sizeof(proto_buf), prot_sz + 1));
370:
371: data_buf[0] = '\0';
372: rate_buf[0] = '\0';
373: switch (show_stat_mode) {
374: case Size:
375: if (ns->pkt_len >= 10000)
376: snprintf(data_buf, sizeof(data_buf), "%uK", ns->pkt_len / 1024);
377: else snprintf(data_buf, sizeof(data_buf), "%u", ns->pkt_len);
378:
379: if (ns->pkt_len_rate >= 10000)
380: snprintf(rate_buf, sizeof(rate_buf), "%uK", ns->pkt_len_rate / 1024);
381: else if (ns->pkt_len_rate > 0)
382: snprintf(rate_buf, sizeof(rate_buf), "%u", ns->pkt_len_rate);
383: break;
384: case Data:
385: if (ns->data_len >= 10000)
386: snprintf(data_buf, sizeof(data_buf), "%uK", ns->data_len / 1024);
387: else snprintf(data_buf, sizeof(data_buf), "%u", ns->data_len);
388:
389: if (ns->data_len_rate >= 10000)
390: snprintf(rate_buf, sizeof(rate_buf), "%uK", ns->data_len_rate / 1024);
391: else if (ns->data_len_rate > 0)
392: snprintf(rate_buf, sizeof(rate_buf), "%u", ns->data_len_rate);
393: break;
394: case Packets:
395: snprintf(data_buf, sizeof(data_buf), "%u", ns->pkt_cnt);
396:
397: if (ns->pkt_cnt_rate > 0)
398: snprintf(rate_buf, sizeof(rate_buf), "%u", ns->pkt_cnt_rate);
399: break;
400: }
401:
402: snprintf(dst, size,
403: "%-*.*s %-*.*s %-*.*s %-*.*s %-*.*s",
404: addr_sz, addr_sz, src_buf,
405: addr_sz, addr_sz, dst_buf,
406: prot_sz, prot_sz, proto_buf,
407: data_sz, data_sz, data_buf,
408: rate_sz, rate_sz, rate_buf);
409:
410: return ns->attr;
411: }
412:
413: static int
414: show_stat_footer(dst, size, ph)
415: char *dst;
416: int size;
417: const PCAP_HANDLER *ph;
418: {
419: const PCAP_HANDLER *top;
420: int addr_sz, prot_sz, data_sz, rate_sz, depth;
421: u_int64_t total = 0, rate = 0;
422: char stat_buf[50], data_buf[20], rate_buf[20];
423:
424: /* sanity check */
425: if (!dst || size < 1 || !ph)
426: return 0;
427:
428: scale_size(&addr_sz, &prot_sz, &data_sz, &rate_sz);
429:
430: depth = 0;
431: for (top = ph->top; top; top = top->top) depth++;
432: if (depth) {
433: snprintf(stat_buf, sizeof(stat_buf), "%d Flows (depth %d)",
434: netstat_count(ph), depth);
435: } else {
436: snprintf(stat_buf, sizeof(stat_buf), "%d Flows",
437: netstat_count(ph));
438: }
439:
440: switch (show_stat_mode) {
441: case Size:
442: total = ph->pkt_len;
443: rate = ph->pkt_len_rate;
444: break;
445: case Data:
446: total = ph->data_len;
447: rate = ph->data_len_rate;
448: break;
449: case Packets:
450: total = ph->pkt_cnt;
451: rate = ph->pkt_cnt_rate;
452: break;
453: }
454:
455: if (total >= 10000000)
456: snprintf(data_buf, sizeof(data_buf), "%uM",
457: (unsigned int)(total / (1024 * 1024)));
458: else if (total >= 10000)
459: snprintf(data_buf, sizeof(data_buf), "%uK",
460: (unsigned int)(total / 1024));
461: else snprintf(data_buf, sizeof(data_buf), "%u",
462: (unsigned int)total);
463:
464: if (rate >= 10000000)
465: snprintf(rate_buf, sizeof(rate_buf), "%uM",
466: (unsigned int)(rate / (1024 * 1024)));
467: else if (rate >= 10000)
468: snprintf(rate_buf, sizeof(rate_buf), "%uK",
469: (unsigned int)(rate / 1024));
470: else snprintf(rate_buf, sizeof(rate_buf), "%u",
471: (unsigned int)rate);
472:
473: snprintf(dst, size,
474: "%-*.*s %-*.*s %-*.*s %-*.*s %-*.*s",
475: addr_sz, addr_sz, ph->name,
476: addr_sz, addr_sz, stat_buf,
477: prot_sz, prot_sz, "Total:",
478: data_sz, data_sz, data_buf,
479: rate_sz, rate_sz, rate_buf);
480: return 0;
481: }
482:
483: int
484: show_stat_input(ph, ch)
485: PCAP_HANDLER *ph;
486: int ch;
487: {
488: switch (ch) {
489: case '[': /* rotate list mode left */
490: case K_LEFT:
491: if (show_stat_mode == Size)
492: show_stat_mode = Packets;
493: else show_stat_mode--;
494: return 1;
495: case ']': /* rotate list mode right */
496: case K_RIGHT:
497: if (show_stat_mode == Packets)
498: show_stat_mode = Size;
499: else show_stat_mode++;
500: return 1;
501: case K_CTRL('R'): /* reset current netstat hash */
502: if (ph) {
503: netstat_purge(ph, 0);
504: show_stat_list(ph);
505: return 1;
506: }
507: break;
508: case K_TAB: /* follow to backflow */
509: if (ph) {
510: SELECTOR *sp = show_stat_selector(ph);
511: int idx = selector_get(sp);
512:
513: if (idx >= 0) {
514: NETSTAT **ns_list = (NETSTAT **)sp->list;
515: const NETSTAT *ns = ns_list[idx];
516:
517: for (idx = 0; idx < sp->items; idx++) {
518: if (netstat_bidir(ns, ns_list[idx])) {
519: selector_set(idx, sp);
520: return 1;
521: }
522: }
523: }
524: }
525: break;
526: }
527: return 0;
528: }
529:
530: SELECTOR *
531: show_stat_selector(ph)
532: PCAP_HANDLER *ph;
533: {
534: if (!ph) return 0;
535: if (!ph->selector && (ph->selector = selector_init()) != 0) {
536: ph->selector->get_header = show_stat_header;
537: ph->selector->get_line = show_stat_line;
538: ph->selector->get_footer = show_stat_footer;
539: }
540: return ph->selector;
541: }
542:
543: NETSTAT *
544: show_stat_get(ph, idx)
545: PCAP_HANDLER *ph;
546: int idx;
547: {
548: SELECTOR *sp;
549: NETSTAT **ns_list;
550:
551: /* sanity check */
552: if (!ph || idx < 0 || (sp = show_stat_selector(ph)) == 0 || idx >= sp->items)
553: return 0;
554:
555: ns_list = (NETSTAT **)sp->list;
556: return ns_list[idx];
557: }
558:
559: int
560: show_stat_search(ph, str)
561: PCAP_HANDLER *ph;
562: const char *str;
563: {
564: SELECTOR *sp;
565: NETSTAT **ns_list;
566: const NETSTAT *ns;
567: int idx;
568: char src_buf[100], dst_buf[100], proto_buf[20];
569:
570: /* sanity check */
571: if (!ph || !str || *str == '\0' || (sp = show_stat_selector(ph)) == 0)
572: return -1;
573:
574: ns_list = (NETSTAT **)sp->list;
575: for (idx = 0; idx < sp->items; idx++) {
576: ns = ns_list[idx];
577: hdr2str(&ns->ns_hdr,
578: src_buf, sizeof(src_buf),
579: dst_buf, sizeof(dst_buf),
580: proto_buf, sizeof(proto_buf));
581: if (strstr(src_buf, str) ||
582: strstr(dst_buf, str) ||
583: strstr(proto_buf, str))
584: return idx;
585: }
586: return -1;
587: }
588:
589: SELECTOR *
590: show_stat_list(ph)
591: PCAP_HANDLER *ph;
592: {
593: SELECTOR *sp;
594: int cnt;
595:
596: /* sanity check */
597: if (!ph || (sp = show_stat_selector(ph)) == 0)
598: return 0;
599:
600: sp->header = ph;
601: sp->footer = ph;
602:
603: if ((cnt = netstat_fetch((NETSTAT ***)&sp->list, ph)) < 0)
604: return sp;
605:
606: sp->items = cnt;
607: if (cnt < 2) /* no sorting required */
608: return sp;
609:
610: /* sort it accroding to current mode */
611: switch (show_stat_mode) {
612: case Size:
613: qsort(sp->list, sp->items, sizeof(NETSTAT *), compare_pkt_len);
614: break;
615: case Data:
616: qsort(sp->list, sp->items, sizeof(NETSTAT *), compare_data_len);
617: break;
618: case Packets:
619: qsort(sp->list, sp->items, sizeof(NETSTAT *), compare_pkt_cnt);
620: break;
621: }
622: if (popbackflow)
623: sort_backflow(sp->list, sp->items);
624:
625: return sp;
626: }
627: