Changeset 4dedc28


Ignore:
Timestamp:
07/29/05 09:26:57 (15 years ago)
Author:
Daniel Lawson <dlawson@…>
Branches:
4.0.1-hotfixes, cachetimestamps, develop, dpdk-ndag, etsilive, getfragoff, help, libtrace4, master, ndag_format, pfring, rc-4.0.1, rc-4.0.2, rc-4.0.3, rc-4.0.4, ringdecrementfix, ringperformance, ringtimestampfixes
Children:
7050c10
Parents:
dd6e168
Message:

isplit input formats out

Location:
lib
Files:
4 added
2 edited

Legend:

Unmodified
Added
Removed
  • lib/Makefile.am

    rd2d527f r4dedc28  
    11lib_LTLIBRARIES = libtrace.la
    22include_HEADERS = libtrace.h dagformat.h wag.h
    3 libtrace_la_SOURCES = trace.c fifo.c fifo.h common.h
     3libtrace_la_SOURCES = trace.c fifo.c fifo.h common.h format_template.c format_erf.c format_pcap.c format_rtclient.c
    44libtrace_la_CFLAGS = @ADD_INCLS@
    55libtrace_la_LIBADD = @ADD_LIBS@ @LTLIBOBJS@
    6 libtrace_la_LDFLAGS=-version-info 2:18:0 @ADD_LDFLAGS@
     6libtrace_la_LDFLAGS=-version-info 2:19:0 @ADD_LDFLAGS@
    77
    88#dagapi.c:
  • lib/trace.c

    rdd6e168 r4dedc28  
    4242#include "common.h"
    4343#include "config.h"
     44#include "format.h"
    4445#include <assert.h>
    4546#include <errno.h>
     
    132133#endif
    133134
     135#include "format.h"
     136//#include "format/format_list.h"
    134137#include <err.h>
    135138
    136 typedef enum {SOCKET, TRACE, STDIN, DEVICE, INTERFACE, RT } source_t;
    137 
    138 typedef enum {ERF, PCAP, PCAPINT, DAG, RTCLIENT, WAG, WAGINT } format_t;
     139//typedef enum {SOCKET, TRACE, STDIN, DEVICE, INTERFACE, RT } source_t;
     140
     141//typedef enum {ERF, PCAP, PCAPINT, DAG, RTCLIENT, WAG, WAGINT } format_e_t;
    139142
    140143typedef enum {RTSERVER, GZERF } output_t;
     
    176179
    177180        struct fifo_t *fifo;
    178 
    179         // rtserver stuff
    180        
    181         /** fd that watches for incoming connections */
    182         int connect_fd;
    183         /** fds that represent connected clients */
    184         fd_set rt_fds;
    185         /** fds that are listening for connections (this should only contain connect_fd) */
    186         fd_set listen;
    187         int max_rtfds;
    188         /** Used for creating new fds as required */
    189         struct sockaddr_in * remote;
    190181};
    191182
    192 /** The information about traces that are open
    193  * @internal
    194  */
    195 struct libtrace_t {
    196         format_t format;        /**< The format that this trace is in */
    197         source_t sourcetype;    /**< The type (device,file, etc */
    198 
    199         union {
    200                 /** Information about rtclients */
    201                 struct {
    202                         char *hostname;
    203                         short port;
    204                 } rt;
    205                 char *path;             /**< information for local sockets */
    206                 char *interface;        /**< intormation for reading of network
    207                                              interfaces */
    208         } conn_info;
    209         /** Information about the current state of the input device */
    210         union {
    211                 int fd;
    212 #if HAVE_ZLIB
    213                 gzFile *file;
    214 #else   
    215                 FILE *file;
    216 #endif
    217 #if HAVE_PCAP
    218                 pcap_t *pcap;
    219 #endif
    220         } input;
    221 
    222         struct fifo_t *fifo;   
    223         struct {
    224                 void *buf;
    225                 unsigned bottom;
    226                 unsigned top;
    227                 unsigned diff;
    228                 unsigned curr;
    229                 unsigned offset;
    230         } dag;
    231         struct {
    232                 void *buffer;
    233                 int size;
    234         } packet;
    235         double tdelta;
    236         double trace_start_ts;
    237         double real_start_ts;
    238         double trace_last_ts;
    239 
    240         double last_ts;
    241         double start_ts;
    242 };
    243 
    244 struct trace_sll_header_t {
    245         uint16_t pkttype;               /* packet type */
    246         uint16_t hatype;                /* link-layer address type */
    247         uint16_t halen;                 /* link-layer address length */
    248         char addr[8];                   /* link-layer address */
    249         uint16_t protocol;              /* protocol */
    250 };
    251 
    252 #ifndef PF_RULESET_NAME_SIZE
    253 #define PF_RULESET_NAME_SIZE 16
    254 #endif
    255 
    256 #ifndef IFNAMSIZ
    257 #define IFNAMSIZ 16
    258 #endif
    259 
    260 struct trace_pflog_header_t {
    261         uint8_t    length;
    262         sa_family_t   af;
    263         uint8_t    action;
    264         uint8_t    reason;
    265         char       ifname[IFNAMSIZ];
    266         char       ruleset[PF_RULESET_NAME_SIZE];
    267         uint32_t   rulenr;
    268         uint32_t   subrulenr;
    269         uint8_t    dir;
    270         uint8_t    pad[3];
    271 };
     183
     184
     185struct format_t **format_list = 0;
     186int format_size = 0;
     187int nformats = 0;
     188
     189void register_format(struct format_t *f) {
     190        fprintf(stderr,"Registering input format %s\n",f->name);
     191        if (format_list == 0) {
     192                format_size = 10;
     193                format_list = malloc(sizeof(struct format_t *) * format_size);
     194        } else if (format_size == nformats) {
     195                format_size = format_size + 10;
     196                format_list = realloc(format_list,
     197                                sizeof(struct format_t *) * format_size);
     198        }
     199        format_list[nformats] = f;
     200        nformats++;
     201}
     202
    272203
    273204#define RP_BUFSIZE 65536
     
    277208        char *scan = calloc(sizeof(char),URI_PROTO_LINE);
    278209        char *uridata = 0;                 
     210        int i = 0;
    279211        struct stat buf;
    280212       
     
    296228        (*libtrace)->tdelta = 0.0;
    297229
    298         if (!strncasecmp(scan,"erf",3)) {
    299                 (*libtrace)->format=ERF;
    300 #if HAVE_PCAP
    301         } else if (!strncasecmp(scan,"pcapint",7)) {
    302                 (*libtrace)->format=PCAPINT;
    303         } else if (!strncasecmp(scan,"pcap",4)) {
    304                 (*libtrace)->format=PCAP;
    305 #else
    306         } else if (!strncasecmp(scan,"pcap",4)) { // also catches pcapint
    307                 fprintf(stderr,"This version of libtrace has been compiled without PCAP support\n");
     230
     231        (*libtrace)->format = 0;
     232        for (i = 0; i < nformats; i++) {
     233                if (strlen(scan) == strlen(format_list[i]->name) &&
     234                                !strncasecmp(scan,
     235                                        format_list[i]->name,
     236                                        strlen(scan))) {
     237                                (*libtrace)->format=format_list[i];
     238                                break;
     239                                }
     240        }
     241        if ((*libtrace)->format == 0) {
     242                fprintf(stderr,
     243                        "libtrace has no support for this format (%s)\n",scan);
    308244                return 0;
    309 #endif
    310        
    311 #if HAVE_DAG
    312         } else if (!strncasecmp(scan,"dag",3)) {
    313                 (*libtrace)->format=DAG;
    314 #else
    315         } else if (!strncasecmp(scan,"dag",3)) {
    316                 fprintf(stderr,"This version of libtrace has been compiled without DAG support\n");
    317                 return 0;
    318 #endif
    319         } else if (!strncasecmp(scan,"rtclient",7)) {
    320                 (*libtrace)->format=RTCLIENT;
    321         } else if (!strncasecmp(scan,"wagint",6)) {
    322         struct ports_t *port;
    323                 (*libtrace)->format=WAGINT;
    324         } else if (!strncasecmp(scan,"wag",3)) {
    325                 (*libtrace)->format=WAG;
    326         } else {
    327                 //badly formed URI
    328                 return 0;
    329         }
    330        
     245        }
     246
    331247        // push uridata past the delimiter
    332248        uridata++;
    333        
     249        (*libtrace)->conn_info.path = strdup(uridata);
     250
    334251        // libtrace->format now contains the type of uri
    335252        // libtrace->uridata contains the appropriate data for this
    336253       
    337         switch((*libtrace)->format) {
    338 #if HAVE_PCAP
    339                 case PCAPINT:
    340 #endif
    341                 case WAGINT:
    342                         /* Can have uridata of the following format
    343                          * eth0
    344                          * etc
    345                          */
    346                         // We basically assume this is correct.
    347                         (*libtrace)->sourcetype = INTERFACE;   
    348                         (*libtrace)->conn_info.path = strdup(uridata);
    349                         break;
    350 #if HAVE_PCAP
    351                 case PCAP:
    352 #endif
    353                 case ERF:
    354                 case WAG:
    355                         /*
    356                          * Can have uridata of the following format
    357                          * /path/to/socket (probably not PCAP)
    358                          * /path/to/file
    359                          * /path/to/file.gz (not PCAP)
    360                          * /dev/device (use PCAPINT)
    361                          * -
    362                          */
    363                         if (!strncmp(uridata,"-",1)) {
    364                                 (*libtrace)->sourcetype = STDIN;
    365                         } else {
    366                                 if (stat(uridata,&buf) == -1) {
    367                                         perror("stat");
    368                                         return 0;
    369                                 }
    370                                 if (S_ISSOCK(buf.st_mode)) {
    371                                         (*libtrace)->sourcetype = SOCKET;
    372                                 } else if (S_ISCHR(buf.st_mode)) {
    373                                         (*libtrace)->sourcetype = DEVICE;
    374                                 } else {
    375                                         (*libtrace)->sourcetype = TRACE;
    376                                 }
    377                                 (*libtrace)->conn_info.path = strdup(uridata);
    378                         }
    379                         break;
    380                 case DAG:
    381 #if HAVE_DAG
    382                         /*
    383                          * Can have uridata of the following format:
    384                          * /dev/device
    385                          */
    386                         if (stat(uridata,&buf) == -1) {
    387                                 perror("stat");
    388                                 return 0;
    389                         }
    390                         if (S_ISCHR(buf.st_mode)) {
    391                                 (*libtrace)->sourcetype = DEVICE;
    392                         } else {
    393                                 fprintf(stderr,"%s isn't a valid char device, exiting\n",uridata);
    394                                 exit(1);
    395                         }
    396                         (*libtrace)->conn_info.path = strdup(uridata);
    397 #endif
    398                         break;
    399 
    400                 case RTCLIENT:
    401                         /*
    402                          * Can have the uridata in the format
    403                          * hostname
    404                          * hostname:port
    405                          */
    406                         (*libtrace)->sourcetype = RT;
    407                         if (strlen(uridata) == 0) {
    408                                 (*libtrace)->conn_info.rt.hostname =
    409                                         strdup("localhost");
    410                                 (*libtrace)->conn_info.rt.port =
    411                                         COLLECTOR_PORT;
    412                                 break;
    413                         }
    414                         if ((scan = strchr(uridata,':')) == NULL) {
    415                                 (*libtrace)->conn_info.rt.hostname =
    416                                         strdup(uridata);
    417                                 (*libtrace)->conn_info.rt.port =
    418                                         COLLECTOR_PORT;
    419                         } else {
    420                                 (*libtrace)->conn_info.rt.hostname =
    421                                         (char *)strndup(uridata,(scan - uridata));
    422                                        
    423                                 (*libtrace)->conn_info.rt.port =
    424                                         atoi(++scan);                           
    425                         }
    426                         break;
    427         }
    428        
     254        if ((*libtrace)->format->init_input) {
     255                (*libtrace)->format->init_input( (*libtrace));
     256        } else {
     257                fprintf(stderr,
     258                        "No init function for format %s\n",scan);
     259                return 0;
     260        }
     261       
    429262
    430263        (*libtrace)->fifo = create_fifo(1048576);
     
    554387        }
    555388       
    556         switch(libtrace->sourcetype) {
    557                 case RT:
    558                         if ((he=gethostbyname(libtrace->conn_info.rt.hostname)) == NULL) { 
    559                                 perror("gethostbyname");
    560                                 return 0;
    561                         }
    562                         if ((libtrace->input.fd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
    563                                 perror("socket");
    564                                 return 0;
    565                         }
    566 
    567                         remote.sin_family = AF_INET;   
    568                         remote.sin_port = htons(libtrace->conn_info.rt.port);
    569                         remote.sin_addr = *((struct in_addr *)he->h_addr);
    570                         bzero(&(remote.sin_zero), 8);
    571 
    572                         if (connect(libtrace->input.fd, (struct sockaddr *)&remote,
    573                                                 sizeof(struct sockaddr)) == -1) {
    574                                 perror("connect (inet)");
    575                                 return 0;
    576                         }
    577                         break;
    578                 case TRACE:
    579 #if HAVE_PCAP
    580                         if (libtrace->format == PCAP) {
    581                                 if ((libtrace->input.pcap = pcap_open_offline(libtrace->conn_info.path, errbuf)) == NULL) {
    582                                         fprintf(stderr,"%s\n",errbuf);
    583                                         return 0;
    584                                 }
    585                         } else {
    586 #else
    587                         {
    588 #endif
    589 
    590 /* Catch undefined O_LARGEFILE on *BSD etc */
    591 #ifndef O_LARGEFILE
    592 #  define O_LARGEFILE 0
    593 #endif
    594                                
    595 #if HAVE_ZLIB
    596                                 // using gzdopen means we can set O_LARGEFILE
    597                                 // ourselves. However, this way is messy and
    598                                 // we lose any error checking on "open"
    599                                 libtrace->input.file = gzdopen(open(libtrace->conn_info.path,O_LARGEFILE), "r");
    600 #else
    601                                 libtrace->input.file = fdopen(open(libtrace->conn_info.path,O_LARGEFILE), "r");
    602 #endif
    603                         }
    604                         break;
    605                 case STDIN:
    606 #if HAVE_PCAP
    607                         if (libtrace->format == PCAP) {
    608                                 libtrace->input.pcap = pcap_open_offline("-",errbuf);
    609                         } else {
    610 #else
    611                         {
    612 #endif
    613 #if HAVE_ZLIB
    614                                 libtrace->input.file = gzdopen(STDIN, "r");
    615 #else   
    616                                 libtrace->input.file = stdin;
    617 #endif
    618                         }
    619                         break;
    620                 case SOCKET:
    621                         /* Pcap doesn't work */
    622                         if (libtrace->format != PCAP) {
    623                                 if ((libtrace->input.fd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) {
    624                                         perror("socket");
    625                                         return 0;
    626                                 }
    627                                 unix_sock.sun_family = AF_UNIX;
    628                                 bzero(unix_sock.sun_path,108);
    629                                 snprintf(unix_sock.sun_path,108,"%s",libtrace->conn_info.path);
    630 
    631                                 if (connect(libtrace->input.fd, (struct sockaddr *)&unix_sock,
    632                                                         sizeof(struct sockaddr)) == -1) {
    633                                         perror("connect (unix)");
    634                                         return 0;
    635                                 }
    636                         }
    637                         break;
    638                 case DEVICE:
    639                 case INTERFACE:
    640                         switch (libtrace->format) {
    641 #if HAVE_PCAP
    642                                 case PCAPINT:
    643                                 case PCAP:
    644                                         libtrace->input.pcap = pcap_open_live(
    645                                                 libtrace->conn_info.path,
    646                                                 4096,
    647                                                 1,
    648                                                 1,
    649                                                 errbuf);
    650                                         break;
    651 #endif
    652                                 case WAGINT:
    653                                 case WAG:
    654                                         libtrace->input.fd = open(
    655                                                 libtrace->conn_info.path,
    656                                                 O_RDONLY);
    657                                         break;
    658 #if HAVE_DAG
    659                                 case DAG:
    660                                         if((libtrace->input.fd = dag_open(libtrace->conn_info.path)) < 0) {
    661                                                 fprintf(stderr,"Cannot open DAG %s: %m\n", libtrace->conn_info.path,errno);
    662                                                 exit(0);
    663                                         }
    664                                         if((libtrace->dag.buf = dag_mmap(libtrace->input.fd)) == MAP_FAILED) {
    665                                                 fprintf(stderr,"Cannot mmap DAG %s: %m\n", libtrace->conn_info.path,errno);
    666                                                 exit(0);
    667                                         }
    668                                         if(dag_start(libtrace->input.fd) < 0) {
    669                                                 fprintf(stderr,"Cannot start DAG %s: %m\n", libtrace->conn_info.path,errno);
    670                                                 exit(0);
    671                                         }
    672                                         break;
    673 #endif
    674                                 default:
    675                                         fprintf(stderr,"Unknown format trace, hoping I can just read\n");
    676                                         break;
    677                                        
    678                         }
    679                         break;
    680                 default:
    681                         fprintf(stderr,"Unsupported source type for libtrace, terminating (%i)\n",libtrace->sourcetype);
    682                         exit(0);
    683                
    684         }
    685389        return libtrace;
    686390}
     
    689393 *
    690394 * @param uri   the uri string describing the output format and the destination
    691  * @returns the newly created libtrace_out_t structure, or NULL if an error occurs
     395 * @returns the newly created libtrace_out_t structure
    692396 *
    693397 * @author Shane Alcock
     
    695399struct libtrace_out_t *trace_output_create(char *uri) {
    696400        struct libtrace_out_t *libtrace = malloc(sizeof(struct libtrace_out_t));
    697         struct sockaddr_in listener;
     401        struct sockaddr_in remote, client;
     402        int client_fd, clilen;
    698403        struct hostent *he;
    699         int yes = 1;
    700404       
    701405        if (init_output(&libtrace, uri) == 0)
     
    704408        switch(libtrace->outputformat) {
    705409                case RTSERVER:
    706                         FD_ZERO(&libtrace->listen);
    707                         FD_ZERO(&libtrace->rt_fds);
    708                        
    709410                        if ((he=gethostbyname(libtrace->conn_info.rt.hostname)) == NULL) {
    710411                                perror("gethostbyname");
    711412                                return 0;
    712413                        }
    713                         if ((libtrace->connect_fd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
     414                        if ((libtrace->output.fd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
    714415                                perror("socket");
    715416                                return 0;
    716417                        }
    717                         if (setsockopt(libtrace->connect_fd,SOL_SOCKET,SO_REUSEADDR,&yes,sizeof(int)) == -1) {
    718                                 perror("setsockopt");
    719                                 return 0;
    720                         }
    721                         libtrace->remote = calloc(1,sizeof(struct sockaddr_in));
    722418                        // Need to set up a listening server here
    723                         bzero((char *) libtrace->remote, sizeof(libtrace->remote));
    724                         libtrace->remote->sin_family = AF_INET;
    725                         libtrace->remote->sin_addr.s_addr = INADDR_ANY;
    726                         libtrace->remote->sin_port = htons(libtrace->conn_info.rt.port);
    727                        
    728                         if (bind(libtrace->connect_fd, (struct sockaddr *) libtrace->remote, sizeof(struct sockaddr_in)) < 0) {
     419                        bzero((char *) &remote, sizeof(remote));
     420                        remote.sin_family = AF_INET;
     421                        remote.sin_addr.s_addr = INADDR_ANY;
     422                        remote.sin_port = htons(libtrace->conn_info.rt.port);
     423
     424                        if (bind(libtrace->output.fd, (struct sockaddr *) &remote, sizeof(remote)) < 0) {
    729425                                perror("bind");
    730426                                return 0;
    731427                        }
    732                         // fprintf(stderr, "Waiting for client to connect\n");
    733 
    734                         if (listen(libtrace->connect_fd, 10) == -1) {
    735                                 perror("listen");
    736                                 return 0;
    737                         }
    738                                
    739                         FD_SET(libtrace->connect_fd, &libtrace->listen);
    740                         libtrace->max_rtfds = libtrace->connect_fd;
    741                         /*
     428                        fprintf(stderr, "Waiting for client to connect\n");
     429
     430                        listen(libtrace->output.fd, 5);
    742431                        clilen = sizeof(client);
    743432                        if ((client_fd = accept(libtrace->output.fd, (struct sockaddr *) &client, &clilen)) < 0) {
     
    747436                        libtrace->output.fd = client_fd;
    748437                        fprintf(stderr, "Client connected\n");                       
    749                         */
    750438                        break;
    751439
     
    782470void trace_destroy(struct libtrace_t *libtrace) {
    783471        assert(libtrace);
    784 #if HAVE_PCAP
    785         if (libtrace->format == PCAP || libtrace->format == PCAPINT) {
    786                 pcap_close(libtrace->input.pcap);
    787 #else
    788         if (0) {
    789 #endif
    790         } else if (libtrace->sourcetype == SOCKET || libtrace->sourcetype == RT) {
    791                 close(libtrace->input.fd);
    792 #if HAVE_DAG
    793         } else if (libtrace->format == DAG) {
    794                 dag_stop(libtrace->input.fd);
    795 #endif
    796         } else {
    797 #if HAVE_ZLIB
    798                 gzclose(libtrace->input.file);
    799 #else   
    800                 fclose(libtrace->input.file);   
    801 #endif
    802         }       
     472        libtrace->format->fin_input(libtrace);
    803473        // need to free things!
    804474        destroy_fifo(libtrace->fifo);
     
    826496        }
    827497        destroy_fifo(libtrace->fifo);
    828         free(libtrace->remote);
    829498        free(libtrace);
    830499}
     
    864533                                break;
    865534                        case DEVICE:
    866                                 switch(libtrace->format) {
    867 #if HAVE_DAG
    868                                         case DAG:
    869 
    870                                                 libtrace->dag.bottom = libtrace->dag.top;
    871                                                 libtrace->dag.top = dag_offset(
    872                                                                 libtrace->input.fd,
    873                                                                 &(libtrace->dag.bottom),
    874                                                                 0);
    875                                                 libtrace->dag.diff = libtrace->dag.top -
    876                                                         libtrace->dag.bottom;
    877                                                
    878                                                 numbytes=libtrace->dag.diff;
    879                                                 libtrace->dag.offset = 0;
    880                                                
    881                                                 break;
    882 #endif
    883                                         default:
    884                                                 if ((numbytes=read(libtrace->input.fd,
     535                                if (libtrace->format->read) {
     536                                        libtrace->format->read(libtrace,buffer,len);
     537                                } else {
     538                                        if ((numbytes=read(libtrace->input.fd,
    885539                                                                buffer,
    886540                                                                len)) == -1) {
    887541                                                perror("read");
    888542                                                return -1;
    889                                                 }
     543                                        }
    890544                                }
    891545                                break;
     
    939593 */
    940594int trace_read_packet(struct libtrace_t *libtrace, struct libtrace_packet_t *packet) {
    941         int numbytes;
    942         int size;
    943         char buf[RP_BUFSIZE];
    944 #if HAVE_PCAP
    945         //struct pcap_pkthdr *pcaphdr = malloc(sizeof(struct pcap_pkthdr));
    946         const u_char *pcappkt;
    947         int pcapbytes = 0;
    948 #endif
    949         dag_record_t *erfptr;
    950         int read_required = 0;
    951 
    952         void *buffer = 0;
     595
    953596        if (!libtrace) {
    954597                fprintf(stderr,"Oi! You called trace_read_packet() with a NULL libtrace parameter!\n");
     
    961604        packet->trace = libtrace;
    962605
    963         buffer = packet->buffer;
    964 #if HAVE_PCAP
    965         /* PCAP gives us it's own per-packet interface. Let's use it */
    966         if (libtrace->format == PCAP || libtrace->format == PCAPINT) {
    967                 /* pcap_next doesn't return enough information for us
    968                  * newer libpcap has pcap_next_ex, which does, but we'd
    969                  * really rather have it all the time. */
    970                
    971                 //if ((pcappkt = pcap_next(libtrace->input.pcap, &pcaphdr)) == NULL) {
    972                 /*
    973                 if ((pcapbytes = pcap_next_ex(libtrace->input.pcap,
    974                                                 &pcaphdr,
    975                                                 &pcappkt)) < 0 ) {
    976                 */
    977                 /* Instead of pcap_next/pcap_next_ex, we do this ourselves
    978                  * with a trivial callback function. This lets us
    979                  * catch the same errors as pcap_next_ex, but removes
    980                  * the requirement for libpcap >= 0.8.x
    981                  */
    982                 while ((pcapbytes = pcap_dispatch(libtrace->input.pcap,
    983                                                 1, /* number of packets */
    984                                                 &trace_pcap_handler,
    985                                                 (u_char *)packet)) == 0);
    986                        
    987                 if (pcapbytes < 0 ) {                   
    988                         return -1;
    989                 }
    990                 return (packet->size - sizeof(struct pcap_pkthdr));
    991                 //memcpy(buffer,&pcaphdr,sizeof(struct pcap_pkthdr));
    992                 //numbytes = pcaphdr->len;
    993                 //memcpy(buffer + sizeof(struct pcap_pkthdr),pcappkt,numbytes);
    994        
    995                 //packet->size = numbytes + sizeof(struct pcap_pkthdr);
    996                 //return numbytes;
    997         }
    998 #endif
    999 
    1000         /* If we're reading from an ERF input, it's an offline trace. We can make some assumptions */
    1001         if (libtrace->format == ERF) {
    1002                 void *buffer2 = buffer;
    1003                 int rlen;
    1004                 // read in the trace header
    1005                 if ((numbytes=gzread(libtrace->input.file,
    1006                                                 buffer,
    1007                                                 dag_record_size)) == -1) {
    1008                         perror("gzread");
    1009                         return -1;
    1010                 }
    1011                 if (numbytes == 0) {
    1012                         return 0;
    1013                 }
    1014                 rlen = ntohs(((dag_record_t *)buffer)->rlen);
    1015                 size = rlen - dag_record_size;
    1016                 assert(size < LIBTRACE_PACKET_BUFSIZE);
    1017                 buffer2 = buffer +  dag_record_size;
    1018 
    1019                 // read in the rest of the packet
    1020                 if ((numbytes=gzread(libtrace->input.file,
    1021                                                 buffer2,
    1022                                                 size)) == -1) {
    1023                         perror("gzread");
    1024                         return -1;
    1025                 }
    1026                 //if ((numbytes + dag_record_size) != rlen) {
    1027                 //      printf("read %d wanted %d\n",numbytes +dag_record_size, rlen);
    1028                 //}
    1029                 packet->size = rlen;
    1030                        
    1031                 return rlen;
    1032         }
    1033 
    1034 #if HAVE_DAG
    1035         if (libtrace->format == DAG) {
    1036                 if (libtrace->dag.diff == 0) {
    1037                         if ((numbytes = trace_read(libtrace,buf,RP_BUFSIZE)) <= 0)
    1038                                 return numbytes;
    1039                 }
    1040                 // DAG always gives us whole packets.
    1041 
    1042                 erfptr = (dag_record_t *) ((void *)libtrace->dag.buf + (libtrace->dag.bottom + libtrace->dag.offset));
    1043                 size = ntohs(erfptr->rlen);
    1044 
    1045                 if ( size  > LIBTRACE_PACKET_BUFSIZE) {
    1046                         printf("%d\n",size);
    1047                         assert( size < LIBTRACE_PACKET_BUFSIZE);
    1048                 }
    1049 
    1050                 // have to copy it out of the memory hole at this stage:
    1051                 memcpy(packet->buffer, erfptr, size);
    1052 
    1053                 packet->size = size;
    1054                 libtrace->dag.offset += size;
    1055                 libtrace->dag.diff -= size;
    1056                
    1057                 assert(libtrace->dag.diff >= 0);
    1058                 //assert(libtrace->dag.offset <= libtrace->dag.top);
    1059                 return (size);
    1060                
    1061         }
    1062 #endif
    1063         do {
    1064                 if (fifo_out_available(libtrace->fifo) == 0 || read_required) {
    1065                         if ((numbytes = trace_read(libtrace,buf,RP_BUFSIZE))<=0){
    1066                                 return numbytes;
    1067                         }
    1068                         assert(libtrace->fifo);
    1069                         fifo_write(libtrace->fifo,buf,numbytes);
    1070 
    1071                         read_required = 0;
    1072                 }
    1073 
    1074                 switch (libtrace->format) {
    1075                         case RTCLIENT:
    1076                                 // only do this if we're reading from the RT interface
    1077                                 if (fifo_out_read(libtrace->fifo, &packet->status, sizeof(int)) == 0) {
    1078                                         read_required = 1;
    1079                                         continue;
    1080                                 }
    1081 
    1082                                 fifo_out_update(libtrace->fifo,sizeof(int));
    1083 
    1084                                 /* FALL THRU */
    1085                         case ERF:
    1086                         //case DAG:
    1087                                 // read in the erf header
    1088                                 if ((numbytes = fifo_out_read(libtrace->fifo, buffer, sizeof(dag_record_t))) == 0) {
    1089                                         fifo_out_reset(libtrace->fifo);
    1090                                         read_required = 1;
    1091                                         continue;
    1092                                 }
    1093 
    1094                                 size = ntohs(((dag_record_t *)buffer)->rlen);
    1095                                 break;
    1096                         case WAG:
    1097                                 if ((numbytes = fifo_out_read(libtrace->fifo,
    1098                                                                 &size,
    1099                                                                 sizeof(size)))
    1100                                                                 == 0) {
    1101                                         fifo_out_reset(libtrace->fifo);
    1102                                         read_required = 1;
    1103                                         continue;
    1104                                 }
    1105                                 size*=4;
    1106                                 break;
    1107                         default:
    1108                                 fprintf(stderr,"Unknown type in _read()\n");
    1109                                 assert(0);
    1110                 }
    1111 
    1112                 assert(size < LIBTRACE_PACKET_BUFSIZE);
    1113                 // read in the full packet
    1114                 if ((numbytes = fifo_out_read(libtrace->fifo, buffer, size)) == 0) {
    1115                         fifo_out_reset(libtrace->fifo);
    1116                         read_required = 1;
    1117                         continue;
    1118                 }
    1119 
    1120                 // got in our whole packet, so...
    1121                 fifo_out_update(libtrace->fifo,size);
    1122 
    1123                 if (libtrace->sourcetype == SOCKET || libtrace->sourcetype == RT) {
    1124                         fifo_ack_update(libtrace->fifo,size + sizeof(int));
    1125                 } else {
    1126                         fifo_ack_update(libtrace->fifo,size);
    1127                 }
    1128                
    1129                 packet->size = numbytes;
    1130                 return numbytes;
    1131 
    1132         } while (1);
     606        if (libtrace->format->read_packet) {
     607                return libtrace->format->read_packet(libtrace,packet);
     608        }
    1133609}
    1134610
     
    1202678        void *buffer = &buf[intsize];
    1203679        int write_required = 0;
    1204         struct timeval tv;
    1205         int i;
    1206         int rt_fd;
    1207         int sin_size = sizeof(struct sockaddr_in);
    1208        
    1209         fd_set current;
    1210        
     680
    1211681        assert(libtrace);
    1212682        assert(packet);
     
    1224694        if (libtrace->outputformat == RTSERVER) {
    1225695                do {
    1226                         // check for incoming connections  NOTE: Should this be inside the do { }
    1227                         tv.tv_sec = 0;
    1228                         tv.tv_usec = 10;
    1229                         current = libtrace->listen;
    1230                         do {
    1231                                 if (select(libtrace->max_rtfds + 1, &current, NULL, NULL,&tv) >=0 ) {
    1232                                         break;
    1233                                 }
    1234                         }
    1235                         while (errno == EINTR);
    1236                         for (i = 0; i <= libtrace->max_rtfds; i++) {
    1237                                 if (FD_ISSET(i, &current)) {
    1238                                         // Got something on the listening socket
    1239                                         if (i == libtrace->connect_fd) {
    1240                                                 if ((rt_fd = accept(i, (struct sockaddr *) libtrace->remote,
    1241                                                                                 &sin_size)) == -1) {
    1242                                                         perror("accept");
    1243                                                 } else {
    1244                                                         printf("Client connected\n");
    1245                                                         FD_SET(rt_fd, &libtrace->rt_fds);
    1246                                                         if (rt_fd > libtrace->max_rtfds)
    1247                                                                 libtrace->max_rtfds = rt_fd;
    1248                                                 }
    1249                                         }
    1250                                 }
    1251                         }
    1252                        
    1253696                        assert(libtrace->fifo);
    1254697
     
    1279722                                continue;
    1280723                        }
    1281                         current = libtrace->rt_fds;
     724                        fifo_out_update(libtrace->fifo, size); 
    1282725                        // Sort out the protocol header
    1283726                        memcpy(buf, &packet->status, intsize);
    1284                         if (select(libtrace->max_rtfds + 1, NULL, &current, NULL, &tv) == -1 ) {
    1285                                 perror("select");
    1286                                 write_required = 0;
    1287                                 continue;
     727                                               
     728
     729                        // Send the buffer out on the wire
     730                        if ((numbytes = trace_write(libtrace, buf, size + sizeof(int))) <=0 ) {
     731                                return numbytes;
    1288732                        }
    1289                        
    1290                         // Send the data to each ready client
    1291                         for (i = 0; i <= libtrace->max_rtfds; i++) {
    1292                                 if (FD_ISSET(i, &current)) {
    1293                                         libtrace->output.fd = i;
    1294                                         if ((numbytes = trace_write(libtrace, buf, size + sizeof(int))) <=0 ) {
    1295                                                 // close rt_client
    1296                                                 FD_CLR(i, &libtrace->rt_fds);
    1297                                                 close(i);
    1298                                                 numbytes = 0;
    1299                                                 continue;
    1300                                         }
    1301                                 }
    1302                         }
    1303 
    1304                         fifo_out_update(libtrace->fifo, size);
     733
    1305734                        // Need an ack to come back
    1306735                        // TODO: Obviously this is a little unfinished
     
    1327756void *trace_get_link(const struct libtrace_packet_t *packet) {
    1328757        const void *ethptr = 0;
    1329         dag_record_t *erfptr = 0;
    1330         struct wag_event_t *event = (struct wag_event_t *)packet->buffer;
    1331         struct wag_data_event_t *data_event;
    1332758       
    1333        
    1334         switch(packet->trace->format) {
    1335                 case ERF:
    1336                 case DAG:
    1337                 case RTCLIENT:
    1338                         erfptr = (dag_record_t *)packet->buffer;
    1339                         if (erfptr->flags.rxerror == 1) {
    1340                                 return NULL;
    1341                         }
    1342                         if (trace_get_link_type(packet)==TRACE_TYPE_ETH)
    1343                                 ethptr = ((uint8_t *)packet->buffer +
    1344                                                 dag_record_size + 2);
    1345                         else
    1346                                 ethptr = ((uint8_t *)packet->buffer +
    1347                                                 dag_record_size + 2);
    1348                         break;
    1349 #if HAVE_PCAP
    1350                 case PCAPINT:
    1351                 case PCAP:
    1352                         ethptr = (packet->buffer + sizeof(struct pcap_pkthdr));
    1353                         break;
    1354 #endif
    1355                 case WAGINT:
    1356                 case WAG:
    1357                         switch (event->type) {
    1358                                 case 0x0:
    1359                                         data_event = (void*)&(event->payload);
    1360                                         return data_event->data;
    1361                                 default:
    1362                                         fprintf(stderr,"Unknown WAG Event (0x%08x)\n",event->type);
    1363                                         return NULL;
    1364                         }
    1365                        
    1366                 default:
    1367                         fprintf(stderr,"Don't know this trace format\n");
    1368                         assert(0);
    1369         }
     759        if (packet->trace->format->get_link) {
     760                ethptr = packet->trace->format->get_link(packet);
     761        }
    1370762        return (void *)ethptr;
    1371763}
     
    16591051uint64_t trace_get_erf_timestamp(const struct libtrace_packet_t *packet) {
    16601052        uint64_t timestamp = 0;
    1661         dag_record_t *erfptr = 0;
    1662         struct pcap_pkthdr *pcapptr = 0;
    1663         struct wag_event_t *wagptr = 0;
    1664         switch (packet->trace->format) {
    1665                 case DAG:
    1666                 case ERF:
    1667                 case RTCLIENT:
    1668                         erfptr = (dag_record_t *)packet->buffer;
    1669                         timestamp = erfptr->ts;
    1670                         break;
    1671 #if HAVE_PCAP
    1672                 case PCAPINT:
    1673                 case PCAP:
    1674                         pcapptr = (struct pcap_pkthdr *)packet->buffer;
    1675                         timestamp = ((((uint64_t)pcapptr->ts.tv_sec) << 32) + \
    1676                                 (((uint64_t)pcapptr->ts.tv_usec*UINT_MAX)/1000000));
    1677                         break;
    1678 #endif
    1679                 case WAGINT:
    1680                 case WAG:
    1681                         wagptr = (struct wag_event_t *)packet->buffer;
    1682                         timestamp = wagptr->timestamp_lo;
    1683                         timestamp |= (uint64_t)wagptr->timestamp_hi<<32;
    1684                         timestamp = ((timestamp%44000000)*(UINT_MAX/44000000))
    1685                                   | ((timestamp/44000000)<<32);
    1686                         break;
    1687                 default:
    1688                         fprintf(stderr,"Unknown format in trace_get_erf_timestamp\n");
    1689                         timestamp = 0;
    1690         }
    1691         return timestamp;
     1053        struct timeval ts;
     1054
     1055        if (packet->trace->format->get_erf_timestamp) {
     1056                timestamp = packet->trace->format->get_erf_timestamp(packet);
     1057        } else if (packet->trace->format->get_timeval) {
     1058                ts = packet->trace->format->get_timeval(packet);
     1059                timestamp = ((((uint64_t)ts.tv_sec) << 32) + \
     1060                                (((uint64_t)ts.tv_usec * UINT_MAX)/1000000));
     1061        }
     1062        return timestamp;
    16921063}
    16931064
     
    17011072struct timeval trace_get_timeval(const struct libtrace_packet_t *packet) {
    17021073        struct timeval tv;
    1703 #if HAVE_PCAP
    1704         struct pcap_pkthdr *pcapptr = 0;
    1705 #endif
    1706         uint64_t ts;
    1707         //uint32_t seconds;
    1708         switch (packet->trace->format) {
    1709 #if HAVE_PCAP
    1710                 case PCAPINT:
    1711                 case PCAP:
    1712                         pcapptr = (struct pcap_pkthdr *)packet->buffer;
    1713                         // ick. FIXME
    1714                         tv = pcapptr->ts;
    1715                         break;
    1716 #endif
    1717                 case WAGINT:
    1718                 case WAG:
    1719                 case DAG:
    1720                 case ERF:
    1721                 case RTCLIENT:
    1722                 default:
    1723                         // FIXME: This isn't portable to big-endian machines
    1724                         ts = trace_get_erf_timestamp(packet);
     1074        uint64_t ts = 0;
     1075
     1076        if (packet->trace->format->get_timeval) {
     1077                tv = packet->trace->format->get_timeval(packet);
     1078        } else if (packet->trace->format->get_erf_timestamp) {
     1079                ts = packet->trace->format->get_erf_timestamp(packet);
    17251080#if __BYTE_ORDER == __BIG_ENDIAN
    1726                         tv.tv_sec = ts & 0xFFFFFFFF;
     1081                tv.tv_sec = ts & 0xFFFFFFFF;
    17271082#elif __BYTE_ORDER == __LITTLE_ENDIAN
    1728                         tv.tv_sec = ts >> 32;
     1083                tv.tv_sec = ts >> 32;
    17291084#else
    17301085#error "What on earth are you running this on?"
    17311086#endif
    1732                         ts = (1000000 * (ts & 0xffffffffULL));
    1733                         ts += (ts & 0x80000000ULL) << 1;
    1734                         tv.tv_usec = ts >> 32;
    1735                         if (tv.tv_usec >= 1000000) {
    1736                                 tv.tv_usec -= 1000000;
    1737                                 tv.tv_sec += 1;
    1738                         }
    1739                         break;
    1740         }
     1087                ts = (1000000 * (ts & 0xffffffffULL));
     1088                ts += (ts & 0x80000000ULL) << 1;
     1089                tv.tv_usec = ts >> 32;
     1090                if (tv.tv_usec >= 1000000) {
     1091                        tv.tv_usec -= 1000000;
     1092                        tv.tv_sec += 1;
     1093                }
     1094        }
     1095
    17411096        return tv;
    17421097}
     
    17481103 */
    17491104double trace_get_seconds(const struct libtrace_packet_t *packet) {
     1105        double seconds;
    17501106        uint64_t ts;
    1751         ts = trace_get_erf_timestamp(packet);
    1752         return (ts>>32) + ((ts & UINT_MAX)*1.0 / UINT_MAX);
     1107       
     1108        if (packet->trace->format->get_seconds) {
     1109                seconds = packet->trace->format->get_seconds(packet);
     1110        } else if (packet->trace->format->get_erf_timestamp) {
     1111                ts = packet->trace->format->get_erf_timestamp(packet);
     1112                seconds =  (ts>>32) + ((ts & UINT_MAX)*1.0 / UINT_MAX);
     1113        }
     1114        return seconds;
    17531115}
    17541116
     
    17651127 */
    17661128int trace_get_capture_length(const struct libtrace_packet_t *packet) {
    1767         dag_record_t *erfptr = 0;
    1768 #if HAVE_PCAP
    1769         struct pcap_pkthdr *pcapptr = 0;
    1770 #endif
    1771         struct wag_event_t *wag_event;
    1772         switch (packet->trace->format) {
    1773                 case DAG:
    1774                 case ERF:
    1775                 case RTCLIENT:
    1776                         erfptr = (dag_record_t *)packet->buffer;
    1777                         return ntohs(erfptr->rlen);
    1778 #if HAVE_PCAP
    1779                 case PCAPINT:
    1780                 case PCAP:
    1781                         pcapptr = (struct pcap_pkthdr *)packet->buffer;
    1782                         //return ntohs(pcapptr->caplen);
    1783                         return pcapptr->caplen;
    1784 #endif
    1785                 case WAGINT:
    1786                 case WAG:
    1787                         wag_event = (struct wag_event_t *)packet->buffer;
    1788                         switch(wag_event->type) {
    1789                                 case 0:
    1790                                         return wag_event->length*4-(
    1791                                                 sizeof(struct wag_event_t)+
    1792                                                 sizeof(struct wag_data_event_t)
    1793                                                 );
    1794                                 default:
    1795                                         assert(0);
    1796                         }
    1797                 default:
    1798                         assert(0);
     1129
     1130        if (packet->trace->format->get_capture_length) {
     1131                return packet->trace->format->get_capture_length(packet);
    17991132        }
    18001133        return -1;
     
    18111144 */
    18121145int trace_get_wire_length(const struct libtrace_packet_t *packet){
    1813         dag_record_t *erfptr = 0;
    1814 #if HAVE_PCAP
    1815         struct pcap_pkthdr *pcapptr = 0;
    1816 #endif
    1817         struct wag_event_t *wag_event = 0;
    1818         switch (packet->trace->format) {
    1819                 case DAG:
    1820                 case ERF:
    1821                 case RTCLIENT:
    1822                         erfptr = (dag_record_t *)packet->buffer;
    1823                         return ntohs(erfptr->wlen);
    1824                         break;
    1825 #if HAVE_PCAP
    1826                 case PCAPINT:
    1827                 case PCAP:
    1828                         pcapptr = (struct pcap_pkthdr *)packet->buffer;
    1829                         return ntohs(pcapptr->len);
    1830                         break;
    1831 #endif
    1832                 case WAGINT:
    1833                 case WAG:
    1834                         wag_event = (struct wag_event_t *)packet->buffer;
    1835                         switch(wag_event->type) {
    1836                                 case 0:
    1837                                         return ((struct wag_data_event_t *)(&wag_event->payload))->frame_length;
    1838                                 default:
    1839                                         assert(0);
    1840                         }
     1146        if (packet->trace->format->get_wire_length) {
     1147                return packet->trace->format->get_wire_length(packet);
    18411148        }
    18421149        return -1;
     
    18511158 */
    18521159libtrace_linktype_t trace_get_link_type(const struct libtrace_packet_t *packet ) {
    1853         dag_record_t *erfptr = 0;
    1854 #if HAVE_PCAP
    1855         struct pcap_pkthdr *pcapptr = 0;
    1856 #endif
    1857         int linktype = 0;
    1858         switch (packet->trace->format) {
    1859                 case DAG:
    1860                 case ERF:
    1861                 case RTCLIENT:
    1862                         erfptr = (dag_record_t *)packet->buffer;
    1863                         switch (erfptr->type) {
    1864                                 case TYPE_ETH: return TRACE_TYPE_ETH;
    1865                                 case TYPE_ATM: return TRACE_TYPE_ATM;
    1866                                 default: assert(0);
    1867                         }
    1868                         return erfptr->type;
    1869                        
    1870                         break;
    1871 #if HAVE_PCAP
    1872                 case PCAPINT:
    1873                 case PCAP:
    1874                         pcapptr = (struct pcap_pkthdr *)packet->buffer;
    1875                         linktype = pcap_datalink(packet->trace->input.pcap);
    1876                         switch (linktype) {
    1877                                 case DLT_NULL:
    1878                                         return TRACE_TYPE_NONE;
    1879                                 case DLT_EN10MB:
    1880                                         return TRACE_TYPE_ETH;
    1881                                 case DLT_ATM_RFC1483:
    1882                                         return TRACE_TYPE_ATM;
    1883                                 case DLT_IEEE802_11:
    1884                                         return TRACE_TYPE_80211;
    1885 #ifdef DLT_LINUX_SLL
    1886                                 case DLT_LINUX_SLL:
    1887                                         return TRACE_TYPE_LINUX_SLL;
    1888 #endif
    1889 #ifdef DLT_PFLOG
    1890                                 case DLT_PFLOG:
    1891                                         return TRACE_TYPE_PFLOG;
    1892 #endif
    1893                         }
    1894                         break;
    1895 #endif
    1896                 case WAGINT:
    1897                 case WAG:
    1898                         return TRACE_TYPE_80211;
     1160        if (packet->trace->format->get_link_type) {
     1161                return packet->trace->format->get_link_type(packet);
    18991162        }
    19001163        return -1;
     
    21581421 */
    21591422int8_t trace_set_direction(struct libtrace_packet_t *packet, int8_t direction) {
    2160        
    2161         dag_record_t *erfptr = 0;
    2162         assert(packet);
    2163 
    2164         switch(packet->trace->format) {
    2165                 case DAG:
    2166                 case ERF:
    2167                 case RTCLIENT:
    2168                         erfptr = (dag_record_t *)packet->buffer;
    2169                         erfptr->flags.iface = direction;
    2170                         break;
    2171                 default:
    2172                         direction = -1;
    2173         }
    2174        
    2175         return direction;
    2176        
    2177        
     1423
     1424
     1425        if (packet->trace->format->set_direction) {
     1426                return packet->trace->format->set_direction(packet,direction);
     1427        }
     1428        return -1;
    21781429}
    21791430
     
    21891440int8_t trace_get_direction(const struct libtrace_packet_t *packet) {
    21901441       
    2191         int8_t direction;
    2192         dag_record_t *erfptr = 0;
    21931442        assert(packet);
    2194         direction = -1;
    2195 
    2196         switch(packet->trace->format) {
    2197                 case DAG:
    2198                 case ERF:
    2199                 case RTCLIENT:
    2200                         erfptr = (dag_record_t *)packet->buffer;
    2201                         direction = erfptr->flags.iface;
    2202                         break;
    2203                 case PCAP:
    2204                 case PCAPINT:
    2205                         switch (trace_get_link_type(packet)) {
    2206                                 case TRACE_TYPE_LINUX_SLL:
    2207                                 {
    2208                                         struct trace_sll_header_t *sll;
    2209                                         sll = trace_get_link(packet);
    2210                                         if (!sll) {
    2211                                                 return -1;
    2212                                         }
    2213                                         /* 0 == LINUX_SLL_HOST */
    2214                                         /* the Waikato Capture point defines "packets
    2215                                          * originating locally" (ie, outbound), with a
    2216                                          * direction of 0, and "packets destined locally"
    2217                                          * (ie, inbound), with a direction of 1.
    2218                                          * This is kind-of-opposite to LINUX_SLL.
    2219                                          * We return consistent values here, however
    2220                                          *
    2221                                          * Note that in recent versions of pcap, you can
    2222                                          * use "inbound" and "outbound" on ppp in linux
    2223                                          */
    2224                                         if (ntohs(sll->pkttype==0)) {
    2225 
    2226                                                 direction = 1;
    2227                                         }
    2228                                         else {
    2229                                                 direction = 0;
    2230                                         }
    2231                                         break;
    2232                                 }
    2233                                 case TRACE_TYPE_PFLOG:
    2234                                 {
    2235                                         struct trace_pflog_header_t *pflog;
    2236                                         pflog = trace_get_link(packet);
    2237                                         if (!pflog) {
    2238                                                 return -1;
    2239                                         }
    2240                                         /* enum    { PF_IN=0, PF_OUT=1 }; */
    2241                                         if (ntohs(pflog->dir==0)) {
    2242 
    2243                                                 direction = 1;
    2244                                         }
    2245                                         else {
    2246                                                 direction = 0;
    2247                                         }
    2248                                         break;
    2249                                 }
    2250                                 default:
    2251                                         /* pass */
    2252                                         break;
    2253                         }
    2254                 default:
    2255                         /* pass */
    2256                         break;
    2257         }
    2258        
    2259         return direction;
    2260        
     1443
     1444        if (packet->trace->format->get_direction) {
     1445                return packet->trace->format->get_direction(packet);
     1446        }
     1447        return -1;
    22611448       
    22621449}
     
    24391626                return packet->size;
    24401627        }
    2441         switch (packet->trace->format) {
    2442 #if HAVE_PCAP
    2443                 case PCAPINT:
    2444                 case PCAP:
    2445                         pcaphdr = (struct pcap_pkthdr *)packet->buffer;
    2446                         pcaphdr->caplen = size + sizeof(struct pcap_pkthdr);
    2447                         packet->size = pcaphdr->caplen;
    2448                         break;
    2449 #endif
    2450                 case ERF:
    2451                 case DAG:
    2452                 case RTCLIENT:
    2453                         erfptr = (dag_record_t *)packet->buffer;
    2454                         erfptr->rlen = ntohs(size + sizeof(dag_record_t));
    2455                         packet->size = size + sizeof(dag_record_t);
    2456                         break;
    2457                 case WAGINT:
    2458                 case WAG:
    2459                         // don't know how to do this?
    2460                         break;
    2461         }
    2462         return packet->size;
    2463 }
    2464 
     1628        if (packet->trace->format->truncate_packet) {
     1629                return packet->trace->format->truncate_packet(packet,size);
     1630        }
     1631        return -1;
     1632}
     1633
Note: See TracChangeset for help on using the changeset viewer.