contrib/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 #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_snprintf(errbuf, PCAP_ERRBUF_SIZE, "malloc: %s", pcap_strerror(errno));
 297                         continue;
 298                 }
 299                 strcpy(ptr2, ptr);                                                              /* copy the IP address into our malloc'ed memory */
 300                 u = &units[chassis][geoslot];
 301                 u->ip = ptr2;                                                                   /* and remember the whole shebang */
 302                 u->chassis = chassis;
 303                 u->geoslot = geoslot;
 304         }
 305         fclose(fp);
 306         if (*errbuf)    return -1;
 307         else                    return 0;
 308 }
 309
 310 static int open_with_IOP(unit_t  *u, int flag) {
 311         int                                     sockfd;
 312         char                            *ip;
 313
 314         if (u->serv_addr == NULL) {
 315                 u->serv_addr = malloc(sizeof(struct sockaddr_in));
 316
 317                 /* since we called malloc(), lets check to see if we actually got the memory    */
 318                 if (u->serv_addr == NULL) {     /* oops, we didn't get the memory requested     */
 319                         fprintf(stderr, "malloc() request for u->serv_addr failed, value of errno is: %d\n", errno);
 320                         return 0;
 321                 }
 322
 323         }
 324         ip = u->ip;
 325         /* bzero() is deprecated, replaced with memset()        */
 326         memset((char *)u->serv_addr, 0, sizeof(struct sockaddr_in));
 327         u->serv_addr->sin_family                = AF_INET;
 328         u->serv_addr->sin_addr.s_addr   = inet_addr(ip);
 329         u->serv_addr->sin_port                  = htons(IOP_SNIFFER_PORT);
 330
 331         if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
 332                 fprintf(stderr, "pcap can't open a socket for connecting to IOP at %s\n", ip);
 333                 return 0;
 334         }
 335         if (connect(sockfd, (struct sockaddr *)u->serv_addr, sizeof(struct sockaddr_in)) < 0) {
 336                 fprintf(stderr, "pcap can't connect to IOP at %s\n", ip);
 337                 return 0;
 338         }
 339         if (flag == LIVE)       u->fd = sockfd;
 340         else                            u->find_fd = sockfd;
 341         u->first_time = 0;
 342         return sockfd;                  /* return the non-zero file descriptor as a 'success' indicator */
 343 }
 344
 345 static void close_with_IOP(int chassis, int geoslot, int flag) {
 346         int             *id;
 347
 348         if (flag == LIVE)       id = &units[chassis][geoslot].fd;
 349         else                            id = &units[chassis][geoslot].find_fd;
 350
 351         if (*id) {                                                                              /* this was the last time, so... if we are connected... */
 352                 close(*id);                                                                     /* disconnect us */
 353                 *id = 0;                                                                        /* and forget that the descriptor exists because we are not open */
 354         }
 355 }
 356
 357 static void pcap_cleanup_acn(pcap_t *handle) {
 358         int             chassis, geoslot;
 359         unit_t  *u;
 360
 361         if (find_unit_by_fd(handle->fd, &chassis, &geoslot, &u) == 0)
 362                 return;
 363         close_with_IOP(chassis, geoslot, LIVE);
 364         if (u)
 365                 u->first_time = 0;
 366         pcap_cleanup_live_common(handle);
 367 }
 368
 369 static void send_to_fd(int fd, int len, unsigned char *str) {
 370         int             nwritten;
 371         int             chassis, geoslot;
 372
 373         while (len > 0) {
 374                 if ((nwritten = write(fd, str, len)) <= 0) {
 375                         find_unit_by_fd(fd, &chassis, &geoslot, NULL);
 376                         if (units[chassis][geoslot].fd == fd)                   close_with_IOP(chassis, geoslot, LIVE);
 377                         else if (units[chassis][geoslot].find_fd == fd) close_with_IOP(chassis, geoslot, FIND);
 378                         empty_unit(chassis, geoslot);
 379                         return;
 380                 }
 381                 len -= nwritten;
 382                 str += nwritten;
 383         }
 384 }
 385
 386 static void acn_freealldevs(void) {
 387
 388         pcap_if_t       *iff, *next_iff;
 389         pcap_addr_t     *addr, *next_addr;
 390
 391         for (iff = acn_if_list; iff != NULL; iff = next_iff) {
 392                 next_iff = iff->next;
 393                 for (addr = iff->addresses; addr != NULL; addr = next_addr) {
 394                         next_addr = addr->next;
 395                         if (addr->addr)                 free(addr->addr);
 396                         if (addr->netmask)              free(addr->netmask);
 397                         if (addr->broadaddr)    free(addr->broadaddr);
 398                         if (addr->dstaddr)              free(addr->dstaddr);
 399                         free(addr);
 400                 }
 401                 if (iff->name)                  free(iff->name);
 402                 if (iff->description)   free(iff->description);
 403                 free(iff);
 404         }
 405 }
 406
 407 static void nonUnified_IOP_port_name(char *buf, size_t bufsize, const char *proto, unit_t *u) {
 408
 409         pcap_snprintf(buf, bufsize, "%s_%d_%d", proto, u->chassis, u->geoslot);
 410 }
 411
 412 static void unified_IOP_port_name(char *buf, size_t bufsize, const char *proto, unit_t *u, int IOPportnum) {
 413         int                     portnum;
 414
 415         portnum = ((u->chassis - 1) * 64) + ((u->geoslot - 1) * 8) + IOPportnum + 1;
 416         pcap_snprintf(buf, bufsize, "%s_%d", proto, portnum);
 417 }
 418
 419 static char *translate_IOP_to_pcap_name(unit_t *u, char *IOPname, bpf_u_int32 iftype) {
 420         iface_t         *iface_ptr, *iface;
 421         char            *name;
 422         char            buf[32];
 423         char            *proto;
 424         char            *port;
 425         int                     IOPportnum = 0;
 426
 427         iface = malloc(sizeof(iface_t));                /* get memory for a structure */
 428         if (iface == NULL) {    /* oops, we didn't get the memory requested     */
 429                 fprintf(stderr, "Error...couldn't allocate memory for interface structure...value of errno is: %d\n", errno);
 430                 return NULL;
 431         }
 432         memset((char *)iface, 0, sizeof(iface_t));      /* bzero is deprecated(), replaced with memset() */
 433
 434         iface->iftype = iftype;                                 /* remember the interface type of this interface */
 435
 436         name = malloc(strlen(IOPname) + 1);             /* get memory for the IOP's name */
 437         if (name == NULL) {    /* oops, we didn't get the memory requested     */
 438                 fprintf(stderr, "Error...couldn't allocate memory for IOPname...value of errno is: %d\n", errno);
 439                 return NULL;
 440         }
 441
 442         strcpy(name, IOPname);                                  /* and copy it in */
 443         iface->IOPname = name;                                  /* and stick it into the structure */
 444
 445         if (strncmp(IOPname, "lo", 2) == 0) {
 446                 IOPportnum = atoi(&IOPname[2]);
 447                 switch (iftype) {
 448                         case DLT_EN10MB:
 449                                 nonUnified_IOP_port_name(buf, sizeof buf, "lo", u);
 450                                 break;
 451                         default:
 452                                 unified_IOP_port_name(buf, sizeof buf, "???", u, IOPportnum);
 453                                 break;
 454                 }
 455         } else if (strncmp(IOPname, "eth", 3) == 0) {
 456                 IOPportnum = atoi(&IOPname[3]);
 457                 switch (iftype) {
 458                         case DLT_EN10MB:
 459                                 nonUnified_IOP_port_name(buf, sizeof buf, "eth", u);
 460                                 break;
 461                         default:
 462                                 unified_IOP_port_name(buf, sizeof buf, "???", u, IOPportnum);
 463                                 break;
 464                 }
 465         } else if (strncmp(IOPname, "wan", 3) == 0) {
 466                 IOPportnum = atoi(&IOPname[3]);
 467                 switch (iftype) {
 468                         case DLT_SITA:
 469                                 unified_IOP_port_name(buf, sizeof buf, "wan", u, IOPportnum);
 470                                 break;
 471                         default:
 472                                 unified_IOP_port_name(buf, sizeof buf, "???", u, IOPportnum);
 473                                 break;
 474                 }
 475         } else {
 476                 fprintf(stderr, "Error... invalid IOP name %s\n", IOPname);
 477                 return NULL;
 478         }
 479
 480         name = malloc(strlen(buf) + 1);                 /* get memory for that name */
 481         if (name == NULL) {    /* oops, we didn't get the memory requested     */
 482                 fprintf(stderr, "Error...couldn't allocate memory for IOP port name...value of errno is: %d\n", errno);
 483                 return NULL;
 484         }
 485
 486         strcpy(name, buf);                                              /* and copy it in */
 487         iface->name = name;                                             /* and stick it into the structure */
 488
 489         if (u->iface == 0) {                                    /* if this is the first name */
 490                 u->iface = iface;                                       /* stick this entry at the head of the list */
 491         } else {
 492                 iface_ptr = u->iface;
 493                 while (iface_ptr->next) {                       /* othewise scan the list */
 494                         iface_ptr = iface_ptr->next;    /* till we're at the last entry */
 495                 }
 496                 iface_ptr->next = iface;                        /* then tack this entry on the end of the list */
 497         }
 498         return iface->name;
 499 }
 500
 501 static int if_sort(char *s1, char *s2) {
 502         char    *s1_p2, *s2_p2;
 503         char    str1[MAX_LINE_SIZE], str2[MAX_LINE_SIZE];
 504         int             s1_p1_len, s2_p1_len;
 505         int             retval;
 506
 507         if ((s1_p2 = strchr(s1, '_'))) {        /* if an underscore is found... */
 508                 s1_p1_len = s1_p2 - s1;                 /* the prefix length is the difference in pointers */
 509                 s1_p2++;                                                /* the suffix actually starts _after_ the underscore */
 510         } else {                                                        /* otherwise... */
 511                 s1_p1_len = strlen(s1);                 /* the prefix length is the length of the string itself */
 512                 s1_p2 = 0;                                              /* and there is no suffix */
 513         }
 514         if ((s2_p2 = strchr(s2, '_'))) {        /* now do the same for the second string */
 515                 s2_p1_len = s2_p2 - s2;
 516                 s2_p2++;
 517         } else {
 518                 s2_p1_len = strlen(s2);
 519                 s2_p2 = 0;
 520         }
 521         strncpy(str1, s1, (s1_p1_len > sizeof(str1)) ? s1_p1_len : sizeof(str1));   *(str1 + s1_p1_len) = 0;
 522         strncpy(str2, s2, (s2_p1_len > sizeof(str2)) ? s2_p1_len : sizeof(str2));   *(str2 + s2_p1_len) = 0;
 523         retval = strcmp(str1, str2);
 524         if (retval != 0) return retval;         /* if they are not identical, then we can quit now and return the indication */
 525         return strcmp(s1_p2, s2_p2);            /* otherwise we return the result of comparing the 2nd half of the string */
 526 }
 527
 528 static void sort_if_table(void) {
 529         pcap_if_t       *p1, *p2, *prev, *temp;
 530         int                     has_swapped;
 531
 532         if (!acn_if_list) return;                               /* nothing to do if the list is empty */
 533
 534         while (1) {
 535                 p1 = acn_if_list;                                       /* start at the head of the list */
 536                 prev = 0;
 537                 has_swapped = 0;
 538                 while ((p2 = p1->next)) {
 539                         if (if_sort(p1->name, p2->name) > 0) {
 540                                 if (prev) {                                     /* we are swapping things that are _not_ at the head of the list */
 541                                         temp = p2->next;
 542                                         prev->next = p2;
 543                                         p2->next = p1;
 544                                         p1->next = temp;
 545                                 } else {                                        /* special treatment if we are swapping with the head of the list */
 546                                         temp = p2->next;
 547                                         acn_if_list= p2;
 548                                         p2->next = p1;
 549                                         p1->next = temp;
 550                                 }
 551                                 p1 = p2;
 552                                 prev = p1;
 553                                 has_swapped = 1;
 554                         }
 555                         prev = p1;
 556                         p1 = p1->next;
 557                 }
 558                 if (has_swapped == 0)
 559                         return;
 560         }
 561         return;
 562 }
 563
 564 static int process_client_data (char *errbuf) {                                                         /* returns: -1 = error, 0 = OK */
 565         int                                     chassis, geoslot;
 566         unit_t                          *u;
 567         pcap_if_t                       *iff, *prev_iff;
 568         pcap_addr_t                     *addr, *prev_addr;
 569         char                            *ptr;
 570         int                                     address_count;
 571         struct sockaddr_in      *s;
 572         char                            *newname;
 573         bpf_u_int32                             interfaceType;
 574         unsigned char           flags;
 575         void *bigger_buffer;
 576
 577         prev_iff = 0;
 578         for (chassis = 0; chassis <= MAX_CHASSIS; chassis++) {
 579                 for (geoslot = 0; geoslot <= MAX_GEOSLOT; geoslot++) {                          /* now loop over all the devices */
 580                         u = &units[chassis][geoslot];
 581                         empty_unit_iface(u);
 582                         ptr = u->imsg;                                                                                                  /* point to the start of the msg for this IOP */
 583                         while (ptr < (u->imsg + u->len)) {
 584                                 if ((iff = malloc(sizeof(pcap_if_t))) == NULL) {
 585                                         pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE, "malloc: %s", pcap_strerror(errno));
 586                                         return -1;
 587                                 }
 588                                 memset((char *)iff, 0, sizeof(pcap_if_t)); /* bzero() is deprecated, replaced with memset() */
 589                                 if (acn_if_list == 0)   acn_if_list = iff;                                      /* remember the head of the list */
 590                                 if (prev_iff)                   prev_iff->next = iff;                           /* insert a forward link */
 591
 592                                 if (*ptr) {                                                                                                     /* if there is a count for the name */
 593                                         if ((iff->name = malloc(*ptr + 1)) == NULL) {                   /* get that amount of space */
 594                                                 pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE, "malloc: %s", pcap_strerror(errno));
 595                                                 return -1;
 596                                         }
 597                                         memcpy(iff->name, (ptr + 1), *ptr);                                             /* copy the name into the malloc'ed space */
 598                                         *(iff->name + *ptr) = 0;                                                                /* and null terminate the string */
 599                                         ptr += *ptr;                                                                                    /* now move the pointer forwards by the length of the count plus the length of the string */
 600                                 }
 601                                 ptr++;
 602
 603                                 if (*ptr) {                                                                                                     /* if there is a count for the description */
 604                                         if ((iff->description = malloc(*ptr + 1)) == NULL) {    /* get that amount of space */
 605                                                 pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE, "malloc: %s", pcap_strerror(errno));
 606                                                 return -1;
 607                                         }
 608                                         memcpy(iff->description, (ptr + 1), *ptr);                              /* copy the name into the malloc'ed space */
 609                                         *(iff->description + *ptr) = 0;                                                 /* and null terminate the string */
 610                                         ptr += *ptr;                                                                                    /* now move the pointer forwards by the length of the count plus the length of the string */
 611                                 }
 612                                 ptr++;
 613
 614                                 interfaceType = ntohl(*(bpf_u_int32 *)ptr);
 615                                 ptr += 4;                                                                                                       /* skip over the interface type */
 616
 617                                 flags = *ptr++;
 618                                 if (flags) iff->flags = PCAP_IF_LOOPBACK;                                       /* if this is a loopback style interface, lets mark it as such */
 619
 620                                 address_count = *ptr++;
 621
 622                                 prev_addr = 0;
 623                                 while (address_count--) {
 624                                         if ((addr = malloc(sizeof(pcap_addr_t))) == NULL) {
 625                                                 pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE, "malloc: %s", pcap_strerror(errno));
 626                                                 return -1;
 627                                         }
 628                                         memset((char *)addr, 0, sizeof(pcap_addr_t)); /* bzero() is deprecated, replaced with memset() */
 629                                         if (iff->addresses == 0) iff->addresses = addr;
 630                                         if (prev_addr) prev_addr->next = addr;                                                  /* insert a forward link */
 631                                         if (*ptr) {                                                                                                             /* if there is a count for the address */
 632                                                 if ((s = malloc(sizeof(struct sockaddr_in))) == NULL) {         /* get that amount of space */
 633                                                         pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE, "malloc: %s", pcap_strerror(errno));
 634                                                         return -1;
 635                                                 }
 636                                                 memset((char *)s, 0, sizeof(struct sockaddr_in)); /* bzero() is deprecated, replaced with memset() */
 637                                                 addr->addr = (struct sockaddr *)s;
 638                                                 s->sin_family           = AF_INET;
 639                                                 s->sin_addr.s_addr      = *(bpf_u_int32 *)(ptr + 1);                    /* copy the address in */
 640                                                 ptr += *ptr;                                                                            /* now move the pointer forwards according to the specified length of the address */
 641                                         }
 642                                         ptr++;                                                                                                  /* then forwards one more for the 'length of the address' field */
 643                                         if (*ptr) {                                                                                             /* process any netmask */
 644                                                 if ((s = malloc(sizeof(struct sockaddr_in))) == NULL) {
 645                                                         pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE, "malloc: %s", pcap_strerror(errno));
 646                                                         return -1;
 647                                                 }
 648                                                 /* bzero() is deprecated, replaced with memset() */
 649                                                 memset((char *)s, 0, sizeof(struct sockaddr_in));
 650
 651                                                 addr->netmask = (struct sockaddr *)s;
 652                                                 s->sin_family           = AF_INET;
 653                                                 s->sin_addr.s_addr      = *(bpf_u_int32*)(ptr + 1);
 654                                                 ptr += *ptr;
 655                                         }
 656                                         ptr++;
 657                                         if (*ptr) {                                                                                             /* process any broadcast address */
 658                                                 if ((s = malloc(sizeof(struct sockaddr_in))) == NULL) {
 659                                                         pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE, "malloc: %s", pcap_strerror(errno));
 660                                                         return -1;
 661                                                 }
 662                                                 /* bzero() is deprecated, replaced with memset() */
 663                                                 memset((char *)s, 0, sizeof(struct sockaddr_in));
 664
 665                                                 addr->broadaddr = (struct sockaddr *)s;
 666                                                 s->sin_family           = AF_INET;
 667                                                 s->sin_addr.s_addr      = *(bpf_u_int32*)(ptr + 1);
 668                                                 ptr += *ptr;
 669                                         }
 670                                         ptr++;
 671                                         if (*ptr) {                                                                                             /* process any destination address */
 672                                                 if ((s = malloc(sizeof(struct sockaddr_in))) == NULL) {
 673                                                         pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE, "malloc: %s", pcap_strerror(errno));
 674                                                         return -1;
 675                                                 }
 676                                                 /* bzero() is deprecated, replaced with memset() */
 677                                                 memset((char *)s, 0, sizeof(struct sockaddr_in));
 678
 679                                                 addr->dstaddr = (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                                         prev_addr = addr;
 686                                 }
 687                                 prev_iff = iff;
 688
 689                                 newname = translate_IOP_to_pcap_name(u, iff->name, interfaceType);              /* add a translation entry and get a point to the mangled name */
 690                                 bigger_buffer = realloc(iff->name, strlen(newname) + 1));
 691                                 if (bigger_buffer == NULL) {    /* we now re-write the name stored in the interface list */
 692                                         pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE, "realloc: %s", pcap_strerror(errno));
 693                                         return -1;
 694                                 }
 695                                 iff->name = bigger_buffer;
 696                                 strcpy(iff->name, newname);                                                                                             /* to this new name */
 697                         }
 698                 }
 699         }
 700         return 0;
 701 }
 702
 703 static int read_client_data (int fd) {
 704         unsigned char   buf[256];
 705         int                             chassis, geoslot;
 706         unit_t                  *u;
 707         int                             len;
 708
 709         find_unit_by_fd(fd, &chassis, &geoslot, &u);
 710
 711         if ((len = recv(fd, buf, sizeof(buf), 0)) <= 0) return 0;       /* read in whatever data was sent to us */
 712
 713         if ((u->imsg = realloc(u->imsg, (u->len + len))) == NULL)       /* extend the buffer for the new data */
 714                 return 0;
 715         memcpy((u->imsg + u->len), buf, len);                                           /* append the new data */
 716         u->len += len;
 717         return 1;
 718 }
 719
 720 static void wait_for_all_answers(void) {
 721         int             retval;
 722         struct  timeval tv;
 723         int             fd;
 724         int             chassis, geoslot;
 725
 726         tv.tv_sec = 2;
 727         tv.tv_usec = 0;
 728
 729         while (1) {
 730                 int flag = 0;
 731                 fd_set working_set;
 732
 733                 for (fd = 0; fd <= max_fs; fd++) {                                                              /* scan the list of descriptors we may be listening to */
 734                         if (FD_ISSET(fd, &readfds)) flag = 1;                                           /* and see if there are any still set */
 735                 }
 736                 if (flag == 0) return;                                                                                  /* we are done, when they are all gone */
 737
 738                 memcpy(&working_set, &readfds, sizeof(readfds));                                /* otherwise, we still have to listen for more stuff, till we timeout */
 739                 retval = select(max_fs + 1, &working_set, NULL, NULL, &tv);
 740                 if (retval == -1) {                                                                                             /* an error occured !!!!! */
 741                         return;
 742                 } else if (retval == 0) {                                                                               /* timeout occured, so process what we've got sofar and return */
 743                         printf("timeout\n");
 744                         return;
 745                 } else {
 746                         for (fd = 0; fd <= max_fs; fd++) {                                                      /* scan the list of things to do, and do them */
 747                                 if (FD_ISSET(fd, &working_set)) {
 748                                         if (read_client_data(fd) == 0) {                                        /* if the socket has closed */
 749                                                 FD_CLR(fd, &readfds);                                                   /* and descriptors we listen to for errors */
 750                                                 find_unit_by_fd(fd, &chassis, &geoslot, NULL);
 751                                                 close_with_IOP(chassis, geoslot, FIND);                 /* and close out connection to him */
 752                                         }
 753                                 }
 754                         }
 755                 }
 756         }
 757 }
 758
 759 static char *get_error_response(int fd, char *errbuf) {         /* return a pointer on error, NULL on no error */
 760         char    byte;
 761         int             len = 0;
 762
 763         while (1) {
 764                 recv(fd, &byte, 1, 0);                                                  /* read another byte in */
 765                 if (errbuf && (len++ < PCAP_ERRBUF_SIZE)) {             /* and if there is still room in the buffer */
 766                         *errbuf++ = byte;                                                       /* stick it in */
 767                         *errbuf = '\0';                                                         /* ensure the string is null terminated just in case we might exceed the buffer's size */
 768                 }
 769                 if (byte == '\0') {
 770                         if (len > 1)    { return errbuf;        }
 771                         else                    { return NULL;          }
 772                 }
 773         }
 774 }
 775
 776 int acn_findalldevs(char *errbuf) {                                                             /* returns: -1 = error, 0 = OK */
 777         int             chassis, geoslot;
 778         unit_t  *u;
 779
 780         FD_ZERO(&readfds);
 781         max_fs = 0;
 782         for (chassis = 0; chassis <= MAX_CHASSIS; chassis++) {
 783                 for (geoslot = 0; geoslot <= MAX_GEOSLOT; geoslot++) {
 784                         u = &units[chassis][geoslot];
 785                         if (u->ip && (open_with_IOP(u, FIND))) {                        /* connect to the remote IOP */
 786                                 send_to_fd(u->find_fd, 1, (unsigned char *)"\0");
 787                                 if (get_error_response(u->find_fd, errbuf))
 788                                         close_with_IOP(chassis, geoslot, FIND);
 789                                 else {
 790                                         if (u->find_fd > max_fs)
 791                                                 max_fs = u->find_fd;                                                            /* remember the highest number currently in use */
 792                                         FD_SET(u->find_fd, &readfds);                                           /* we are going to want to read this guy's response to */
 793                                         u->len = 0;
 794                                         send_to_fd(u->find_fd, 1, (unsigned char *)"Q");                /* this interface query request */
 795                                 }
 796                         }
 797                 }
 798         }
 799         wait_for_all_answers();
 800         if (process_client_data(errbuf))
 801                 return -1;
 802         sort_if_table();
 803         return 0;
 804 }
 805
 806 static int pcap_stats_acn(pcap_t *handle, struct pcap_stat *ps) {
 807         unsigned char   buf[12];
 808
 809         send_to_fd(handle->fd, 1, (unsigned char *)"S");                                                /* send the get_stats command to the IOP */
 810
 811         if (read_client_nbytes(handle->fd, sizeof(buf), buf) == -1) return -1;  /* try reading the required bytes */
 812
 813         ps->ps_recv             = ntohl(*(uint32_t *)&buf[0]);                                                  /* break the buffer into its three 32 bit components */
 814         ps->ps_drop             = ntohl(*(uint32_t *)&buf[4]);
 815         ps->ps_ifdrop   = ntohl(*(uint32_t *)&buf[8]);
 816
 817         return 0;
 818 }
 819
 820 static int acn_open_live(const char *name, char *errbuf, int *linktype) {               /* returns 0 on error, else returns the file descriptor */
 821         int                     chassis, geoslot;
 822         unit_t          *u;
 823         iface_t         *p;
 824         pcap_if_t       *alldevsp;
 825
 826         pcap_platform_finddevs(&alldevsp, errbuf);
 827         for (chassis = 0; chassis <= MAX_CHASSIS; chassis++) {                                                                          /* scan the table... */
 828                 for (geoslot = 0; geoslot <= MAX_GEOSLOT; geoslot++) {
 829                         u = &units[chassis][geoslot];
 830                         if (u->ip != NULL) {
 831                                 p = u->iface;
 832                                 while (p) {                                                                                                                                             /* and all interfaces... */
 833                                         if (p->IOPname && p->name && (strcmp(p->name, name) == 0)) {                            /* and if we found the interface we want... */
 834                                                 *linktype = p->iftype;
 835                                                 open_with_IOP(u, LIVE);                                                                                                 /* start a connection with that IOP */
 836                                                 send_to_fd(u->fd, strlen(p->IOPname)+1, (unsigned char *)p->IOPname);   /* send the IOP's interface name, and a terminating null */
 837                                                 if (get_error_response(u->fd, errbuf)) {
 838                                                         return -1;
 839                                                 }
 840                                                 return u->fd;                                                                                                                   /* and return that open descriptor */
 841                                         }
 842                                         p = p->next;
 843                                 }
 844                         }
 845                 }
 846         }
 847         return -1;                                                                                                                                                              /* if the interface wasn't found, return an error */
 848 }
 849
 850 static void acn_start_monitor(int fd, int snaplen, int timeout, int promiscuous, int direction) {
 851         unsigned char   buf[8];
 852         unit_t                  *u;
 853
 854         //printf("acn_start_monitor()\n");                              // fulko
 855         find_unit_by_fd(fd, NULL, NULL, &u);
 856         if (u->first_time == 0) {
 857                 buf[0]                                  = 'M';
 858                 *(uint32_t *)&buf[1]    = htonl(snaplen);
 859                 buf[5]                                  = timeout;
 860                 buf[6]                                  = promiscuous;
 861                 buf[7]                                  = direction;
 862         //printf("acn_start_monitor() first time\n");                           // fulko
 863                 send_to_fd(fd, 8, buf);                                                         /* send the start monitor command with its parameters to the IOP */
 864                 u->first_time = 1;
 865         }
 866         //printf("acn_start_monitor() complete\n");                             // fulko
 867 }
 868
 869 static int pcap_inject_acn(pcap_t *p, const void *buf _U_, size_t size _U_) {
 870         strlcpy(p->errbuf, "Sending packets isn't supported on ACN adapters",
 871             PCAP_ERRBUF_SIZE);
 872         return (-1);
 873 }
 874
 875 static int pcap_setfilter_acn(pcap_t *handle, struct bpf_program *bpf) {
 876         int                             fd = handle->fd;
 877         int                             count;
 878         struct bpf_insn *p;
 879         uint16_t                shortInt;
 880         uint32_t                longInt;
 881
 882         send_to_fd(fd, 1, (unsigned char *)"F");                        /* BPF filter follows command */
 883         count = bpf->bf_len;
 884         longInt = htonl(count);
 885         send_to_fd(fd, 4, (unsigned char *)&longInt);           /* send the instruction sequence count */
 886         p = bpf->bf_insns;
 887         while (count--) {                                                                       /* followed by the list of instructions */
 888                 shortInt = htons(p->code);
 889                 longInt = htonl(p->k);
 890                 send_to_fd(fd, 2, (unsigned char *)&shortInt);
 891                 send_to_fd(fd, 1, (unsigned char *)&p->jt);
 892                 send_to_fd(fd, 1, (unsigned char *)&p->jf);
 893                 send_to_fd(fd, 4, (unsigned char *)&longInt);
 894                 p++;
 895         }
 896         if (get_error_response(fd, NULL))
 897                 return -1;
 898         return 0;
 899 }
 900
 901 static int pcap_setdirection_acn(pcap_t *handle, pcap_direction_t d) {
 902         pcap_snprintf(handle->errbuf, sizeof(handle->errbuf),
 903             "Setting direction is not supported on ACN adapters");
 904         return -1;
 905 }
 906
 907 static int acn_read_n_bytes_with_timeout(pcap_t *handle, int count) {
 908         struct          timeval tv;
 909         int                     retval, fd;
 910         fd_set          r_fds;
 911         fd_set          w_fds;
 912         u_char          *bp;
 913         int                     len = 0;
 914         int                     offset = 0;
 915
 916         tv.tv_sec = 5;
 917         tv.tv_usec = 0;
 918
 919         fd = handle->fd;
 920         FD_ZERO(&r_fds);
 921         FD_SET(fd, &r_fds);
 922         memcpy(&w_fds, &r_fds, sizeof(r_fds));
 923         bp = handle->bp;
 924         while (count) {
 925                 retval = select(fd + 1, &w_fds, NULL, NULL, &tv);
 926                 if (retval == -1) {                                                                                     /* an error occured !!!!! */
 927 //                      fprintf(stderr, "error during packet data read\n");
 928                         return -1;                                                                                              /* but we need to return a good indication to prevent unneccessary popups */
 929                 } else if (retval == 0) {                                                                       /* timeout occured, so process what we've got sofar and return */
 930 //                      fprintf(stderr, "timeout during packet data read\n");
 931                         return -1;
 932                 } else {
 933                         if ((len = recv(fd, (bp + offset), count, 0)) <= 0) {
 934 //                              fprintf(stderr, "premature exit during packet data rx\n");
 935                                 return -1;
 936                         }
 937                         count -= len;
 938                         offset += len;
 939                 }
 940         }
 941         return 0;
 942 }
 943
 944 static int pcap_read_acn(pcap_t *handle, int max_packets, pcap_handler callback, u_char *user) {
 945         #define HEADER_SIZE (4 * 4)
 946         unsigned char           packet_header[HEADER_SIZE];
 947         struct pcap_pkthdr      pcap_header;
 948
 949         //printf("pcap_read_acn()\n");                  // fulko
 950         acn_start_monitor(handle->fd, handle->snapshot, handle->opt.timeout, handle->opt.promisc, handle->direction);   /* maybe tell him to start monitoring */
 951         //printf("pcap_read_acn() after start monitor\n");                      // fulko
 952
 953         handle->bp = packet_header;
 954         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 */
 955
 956         pcap_header.ts.tv_sec   = ntohl(*(uint32_t *)&packet_header[0]);                                /* tv_sec */
 957         pcap_header.ts.tv_usec  = ntohl(*(uint32_t *)&packet_header[4]);                                /* tv_usec */
 958         pcap_header.caplen              = ntohl(*(uint32_t *)&packet_header[8]);                                /* caplen */
 959         pcap_header.len                 = ntohl(*(uint32_t *)&packet_header[12]);                               /* len */
 960
 961         handle->bp = (u_char *)handle->buffer + handle->offset;                                                                 /* start off the receive pointer at the right spot */
 962         if (acn_read_n_bytes_with_timeout(handle, pcap_header.caplen) == -1) return 0;  /* then try to read in the rest of the data */
 963
 964         callback(user, &pcap_header, handle->bp);                                                                               /* call the user supplied callback function */
 965         return 1;
 966 }
 967
 968 static int pcap_activate_sita(pcap_t *handle) {
 969         int             fd;
 970
 971         if (handle->opt.rfmon) {
 972                 /*
 973                  * No monitor mode on SITA devices (they're not Wi-Fi
 974                  * devices).
 975                  */
 976                 return PCAP_ERROR_RFMON_NOTSUP;
 977         }
 978
 979         /* Initialize some components of the pcap structure. */
 980
 981         handle->inject_op = pcap_inject_acn;
 982         handle->setfilter_op = pcap_setfilter_acn;
 983         handle->setdirection_op = pcap_setdirection_acn;
 984         handle->set_datalink_op = NULL; /* can't change data link type */
 985         handle->getnonblock_op = pcap_getnonblock_fd;
 986         handle->setnonblock_op = pcap_setnonblock_fd;
 987         handle->cleanup_op = pcap_cleanup_acn;
 988         handle->read_op = pcap_read_acn;
 989         handle->stats_op = pcap_stats_acn;
 990
 991         fd = acn_open_live(handle->opt.device, handle->errbuf,
 992             &handle->linktype);
 993         if (fd == -1)
 994                 return PCAP_ERROR;
 995         handle->fd = fd;
 996         handle->bufsize = handle->snapshot;
 997
 998         /* Allocate the buffer */
 999
1000         handle->buffer   = malloc(handle->bufsize + handle->offset);
1001         if (!handle->buffer) {
1002                 pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
1003                          "malloc: %s", pcap_strerror(errno));
1004                 pcap_cleanup_acn(handle);
1005                 return PCAP_ERROR;
1006         }
1007
1008         /*
1009          * "handle->fd" is a socket, so "select()" and "poll()"
1010          * should work on it.
1011          */
1012         handle->selectable_fd = handle->fd;
1013
1014         return 0;
1015 }
1016
1017 pcap_t *pcap_create_interface(const char *device _U_, char *ebuf) {
1018         pcap_t *p;
1019
1020         p = pcap_create_common(ebuf, 0);
1021         if (p == NULL)
1022                 return (NULL);
1023
1024         p->activate_op = pcap_activate_sita;
1025         return (p);
1026 }
1027
1028 int pcap_platform_finddevs(pcap_if_t **alldevsp, char *errbuf) {
1029
1030         //printf("pcap_findalldevs()\n");                               // fulko
1031
1032         *alldevsp = 0;                                                                                          /* initialize the returned variables before we do anything */
1033         strcpy(errbuf, "");
1034         if (acn_parse_hosts_file(errbuf))                                                       /* scan the hosts file for potential IOPs */
1035                 {
1036                 //printf("pcap_findalldevs() returning BAD after parsehosts\n");                                // fulko
1037                 return -1;
1038                 }
1039         //printf("pcap_findalldevs() got hostlist now finding devs\n");                         // fulko
1040         if (acn_findalldevs(errbuf))                                                            /* then ask the IOPs for their monitorable devices */
1041                 {
1042                 //printf("pcap_findalldevs() returning BAD after findalldevs\n");                               // fulko
1043                 return -1;
1044                 }
1045         *alldevsp = acn_if_list;
1046         acn_if_list = 0;                                                                                        /* then forget our list head, because someone will call pcap_freealldevs() to empty the malloc'ed stuff */
1047         //printf("pcap_findalldevs() returning ZERO OK\n");                             // fulko
1048         return 0;
1049 }