1: /*
2: * Copyright (c) 1993-2006 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: #ifdef HAVE_SLCURSES
15: #include <slcurses.h>
16: #elif HAVE_NCURSES
17: #include <ncurses.h>
18: #else
19: #include <curses.h>
20: #endif
21: #include <sys/types.h>
22: #include <sys/socket.h>
23: #ifdef HAVE_PCAP_GET_SELECTABLE_FD
24: #include <sys/select.h>
25: #endif
26: #include <stdio.h>
27: #include <stdlib.h>
28: #include <signal.h>
29: #include <string.h>
30: #include <unistd.h>
31: #include <time.h>
32: #include <pcap.h>
33: #include <pthread.h>
34: #include <errno.h>
35: #ifdef linux
36: #include <sys/ioctl.h>
37: #include <linux/if.h>
38: #endif
39:
40: #include "trafshow.h"
41: #include "parse_dl.h"
42: #include "screen.h"
43: #include "show_if.h"
44: #include "show_stat.h"
45: #include "show_dump.h"
46: #include "getkey.h"
47: #include "selector.h"
48: #include "addrtoname.h"
49: #include "netstat.h"
50: #include "util.h"
51: #include "events.h"
52: #include "session.h"
53: #include "cisco_netflow.h"
54: #include "help_page.h"
55:
56: char copyright[] = "Copyright (c) 1993-2006 Rinet Corp., Novosibirsk, Russia";
57:
58: static void vers();
59: static void usage();
60: static pcap_if_t *pcap_matchdev(pcap_if_t *dp, const char *name);
61: static int pcap_init(PCAP_HANDLER **ph_list, pcap_if_t *dp);
62: static void *pcap_feed(void *arg); /* PCAP_HANDLER *ph */
63: #ifdef HAVE_PCAP_GET_SELECTABLE_FD
64: static void *pcap_feed2(void *arg); /* PCAP_HANDLER *ph */
65: #endif
66: static void parse_feed(u_char *a, const struct pcap_pkthdr *h, const u_char *p);
67: static void *traf_show(void *arg); /* PCAP_HANDLER *ph_list */
68: static void *catch_signals(void *arg); /* sigset_t *set */
69: static void cleanup(void);
70:
71: static int resize_pending = 0;
72:
73: const char *progname;
74: const char *hostname;
75: const char *color_conf = 0;
76: char *expression = 0;
77: char *search = 0;
78: int aggregate = -1;
79: int popbackflow = 0;
80: int refresh_time = REFRESH_TIME;
81: int purge_time = PURGE_TIME;
82: ShowMode show_mode = Interfaces;
83:
84: int promisc = 1; /* promiscuous mode */
85: int Oflag = 1; /* optimize filter code */
86: int nflag = 0; /* use numeric value of service ports and protocols */
87:
88: int
89: main(argc, argv)
90: int argc;
91: char **argv;
92: {
93: char buf[256], *dev_name = 0, *filter = 0;
94: pcap_if_t *dev_list = 0;
95: PCAP_HANDLER *ph_list = 0;
96: int op, udp_port = CNF_PORT;
97: sigset_t sigset;
98: pthread_t show_thr, sig_thr, pcap_thr;
99: extern char *optarg;
100: extern int optind, opterr;
101:
102: progname = strdup(strip_path(argv[0]));
103:
104: if (gethostname(buf, sizeof(buf)) < 0)
105: (void)strcpy(buf, "localhost");
106: hostname = strdup(buf);
107:
108: /* get list of all pcap devices */
109: if (pcap_findalldevs(&dev_list, buf) < 0) {
110: fprintf(stderr, "pcap_findalldevs: %s\n", buf);
111: exit(1);
112: }
113:
114: opterr = 0;
115: while ((op = getopt(argc, argv, "a:bc:i:ns:u:pF:R:P:vh?")) != EOF) {
116: switch (op) {
117: case 'a':
118: aggregate = atoi(optarg);
119: if (aggregate < 0 || aggregate > ADDRBITLEN)
120: usage();
121: break;
122: case 'b':
123: popbackflow = 1;
124: break;
125: case 'c':
126: color_conf = optarg;
127: break;
128: case 'i':
129: dev_name = optarg;
130: break;
131: case 'n':
132: nflag = 1;
133: break;
134: case 's':
135: search = strdup(optarg);
136: break;
137: case 'u':
138: udp_port = atoi(optarg);
139: break;
140: case 'p':
141: promisc = 0;
142: break;
143: case 'F':
144: filter = optarg;
145: break;
146: case 'R':
147: if ((refresh_time = atoi(optarg)) < 1)
148: usage();
149: break;
150: case 'P':
151: if ((purge_time = atoi(optarg)) < 1)
152: usage();
153: break;
154: case 'v':
155: vers();
156: case 'h':
157: case '?':
158: default:
159: usage();
160: }
161: }
162:
163: /* check for command line options */
164: if (dev_name && (dev_list = pcap_matchdev(dev_list, dev_name)) == 0) {
165: fprintf(stderr, "Interface %s not found\n", dev_name);
166: exit(1);
167: }
168: if (refresh_time >= purge_time) {
169: fprintf(stderr, "Refresh Time (%d sec) must be less than Purge Time (%d sec)\n",
170: refresh_time, purge_time);
171: exit(1);
172: }
173:
174: /* initialize list of pcap handlers */
175: if ((op = pcap_init(&ph_list, dev_list)) < 1) {
176: fprintf(stderr, "No packet capture device available (no permission?)\n");
177: exit(1);
178: }
179:
180: /* listen for cisco netflow */
181: if (udp_port > 1 && (cisco_netflow_init(&ph_list, udp_port) < 0)) {
182: fprintf(stderr, "Can't start cisco-netflow collector at UDP port %d\n",
183: udp_port);
184: exit(1);
185: }
186:
187: /* if only one interface -- make it selected */
188: if (ph_list && op == 1) {
189: ph_list->selected = 1;
190: show_mode = NetStat;
191: }
192:
193: /* get back to user process */
194: setuid(getuid());
195:
196: /* set the filter expression if any */
197: if (ph_list && (argv[optind] || filter)) {
198: if (filter)
199: expression = load_file(filter);
200: else expression = copy_argv(&argv[optind]);
201: if (!expression) exit(1);
202:
203: if ((filter = pcap_setexpr(ph_list, expression)) != 0) {
204: fprintf(stderr, "%s\n", filter);
205: exit(1);
206: }
207: }
208:
209: /* intialize addrtoname stuff */
210: init_addrtoname();
211:
212: /* initialize curses */
213: if (screen_open(0) < 0)
214: exit(1);
215:
216: /* register cleanup function at exit */
217: atexit(cleanup);
218:
219: show_thr = pthread_self();
220:
221: /* spawn thread to catch some usefull signals */
222: sigemptyset(&sigset);
223: sigaddset(&sigset, SIGWINCH);
224: sigprocmask(SIG_BLOCK, &sigset, 0);
225: if (pthread_create(&sig_thr, 0, catch_signals, &sigset)) {
226: perror("pthread_create(catch_signals)");
227: exit(1);
228: }
229:
230: /* spawn thread for the live packet capture */
231: if (ph_list) {
232: #ifdef HAVE_PCAP_GET_SELECTABLE_FD
233: PCAP_HANDLER *ph;
234: for (ph = ph_list; ph; ph = ph->next) {
235: if (pcap_get_selectable_fd(ph->pcap) < 0)
236: break;
237: }
238: if (!ph) {
239: if (pthread_create(&pcap_thr, 0, pcap_feed2, ph_list)) {
240: perror("pthread_create(pcap_feed2)");
241: exit(1);
242: }
243: } else
244: #endif
245: if (pthread_create(&pcap_thr, 0, pcap_feed, ph_list)) {
246: perror("pthread_create(pcap_feed)");
247: exit(1);
248: }
249: }
250:
251: /* start main loop */
252: (void)traf_show(ph_list);
253:
254: exit(0);
255: }
256:
257: static void
258: cleanup()
259: {
260: if (dump_file) (void)unlink(dump_file);
261: screen_close();
262: _exit(0);
263: }
264:
265: static void *
266: catch_signals(arg)
267: void *arg;
268: {
269: sigset_t sigset;
270: int sig;
271:
272: for (;;) {
273: sigset = *(sigset_t *)arg;
274: if (sigwait(&sigset, &sig))
275: break; /* should not happen */
276:
277: if (sig == SIGWINCH)
278: resize_pending++;
279: }
280: return 0;
281: }
282:
283: static pcap_if_t *
284: pcap_matchdev(dp, name)
285: pcap_if_t *dp;
286: const char *name;
287: {
288: for (; dp; dp = dp->next) {
289: if (!strcasecmp(dp->name, "any"))
290: continue; /* discard linux's any device silently */
291:
292: if (!strcasecmp(dp->name, name)) {
293: dp->next = 0;
294: return dp;
295: }
296: }
297: return 0;
298: }
299:
300: static int
301: pcap_init(ph_list, dp)
302: PCAP_HANDLER **ph_list;
303: pcap_if_t *dp;
304: {
305: int cnt = 0, err = 0, type;
306: pcap_t *pd;
307: const pcap_addr_t *ap;
308: PCAP_HANDLER *ph, *ph_prev = 0;
309: char *cp, buf[256];
310:
311: if (!ph_list) return -1;
312:
313: for (; dp; dp = dp->next) {
314: if (!strcasecmp(dp->name, "any"))
315: continue; /* discard linux's any device silently */
316:
317: buf[0] = '\0';
318: if ((pd = pcap_open_live(dp->name, SNAPLEN, promisc, 1, buf)) == 0) {
319: fprintf(stderr, "%s: %s\n", dp->name, buf);
320: err++;
321: continue;
322: }
323: type = pcap_datalink(pd);
324: if (!is_parse_dl(type)) {
325: fprintf(stderr, "%s: datalink type %d is not supported\n",
326: dp->name, type);
327: pcap_close(pd);
328: err++;
329: continue;
330: }
331: if (buf[0] != '\0') {
332: fprintf(stderr, "%s: %s\n", dp->name, buf);
333: err++;
334: }
335: if (pcap_setnonblock(pd, 1, buf) < 0) {
336: fprintf(stderr, "%s: %s\n", dp->name, buf);
337: pcap_close(pd);
338: err++;
339: continue;
340: }
341: if ((ph = (PCAP_HANDLER *)malloc(sizeof(PCAP_HANDLER))) == 0) {
342: perror("malloc");
343: exit(1);
344: }
345: memset(ph, 0, sizeof(PCAP_HANDLER));
346:
347: ph->masklen = aggregate;
348: ph->name = strdup(dp->name);
349: if (dp->description && *dp->description)
350: ph->descr = strdup(dp->description);
351: else if (dp->flags & PCAP_IF_LOOPBACK)
352: ph->descr = strdup("Loopback");
353: else ph->descr = strdup(parse_dl_name(type));
354: ph->pcap = pd;
355: ph->addr = dp->addresses; /* XXX must be deep copy? */
356:
357: /* make string of network address list */
358: buf[0] = '\0';
359: cp = buf;
360: #ifdef linux
361: if (type == DLT_EN10MB && (dp->flags & PCAP_IF_LOOPBACK) == 0) {
362: int sfd = socket(AF_INET, SOCK_DGRAM, 0);
363: if (sfd != -1) {
364: struct ifreq ifr;
365: memset(&ifr, 0, sizeof(struct ifreq));
366: memcpy(ifr.ifr_name, dp->name,
367: MIN(strlen(dp->name), sizeof(ifr.ifr_name)-1));
368: if (ioctl(sfd, SIOCGIFHWADDR, &ifr) != -1) {
369: (void)strcpy(cp, linkaddr_string((u_char *)ifr.ifr_hwaddr.sa_data,
370: ETHER_ADDR_LEN));
371: cp += strlen(cp);
372: }
373: close(sfd);
374: }
375: }
376: #endif
377: for (ap = dp->addresses; ap && cp < (buf + sizeof(buf)-1);
378: ap = ap->next) {
379: if (buf[0]) {
380: *cp++ = ' ';
381: *cp = '\0';
382: }
383: if (satoa(ap->addr, cp, (buf + sizeof(buf)) - cp))
384: cp += strlen(cp);
385: }
386: *cp = '\0';
387: ph->addrstr = strdup(buf);
388:
389: if ((ph->ns_mutex = (pthread_mutex_t *)malloc(sizeof(pthread_mutex_t))) == 0) {
390: perror("malloc");
391: exit(1);
392: }
393: pthread_mutex_init(ph->ns_mutex, 0);
394:
395: ph->prev = ph_prev;
396: if (ph_prev)
397: ph_prev->next = ph;
398: else *ph_list = ph;
399: ph_prev = ph;
400:
401: cnt++;
402: }
403: if (cnt && err) {
404: fflush(stderr);
405: sleep(1);
406: }
407: return cnt;
408: }
409:
410: PCAP_HANDLER *
411: pcaph_create(top, nh)
412: PCAP_HANDLER *top;
413: const struct netstat_header *nh;
414: {
415: PCAP_HANDLER *ph;
416:
417: /* sanity check */
418: if (!top || top->masklen < 0 || !nh)
419: return 0;
420:
421: if ((ph = (PCAP_HANDLER *)malloc(sizeof(PCAP_HANDLER))) == 0)
422: return 0;
423: memset(ph, 0, sizeof(PCAP_HANDLER));
424:
425: ph->masklen = -1;
426: ph->maskhdr = (struct netstat_header *)malloc(sizeof(struct netstat_header));
427: if (!ph->maskhdr) return 0;
428: memcpy(ph->maskhdr, nh, sizeof(struct netstat_header));
429: netstat_aggregate(ph->maskhdr, top->masklen);
430:
431: if ((ph->ns_mutex = (pthread_mutex_t *)malloc(sizeof(pthread_mutex_t))) == 0) {
432: free(ph->maskhdr);
433: return 0;
434: }
435: pthread_mutex_init(ph->ns_mutex, 0);
436:
437: ph->name = top->name;
438: ph->descr = top->descr;
439: ph->pcap = top->pcap;
440: ph->selected = 1;
441:
442: ph->top = top;
443: top->deep = ph;
444: return ph;
445: }
446:
447: void
448: pcaph_close(ph)
449: PCAP_HANDLER *ph;
450: {
451: /* sanity check */
452: if (!ph || !ph->top) return;
453:
454: ph->top->deep = 0;
455: if (ph->deep) pcaph_close(ph->deep); /* recursion */
456:
457: netstat_free(ph);
458: if (ph->ns_mutex) {
459: pthread_mutex_destroy(ph->ns_mutex);
460: free(ph->ns_mutex);
461: ph->ns_mutex = 0;
462: }
463: remove_event(0, ph);
464: if (ph->maskhdr) free(ph->maskhdr);
465: if (ph->selector) {
466: if (ph->selector->list)
467: free(ph->selector->list);
468: free(ph->selector);
469: }
470: free(ph);
471: }
472:
473: char *
474: pcap_setexpr(ph, expr)
475: PCAP_HANDLER *ph;
476: const char *expr;
477: {
478: int op;
479: struct bpf_program filter;
480: bpf_u_int32 net;
481: bpf_u_int32 mask;
482: char name[100], buf[256];
483:
484: if (!expr) return 0;
485:
486: for (; ph; ph = ph->next) {
487: if (!ph->pcap) /* skip non-pcap devices */
488: continue;
489:
490: if (pcap_lookupnet(strcpy(name, ph->name), &net, &mask, buf) < 0) {
491: /* ignore error */
492: net = 0;
493: mask = 0;
494: }
495:
496: (void)strncpy(buf, expr, sizeof(buf));
497: buf[sizeof(buf)-1] = '\0';
498: if (pcap_compile(ph->pcap, &filter, buf, Oflag, mask) < 0)
499: return pcap_geterr(ph->pcap);
500:
501: op = pcap_setfilter(ph->pcap, &filter);
502: pcap_freecode(&filter);
503: if (op < 0) return pcap_geterr(ph->pcap);
504: }
505: return 0;
506: }
507:
508: static void *
509: pcap_feed(arg)
510: void *arg;
511: {
512: PCAP_HANDLER *ph, *ph_list = (PCAP_HANDLER *)arg;
513: int npkt = -1, ndev, op;
514:
515: do {
516: if (!npkt) usleep(1000); /* 1ms idle to prevent deadloop */
517: npkt = 0;
518: ndev = 0;
519: for (ph = ph_list; ph; ph = ph->next) {
520: if (!ph->pcap) /* skip non-pcap devices */
521: continue;
522: op = pcap_dispatch(ph->pcap, -1, parse_feed, (u_char *)ph);
523:
524: if (op > 0) {
525: npkt += op;
526: } else if (op == -2 || (op == -1 && errno != EAGAIN)) {
527: pcap_close(ph->pcap);
528: ph->pcap = 0;
529: continue;
530: }
531: ndev++;
532: }
533: } while (ndev);
534:
535: return 0;
536: }
537:
538: #ifdef HAVE_PCAP_GET_SELECTABLE_FD
539: static void *
540: pcap_feed2(arg)
541: void *arg;
542: {
543: PCAP_HANDLER *ph, *ph_list = (PCAP_HANDLER *)arg;
544: int npkt = -1, ndev, op;
545: fd_set readfds;
546:
547: for (;;) {
548: #ifdef notdef
549: if (!npkt) usleep(1000); /* 1ms idle to prevent deadloop */
550: #endif
551: npkt = 0;
552: ndev = 0;
553: FD_ZERO(&readfds);
554: for (ph = ph_list; ph; ph = ph->next) {
555: if (!ph->pcap) /* skip non-pcap devices */
556: continue;
557: op = pcap_get_selectable_fd(ph->pcap);
558: if (op < 0) /* should not happen */
559: continue;
560: if (op + 1 > ndev)
561: ndev = op + 1;
562: FD_SET(op, &readfds);
563: }
564: if (ndev < 1) /* no one device fd for selecting? */
565: break;
566:
567: if ((op = select(ndev, &readfds, 0, 0, 0)) < 0) {
568: if (errno == EINTR || errno == EAGAIN)
569: continue;
570: /* select error? */
571: break;
572: }
573: if (!op) /* select timed out, try again */
574: continue;
575: for (ph = ph_list; ph; ph = ph->next) {
576: if (!ph->pcap) /* skip non-pcap devices */
577: continue;
578: #ifdef notdef
579: if (!FD_ISSET(pcap_get_selectable_fd(ph->pcap), &readfds))
580: continue; /* skip silent devices */
581: #endif
582: op = pcap_dispatch(ph->pcap, -1, parse_feed, (u_char *)ph);
583: if (op > 0) {
584: npkt += op;
585: } else if (op == -2 || (op == -1 && errno != EAGAIN)) {
586: pcap_close(ph->pcap);
587: ph->pcap = 0;
588: }
589: }
590: }
591: return 0;
592: }
593: #endif
594:
595: static void
596: parse_feed(a, h, p)
597: u_char *a;
598: const struct pcap_pkthdr *h;
599: const u_char *p;
600: {
601: PCAP_HANDLER *ph = (PCAP_HANDLER *)a;
602: NETSTAT ns;
603:
604: /* sanity check */
605: if (!ph || !ph->pcap) return;
606:
607: /*ph->pcap_time = h->ts;*/
608: memset(&ns, 0, sizeof(NETSTAT));
609:
610: if (parse_dl(&ns, pcap_datalink(ph->pcap), h->caplen, h->len, p) < 0)
611: return;
612:
613: ns.mtime = h->ts;
614: pcap_save(ph, &ns);
615: }
616:
617: void
618: pcap_save(ph, ns)
619: PCAP_HANDLER *ph;
620: const NETSTAT *ns;
621: {
622: int num;
623: struct netstat_header nh;
624:
625: /* sanity check */
626: if (!ph || !ns) return;
627:
628: if (netstat_insert(ph, ns) && aggregate < 0) {
629: num = netstat_count(ph);
630: if (num > 5000) {
631: if (ph->masklen)
632: ph->masklen = 0;
633: } else if (num > 1000) {
634: if (ph->masklen < 0 || ph->masklen > 16)
635: ph->masklen = 16;
636: } else if (num > 250) {
637: if (ph->masklen < 0 || ph->masklen > 24)
638: ph->masklen = 24;
639: }
640: }
641: while (ph->deep) {
642: num = ph->masklen;
643: ph = ph->deep;
644: if (!ph->maskhdr) /* should not happen */
645: continue;
646: memcpy(&nh, &ns->ns_hdr, sizeof(struct netstat_header));
647: netstat_aggregate(&nh, num);
648: if (!memcmp(&nh, ph->maskhdr, sizeof(struct netstat_header)))
649: netstat_insert(ph, ns);
650: }
651: }
652:
653: void
654: pcap_show(arg)
655: void *arg;
656: {
657: PCAP_HANDLER *ph = (PCAP_HANDLER *)arg;
658: SELECTOR *sp;
659: int idx;
660: struct timeval now;
661:
662: gettimeofday(&now, 0);
663:
664: switch (show_mode) {
665: case Interfaces:
666: sp = show_if_list(ph);
667: if (search && (idx = show_if_search(ph, search)) != -1)
668: selector_set(idx, sp);
669: selector_redraw(sp);
670: break;
671: case NetStat:
672: ph = pcap_get_selected(ph);
673: sp = show_stat_list(ph);
674: if (search && (idx = show_stat_search(ph, search)) != -1)
675: selector_set(idx, sp);
676: selector_redraw(sp);
677: break;
678: case FlowDump:
679: show_dump_print(pcap_get_selected(ph));
680: break;
681: case HelpPage:
682: #ifdef notdef
683: /* overlapping is not good idea -- too flicker */
684: show_mode = help_page_mode();
685: if (show_mode != HelpPage) { /* just for sanity */
686: pcap_show(arg);
687: show_mode = HelpPage;
688: }
689: #endif
690: selector_redraw(help_page_selector());
691: break;
692: }
693:
694: /* schedule next time */
695: now.tv_sec += refresh_time;
696: add_event(&now, pcap_show, arg);
697: }
698:
699: void
700: pcap_purge(arg)
701: void *arg;
702: {
703: PCAP_HANDLER *ph = (PCAP_HANDLER *)arg, *p;
704: struct timeval now;
705:
706: gettimeofday(&now, 0);
707: now.tv_sec -= purge_time;
708:
709: for (; ph; ph = ph->next) {
710: for (p = ph; p; p = p->deep)
711: netstat_purge(p, &now);
712: }
713: /* schedule next time */
714: now.tv_sec += purge_time * 2;
715: add_event(&now, pcap_purge, arg);
716:
717: pcap_show(arg);
718: }
719:
720: void
721: pcap_clear(arg)
722: void *arg;
723: {
724: PCAP_HANDLER *ph = (PCAP_HANDLER *)arg, *p;
725:
726: for (; ph; ph = ph->next) {
727: for (p = ph; p; p = p->deep)
728: netstat_purge(p, 0);
729: }
730: pcap_show(arg);
731: }
732:
733: PCAP_HANDLER *
734: pcap_get_selected(ph)
735: PCAP_HANDLER *ph;
736: {
737: for (; ph; ph = ph->next) {
738: if (ph->selected) {
739: while (ph->deep) ph = ph->deep;
740: return ph;
741: }
742: }
743: return 0;
744: }
745:
746: PCAP_HANDLER *
747: pcap_set_selected(ph, idx)
748: PCAP_HANDLER *ph;
749: int idx;
750: {
751: PCAP_HANDLER *sel = 0;
752: int i = 0;
753:
754: for (; ph; ph = ph->next) {
755: if (i++ == idx) {
756: sel = ph;
757: ph->selected = 1;
758: } else ph->selected = 0;
759: }
760: return sel;
761: }
762:
763: static void *
764: traf_show(arg)
765: void *arg;
766: {
767: PCAP_HANDLER *ph_list = (PCAP_HANDLER *)arg;
768: int op, nfds;
769: fd_set readfds, writefds;
770: struct timeval timeout;
771:
772: /* start show */
773: pcap_purge(ph_list);
774:
775: /* init keyboard functions */
776: getkey_init(ph_list);
777:
778: for (;;) {
779: if (resize_pending) {
780: if (screen_open(resize_pending) < 0)
781: return 0;
782: add_event(0, pcap_show, ph_list);
783: resize_pending = 0;
784: }
785: nfds = 0;
786: FD_ZERO(&readfds);
787: FD_ZERO(&writefds);
788: op = select_event(&timeout);
789: if (!session_select(&nfds, &readfds, &writefds, &timeout, &op)) {
790: /* no one active session?? should not happen */
791: return 0;
792: }
793: op = select(nfds, &readfds, &writefds, 0, op ? 0 : &timeout);
794: if (op < 1) { /* select interrupted by signals or timed out */
795: if (op < 0) {
796: if (errno == EINTR || errno == EAGAIN)
797: continue;
798: screen_status("select: %s", strerror(errno));
799: return 0;
800: } else session_timeout();
801: } else session_operate(&readfds, &writefds);
802: }
803:
804: /* NOT REACHED */
805: return 0;
806: }
807:
808: static void
809: vers()
810: {
811: extern char pcap_version[];
812:
813: int hc = 0;
814: #ifdef HAVE_HAS_COLORS
815: initscr();
816: hc = has_colors();
817: endwin();
818: #endif /* HAVE_HAS_COLORS */
819:
820: fprintf(stderr, "\n%s Version %s\ncompiled for %s with\n %s\n",
821: progname, version, target, compiled);
822:
823: fprintf(stderr, "\tlibpcap version %s\n", pcap_version);
824:
825: #ifdef HAVE_SLCURSES
826: fprintf(stderr, "\tslcurses version %d\n", SLang_Version);
827: #elif HAVE_NCURSES
828: #ifdef NCURSES_VERSION
829: fprintf(stderr, "\tncurses version %s\n", NCURSES_VERSION);
830: #else
831: fprintf(stderr, "\tncurses version unknown\n");
832: #endif /* NCURSES_VERSION */
833: #elif HAVE_CURSES
834: fprintf(stderr, "\tunknown curses library\n");
835: #endif /* HAVE_SLCURSES */
836:
837: #ifdef HAVE_HAS_COLORS
838: fprintf(stderr, "\tcolors support\n");
839: if (hc) fprintf(stderr, "\tyour current terminal has color capability\n");
840: #ifndef HAVE_SLCURSES
841: else fprintf(stderr, "\tyour current terminal has no color capability\n");
842: #endif
843: #else
844: fprintf(stderr, "\tno colors support\n");
845: #endif /* HAVE_HAS_COLORS */
846:
847: fprintf(stderr, "\n%s\n", copyright);
848: fprintf(stderr,"For bug report please email to trafshow@risp.ru (include this page)\n\n");
849:
850: exit(1);
851: }
852:
853: static void
854: usage()
855: {
856: fprintf(stderr,
857: "Usage:\n\
858: %s [-vpnb] [-a len] [-c conf] [-i ifname] [-s str] [-u port] [-R refresh] [-P purge] [-F file | expr]\n\
859: Where:\n\
860: -v Print version number, compile-time definitions, and exit\n\
861: -p Don't put the interface(s) into promiscuous mode\n\
862: -n Don't convert numeric values to names\n\
863: -b To place a backflow near to the main stream\n\
864: -a len To aggregate IP addresses using the prefix length\n\
865: -c conf Color config file instead of default /etc/trafshow\n\
866: -i ifname Network interface name; all by default\n\
867: -s str To search & follow for string in the list show\n\
868: -u port UDP port number to listen for Cisco Netflow; default %d\n\
869: -R refresh Set the refresh-period of data show to seconds; default %d sec\n\
870: -P purge Set the expired data purge-period to seconds; default %d sec\n\
871: -F file Use file as input for the filter expression\n\
872: expr Filter expression; see tcpdump(1) for syntax\n\
873: \n", progname, CNF_PORT, REFRESH_TIME, PURGE_TIME);
874:
875: exit(1);
876: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to trafshow.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