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