Annotation of embedaddon/iftop/options.c, revision 1.1.1.1
1.1 misho 1: /*
2: * options.c:
3: *
4: *
5: */
6:
7: #include "config.h"
8:
9: #include <sys/types.h>
10:
11: #include <stdio.h>
12: #include <string.h>
13: #include <stdlib.h>
14: #include <unistd.h>
15:
16: #include <sys/ioctl.h>
17: #include <sys/socket.h>
18: #include <netinet/in.h>
19: #include <arpa/inet.h>
20: #include <net/if.h>
21:
22: #include "iftop.h"
23: #include "options.h"
24: #include "cfgfile.h"
25: #include "integers.h"
26:
27: #if !defined(HAVE_INET_ATON) && defined(HAVE_INET_PTON)
28: # define inet_aton(a, b) inet_pton(AF_INET, (a), (b))
29: #endif
30:
31: options_t options;
32:
33: char optstr[] = "+i:f:nNF:hpbBPm:c:";
34:
35: /* Global options. */
36:
37: /* Selecting an interface on which to listen: */
38:
39: /* This is a list of interface name prefixes which are `bad' in the sense
40: * that they don't refer to interfaces of external type on which we are
41: * likely to want to listen. We also compare candidate interfaces to lo. */
42: static char *bad_interface_names[] = {
43: "lo:",
44: "lo",
45: "stf", /* pseudo-device 6to4 tunnel interface */
46: "gif", /* psuedo-device generic tunnel interface */
47: "dummy",
48: "vmnet",
49: NULL /* last entry must be NULL */
50: };
51:
52: config_enumeration_type sort_enumeration[] = {
53: { "2s", OPTION_SORT_DIV1 },
54: { "10s", OPTION_SORT_DIV2 },
55: { "40s", OPTION_SORT_DIV3 },
56: { "source", OPTION_SORT_SRC },
57: { "destination", OPTION_SORT_SRC },
58: { NULL, -1 }
59: };
60:
61: config_enumeration_type linedisplay_enumeration[] = {
62: { "two-line", OPTION_LINEDISPLAY_TWO_LINE },
63: { "one-line-both", OPTION_LINEDISPLAY_ONE_LINE_BOTH },
64: { "one-line-sent", OPTION_LINEDISPLAY_ONE_LINE_SENT },
65: { "one-line-received", OPTION_LINEDISPLAY_ONE_LINE_RECV },
66: { NULL, -1 }
67: };
68:
69: config_enumeration_type showports_enumeration[] = {
70: { "off", OPTION_PORTS_OFF },
71: { "source-only", OPTION_PORTS_SRC },
72: { "destination-only", OPTION_PORTS_DEST },
73: { "on", OPTION_PORTS_ON },
74: { NULL, -1 }
75: };
76:
77: static int is_bad_interface_name(char *i) {
78: char **p;
79: for (p = bad_interface_names; *p; ++p)
80: if (strncmp(i, *p, strlen(*p)) == 0)
81: return 1;
82: return 0;
83: }
84:
85: /* This finds the first interface which is up and is not the loopback
86: * interface or one of the interface types listed in bad_interface_names. */
87: static char *get_first_interface(void) {
88: struct if_nameindex * nameindex;
89: char *i = NULL;
90: int j = 0;
91: /* Use if_nameindex(3) instead? */
92:
93: nameindex = if_nameindex();
94: if(nameindex == NULL) {
95: return NULL;
96: }
97:
98: while(nameindex[j].if_index != 0) {
99: if (strcmp(nameindex[j].if_name, "lo") != 0 && !is_bad_interface_name(nameindex[j].if_name)) {
100: i = xstrdup(nameindex[j].if_name);
101: break;
102: }
103: j++;
104: }
105: if_freenameindex(nameindex);
106: return i;
107: }
108:
109: void options_set_defaults() {
110: char *s;
111: /* Should go through the list of interfaces, and find the first one which
112: * is up and is not lo or dummy*. */
113: options.interface = get_first_interface();
114: if (!options.interface)
115: options.interface = "eth0";
116:
117: options.filtercode = NULL;
118: options.netfilter = 0;
119: inet_aton("10.0.1.0", &options.netfilternet);
120: inet_aton("255.255.255.0", &options.netfiltermask);
121: options.dnsresolution = 1;
122: options.portresolution = 1;
123: #ifdef NEED_PROMISCUOUS_FOR_OUTGOING
124: options.promiscuous = 1;
125: options.promiscuous_but_choosy = 1;
126: #else
127: options.promiscuous = 0;
128: options.promiscuous_but_choosy = 0;
129: #endif
130: options.showbars = 1;
131: options.showports = OPTION_PORTS_OFF;
132: options.aggregate_src = 0;
133: options.aggregate_dest = 0;
134: options.paused = 0;
135: options.showhelp = 0;
136: options.bandwidth_in_bytes = 0;
137: options.sort = OPTION_SORT_DIV2;
138: options.screenfilter = NULL;
139: options.freezeorder = 0;
140: options.linedisplay = OPTION_LINEDISPLAY_TWO_LINE;
141: options.screen_offset = 0;
142: options.show_totals = 0;
143: options.max_bandwidth = 0; /* auto */
144: options.log_scale = 0;
145: options.bar_interval = 1;
146:
147: /* Figure out the name for the config file */
148: s = getenv("HOME");
149: if(s != NULL) {
150: int i = strlen(s) + 9 + 1;
151: options.config_file = xmalloc(i);
152: snprintf(options.config_file,i,"%s/.iftoprc",s);
153: }
154: else {
155: options.config_file = xstrdup("iftoprc");
156: }
157: options.config_file_specified = 0;
158:
159: }
160:
161: static void die(char *msg) {
162: fprintf(stderr, msg);
163: exit(1);
164: }
165:
166: static void set_max_bandwidth(char* arg) {
167: char* units;
168: long long mult = 1;
169: long long value;
170: units = arg + strspn(arg, "0123456789");
171: if(strlen(units) > 1) {
172: die("Invalid units\n");
173: }
174: if(strlen(units) == 1) {
175: if(*units == 'k' || *units == 'K') {
176: mult = 1024;
177: }
178: else if(*units == 'm' || *units == 'M') {
179: mult = 1024 * 1024;
180: }
181: else if(*units == 'g' || *units == 'G') {
182: mult = 1024 * 1024 * 1024;
183: }
184: }
185: *units = '\0';
186: if(sscanf(arg, "%lld", &value) != 1) {
187: die("Error reading max bandwidth\n");
188: }
189: options.max_bandwidth = value * mult;
190: }
191:
192: static void set_net_filter(char* arg) {
193: char* mask;
194:
195: mask = strchr(arg, '/');
196: if (mask == NULL) {
197: die("Could not parse net/mask\n");
198: }
199: *mask = '\0';
200: mask++;
201: if (inet_aton(arg, &options.netfilternet) == 0)
202: die("Invalid network address\n");
203: /* Accept a netmask like /24 or /255.255.255.0. */
204: if (mask[strspn(mask, "0123456789")] == '\0') {
205: /* Whole string is numeric */
206: int n;
207: n = atoi(mask);
208: if (n > 32) {
209: die("Invalid netmask");
210: }
211: else {
212: if(n == 32) {
213: /* This needs to be special cased, although I don't fully
214: * understand why -pdw
215: */
216: options.netfiltermask.s_addr = htonl(0xffffffffl);
217: }
218: else {
219: u_int32_t mm = 0xffffffffl;
220: mm >>= n;
221: options.netfiltermask.s_addr = htonl(~mm);
222: }
223: }
224: }
225: else if (inet_aton(mask, &options.netfiltermask) == 0) {
226: die("Invalid netmask\n");
227: }
228: options.netfilternet.s_addr = options.netfilternet.s_addr & options.netfiltermask.s_addr;
229:
230: options.netfilter = 1;
231:
232: }
233:
234: /* usage:
235: * Print usage information. */
236: static void usage(FILE *fp) {
237: fprintf(fp,
238: "iftop: display bandwidth usage on an interface by host\n"
239: "\n"
240: "Synopsis: iftop -h | [-npbBP] [-i interface] [-f filter code] [-N net/mask]\n"
241: "\n"
242: " -h display this message\n"
243: " -n don't do hostname lookups\n"
244: " -N don't convert port numbers to services\n"
245: " -p run in promiscuous mode (show traffic between other\n"
246: " hosts on the same network segment)\n"
247: " -b don't display a bar graph of traffic\n"
248: " -B Display bandwidth in bytes\n"
249: " -i interface listen on named interface\n"
250: " -f filter code use filter code to select packets to count\n"
251: " (default: none, but only IP packets are counted)\n"
252: " -F net/mask show traffic flows in/out of network\n"
253: " -P show ports as well as hosts\n"
254: " -m limit sets the upper limit for the bandwidth scale\n"
255: " -c config file specifies an alternative configuration file\n"
256: "\n"
257: "iftop, version " IFTOP_VERSION "\n"
258: "copyright (c) 2002 Paul Warren <pdw@ex-parrot.com> and contributors\n"
259: );
260: }
261:
262: void options_read_args(int argc, char **argv) {
263: int opt;
264:
265: opterr = 0;
266: while ((opt = getopt(argc, argv, optstr)) != -1) {
267: switch (opt) {
268: case 'h':
269: usage(stdout);
270: exit(0);
271:
272: case 'n':
273: config_set_string("dns-resolution","false");
274: break;
275:
276: case 'N':
277: config_set_string("port-resolution","false");
278: break;
279:
280: case 'i':
281: config_set_string("interface", optarg);
282: break;
283:
284: case 'f':
285: config_set_string("filter-code", optarg);
286: break;
287:
288: case 'p':
289: config_set_string("promiscuous", "true");
290: break;
291:
292: case 'P':
293: config_set_string("port-display", "on");
294: break;
295:
296: case 'F':
297: config_set_string("net-filter", optarg);
298: break;
299:
300: case 'm':
301: config_set_string("max-bandwidth", optarg);
302: break;
303:
304: case 'b':
305: config_set_string("show-bars", "true");
306: break;
307:
308: case 'B':
309: config_set_string("use-bytes", "true");
310: break;
311:
312: case 'c':
313: xfree(options.config_file);
314: options.config_file = xstrdup(optarg);
315: options.config_file_specified = 1;
316: break;
317:
318: case '?':
319: fprintf(stderr, "iftop: unknown option -%c\n", optopt);
320: usage(stderr);
321: exit(1);
322:
323: case ':':
324: fprintf(stderr, "iftop: option -%c requires an argument\n", optopt);
325: usage(stderr);
326: exit(1);
327: }
328: }
329:
330: if (optind != argc) {
331: fprintf(stderr, "iftop: found arguments following options\n");
332: fprintf(stderr, "*** some options have changed names since v0.9 ***\n");
333: usage(stderr);
334: exit(1);
335: }
336: }
337:
338: /* options_config_get_string:
339: * Gets a value from the config, sets *value to a copy of the value, if
340: * found. Leaves the option unchanged otherwise. */
341: int options_config_get_string(const char *name, char** value) {
342: char *s;
343: s = config_get_string(name);
344: if(s != NULL) {
345: *value = xstrdup(s);
346: return 1;
347: }
348: return 0;
349: }
350:
351: int options_config_get_bool(const char *name, int* value) {
352: if(config_get_string(name)) {
353: *value = config_get_bool(name);
354: return 1;
355: }
356: return 0;
357: }
358:
359: int options_config_get_int(const char *name, int* value) {
360: if(config_get_string(name)) {
361: config_get_int(name, value);
362: return 1;
363: }
364: return 0;
365: }
366:
367: int options_config_get_enum(char *name, config_enumeration_type* enumeration, int *result) {
368: int i;
369: if(config_get_string(name)) {
370: if(config_get_enum(name, enumeration, &i)) {
371: *result = i;
372: return 1;
373: }
374: }
375: return 0;
376: }
377:
378: int options_config_get_promiscuous() {
379: if(config_get_string("promiscuous")) {
380: options.promiscuous = config_get_bool("promiscuous");
381: if(options.promiscuous) {
382: /* User has explicitly requested promiscuous mode, so don't be
383: * choosy */
384: options.promiscuous_but_choosy = 0;
385: }
386: return 1;
387: }
388: return 0;
389: }
390:
391: int options_config_get_bw_rate(char *directive, long long* result) {
392: char* units;
393: long long mult = 1;
394: long long value;
395: char *s;
396: s = config_get_string(directive);
397: if(s) {
398: units = s + strspn(s, "0123456789");
399: if(strlen(units) > 1) {
400: fprintf(stderr, "Invalid units in value: %s\n", s);
401: return 0;
402: }
403: if(strlen(units) == 1) {
404: if(*units == 'k' || *units == 'K') {
405: mult = 1024;
406: }
407: else if(*units == 'm' || *units == 'M') {
408: mult = 1024 * 1024;
409: }
410: else if(*units == 'g' || *units == 'G') {
411: mult = 1024 * 1024 * 1024;
412: }
413: else if(*units == 'b' || *units == 'B') {
414: /* bits => mult = 1 */
415: }
416: else {
417: fprintf(stderr, "Invalid units in value: %s\n", s);
418: return 0;
419: }
420: }
421: *units = '\0';
422: if(sscanf(s, "%lld", &value) != 1) {
423: fprintf(stderr, "Error reading rate: %s\n", s);
424: }
425: options.max_bandwidth = value * mult;
426: return 1;
427: }
428: return 0;
429: }
430:
431: /*
432: * Read the net filter option.
433: */
434: int options_config_get_net_filter() {
435: char* s;
436: s = config_get_string("net-filter");
437: if(s) {
438: char* mask;
439:
440: mask = strchr(s, '/');
441: if (mask == NULL) {
442: fprintf(stderr, "Could not parse net/mask: %s\n", s);
443: return 0;
444: }
445: *mask = '\0';
446: mask++;
447: if (inet_aton(s, &options.netfilternet) == 0) {
448: fprintf(stderr, "Invalid network address: %s\n", s);
449: return 0;
450: }
451: /* Accept a netmask like /24 or /255.255.255.0. */
452: if (mask[strspn(mask, "0123456789")] == '\0') {
453: /* Whole string is numeric */
454: int n;
455: n = atoi(mask);
456: if (n > 32) {
457: fprintf(stderr, "Invalid netmask: %s\n", s);
458: }
459: else {
460: if(n == 32) {
461: /* This needs to be special cased, although I don't fully
462: * understand why -pdw
463: */
464: options.netfiltermask.s_addr = htonl(0xffffffffl);
465: }
466: else {
467: u_int32_t mm = 0xffffffffl;
468: mm >>= n;
469: options.netfiltermask.s_addr = htonl(~mm);
470: }
471: }
472: }
473: else if (inet_aton(mask, &options.netfiltermask) == 0) {
474: fprintf(stderr, "Invalid netmask: %s\n", s);
475: }
476: options.netfilternet.s_addr = options.netfilternet.s_addr & options.netfiltermask.s_addr;
477: options.netfilter = 1;
478: return 1;
479: }
480: return 0;
481: }
482:
483:
484: void options_make() {
485: options_config_get_string("interface", &options.interface);
486: options_config_get_bool("dns-resolution", &options.dnsresolution);
487: options_config_get_bool("port-resolution", &options.portresolution);
488: options_config_get_string("filter-code", &options.filtercode);
489: options_config_get_bool("show-bars", &options.showbars);
490: options_config_get_promiscuous();
491: options_config_get_bool("hide-source", &options.aggregate_src);
492: options_config_get_bool("hide-destination", &options.aggregate_dest);
493: options_config_get_bool("use-bytes", &options.bandwidth_in_bytes);
494: options_config_get_enum("sort", sort_enumeration, (int*)&options.sort);
495: options_config_get_enum("line-display", linedisplay_enumeration, (int*)&options.linedisplay);
496: options_config_get_bool("show-totals", &options.show_totals);
497: options_config_get_bool("log-scale", &options.log_scale);
498: options_config_get_bw_rate("max-bandwidth", &options.max_bandwidth);
499: options_config_get_enum("port-display", showports_enumeration, (int*)&options.showports);
500: options_config_get_string("screen-filter", &options.screenfilter);
501: options_config_get_net_filter();
502: };
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to options.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / iftop