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