]> The Tcpdump Group git mirrors - libpcap/blob - pcap-sita.c
projects / libpcap / blob
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
The SITA code in pcap-linux.c shares very little with the Linux code;
[libpcap] / pcap-sita.c
1 /*
2 * pcap-sita.c: Packet capture interface additions for SITA ACN devices
3 *
4 * Copyright (c) 2007 Fulko Hew, SITA INC Canada, Inc <fulko.hew@sita.aero>
5 *
6 * License: BSD
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 *
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in
16 * the documentation and/or other materials provided with the
17 * distribution.
18 * 3. The names of the authors may not be used to endorse or promote
19 * products derived from this software without specific prior
20 * written permission.
21 *
22 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
23 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
24 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
25 */
26
27 /* $Id: pcap-sita.c */
28
29 #ifdef HAVE_CONFIG_H
30 #include "config.h"
31 #endif
32
33 #include <stdio.h>
34 #include <string.h>
35 #include <stdlib.h>
36 #include <unistd.h>
37 #include <fcntl.h>
38 #include <errno.h>
39 #include <sys/time.h>
40 #include <sys/socket.h>
41 #include <netinet/in.h>
42 #include <arpa/inet.h>
43 #include "pcap-int.h"
44
45 #include "pcap-sita.h"
46
47 /* non-configureable manifests follow */
48
49 #define IOP_SNIFFER_PORT 49152 /* TCP port on the IOP used for 'distributed pcap' usage */
50 #define MAX_LINE_SIZE 255 /* max size of a buffer/line in /etc/hosts we allow */
51 #define MAX_CHASSIS 8 /* number of chassis in an ACN site */
52 #define MAX_GEOSLOT 8 /* max number of access units in an ACN site */
53
54 #define FIND 0
55 #define LIVE 1
56
57 typedef struct iface {
58 struct iface *next; /* a pointer to the next interface */
59 char *name; /* this interface's name on Wireshark */
60 char *IOPname; /* this interface's name on an IOP */
61 uint32_t iftype; /* the type of interface (DLT values) */
62 } iface_t;
63
64 typedef struct unit {
65 char *ip; /* this unit's IP address (as extracted from /etc/hosts) */
66 int fd; /* the connection to this unit (if it exists) */
67 int find_fd; /* a big kludge to avoid my programming limitations since I could have this unit open for findalldevs purposes */
68 int first_time; /* 0 = just opened via acn_open_live(), ie. the first time, NZ = nth time */
69 struct sockaddr_in *serv_addr; /* the address control block for comms to this unit */
70 int chassis;
71 int geoslot;
72 iface_t *iface; /* a pointer to a linked list of interface structures */
73 char *imsg; /* a pointer to an inbound message */
74 int len; /* the current size of the inbound message */
75 } unit_t;
76
77 static char *errorString;
78 static unit_t units[MAX_CHASSIS+1][MAX_GEOSLOT+1]; /* we use indexes of 1 through 8, but we reserve/waste index 0 */
79 static fd_set readfds; /* a place to store the file descriptors for the connections to the IOPs */
80 static fd_set working_set;
81 static int max_fs;
82 static char static_buf[32];
83
84 pcap_if_t *acn_if_list; /* pcap's list of available interfaces */
85
86 static void dump_interface_list(void) {
87 pcap_if_t *iff;
88 pcap_addr_t *addr;
89 int longest_name_len = 0;
90 char *n, *d, *f;
91 int if_number = 0;
92
93 iff = acn_if_list;
94 while (iff) {
95 if (iff->name && (strlen(iff->name) > longest_name_len)) longest_name_len = strlen(iff->name);
96 iff = iff->next;
97 }
98 iff = acn_if_list;
99 printf("Interface List:\n");
100 while (iff) {
101 n = (iff->name) ? iff->name : "";
102 d = (iff->description) ? iff->description : "";
103 f = (iff->flags == PCAP_IF_LOOPBACK) ? "L" : "";
104 printf("%3d: %*s %s '%s'\n", if_number++, longest_name_len, n, f, d);
105 addr = iff->addresses;
106 while (addr) {
107 printf("%*s ", (5 + longest_name_len), ""); /* add some indentation */
108 printf("%15s ", (addr->addr) ? inet_ntoa(((struct sockaddr_in *)addr->addr)->sin_addr) : "");
109 printf("%15s ", (addr->netmask) ? inet_ntoa(((struct sockaddr_in *)addr->netmask)->sin_addr) : "");
110 printf("%15s ", (addr->broadaddr) ? inet_ntoa(((struct sockaddr_in *)addr->broadaddr)->sin_addr) : "");
111 printf("%15s ", (addr->dstaddr) ? inet_ntoa(((struct sockaddr_in *)addr->dstaddr)->sin_addr) : "");
112 printf("\n");
113 addr = addr->next;
114 }
115 iff = iff->next;
116 }
117 }
118
119 static void dump(unsigned char *ptr, int i, int indent) {
120 fprintf(stderr, "%*s", indent, " ");
121 for (; i > 0; i--) {
122 fprintf(stderr, "%2.2x ", *ptr++);
123 }
124 fprintf(stderr, "\n");
125 }
126
127 static void dump_interface_list_p(void) {
128 pcap_if_t *iff;
129 pcap_addr_t *addr;
130 int if_number = 0;
131
132 iff = acn_if_list;
133 printf("Interface Pointer @ %p is %p:\n", &acn_if_list, iff);
134 while (iff) {
135 printf("%3d: %p %p next: %p\n", if_number++, iff->name, iff->description, iff->next);
136 dump((unsigned char *)iff, sizeof(pcap_if_t), 5);
137 addr = iff->addresses;
138 while (addr) {
139 printf(" %p %p %p %p, next: %p\n", addr->addr, addr->netmask, addr->broadaddr, addr->dstaddr, addr->next);
140 dump((unsigned char *)addr, sizeof(pcap_addr_t), 10);
141 addr = addr->next;
142 }
143 iff = iff->next;
144 }
145 }
146
147 static void dump_unit_table(void) {
148 int chassis, geoslot;
149 iface_t *p;
150
151 printf("%c:%c %s %s\n", 'C', 'S', "fd", "IP Address");
152 for (chassis = 0; chassis <= MAX_CHASSIS; chassis++) {
153 for (geoslot = 0; geoslot <= MAX_GEOSLOT; geoslot++) {
154 if (units[chassis][geoslot].ip != NULL)
155 printf("%d:%d %2d %s\n", chassis, geoslot, units[chassis][geoslot].fd, units[chassis][geoslot].ip);
156 p = units[chassis][geoslot].iface;
157 while (p) {
158 char *n = (p->name) ? p->name : "";
159 char *i = (p->IOPname) ? p->IOPname : "";
160 p = p->next;
161 printf(" %12s -> %12s\n", i, n);
162 }
163 }
164 }
165 }
166
167 static int find_unit_by_fd(int fd, int *chassis, int *geoslot, unit_t **unit_ptr) {
168 int c, s;
169
170 for (c = 0; c <= MAX_CHASSIS; c++) {
171 for (s = 0; s <= MAX_GEOSLOT; s++) {
172 if (units[c][s].fd == fd || units[c][s].find_fd == fd) {
173 if (chassis) *chassis = c;
174 if (geoslot) *geoslot = s;
175 if (unit_ptr) *unit_ptr = &units[c][s];
176 return 1;
177 }
178 }
179 }
180 return 0;
181 }
182
183 static int read_client_nbytes(int fd, int count, unsigned char *buf) {
184 unit_t *u;
185 int chassis, geoslot;
186 int len;
187
188 find_unit_by_fd(fd, &chassis, &geoslot, &u);
189 while (count) {
190 if ((len = recv(fd, buf, count, 0)) <= 0) return -1; /* read in whatever data was sent to us */
191 count -= len;
192 buf += len;
193 } /* till we have everything we are looking for */
194 return 0;
195 }
196
197 static void empty_unit_iface(unit_t *u) {
198 iface_t *p, *cur;
199
200 cur = u->iface;
201 while (cur) { /* loop over all the interface entries */
202 if (cur->name) free(cur->name); /* throwing away the contents if they exist */
203 if (cur->IOPname) free(cur->IOPname);
204 p = cur->next;
205 free(cur); /* then throw away the structure itself */
206 cur = p;
207 }
208 u->iface = 0; /* and finally remember that there are no remaining structure */
209 }
210
211 static void empty_unit(int chassis, int geoslot) {
212 unit_t *u = &units[chassis][geoslot];
213
214 empty_unit_iface(u);
215 if (u->imsg) { /* then if an inbound message buffer exists */
216 u->imsg = (char *)realloc(u->imsg, 1); /* and re-allocate the old large buffer into a new small one */
217 }
218 }
219
220 static void empty_unit_table(void) {
221 int chassis, geoslot;
222
223 for (chassis = 0; chassis <= MAX_CHASSIS; chassis++) {
224 for (geoslot = 0; geoslot <= MAX_GEOSLOT; geoslot++) {
225 if (units[chassis][geoslot].ip != NULL) {
226 free(units[chassis][geoslot].ip); /* get rid of the malloc'ed space that holds the IP address */
227 units[chassis][geoslot].ip = 0; /* then set the pointer to NULL */
228 }
229 empty_unit(chassis, geoslot);
230 }
231 }
232 }
233
234 static char *find_nth_interface_name(int n) {
235 int chassis, geoslot;
236 iface_t *p;
237 char *last_name = 0;
238
239 if (n < 0) n = 0; /* ensure we are working with a valid number */
240 for (chassis = 0; chassis <= MAX_CHASSIS; chassis++) { /* scan the table... */
241 for (geoslot = 0; geoslot <= MAX_GEOSLOT; geoslot++) {
242 if (units[chassis][geoslot].ip != NULL) {
243 p = units[chassis][geoslot].iface;
244 while (p) { /* and all interfaces... */
245 if (p->IOPname) last_name = p->name; /* remembering the last name found */
246 if (n-- == 0) return last_name; /* and if we hit the instance requested */
247 p = p->next;
248 }
249 }
250 }
251 }
252 /* if we couldn't fine the selected entry */
253 if (last_name) return last_name; /* ... but we did have at least one entry... return the last entry found */
254 return ""; /* ... but if there wasn't any entry... return an empty string instead */
255 }
256
257 int acn_parse_hosts_file(char *errbuf) { /* returns: -1 = error, 0 = OK */
258 FILE *fp;
259 char buf[MAX_LINE_SIZE];
260 char *ptr, *ptr2;
261 int pos;
262 int chassis, geoslot;
263 unit_t *u;
264
265 empty_unit_table();
266 if ((fp = fopen("/etc/hosts", "r")) == NULL) { /* try to open the hosts file and if it fails */
267 snprintf(errbuf, PCAP_ERRBUF_SIZE, "Cannot open '/etc/hosts' for reading."); /* return the nohostsfile error response */
268 return -1;
269 }
270 while (fgets(buf, MAX_LINE_SIZE-1, fp)) { /* while looping over the file */
271
272 pos = strcspn(buf, "#\n\r"); /* find the first comment character or EOL */
273 *(buf + pos) = '\0'; /* and clobber it and anything that follows it */
274
275 pos = strspn(buf, " \t"); /* then find the first non-white space */
276 if (pos == strlen(buf)) /* if there is nothing but white space on the line */
277 continue; /* ignore that empty line */
278 ptr = buf + pos; /* and skip over any of that leading whitespace */
279
280 if ((ptr2 = strstr(ptr, "_I_")) == NULL) /* skip any lines that don't have names that look like they belong to IOPs */
281 continue;
282 if (*(ptr2 + 4) != '_') /* and skip other lines that have names that don't look like ACN components */
283 continue;
284 *(ptr + strcspn(ptr, " \t")) = '\0'; /* null terminate the IP address so its a standalone string */
285
286 chassis = *(ptr2 + 3) - '0'; /* extract the chassis number */
287 geoslot = *(ptr2 + 5) - '0'; /* and geo-slot number */
288 if (chassis < 1 || chassis > MAX_CHASSIS ||
289 geoslot < 1 || geoslot > MAX_GEOSLOT) { /* if the chassis and/or slot numbers appear to be bad... */
290 snprintf(errbuf, PCAP_ERRBUF_SIZE, "Invalid ACN name in '/etc/hosts'."); /* warn the user */
291 continue; /* and ignore the entry */
292 }
293 if ((ptr2 = (char *)malloc(strlen(ptr) + 1)) == NULL) {
294 snprintf(errbuf, PCAP_ERRBUF_SIZE, "malloc: %s", pcap_strerror(errno));
295 continue;
296 }
297 strcpy(ptr2, ptr); /* copy the IP address into our malloc'ed memory */
298 u = &units[chassis][geoslot];
299 u->ip = ptr2; /* and remember the whole shebang */
300 u->chassis = chassis;
301 u->geoslot = geoslot;
302 }
303 fclose(fp);
304 if (*errbuf) return -1;
305 else return 0;
306 }
307
308 static int open_with_IOP(unit_t *u, int flag) {
309 int sockfd;
310 char *ip;
311
312 if (u->serv_addr == NULL) {
313 u->serv_addr = malloc(sizeof(struct sockaddr_in));
314 }
315 ip = u->ip;
316 bzero((char *)u->serv_addr, sizeof(struct sockaddr_in));
317 u->serv_addr->sin_family = AF_INET;
318 u->serv_addr->sin_addr.s_addr = inet_addr(ip);
319 u->serv_addr->sin_port = htons(IOP_SNIFFER_PORT);
320
321 if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
322 fprintf(stderr, "pcap can't open a socket for connecting to IOP at %s\n", ip);
323 return 0;
324 }
325 if (connect(sockfd, (struct sockaddr *)u->serv_addr, sizeof(struct sockaddr_in)) < 0) {
326 fprintf(stderr, "pcap can't connect to IOP at %s\n", ip);
327 return 0;
328 }
329 if (flag == LIVE) u->fd = sockfd;
330 else u->find_fd = sockfd;
331 u->first_time = 0;
332 return sockfd; /* return the non-zero file descriptor as a 'success' indicator */
333 }
334
335 static void close_with_IOP(int chassis, int geoslot, int flag) {
336 int *id;
337
338 if (flag == LIVE) id = &units[chassis][geoslot].fd;
339 else id = &units[chassis][geoslot].find_fd;
340
341 if (*id) { /* this was the last time, so... if we are connected... */
342 close(*id); /* disconnect us */
343 *id = 0; /* and forget that the descriptor exists because we are not open */
344 }
345 }
346
347 static void pcap_close_acn(pcap_t *handle) {
348 int chassis, geoslot;
349 unit_t *u;
350
351 if (find_unit_by_fd(handle->fd, &chassis, &geoslot, &u) == 0)
352 return;
353 close_with_IOP(chassis, geoslot, LIVE);
354 if (u)
355 u->first_time = 0;
356 }
357
358 static void send_to_fd(int fd, int len, unsigned char *str) {
359 int nwritten;
360 int chassis, geoslot;
361
362 while (len > 0) {
363 if ((nwritten = write(fd, str, len)) <= 0) {
364 find_unit_by_fd(fd, &chassis, &geoslot, NULL);
365 if (units[chassis][geoslot].fd == fd) close_with_IOP(chassis, geoslot, LIVE);
366 else if (units[chassis][geoslot].find_fd == fd) close_with_IOP(chassis, geoslot, FIND);
367 empty_unit(chassis, geoslot);
368 return;
369 }
370 len -= nwritten;
371 str += nwritten;
372 }
373 }
374
375 static void acn_freealldevs(void) {
376
377 pcap_if_t *iff, *next_iff;
378 pcap_addr_t *addr, *next_addr;
379
380 for (iff = acn_if_list; iff != NULL; iff = next_iff) {
381 next_iff = iff->next;
382 for (addr = iff->addresses; addr != NULL; addr = next_addr) {
383 next_addr = addr->next;
384 if (addr->addr) free(addr->addr);
385 if (addr->netmask) free(addr->netmask);
386 if (addr->broadaddr) free(addr->broadaddr);
387 if (addr->dstaddr) free(addr->dstaddr);
388 free(addr);
389 }
390 if (iff->name) free(iff->name);
391 if (iff->description) free(iff->description);
392 free(iff);
393 }
394 }
395
396 static char *nonUnified_port_num(unit_t *u, int IOPportnum) {
397
398 sprintf(static_buf, "%d_%d", u->chassis, u->geoslot);
399 return static_buf;
400 }
401
402 static char *unified_port_num(unit_t *u, int IOPportnum) {
403 int portnum;
404
405 portnum = ((u->chassis - 1) * 64) + ((u->geoslot - 1) * 8) + IOPportnum + 1;
406 sprintf(static_buf, "%d", portnum);
407 return static_buf;
408 }
409
410 static char *translate_IOP_to_pcap_name(unit_t *u, char *IOPname, bpf_u_int32 iftype) {
411 iface_t *iface_ptr, *iface;
412 char *name;
413 char buf[32];
414 char *proto;
415 char *port;
416 int IOPportnum = 0;
417
418 iface = malloc(sizeof(iface_t)); /* get memory for a structure */
419 bzero((char *)iface, sizeof(iface_t));
420
421 iface->iftype = iftype; /* remember the interface type of this interface */
422
423 name = malloc(strlen(IOPname) + 1); /* get memory for the IOP's name */
424 strcpy(name, IOPname); /* and copy it in */
425 iface->IOPname = name; /* and stick it into the structure */
426
427 if (strncmp(IOPname, "lo", 2) == 0) {
428 IOPportnum = atoi(&IOPname[2]);
429 switch (iftype) {
430 case DLT_EN10MB: proto = "lo"; port = nonUnified_port_num(u, IOPportnum); break;
431 default: proto = "???"; port = unified_port_num(u, IOPportnum); break;
432 }
433 } else if (strncmp(IOPname, "eth", 3) == 0) {
434 IOPportnum = atoi(&IOPname[3]);
435 switch (iftype) {
436 case DLT_EN10MB: proto = "eth"; port = nonUnified_port_num(u, IOPportnum); break;
437 default: proto = "???"; port = unified_port_num(u, IOPportnum); break;
438 }
439 } else if (strncmp(IOPname, "wan", 3) == 0) {
440 IOPportnum = atoi(&IOPname[3]);
441 switch (iftype) {
442 case DLT_SITA: proto = "wan"; port = unified_port_num(u, IOPportnum); break;
443 default: proto = "???"; port = unified_port_num(u, IOPportnum); break;
444 }
445 }
446
447 sprintf(buf, "%s_%s", proto, port); /* compose the user's name for that IOP port name */
448 name = malloc(strlen(buf) + 1); /* get memory for that name */
449 strcpy(name, buf); /* and copy it in */
450 iface->name = name; /* and stick it into the structure */
451
452 if (u->iface == 0) { /* if this is the first name */
453 u->iface = iface; /* stick this entry at the head of the list */
454 } else {
455 iface_ptr = u->iface;
456 while (iface_ptr->next) { /* othewise scan the list */
457 iface_ptr = iface_ptr->next; /* till we're at the last entry */
458 }
459 iface_ptr->next = iface; /* then tack this entry on the end of the list */
460 }
461 return iface->name;
462 }
463
464 static int if_sort(char *s1, char *s2) {
465 char *s1_p2, *s2_p2;
466 char str1[MAX_LINE_SIZE], str2[MAX_LINE_SIZE];
467 int s1_p1_len, s2_p1_len;
468 int retval;
469
470 if ((s1_p2 = strchr(s1, '_'))) { /* if an underscore is found... */
471 s1_p1_len = s1_p2 - s1; /* the prefix length is the difference in pointers */
472 s1_p2++; /* the suffix actually starts _after_ the underscore */
473 } else { /* otherwise... */
474 s1_p1_len = strlen(s1); /* the prefix length is the length of the string itself */
475 s1_p2 = 0; /* and there is no suffix */
476 }
477 if ((s2_p2 = strchr(s2, '_'))) { /* now do the same for the second string */
478 s2_p1_len = s2_p2 - s2;
479 s2_p2++;
480 } else {
481 s2_p1_len = strlen(s2);
482 s2_p2 = 0;
483 }
484 strncpy(str1, s1, (s1_p1_len > sizeof(str1)) ? s1_p1_len : sizeof(str1)); *(str1 + s1_p1_len) = 0;
485 strncpy(str2, s2, (s2_p1_len > sizeof(str2)) ? s2_p1_len : sizeof(str2)); *(str2 + s2_p1_len) = 0;
486 retval = strcmp(str1, str2);
487 if (retval != 0) return retval; /* if they are not identical, then we can quit now and return the indication */
488 return strcmp(s1_p2, s2_p2); /* otherwise we return the result of comparing the 2nd half of the string */
489 }
490
491 static void sort_if_table(void) {
492 pcap_if_t *p1, *p2, *prev, *temp;
493 int has_swapped;
494
495 if (!acn_if_list) return; /* nothing to do if the list is empty */
496
497 while (1) {
498 p1 = acn_if_list; /* start at the head of the list */
499 prev = 0;
500 has_swapped = 0;
501 while ((p2 = p1->next)) {
502 if (if_sort(p1->name, p2->name) > 0) {
503 if (prev) { /* we are swapping things that are _not_ at the head of the list */
504 temp = p2->next;
505 prev->next = p2;
506 p2->next = p1;
507 p1->next = temp;
508 } else { /* special treatment if we are swapping with the head of the list */
509 temp = p2->next;
510 acn_if_list= p2;
511 p2->next = p1;
512 p1->next = temp;
513 }
514 p1 = p2;
515 prev = p1;
516 has_swapped = 1;
517 }
518 prev = p1;
519 p1 = p1->next;
520 }
521 if (has_swapped == 0)
522 return;
523 }
524 return;
525 }
526
527 static int process_client_data (char *errbuf) { /* returns: -1 = error, 0 = OK */
528 int chassis, geoslot;
529 unit_t *u;
530 pcap_if_t *iff, *prev_iff;
531 pcap_addr_t *addr, *prev_addr;
532 char *ptr;
533 int address_count;
534 struct sockaddr_in *s;
535 char *newname;
536 bpf_u_int32 interfaceType;
537 unsigned char flags;
538
539 prev_iff = 0;
540 for (chassis = 0; chassis <= MAX_CHASSIS; chassis++) {
541 for (geoslot = 0; geoslot <= MAX_GEOSLOT; geoslot++) { /* now loop over all the devices */
542 u = &units[chassis][geoslot];
543 empty_unit_iface(u);
544 ptr = u->imsg; /* point to the start of the msg for this IOP */
545 while (ptr < (u->imsg + u->len)) {
546 if ((iff = malloc(sizeof(pcap_if_t))) == NULL) {
547 snprintf(errbuf, PCAP_ERRBUF_SIZE, "malloc: %s", pcap_strerror(errno));
548 return -1;
549 }
550 bzero((char *)iff, sizeof(pcap_if_t));
551 if (acn_if_list == 0) acn_if_list = iff; /* remember the head of the list */
552 if (prev_iff) prev_iff->next = iff; /* insert a forward link */
553
554 if (*ptr) { /* if there is a count for the name */
555 if ((iff->name = malloc(*ptr + 1)) == NULL) { /* get that amount of space */
556 snprintf(errbuf, PCAP_ERRBUF_SIZE, "malloc: %s", pcap_strerror(errno));
557 return -1;
558 }
559 memcpy(iff->name, (ptr + 1), *ptr); /* copy the name into the malloc'ed space */
560 *(iff->name + *ptr) = 0; /* and null terminate the string */
561 ptr += *ptr; /* now move the pointer forwards by the length of the count plus the length of the string */
562 }
563 ptr++;
564
565 if (*ptr) { /* if there is a count for the description */
566 if ((iff->description = malloc(*ptr + 1)) == NULL) { /* get that amount of space */
567 snprintf(errbuf, PCAP_ERRBUF_SIZE, "malloc: %s", pcap_strerror(errno));
568 return -1;
569 }
570 memcpy(iff->description, (ptr + 1), *ptr); /* copy the name into the malloc'ed space */
571 *(iff->description + *ptr) = 0; /* and null terminate the string */
572 ptr += *ptr; /* now move the pointer forwards by the length of the count plus the length of the string */
573 }
574 ptr++;
575
576 interfaceType = ntohl(*(bpf_u_int32 *)ptr);
577 ptr += 4; /* skip over the interface type */
578
579 flags = *ptr++;
580 if (flags) iff->flags = PCAP_IF_LOOPBACK; /* if this is a loopback style interface, lets mark it as such */
581
582 address_count = *ptr++;
583
584 prev_addr = 0;
585 while (address_count--) {
586 if ((addr = malloc(sizeof(pcap_addr_t))) == NULL) {
587 snprintf(errbuf, PCAP_ERRBUF_SIZE, "malloc: %s", pcap_strerror(errno));
588 return -1;
589 }
590 bzero((char *)addr, sizeof(pcap_addr_t));
591 if (iff->addresses == 0) iff->addresses = addr;
592 if (prev_addr) prev_addr->next = addr; /* insert a forward link */
593 if (*ptr) { /* if there is a count for the address */
594 if ((s = malloc(sizeof(struct sockaddr_in))) == NULL) { /* get that amount of space */
595 snprintf(errbuf, PCAP_ERRBUF_SIZE, "malloc: %s", pcap_strerror(errno));
596 return -1;
597 }
598 bzero((char *)s, sizeof(struct sockaddr_in));
599 addr->addr = (struct sockaddr *)s;
600 s->sin_family = AF_INET;
601 s->sin_addr.s_addr = *(bpf_u_int32 *)(ptr + 1); /* copy the address in */
602 ptr += *ptr; /* now move the pointer forwards according to the specified length of the address */
603 }
604 ptr++; /* then forwards one more for the 'length of the address' field */
605 if (*ptr) { /* process any netmask */
606 if ((s = malloc(sizeof(struct sockaddr_in))) == NULL) {
607 snprintf(errbuf, PCAP_ERRBUF_SIZE, "malloc: %s", pcap_strerror(errno));
608 return -1;
609 }
610 bzero((char *)s, sizeof(struct sockaddr_in));
611 addr->netmask = (struct sockaddr *)s;
612 s->sin_family = AF_INET;
613 s->sin_addr.s_addr = *(bpf_u_int32*)(ptr + 1);
614 ptr += *ptr;
615 }
616 ptr++;
617 if (*ptr) { /* process any broadcast address */
618 if ((s = malloc(sizeof(struct sockaddr_in))) == NULL) {
619 snprintf(errbuf, PCAP_ERRBUF_SIZE, "malloc: %s", pcap_strerror(errno));
620 return -1;
621 }
622 bzero((char *)s, sizeof(struct sockaddr_in));
623 addr->broadaddr = (struct sockaddr *)s;
624 s->sin_family = AF_INET;
625 s->sin_addr.s_addr = *(bpf_u_int32*)(ptr + 1);
626 ptr += *ptr;
627 }
628 ptr++;
629 if (*ptr) { /* process any destination address */
630 if ((s = malloc(sizeof(struct sockaddr_in))) == NULL) {
631 snprintf(errbuf, PCAP_ERRBUF_SIZE, "malloc: %s", pcap_strerror(errno));
632 return -1;
633 }
634 bzero((char *)s, sizeof(struct sockaddr_in));
635 addr->dstaddr = (struct sockaddr *)s;
636 s->sin_family = AF_INET;
637 s->sin_addr.s_addr = *(bpf_u_int32*)(ptr + 1);
638 ptr += *ptr;
639 }
640 ptr++;
641 prev_addr = addr;
642 }
643 prev_iff = iff;
644
645 newname = translate_IOP_to_pcap_name(u, iff->name, interfaceType); /* add a translation entry and get a point to the mangled name */
646 if ((iff->name = realloc(iff->name, strlen(newname) + 1)) == NULL) { /* we now re-write the name stored in the interface list */
647 snprintf(errbuf, PCAP_ERRBUF_SIZE, "realloc: %s", pcap_strerror(errno));
648 return -1;
649 }
650 strcpy(iff->name, newname); /* to this new name */
651 }
652 }
653 }
654 return 0;
655 }
656
657 static int read_client_data (int fd) {
658 unsigned char buf[256];
659 int chassis, geoslot;
660 unit_t *u;
661 int len;
662
663 find_unit_by_fd(fd, &chassis, &geoslot, &u);
664
665 if ((len = recv(fd, buf, sizeof(buf), 0)) <= 0) return 0; /* read in whatever data was sent to us */
666
667 if ((u->imsg = realloc(u->imsg, (u->len + len))) == NULL) /* extend the buffer for the new data */
668 return 0;
669 memcpy((u->imsg + u->len), buf, len); /* append the new data */
670 u->len += len;
671 return 1;
672 }
673
674 static void wait_for_all_answers(void) {
675 int retval;
676 struct timeval tv;
677 int fd;
678 int chassis, geoslot;
679
680 tv.tv_sec = 2;
681 tv.tv_usec = 0;
682
683 while (1) {
684 int flag = 0;
685 for (fd = 0; fd <= max_fs; fd++) { /* scan the list of descriptors we may be listening to */
686 if (FD_ISSET(fd, &readfds)) flag = 1; /* and see if there are any still set */
687 }
688 if (flag == 0) return; /* we are done, when they are all gone */
689
690 memcpy(&working_set, &readfds, sizeof(readfds)); /* otherwise, we still have to listen for more stuff, till we timeout */
691 retval = select(max_fs + 1, &working_set, NULL, NULL, &tv);
692 if (retval == -1) { /* an error occured !!!!! */
693 return;
694 } else if (retval == 0) { /* timeout occured, so process what we've got sofar and return */
695 printf("timeout\n");
696 return;
697 } else {
698 for (fd = 0; fd <= max_fs; fd++) { /* scan the list of things to do, and do them */
699 if (FD_ISSET(fd, &working_set)) {
700 if (read_client_data(fd) == 0) { /* if the socket has closed */
701 FD_CLR(fd, &readfds); /* and descriptors we listen to for errors */
702 find_unit_by_fd(fd, &chassis, &geoslot, NULL);
703 close_with_IOP(chassis, geoslot, FIND); /* and close out connection to him */
704 }
705 }
706 }
707 }
708 }
709 }
710
711 static char *get_error_response(int fd, char *errbuf) { /* return a pointer on error, NULL on no error */
712 char byte;
713 int len = 0;
714
715 while (1) {
716 recv(fd, &byte, 1, 0); /* read another byte in */
717 if (errbuf && (len++ < PCAP_ERRBUF_SIZE)) { /* and if there is still room in the buffer */
718 *errbuf++ = byte; /* stick it in */
719 *errbuf = '\0'; /* ensure the string is null terminated just in case we might exceed the buffer's size */
720 }
721 if (byte == '\0') {
722 if (len > 1) { return errbuf; }
723 else { return NULL; }
724 }
725 }
726 }
727
728 int acn_findalldevs(char *errbuf) { /* returns: -1 = error, 0 = OK */
729 int chassis, geoslot;
730 unit_t *u;
731
732 FD_ZERO(&readfds);
733 max_fs = 0;
734 for (chassis = 0; chassis <= MAX_CHASSIS; chassis++) {
735 for (geoslot = 0; geoslot <= MAX_GEOSLOT; geoslot++) {
736 u = &units[chassis][geoslot];
737 if (u->ip && (open_with_IOP(u, FIND))) { /* connect to the remote IOP */
738 send_to_fd(u->find_fd, 1, (unsigned char *)"\0");
739 if (get_error_response(u->find_fd, errbuf))
740 close_with_IOP(chassis, geoslot, FIND);
741 else {
742 if (u->find_fd > max_fs)
743 max_fs = u->find_fd; /* remember the highest number currently in use */
744 FD_SET(u->find_fd, &readfds); /* we are going to want to read this guy's response to */
745 u->len = 0;
746 send_to_fd(u->find_fd, 1, (unsigned char *)"Q"); /* this interface query request */
747 }
748 }
749 }
750 }
751 wait_for_all_answers();
752 if (process_client_data(errbuf))
753 return -1;
754 sort_if_table();
755 return 0;
756 }
757
758 static int pcap_stats_acn(pcap_t *handle, struct pcap_stat *ps) {
759 unsigned char buf[12];
760
761 send_to_fd(handle->fd, 1, (unsigned char *)"S"); /* send the get_stats command to the IOP */
762
763 if (read_client_nbytes(handle->fd, sizeof(buf), buf) == -1) return -1; /* try reading the required bytes */
764
765 ps->ps_recv = ntohl(*(uint32_t *)&buf[0]); /* break the buffer into its three 32 bit components */
766 ps->ps_drop = ntohl(*(uint32_t *)&buf[4]);
767 ps->ps_ifdrop = ntohl(*(uint32_t *)&buf[8]);
768
769 return 0;
770 }
771
772 static int acn_open_live(const char *name, char *errbuf, int *linktype) { /* returns 0 on error, else returns the file descriptor */
773 int chassis, geoslot;
774 unit_t *u;
775 iface_t *p;
776 pcap_if_t *alldevsp;
777
778 pcap_findalldevs(&alldevsp, errbuf);
779 for (chassis = 0; chassis <= MAX_CHASSIS; chassis++) { /* scan the table... */
780 for (geoslot = 0; geoslot <= MAX_GEOSLOT; geoslot++) {
781 u = &units[chassis][geoslot];
782 if (u->ip != NULL) {
783 p = u->iface;
784 while (p) { /* and all interfaces... */
785 if (p->IOPname && p->name && (strcmp(p->name, name) == 0)) { /* and if we found the interface we want... */
786 *linktype = p->iftype;
787 open_with_IOP(u, LIVE); /* start a connection with that IOP */
788 send_to_fd(u->fd, strlen(p->IOPname)+1, (unsigned char *)p->IOPname); /* send the IOP's interface name, and a terminating null */
789 if (get_error_response(u->fd, errbuf)) {
790 return -1;
791 }
792 return u->fd; /* and return that open descriptor */
793 }
794 p = p->next;
795 }
796 }
797 }
798 }
799 return -1; /* if the interface wasn't found, return an error */
800 }
801
802 static void acn_start_monitor(int fd, int snaplen, int timeout, int promiscuous, int direction) {
803 unsigned char buf[8];
804 unit_t *u;
805
806 //printf("acn_start_monitor()\n"); // fulko
807 find_unit_by_fd(fd, NULL, NULL, &u);
808 if (u->first_time == 0) {
809 buf[0] = 'M';
810 *(uint32_t *)&buf[1] = htonl(snaplen);
811 buf[5] = timeout;
812 buf[6] = promiscuous;
813 buf[7] = direction;
814 //printf("acn_start_monitor() first time\n"); // fulko
815 send_to_fd(fd, 8, buf); /* send the start monitor command with its parameters to the IOP */
816 u->first_time = 1;
817 }
818 //printf("acn_start_monitor() complete\n"); // fulko
819 }
820
821 static int pcap_inject_acn(pcap_t *p, const void *buf _U_, size_t size _U_) {
822 strlcpy(p->errbuf, "Sending packets isn't supported on ACN adapters",
823 PCAP_ERRBUF_SIZE);
824 return (-1);
825 }
826
827 static int pcap_setfilter_acn(pcap_t *handle, struct bpf_program *bpf) {
828 int fd = handle->fd;
829 int count;
830 struct bpf_insn *p;
831 uint16_t shortInt;
832 uint32_t longInt;
833
834 send_to_fd(fd, 1, (unsigned char *)"F"); /* BPF filter follows command */
835 count = bpf->bf_len;
836 longInt = htonl(count);
837 send_to_fd(fd, 4, (unsigned char *)&longInt); /* send the instruction sequence count */
838 p = bpf->bf_insns;
839 while (count--) { /* followed by the list of instructions */
840 shortInt = htons(p->code);
841 longInt = htonl(p->k);
842 send_to_fd(fd, 2, (unsigned char *)&shortInt);
843 send_to_fd(fd, 1, (unsigned char *)&p->jt);
844 send_to_fd(fd, 1, (unsigned char *)&p->jf);
845 send_to_fd(fd, 4, (unsigned char *)&longInt);
846 p++;
847 }
848 if (get_error_response(fd, NULL))
849 return -1;
850 return 0;
851 }
852
853 static int pcap_setdirection_acn(pcap_t *handle, pcap_direction_t d) {
854 snprintf(handle->errbuf, sizeof(handle->errbuf),
855 "Setting direction is not supported on ACN adapters");
856 return -1;
857 }
858
859 static int acn_read_n_bytes_with_timeout(pcap_t *handle, int count) {
860 struct timeval tv;
861 int retval, fd;
862 fd_set r_fds;
863 fd_set w_fds;
864 u_char *bp;
865 int len = 0;
866 int offset = 0;
867
868 tv.tv_sec = 5;
869 tv.tv_usec = 0;
870
871 fd = handle->fd;
872 FD_ZERO(&r_fds);
873 FD_SET(fd, &r_fds);
874 memcpy(&w_fds, &r_fds, sizeof(r_fds));
875 bp = handle->bp;
876 while (count) {
877 retval = select(fd + 1, &w_fds, NULL, NULL, &tv);
878 if (retval == -1) { /* an error occured !!!!! */
879 // fprintf(stderr, "error during packet data read\n");
880 return -1; /* but we need to return a good indication to prevent unneccessary popups */
881 } else if (retval == 0) { /* timeout occured, so process what we've got sofar and return */
882 // fprintf(stderr, "timeout during packet data read\n");
883 return -1;
884 } else {
885 if ((len = recv(fd, (bp + offset), count, 0)) <= 0) {
886 // fprintf(stderr, "premature exit during packet data rx\n");
887 return -1;
888 }
889 count -= len;
890 offset += len;
891 }
892 }
893 return 0;
894 }
895
896 static int pcap_read_acn(pcap_t *handle, int max_packets, pcap_handler callback, u_char *user) {
897 #define HEADER_SIZE (4 * 4)
898 unsigned char packet_header[HEADER_SIZE];
899 struct pcap_pkthdr pcap_header;
900
901 //printf("pcap_read_acn()\n"); // fulko
902 acn_start_monitor(handle->fd, handle->snapshot, handle->md.timeout, handle->md.clear_promisc, handle->direction); /* maybe tell him to start monitoring */
903 //printf("pcap_read_acn() after start monitor\n"); // fulko
904
905 handle->bp = packet_header;
906 if (acn_read_n_bytes_with_timeout(handle, HEADER_SIZE) == -1) return 0; /* try to read a packet header in so we can get the sizeof the packet data */
907
908 pcap_header.ts.tv_sec = ntohl(*(uint32_t *)&packet_header[0]); /* tv_sec */
909 pcap_header.ts.tv_usec = ntohl(*(uint32_t *)&packet_header[4]); /* tv_usec */
910 pcap_header.caplen = ntohl(*(uint32_t *)&packet_header[8]); /* caplen */
911 pcap_header.len = ntohl(*(uint32_t *)&packet_header[12]); /* len */
912
913 handle->bp = handle->buffer + handle->offset; /* start off the receive pointer at the right spot */
914 if (acn_read_n_bytes_with_timeout(handle, pcap_header.caplen) == -1) return 0; /* then try to read in the rest of the data */
915
916 callback(user, &pcap_header, handle->bp); /* call the user supplied callback function */
917 return 1;
918 }
919
920 pcap_t *pcap_open_live(const char *device, int snaplen, int promisc, int to_ms, char *ebuf) {
921 pcap_t *handle;
922 int fd;
923
924 /* Allocate a handle for this session. */
925
926 handle = malloc(sizeof(*handle));
927 if (handle == NULL) {
928 snprintf(ebuf, PCAP_ERRBUF_SIZE, "malloc: %s",
929 pcap_strerror(errno));
930 return NULL;
931 }
932
933 /* Initialize some components of the pcap structure. */
934
935 memset(handle, 0, sizeof(*handle));
936 handle->snapshot = snaplen;
937 handle->md.timeout = to_ms;
938
939 handle->inject_op = pcap_inject_acn;
940 handle->setfilter_op = pcap_setfilter_acn;
941 handle->setdirection_op = pcap_setdirection_acn;
942 handle->set_datalink_op = NULL; /* can't change data link type */
943 handle->getnonblock_op = pcap_getnonblock_fd;
944 handle->setnonblock_op = pcap_setnonblock_fd;
945 handle->close_op = pcap_close_acn;
946 handle->read_op = pcap_read_acn;
947 handle->stats_op = pcap_stats_acn;
948
949 fd = acn_open_live(device, ebuf, &handle->linktype);
950 if (fd == -1) {
951 free(handle);
952 return NULL;
953 }
954 handle->md.clear_promisc = promisc;
955 handle->fd = fd;
956 handle->bufsize = handle->snapshot;
957
958 /* Allocate the buffer */
959
960 handle->buffer = malloc(handle->bufsize + handle->offset);
961 if (!handle->buffer) {
962 snprintf(ebuf, PCAP_ERRBUF_SIZE,
963 "malloc: %s", pcap_strerror(errno));
964 pcap_close_acn(handle);
965 free(handle);
966 return NULL;
967 }
968
969 /*
970 * "handle->fd" is a socket, so "select()" and "poll()"
971 * should work on it.
972 */
973 handle->selectable_fd = handle->fd;
974
975 return handle;
976 }
[mirror] the LIBpcap interface to various kernel packet capture mechanism