![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to netstat.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 netstat.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / trafshow |
1.1 misho 1: /*
2: * Copyright (c) 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 <sys/time.h>
18: #include <netinet/in.h>
19: #include <netdb.h>
20: #include <stdio.h>
21: #include <stdlib.h>
22: #include <string.h>
23: #include <errno.h>
24: #include <pthread.h>
25:
26: #include "netstat.h"
27: #include "hashtab.h"
28: #include "trafshow.h"
29: #include "events.h" /* just for tv_diff() */
30: #include "colormask.h"
31: #include "addrtoname.h"
32:
33: int
34: netstat_count(ph)
35: const PCAP_HANDLER *ph;
36: {
37: /* sanity check */
38: if (!ph || !ph->ns_hash)
39: return 0;
40:
41: return hcount(ph->ns_hash);
42: }
43:
44: static void
45: maskit(bp, len, bits)
46: u_int8_t *bp;
47: int len, bits;
48: {
49: register u_int8_t mask;
50: register int i, j;
51:
52: for (i = 0; i < len; i++) {
53: mask = 0;
54: for (j = 0; j < 8 && bits > 0; j++, bits--) {
55: mask >>= 1;
56: mask |= 0x80;
57: }
58: bp[i] &= mask;
59: }
60: }
61:
62: void
63: netstat_aggregate(nh, bits)
64: struct netstat_header *nh;
65: int bits;
66: {
67: /* sanity check */
68: if (!nh || bits < 0)
69: return;
70:
71: memset(&nh->en_hdr.src, 0, sizeof(nh->en_hdr.src));
72: memset(&nh->en_hdr.dst, 0, sizeof(nh->en_hdr.dst));
73:
74: if (nh->in_hdr.ver) {
75: struct ip_address *src = &nh->in_hdr.src;
76: struct ip_address *dst = &nh->in_hdr.dst;
77:
78: maskit((u_int8_t *)&src->ipaddr, sizeof(src->ipaddr), bits);
79: maskit((u_int8_t *)&dst->ipaddr, sizeof(dst->ipaddr), bits);
80:
81: /* guess server port */
82: if (src->ip_port && dst->ip_port) {
83: u_int16_t sport = ntohs(src->ip_port);
84: u_int16_t dport = ntohs(dst->ip_port);
85:
86: if (isservport(sport))
87: dst->ip_port = 0;
88: else if (isservport(dport))
89: src->ip_port = 0;
90: else if (sport < IPPORT_RESERVED)
91: dst->ip_port = 0;
92: else if (dport < IPPORT_RESERVED)
93: src->ip_port = 0;
94: else if (sport >= IPPORT_DYNAMIC)
95: src->ip_port = 0;
96: else if (dport >= IPPORT_DYNAMIC)
97: dst->ip_port = 0;
98: else if (sport > dport)
99: src->ip_port = 0;
100: else dst->ip_port = 0;
101: }
102: }
103: }
104:
105: static int
106: htab_insert(ht, ns)
107: struct htab *ht;
108: const NETSTAT *ns;
109: {
110: ub1 *key;
111: ub4 keyl;
112: int op;
113: NETSTAT *dp;
114:
115: key = (ub1 *)&ns->ns_hdr;
116: keyl = sizeof(ns->ns_hdr);
117: if ((op = hadd(ht, key, keyl, 0)) < 0)
118: return -1;
119:
120: if (op) { /* OK, new item inserted */
121: if ((dp = (NETSTAT *)malloc(sizeof(NETSTAT))) == 0) {
122: hdel(ht);
123: return -1;
124: }
125: memcpy(dp, ns, sizeof(NETSTAT));
126: dp->gain_pkt_cnt = ns->pkt_cnt;
127: dp->gain_pkt_len = ns->pkt_len;
128: dp->gain_data_len = ns->data_len;
129: dp->attr = colormask(&dp->ns_hdr);
130:
131: hkey(ht) = (ub1 *)&dp->ns_hdr;
132: hstuff(ht) = dp;
133: return 1;
134: }
135: /* Failed because already in cache -- update it */
136:
137: if ((dp = (NETSTAT *)hstuff(ht)) == 0)
138: return 0; /* should not happen */
139:
140: dp->pkt_cnt += ns->pkt_cnt;
141: dp->pkt_len += ns->pkt_len;
142: dp->data_len += ns->data_len;
143:
144: dp->gain_pkt_cnt += ns->pkt_cnt;
145: dp->gain_pkt_len += ns->pkt_len;
146: dp->gain_data_len += ns->data_len;
147:
148: if (ns->pkt_cnt_rate || ns->pkt_len_rate || ns->data_len_rate) {
149: dp->mtime = ns->mtime;
150:
151: dp->pkt_cnt_rate = ns->pkt_cnt_rate;
152: dp->pkt_len_rate = ns->pkt_len_rate;
153: dp->data_len_rate = ns->data_len_rate;
154:
155: } else if ((op = tv_diff(&dp->mtime, &ns->mtime)) >= 1000) {
156: dp->mtime = ns->mtime;
157:
158: dp->gain_pkt_cnt = dp->gain_pkt_cnt * 1000 / op;
159: if (dp->gain_pkt_cnt) {
160: dp->pkt_cnt_rate = dp->gain_pkt_cnt;
161: dp->gain_pkt_cnt = 0;
162: }
163: dp->gain_pkt_len = dp->gain_pkt_len * 1000 / op;
164: if (dp->gain_pkt_len) {
165: dp->pkt_len_rate = dp->gain_pkt_len;
166: dp->gain_pkt_len = 0;
167: }
168: dp->gain_data_len = dp->gain_data_len * 1000 / op;
169: if (dp->gain_data_len) {
170: dp->data_len_rate = dp->gain_data_len;
171: dp->gain_data_len = 0;
172: }
173: }
174: return 0;
175: }
176:
177: int
178: netstat_insert(ph, ns)
179: PCAP_HANDLER *ph;
180: const NETSTAT *ns;
181: {
182: int op;
183: NETSTAT ns_buf;
184:
185: /* sanity check */
186: if (!ph || !ns) {
187: errno = EINVAL;
188: return -1;
189: }
190: if (!ph->ns_hash && (ph->ns_hash = hcreate(65536)) == 0)
191: return -1;
192:
193: if (ph->masklen >= 0) {
194: memcpy(&ns_buf, ns, sizeof(NETSTAT));
195: netstat_aggregate(&ns_buf.ns_hdr, ph->masklen);
196: ns = &ns_buf;
197: }
198: if (ph->ns_mutex) pthread_mutex_lock(ph->ns_mutex);
199:
200: op = htab_insert(ph->ns_hash, ns);
201:
202: if (ph->ns_mutex) pthread_mutex_unlock(ph->ns_mutex);
203: return op;
204: }
205:
206: int
207: netstat_find(ph, ns)
208: PCAP_HANDLER *ph;
209: NETSTAT *ns; /* IN/OUT */
210: {
211: struct htab *ht;
212: ub1 *key;
213: ub4 keyl;
214: NETSTAT *found;
215: int ok = 0;
216:
217: /* sanity check */
218: if (!ph || !ns || netstat_count(ph) < 1)
219: return 0;
220:
221: if (ph->ns_mutex) pthread_mutex_lock(ph->ns_mutex);
222: ht = ph->ns_hash;
223:
224: key = (ub1 *)&ns->ns_hdr;
225: keyl = sizeof(ns->ns_hdr);
226: if (hfind(ht, key, keyl) && (found = hstuff(ht)) != 0) {
227: ok = 1;
228: *ns = *found;
229: }
230:
231: if (ph->ns_mutex) pthread_mutex_unlock(ph->ns_mutex);
232: return ok;
233: }
234:
235: int
236: netstat_purge(ph, at)
237: PCAP_HANDLER *ph;
238: const struct timeval *at;
239: {
240: struct htab *ht;
241: int op, cnt = 0;
242: NETSTAT *ns;
243:
244: /* sanity check */
245: if (!ph) {
246: errno = EINVAL;
247: return -1;
248: }
249: if (netstat_count(ph) < 1)
250: return 0;
251:
252: if (ph->ns_mutex) pthread_mutex_lock(ph->ns_mutex);
253: ht = ph->ns_hash;
254:
255: op = hfirst(ht);
256: while (op && hcount(ht) > 0) {
257: ns = hstuff(ht);
258: if (!ns) { /* should not happen */
259: op = hdel(ht);
260: } else if (!at || timercmp(&ns->mtime, at, <)) {
261: free(ns);
262: op = hdel(ht);
263: cnt++;
264: } else {
265: op = hnext(ht);
266: }
267: }
268: if (ph->ns_mutex) pthread_mutex_unlock(ph->ns_mutex);
269: return cnt;
270: }
271:
272: void
273: netstat_free(ph)
274: PCAP_HANDLER *ph;
275: {
276: struct htab *ht;
277:
278: /* sanity check */
279: if (!ph) return;
280:
281: netstat_purge(ph, 0);
282:
283: if (ph->ns_mutex) pthread_mutex_lock(ph->ns_mutex);
284: ht = ph->ns_hash;
285: ph->ns_hash = 0;
286: if (ht) hdestroy(ht);
287: if (ph->ns_mutex) pthread_mutex_unlock(ph->ns_mutex);
288: }
289:
290: int
291: netstat_match(p1, p2)
292: register const NETSTAT *p1, *p2;
293: {
294: /* sanity check */
295: if (!p1 || !p2) return 0;
296:
297: return !memcmp(&p1->ns_hdr, &p2->ns_hdr, sizeof(struct netstat_header));
298: }
299:
300: int
301: netstat_bidir(p1, p2)
302: register const NETSTAT *p1, *p2;
303: {
304: /* sanity check */
305: if (!p1 || !p2) return 0;
306:
307: if (p1->ip_ver) {
308: if (p1->ip_ver == p2->ip_ver &&
309: p1->ip_proto == p2->ip_proto &&
310: !memcmp(&p1->ip_src_addr, &p2->ip_dst_addr,
311: sizeof(struct ip_address)) &&
312: !memcmp(&p2->ip_src_addr, &p1->ip_dst_addr,
313: sizeof(struct ip_address)))
314: return 1;
315: } else if (!p2->ip_ver) {
316: if (p1->eth_type == p2->eth_type &&
317: !memcmp(p1->eth_src_addr, p2->eth_dst_addr,
318: ETHER_ADDR_LEN) &&
319: !memcmp(p2->eth_src_addr, p1->eth_dst_addr,
320: ETHER_ADDR_LEN))
321: return 1;
322: }
323: return 0;
324: }
325:
326: int
327: netstat_fetch(list, ph)
328: NETSTAT **list[];
329: PCAP_HANDLER *ph;
330: {
331: struct htab *ht;
332: int op, cnt, i;
333: NETSTAT *ns, **array;
334:
335: /* sanity check */
336: if (!list || !ph) {
337: errno = EINVAL;
338: return -1;
339: }
340:
341: if ((cnt = netstat_count(ph)) < 1) {
342: /* free previous */
343: if (*list) free(*list);
344: *list = 0;
345: return 0;
346: }
347: if ((array = (NETSTAT **)malloc(cnt * sizeof(NETSTAT *))) == 0)
348: return -1;
349:
350: if (ph->ns_mutex) pthread_mutex_lock(ph->ns_mutex);
351: ht = ph->ns_hash;
352:
353: /* reset total statistics */
354: ph->pkt_cnt = 0;
355: ph->pkt_len = 0;
356: ph->data_len = 0;
357:
358: ph->pkt_cnt_rate = 0;
359: ph->pkt_len_rate = 0;
360: ph->data_len_rate = 0;
361:
362: op = hfirst(ht);
363: i = 0;
364: while (op && i < cnt) {
365: ns = hstuff(ht);
366: if (ns) {
367: array[i++] = ns;
368:
369: /* collect total statistics */
370: ph->pkt_cnt += ns->pkt_cnt;
371: ph->pkt_len += ns->pkt_len;
372: ph->data_len += ns->data_len;
373:
374: ph->pkt_cnt_rate += ns->pkt_cnt_rate;
375: ph->pkt_len_rate += ns->pkt_len_rate;
376: ph->data_len_rate += ns->data_len_rate;
377: }
378: op = hnext(ht);
379: }
380: /* free previous */
381: if (*list) free(*list);
382: *list = array;
383:
384: if (ph->ns_mutex) pthread_mutex_unlock(ph->ns_mutex);
385: return i;
386: }
387: