Changeset 2137b49


Ignore:
Timestamp:
08/05/04 16:14:14 (16 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:
670d3de
Parents:
b535184
Message:

changes to new api

Location:
lib
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • lib/Makefile

    raa60a6b r2137b49  
    11CC=gcc-3.0
    2 CFLAGS= -Wall -Wimplicit -Wformat -pipe -g -O3
     2CFLAGS= -Wall -Wimplicit -Wpedantic -Wformat -pipe -g -O3
    33PROFCFLAGS= -Wall -Wimplicit -Wformat -pipe -g -pg -fprofile-arcs -a
    44
     
    1212
    1313
    14 CURRENT=1
    15 AGE=0
    16 REVISION=10
     14CURRENT=2
     15AGE=1
     16REVISION=0
    1717
    1818INCLIBS=/usr/local/wand/lib/libzl.a /usr/local/wand/lib/libpcapl.a
  • lib/libtrace.h

    rbb313ef r2137b49  
    2929 */
    3030
    31 #ifndef _LIBTRACE_H_
    32 #define _LIBTRACE_H_
     31#ifndef LIBTRACE_H
     32#define LIBTRACE_H
    3333
    3434#include <features.h>
     
    7777       
    7878/** Opaque structure holding information about a bpf filter */
    79 
    8079struct libtrace_filter_t;
     80
     81/** Opaque structure holding information about a packet */
     82#define LIBTRACE_PACKET_BUFSIZE 65536
     83struct libtrace_packet_t {
     84        struct libtrace_t *trace;
     85        char buffer[LIBTRACE_PACKET_BUFSIZE];
     86        size_t size;
     87        uint8_t status;
     88};
     89
    8190/** Structure for dealing with IP packets */
    8291struct libtrace_ip
     
    197206 *  and an error is output to stdout.
    198207 */
    199 struct libtrace_t *create_trace(char *uri);
     208struct libtrace_t *trace_create(char *uri);
    200209
    201210/** Close a trace file, freeing up any resources it may have been using
    202211 *
    203212 */
    204 void destroy_trace(struct libtrace_t *rtclient);
     213void trace_destroy(struct libtrace_t *trace);
    205214
    206215/** Read one packet from the trace into buffer
    207216 *
    208  * @param libtrace      the trace to read from
    209  * @param buffer        the buffer to read into
    210  * @param len           the length of the buffer
    211  * @param status        status of the trace (only used for RTClients)
    212  * @returns number of bytes copied, -1 on error, or 0 at EOF
    213  *
    214  * @note the buffer must be at least as large as the largest packet (plus
    215  * link layer, and trace packet metadata overhead)
    216  */
    217 int libtrace_read_packet(struct libtrace_t *rtclient, void *buffer, size_t len, int *status);
     217 * @param libtrace      the libtrace opaque pointer
     218 * @param packet        the packet opaque pointer
     219 * @returns false if it failed to read a packet
     220 *
     221 */
     222int trace_read_packet(struct libtrace_t *trace, struct libtrace_packet_t *packet);
    218223
    219224/** get a pointer to the link layer
    220  * @param libtrace      a pointer to the trace object returned from gettrace
    221  * @param buffer        a pointer to a filled in buffer
    222  * @param buflen        a pointer to the size of the buffer
     225 * @param packet        the packet opaque pointer
    223226 *
    224227 * @returns a pointer to the link layer, or NULL if there is no link layer
     
    227230 * this is
    228231 */
    229 void *get_link(struct libtrace_t *libtrace, void *buffer, int buflen);
     232void *trace_get_link(struct libtrace_packet_t *packet);
    230233
    231234/** get a pointer to the IP header (if any)
    232  * @param libtrace      a pointer to the trace object returned from gettrace
    233  * @param buffer        a pointer to a filled in buffer
    234  * @param buflen        a pointer to the size of the buffer
     235 * @param packet        the packet opaque pointer
    235236 *
    236237 * @returns a pointer to the IP header, or NULL if there is not an IP packet
    237238 */
    238 struct libtrace_ip *get_ip(struct libtrace_t *libtrace, void *buffer, int buflen);
     239struct libtrace_ip *trace_get_ip(struct libtrace_packet_t *packet);
    239240
    240241/** get a pointer to the TCP header (if any)
    241  * @param libtrace      a pointer to the trace object returned from gettrace
    242  * @param buffer        a pointer to a filled in buffer
    243  * @param buflen        a pointer to the size of the buffer
     242 * @param packet        the packet opaque pointer
    244243 *
    245244 * @returns a pointer to the TCP header, or NULL if there is not a TCP packet
    246245 */
    247 struct libtrace_tcp *get_tcp(struct libtrace_t *libtrace, void *buffer, int buflen);
     246struct libtrace_tcp *trace_get_tcp(struct libtrace_packet_t *packet);
    248247
    249248/** get a pointer to the UDP header (if any)
    250  * @param libtrace      a pointer to the trace object returned from gettrace
    251  * @param buffer        a pointer to a filled in buffer
    252  * @param buflen        a pointer to the size of the buffer
     249 * @param packet        the packet opaque pointer
    253250 *
    254251 * @returns a pointer to the UDP header, or NULL if this is not a UDP packet
    255252 */
    256 struct libtrace_udp *get_udp(struct libtrace_t *libtrace, void *buffer, int buflen);
     253struct libtrace_udp *trace_get_udp(struct libtrace_packet_t *packet);
    257254
    258255/** get a pointer to the ICMP header (if any)
    259  * @param libtrace      a pointer to the trace object returned from gettrace
    260  * @param buffer        a pointer to a filled in buffer
    261  * @param buflen        a pointer to the size of the buffer
     256 * @param packet        the packet opaque pointer
    262257 *
    263258 * @returns a pointer to the ICMP header, or NULL if this is not a ICMP packet
    264259 */
    265 struct libtrace_icmp *get_icmp(struct libtrace_t *libtrace, void *buffer, int buflen);
     260struct libtrace_icmp *trace_get_icmp(struct libtrace_packet_t *packet);
    266261
    267262/** Get the current time in DAG time format
    268  * @param libtrace the libtrace opaque pointer
    269  * @param buffer a pointer to a filled in buffer
    270  * @param buflen the length of the buffer
     263 * @param packet        the packet opaque pointer
     264 *
    271265 * @returns a 64 bit timestamp in DAG ERF format (upper 32 bits are the seconds
    272266 * past 1970-01-01, the lower 32bits are partial seconds)
    273267 * @author Daniel Lawson
    274268 */
    275 uint64_t get_erf_timestamp(struct libtrace_t *libtrace, void *buffer, int buflen);
     269uint64_t trace_get_erf_timestamp(struct libtrace_packet_t *packet);
    276270
    277271/** Get the current time in struct timeval
    278  * @param libtrace the libtrace opaque pointer
    279  * @param buffer a pointer to a filled in buffer
    280  * @param buflen the length of the buffer
     272 * @param packet        the packet opaque pointer
     273 *
    281274 * @returns time that this packet was seen in a struct timeval
    282275 * @author Daniel Lawson
    283276 * @author Perry Lorier
    284277 */
    285 
    286 struct timeval get_timeval(struct libtrace_t *libtrace, void *buffer, int buflen);
     278struct timeval trace_get_timeval(struct libtrace_packet_t *packet);
    287279
    288280/** Get the current time in floating point seconds
    289  * @param libtrace the libtrace opaque pointer
    290  * @param buffer a pointer to a filled in buffer
    291  * @param buflen the length of the buffer
     281 * @param packet        the packet opaque pointer
     282 *
    292283 * @returns time that this packet was seen in 64bit floating point seconds
    293284 * @author Perry Lorier
    294285 */
    295 double get_seconds(struct libtrace_t *libtrace, void *buffer, int buflen);
     286double trace_get_seconds(struct libtrace_packet_t *packet);
    296287
    297288/** Get the size of the packet in the trace
    298  * @param libtrace the libtrace opaque pointer
    299  * @param buffer a pointer to a filled in buffer
    300  * @param buflen the length of the buffer
     289 * @param packet        the packet opaque pointer
    301290 * @returns the size of the packet in the trace
    302291 * @author Perry Lorier
     
    309298 */
    310299
    311 int get_capture_length(struct libtrace_t *libtrace, void *buffer, int buflen);
     300int trace_get_capture_length(struct libtrace_packet_t *packet);
    312301
    313302/** Get the size of the packet as it was seen on the wire.
    314  * @param libtrace the libtrace opaque pointer
    315  * @param buffer a pointer to a filled in buffer
    316  * @param buflen the length of the buffer
     303 * @param packet        the packet opaque pointer
    317304 * @returns the size of the packet as it was on the wire.
    318305 * @author Perry Lorier
     
    322309 */
    323310
    324 int get_wire_length(struct libtrace_t *libtrace, void *buffer, int buflen);
     311int trace_get_wire_length(struct libtrace_packet_t *packet);
    325312
    326313/** Link layer types
     
    335322
    336323/** Get the type of the link layer
    337  * @param libtrace the libtrace opaque pointer
    338  * @param buffer a pointer to a filled in buffer
    339  * @param buflen the length of the buffer
     324 * @param packet        the packet opaque pointer
    340325 * @returns libtrace_linktype_t
    341326 * @author Perry Lorier
     
    343328 */
    344329
    345 inline libtrace_linktype_t get_link_type(
    346                 struct libtrace_t *libtrace,
    347                 void *buffer,
    348                 int buflen);   
     330inline libtrace_linktype_t trace_get_link_type(struct libtrace_packet_t *packet);
    349331
    350332/** Get the destination MAC addres
    351  * @param libtrace the libtrace opaque pointer
    352  * @param buffer a pointer to a filled in buffer
    353  * @param buflen the length of the buffer
     333 * @param packet        the packet opaque pointer
    354334 * @returns a pointer to the destination mac, (or NULL if there is no
    355335 * destination MAC)
    356336 * @author Perry Lorier
    357337 */
    358 uint8_t *get_destination_mac(struct libtrace_t *libtrace,
    359                         void *buffer,
    360                         int buflen);
     338uint8_t *trace_get_destination_mac(struct libtrace_packet_t *packet);
    361339
    362340/** Get the source MAC addres
    363  * @param libtrace the libtrace opaque pointer
    364  * @param buffer a pointer to a filled in buffer
    365  * @param buflen the length of the buffer
     341 * @param packet        the packet opaque pointer
    366342 * @returns a pointer to the source mac, (or NULL if there is no source MAC)
    367343 * @author Perry Lorier
    368344 */
    369 uint8_t *get_source_mac(struct libtrace_t *libtrace,
    370                         void *buffer,
    371                         int buflen);
     345uint8_t *trace_get_source_mac(struct libtrace_packet_t *packet);
    372346
    373347/** Get the direction flag, if it has one
    374  * @param libtrace the libtrace opaque pointer
    375  * @param buffer a point to a fille in buffer
    376  * @param buflen the length of the buffer
     348 * @param packet        the packet opaque pointer
    377349 * @returns a signed value containing the direction flag, or -1 if this is not supported
    378350 * @author Daniel Lawson
    379351 */
    380 int8_t get_direction(struct libtrace_t *libtrace,
    381                       void *buffer,
    382                       int buflen);
     352int8_t trace_get_direction(struct libtrace_packet_t *packet);
    383353
    384354/** Event types */
     
    395365 *  TRACE_EVENT_PACKET  Packet arrived in <buffer> with size <size>
    396366 */
    397 libtrace_event_t libtrace_event(struct libtrace_t *trace,
    398                         int *fd,double *seconds,
    399                         void *buffer, size_t len, int *size);
     367libtrace_event_t trace_event(struct libtrace_packet_t *packet,
     368                int *fd,double *seconds);
    400369
    401370/** setup a BPF filter
     
    404373 * @author Daniel Lawson
    405374 */
    406 struct libtrace_filter_t *libtrace_bpf_setfilter(const char *filterstring);
     375struct libtrace_filter_t *trace_bpf_setfilter(const char *filterstring);
    407376
    408377/** apply a BPF filter
    409  * @param libtrace the libtrace opaque pointer
    410  * @param filter the filter opaque pointer
    411  * @param buffer a pointer to a filled buffer
    412  * @param buflen the length of the buffer
     378 * @param filter        the filter opaque pointer
     379 * @param packet        the packet opaque pointer
    413380 * @returns the return value from bpf_filter
    414381 * @author Daniel Lawson
    415382 */
    416 int libtrace_bpf_filter(struct libtrace_t *trace,
    417                         struct libtrace_filter_t *filter,
    418                         void *buffer,
    419                         int buflen);
     383int trace_bpf_filter(struct libtrace_filter_t *filter,
     384                struct libtrace_packet_t *packet);
    420385
    421386#ifdef __cplusplus
    422387} // extern "C"
    423 #endif // #ifdef _cplusplus
    424 #endif // _LIBTRACE_H_
     388#endif // #ifdef __cplusplus
     389#endif // LIBTRACE_H_
  • lib/trace.c

    raa60a6b r2137b49  
    5959
    6060#include <net/bpf.h>
     61
    6162#include <pcap.h>
    6263
     
    102103};
    103104
     105#define URI_PROTO_LINE 16
    104106static int init_trace(struct libtrace_t **libtrace, char *uri) {
    105         char *scan = calloc(sizeof(char),16);
    106         char *uridata;
     107        char *scan = calloc(sizeof(char),URI_PROTO_LINE);
     108        char *uridata = 0;
    107109       
    108110        // parse the URI to determine what sort of event we are dealing with
     
    111113
    112114        if((uridata = strchr(uri,':')) == NULL) {
    113                 // badly formed URI
     115                // badly formed URI - needs a :
    114116                return 0;
    115117        }
    116118
    117         if ((*uridata - *uri) > 16) {
    118                 // badly formed URI
     119        if ((*uridata - *uri) > URI_PROTO_LINE) {
     120                // badly formed URI - uri type is too long
    119121                return 0;
    120122        }
     
    253255 * and an error is output to stdout.
    254256 */
    255 struct libtrace_t *create_trace(char *uri) {
     257struct libtrace_t *trace_create(char *uri) {
    256258        struct libtrace_t *libtrace = malloc(sizeof(struct libtrace_t));
    257259        struct hostent *he;
     
    351353 *
    352354 */
    353 void destroy_trace(struct libtrace_t *libtrace) {
     355void trace_destroy(struct libtrace_t *libtrace) {
    354356        assert(libtrace);
    355357        if (libtrace->format == PCAP || libtrace->format == PCAPINT) {
     
    365367}
    366368
    367 static int libtrace_read(struct libtrace_t *libtrace, void *buffer, size_t len) {
     369static int trace_read(struct libtrace_t *libtrace, void *buffer, size_t len) {
    368370        int numbytes;
    369371        assert(libtrace);
     
    407409/** Read one packet from the trace into buffer
    408410 *
    409  * @param libtrace      the trace to read from
    410  * @param buffer        the buffer to read into
    411  * @param len           the length of the buffer
    412  * @param status        a pointer to the status byte
    413  * @returns number of bytes copied.
    414  *
    415  * @note the buffer must be at least as large as the largest packet (plus
    416  * link layer, and trace packet metadata overhead)
    417  */
    418 int libtrace_read_packet(struct libtrace_t *libtrace, void *buffer, size_t len, int *status) {
     411 * @param libtrace      the libtrace opaque pointer
     412 * @param packet        the packet opaque pointer
     413 * @returns false if it failed to read a packet
     414 *
     415 */
     416int trace_read_packet(struct libtrace_t *libtrace, struct libtrace_packet_t *packet) {
    419417        int numbytes;
    420418        int size;
     
    423421        const u_char *pcappkt;
    424422        int read_required = 0;
     423
     424        void *buffer = 0;
    425425        if (!libtrace) {
    426                 fprintf(stderr,"Oi! You called libtrace_read_packet() with a NULL libtrace parameter!\n");
     426                fprintf(stderr,"Oi! You called trace_read_packet() with a NULL libtrace parameter!\n");
    427427        }
    428428        assert(libtrace);
    429         assert(buffer);
    430         assert(status);
    431         assert(len > 200);
     429        assert(packet);
    432430
    433431        //bzero(buffer,len);
    434        
     432     
     433        /* Store the trace we are reading from into the packet opaque
     434         * structure */
     435        packet->trace = libtrace;
     436
     437        buffer = packet->buffer;
    435438        /* PCAP gives us it's own per-packet interface. Let's use it */
    436439        if (libtrace->format == PCAP || libtrace->format == PCAPINT) {
     
    441444                memcpy(buffer + sizeof(struct pcap_pkthdr),pcappkt,pcaphdr.len);
    442445                numbytes = pcaphdr.len;
    443 
     446       
     447                packet->size = numbytes;
    444448                return numbytes;
    445449        }
     
    460464                }
    461465                size = ntohs(((dag_record_t *)buffer)->rlen) - sizeof(dag_record_t);
    462                 assert(len > size);
     466                assert(size < LIBTRACE_PACKET_BUFSIZE);
    463467                buffer2 += sizeof(dag_record_t);
    464468
     
    470474                        return -1;
    471475                }
     476                packet->size = numbytes + sizeof(dag_record_t);
    472477                return sizeof(dag_record_t) + numbytes;
    473478        }
    474479        do {
    475480                if (fifo_out_available(libtrace->fifo) == 0 || read_required) {
    476                         if ((numbytes = libtrace_read(libtrace,buf,4096))<=0){
     481                        if ((numbytes = trace_read(libtrace,buf,4096))<=0){
    477482                                return numbytes;
    478483                        }
     
    485490                        case RTCLIENT:
    486491                                // only do this if we're reading from the RT interface
    487                                 if (fifo_out_read(libtrace->fifo, status, sizeof(int)) == 0) {
     492                                if (fifo_out_read(libtrace->fifo, &packet->status, sizeof(int)) == 0) {
    488493                                        read_required = 1;
    489494                                        continue;
     
    520525                }
    521526
    522                 assert(len > size);
     527                assert(size < LIBTRACE_PACKET_BUFSIZE);
    523528
    524529                // read in the full packet
     
    538543                }
    539544               
     545                packet->size = numbytes;
    540546                return numbytes;
    541547
     
    550556 *
    551557 * @returns a pointer to the link layer, or NULL if there is no link layer
    552  * you should call get_link_type() to find out what type of link layer this is
    553  */
    554 void *get_link(struct libtrace_t *libtrace, void *buffer, int buflen) {
     558 * you should call trace_get_link_type() to find out what type of link layer this is
     559 */
     560void *trace_get_link(struct libtrace_packet_t *packet) {
    555561        void *ethptr = 0;
    556         struct wag_event_t *event = buffer;
     562       
     563        struct wag_event_t *event = (struct wag_event_t *)packet->buffer;
    557564        struct wag_data_event_t *data_event;
     565       
    558566       
    559         switch(libtrace->format) {
     567        switch(packet->trace->format) {
    560568                case ERF:
    561569                case DAG:
    562570                case RTCLIENT:
    563                         if (get_link_type(libtrace,buffer,buflen)==TRACE_TYPE_ETH)
    564                                 ethptr = ((uint8_t *)buffer +
     571                        if (trace_get_link_type(packet)==TRACE_TYPE_ETH)
     572                                ethptr = ((uint8_t *)packet->buffer +
    565573                                                dag_record_size + 2);
    566574                        else
    567                                 ethptr = ((uint8_t *)buffer +
     575                                ethptr = ((uint8_t *)packet->buffer +
    568576                                                dag_record_size + 2);
    569577                        break;
    570578                case PCAPINT:
    571579                case PCAP:
    572                         ethptr = (struct ether_header *)(buffer + sizeof(struct pcap_pkthdr));
     580                        ethptr = (struct ether_header *)(packet->buffer + sizeof(struct pcap_pkthdr));
    573581                        break;
    574582                case WAGINT:
     
    597605 * @returns a pointer to the IP header, or NULL if there is not an IP packet
    598606 */
    599 struct libtrace_ip *get_ip(struct libtrace_t *libtrace, void *buffer, int buflen) {
     607struct libtrace_ip *trace_get_ip(struct libtrace_packet_t *packet) {
    600608        struct libtrace_ip *ipptr = 0;
    601609
    602         switch(get_link_type(libtrace,buffer,buflen)) {
     610        switch(trace_get_link_type(packet)) {
    603611                case TRACE_TYPE_80211:
    604612                        {
    605613                               
    606                                 struct ieee_802_11_header *wifi = get_link(libtrace, buffer, buflen);   
     614                                struct ieee_802_11_header *wifi = trace_get_link(packet);       
    607615
    608616                                // Data packet?
     
    622630                case TRACE_TYPE_ETH:
    623631                        {
    624                                 struct ether_header *eth = get_link(libtrace,
    625                                                 buffer, buflen);
     632                                struct ether_header *eth =
     633                                        trace_get_link(packet);
    626634                                if (ntohs(eth->ether_type)!=0x0800) {
    627635                                        ipptr = NULL;
     
    634642                case TRACE_TYPE_ATM:
    635643                        {
    636                                 struct atm_rec *atm = get_link(libtrace,
    637                                                 buffer, buflen);
     644                                struct atm_rec *atm =
     645                                        trace_get_link(packet);
    638646                                // TODO: Find out what ATM does, and return
    639647                                //       NULL for non IP data
     
    643651                        }
    644652                default:
    645                         fprintf(stderr,"Don't understand link layer type %i in get_ip()\n",
    646                                 get_link_type(libtrace,buffer,buflen));
     653                        fprintf(stderr,"Don't understand link layer type %i in trace_get_ip()\n",
     654                                trace_get_link_type(packet));
    647655                        ipptr=NULL;
    648656                        break;
     
    660668 * @returns a pointer to the TCP header, or NULL if there is not a TCP packet
    661669 */
    662 struct libtrace_tcp *get_tcp(struct libtrace_t *libtrace, void *buffer, int buflen) {
     670struct libtrace_tcp *trace_get_tcp(struct libtrace_packet_t *packet) {
    663671        struct libtrace_tcp *tcpptr = 0;
    664672        struct libtrace_ip *ipptr = 0;
    665673
    666         if(!(ipptr = get_ip(libtrace,buffer,buflen))) {
     674        if(!(ipptr = trace_get_ip(packet))) {
    667675                return 0;
    668676        }
     
    680688 * @returns a pointer to the UDP header, or NULL if this is not a UDP packet
    681689 */
    682 struct libtrace_udp *get_udp(struct libtrace_t *libtrace, void *buffer, int buflen) {
     690struct libtrace_udp *trace_get_udp(struct libtrace_packet_t *packet) {
    683691        struct libtrace_udp *udpptr = 0;
    684692        struct libtrace_ip *ipptr = 0;
    685693       
    686         if(!(ipptr = get_ip(libtrace,buffer,buflen))) {
     694        if(!(ipptr = trace_get_ip(packet))) {
    687695                return 0;
    688696        }
     
    700708 * @returns a pointer to the ICMP header, or NULL if this is not a ICMP packet
    701709 */
    702 struct libtrace_icmp *get_icmp(struct libtrace_t *libtrace, void *buffer, int buflen) {
     710struct libtrace_icmp *trace_get_icmp(struct libtrace_packet_t *packet) {
    703711        struct libtrace_icmp *icmpptr = 0;
    704712        struct libtrace_ip *ipptr = 0;
    705713       
    706         if(!(ipptr = get_ip(libtrace,buffer,buflen))) {
     714        if(!(ipptr = trace_get_ip(packet))) {
    707715                return 0;
    708716        }
     
    721729 * @author Daniel Lawson
    722730 */
    723 uint64_t get_erf_timestamp(struct libtrace_t *libtrace, void *buffer, int buflen) {
     731uint64_t trace_get_erf_timestamp(struct libtrace_packet_t *packet) {
    724732        uint64_t timestamp = 0;
    725733        dag_record_t *erfptr = 0;
    726734        struct pcap_pkthdr *pcapptr = 0;
    727735        struct wag_event_t *wagptr = 0;
    728         switch (libtrace->format) {
     736        switch (packet->trace->format) {
    729737                case DAG:
    730738                case ERF:
    731739                case RTCLIENT:
    732                         erfptr = (dag_record_t *)buffer;
     740                        erfptr = (dag_record_t *)packet->buffer;
    733741                        timestamp = erfptr->ts;
    734742                        break;
    735743                case PCAPINT:
    736744                case PCAP:
    737                         pcapptr = (struct pcap_pkthdr *)buffer;
     745                        pcapptr = (struct pcap_pkthdr *)packet->buffer;
    738746                        timestamp = ((((uint64_t)pcapptr->ts.tv_sec) << 32) + \
    739747                                (pcapptr->ts.tv_usec*UINT_MAX/1000000));
     
    741749                case WAGINT:
    742750                case WAG:
    743                         wagptr = buffer;
     751                        wagptr = (struct wag_event_t *)packet->buffer;
    744752                        timestamp = wagptr->timestamp_lo;
    745753                        timestamp |= (uint64_t)wagptr->timestamp_hi<<32;
     
    748756                        break;
    749757                default:
    750                         fprintf(stderr,"Unknown format in get_erf_timestamp\n");
     758                        fprintf(stderr,"Unknown format in trace_get_erf_timestamp\n");
    751759                        timestamp = 0;
    752760        }
     
    762770 * @author Perry Lorier
    763771 */
    764 struct timeval get_timeval(struct libtrace_t *libtrace, void *buffer, int buflen) {
     772struct timeval trace_get_timeval(struct libtrace_packet_t *packet) {
    765773        struct timeval tv;
    766774        struct pcap_pkthdr *pcapptr = 0;
    767775        uint64_t ts;
    768776        //uint32_t seconds;
    769         switch (libtrace->format) {
     777        switch (packet->trace->format) {
    770778                case PCAPINT:
    771779                case PCAP:
    772                         pcapptr = (struct pcap_pkthdr *)buffer;
     780                        pcapptr = (struct pcap_pkthdr *)packet->buffer;
    773781                        tv = pcapptr->ts;
    774782                        break;
     
    780788                default:
    781789                        // FIXME: This isn't portable to big-endian machines
    782                         ts = get_erf_timestamp(libtrace,buffer,buflen);
     790                        ts = trace_get_erf_timestamp(packet);
    783791                        tv.tv_sec = ts >> 32;           
    784792                        ts = (1000000 * (ts & 0xffffffffULL));
     
    801809 * @author Perry Lorier
    802810 */
    803 double get_seconds(struct libtrace_t *libtrace, void *buffer, int buflen) {
     811double trace_get_seconds(struct libtrace_packet_t *packet) {
    804812        uint64_t ts;
    805         ts = get_erf_timestamp(libtrace,buffer,buflen);
     813        ts = trace_get_erf_timestamp(packet);
    806814        return (ts>>32) + ((ts & UINT_MAX)*1.0 / UINT_MAX);
    807815}
    808816
    809817/** Get the size of the packet in the trace
    810  * @param libtrace the libtrace opaque pointer
    811  * @param buffer a pointer to a filled in buffer
    812  * @param buflen the length of the buffer
     818 * @param packet the packet opaque pointer
    813819 * @returns the size of the packet in the trace
    814820 * @author Perry Lorier
    815821 * @note Due to this being a header capture, or anonymisation, this may not
    816  * be the same size as the original packet.  See get_wire_length() for the
     822 * be the same size as the original packet.  See trace_get_wire_length() for the
    817823 * original size of the packet.
    818824 * @note This can (and often is) different for different packets in a trace!
     
    820826 *  This is sometimes called the "snaplen".
    821827 */
    822 int get_capture_length(struct libtrace_t *libtrace, void *buffer, int buflen) {
     828int trace_get_capture_length(struct libtrace_packet_t *packet) {
    823829        dag_record_t *erfptr = 0;
    824830        struct pcap_pkthdr *pcapptr = 0;
    825831        struct wag_event_t *wag_event;
    826         switch (libtrace->format) {
     832        switch (packet->trace->format) {
    827833                case DAG:
    828834                case ERF:
    829835                case RTCLIENT:
    830                         erfptr = (dag_record_t *)buffer;
     836                        erfptr = (dag_record_t *)packet->buffer;
    831837                        return ntohs(erfptr->rlen);
    832838                case PCAPINT:
    833839                case PCAP:
    834                         pcapptr = (struct pcap_pkthdr *)buffer;
     840                        pcapptr = (struct pcap_pkthdr *)packet->buffer;
    835841                        //return ntohs(pcapptr->caplen);
    836842                        return pcapptr->caplen;
    837843                case WAGINT:
    838844                case WAG:
    839                         wag_event = buffer;
     845                        wag_event = (struct wag_event_t *)packet->buffer;
    840846                        switch(wag_event->type) {
    841847                                case 0:
     
    863869 * not be the same as the Capture Len.
    864870 */
    865 int get_wire_length(struct libtrace_t *libtrace, void *buffer, int buflen){
     871int trace_get_wire_length(struct libtrace_packet_t *packet){
    866872        dag_record_t *erfptr = 0;
    867873        struct pcap_pkthdr *pcapptr = 0;
    868874        struct wag_event_t *wag_event = 0;
    869         switch (libtrace->format) {
     875        switch (packet->trace->format) {
    870876                case DAG:
    871877                case ERF:
    872878                case RTCLIENT:
    873                         erfptr = (dag_record_t *)buffer;
     879                        erfptr = (dag_record_t *)packet->buffer;
    874880                        return ntohs(erfptr->wlen);
    875881                        break;
    876882                case PCAPINT:
    877883                case PCAP:
    878                         pcapptr = (struct pcap_pkthdr *)buffer;
     884                        pcapptr = (struct pcap_pkthdr *)packet->buffer;
    879885                        return ntohs(pcapptr->len);
    880886                        break;
    881887                case WAGINT:
    882888                case WAG:
    883                         wag_event = buffer;
     889                        wag_event = (struct wag_event_t *)packet->buffer;
    884890                        switch(wag_event->type) {
    885891                                case 0:
     
    901907 * @author Daniel Lawson
    902908 */
    903 libtrace_linktype_t get_link_type(
    904                 struct libtrace_t *libtrace,
    905                 void *buffer,
    906                 int buflen) {
     909libtrace_linktype_t trace_get_link_type(struct libtrace_packet_t *packet ) {
    907910        dag_record_t *erfptr = 0;
    908911        struct pcap_pkthdr *pcapptr = 0;
    909912        int linktype = 0;
    910         switch (libtrace->format) {
     913        switch (packet->trace->format) {
    911914                case DAG:
    912915                case ERF:
    913916                case RTCLIENT:
    914                         erfptr = (dag_record_t *)buffer;
     917                        erfptr = (dag_record_t *)packet->buffer;
    915918                        switch (erfptr->type) {
    916919                                case TYPE_ETH: return TRACE_TYPE_ETH;
     
    923926                case PCAPINT:
    924927                case PCAP:
    925                         pcapptr = (struct pcap_pkthdr *)buffer;
    926                         linktype = pcap_datalink(libtrace->input.pcap);
     928                        pcapptr = (struct pcap_pkthdr *)packet->buffer;
     929                        linktype = pcap_datalink(packet->trace->input.pcap);
    927930                        switch (linktype) {
    928931                                case 1:
     
    948951 * @author Perry Lorier
    949952 */
    950 uint8_t *get_source_mac(struct libtrace_t *libtrace,
    951                 void *buffer,
    952                 int buflen) {
    953         void *link = get_link(libtrace,buffer,buflen);
     953uint8_t *trace_get_source_mac(struct libtrace_packet_t *packet) {
     954        void *link = trace_get_link(packet);
    954955        struct ieee_802_11_header *wifi = link;
    955956        struct ether_header *ethptr = link;
    956957        if (!link)
    957958                return NULL;
    958         switch (get_link_type(libtrace,buffer,buflen)) {
     959        switch (trace_get_link_type(packet)) {
    959960                case TRACE_TYPE_80211:
    960961                        return (uint8_t*)&wifi->mac2;
     
    975976 * @author Perry Lorier
    976977 */
    977 uint8_t *get_destination_mac(struct libtrace_t *libtrace,
    978                 void *buffer,
    979                 int buflen) {
    980         void *link = get_link(libtrace,buffer,buflen);
     978uint8_t *trace_get_destination_mac(struct libtrace_packet_t *packet) {
     979        void *link = trace_get_link(packet);
    981980        struct ieee_802_11_header *wifi = link;
    982981        struct ether_header *ethptr = link;
    983982        if (!link)
    984983                return NULL;
    985         switch (get_link_type(libtrace,buffer,buflen)) {
     984        switch (trace_get_link_type(packet)) {
    986985                case TRACE_TYPE_80211:
    987986                        return (uint8_t*)&wifi->mac1;
     
    10061005 *  TRACE_EVENT_SLEEP   Next event in <seconds>
    10071006 *  TRACE_EVENT_PACKET  Packet arrived in <buffer> with size <size>
     1007 * FIXME currently keeps a copy of the packet inside the trace pointer,
     1008 * which in turn is stored inside the new packet object...
    10081009 * @author Perry Lorier
    10091010 */
    1010 libtrace_event_t libtrace_event(struct libtrace_t *libtrace,
    1011                         int *fd,double *seconds,
    1012                         void *buffer, size_t len, int *size)
    1013 {
     1011libtrace_event_t libtrace_event(struct libtrace_t *trace,
     1012                struct libtrace_packet_t *packet,
     1013                        int *fd,double *seconds) {
    10141014        *seconds = 0;
    10151015        *fd = 0;
    10161016        /* Is there a packet ready? */
    1017         switch (libtrace->sourcetype) {
     1017        switch (trace->sourcetype) {
    10181018                case INTERFACE:
    10191019                        {
    10201020                                int data;
    1021                                 *fd = pcap_fileno(libtrace->input.pcap);
     1021                                *fd = pcap_fileno(trace->input.pcap);
    10221022                                if(ioctl(*fd,FIONREAD,&data)==-1){
    10231023                                        perror("ioctl(FIONREAD)");
     
    10331033                        {
    10341034                                int data;
    1035                                 if(ioctl(libtrace->input.fd,FIONREAD,&data)==-1){
     1035                                if(ioctl(trace->input.fd,FIONREAD,&data)==-1){
    10361036                                        perror("ioctl(FIONREAD)");
    10371037                                }
     
    10391039                                        return TRACE_EVENT_PACKET;
    10401040                                }
    1041                                 *fd = libtrace->input.fd;
     1041                                *fd = trace->input.fd;
    10421042                                return TRACE_EVENT_IOWAIT;
    10431043                        }
     
    10451045                case TRACE:
    10461046                        {
    1047                                 int status;
    10481047                                double ts;
    10491048                                /* "Prime" the pump */
    1050                                 if (!libtrace->packet.buffer) {
    1051                                         libtrace->packet.buffer = malloc(4096);
    1052                                         libtrace->packet.size=
    1053                                                 libtrace_read_packet(libtrace,
    1054                                                         libtrace->packet.buffer,
    1055                                                         4096,
    1056                                                         &status);
    1057                                 }
    1058                                 ts=get_seconds(libtrace,
    1059                                         libtrace->packet.buffer,
    1060                                         libtrace->packet.size);
    1061                                 if (libtrace->last_ts!=0) {
    1062                                         *seconds = ts - libtrace->last_ts;
    1063                                         if (*seconds>time(NULL)-libtrace->start_ts)
     1049                                if (!trace->packet.buffer) {
     1050                                        trace->packet.buffer = malloc(4096);
     1051                                        trace->packet.size=
     1052                                                trace_read_packet(trace,packet);
     1053                                }
     1054                                ts=trace_get_seconds(packet);
     1055                                if (trace->last_ts!=0) {
     1056                                        *seconds = ts - trace->last_ts;
     1057                                        if (*seconds>time(NULL)-trace->start_ts)
    10641058                                                return TRACE_EVENT_SLEEP;
    10651059                                }
    10661060                                else {
    1067                                         libtrace->start_ts = time(NULL);
    1068                                         libtrace->last_ts = ts;
    1069                                 }
    1070 
    1071                                 *size = libtrace->packet.size;
    1072                                 memcpy(buffer,libtrace->packet.buffer,*size);
    1073 
    1074                                 free(libtrace->packet.buffer);
    1075                                 libtrace->packet.buffer = 0;
     1061                                        trace->start_ts = time(NULL);
     1062                                        trace->last_ts = ts;
     1063                                }
     1064
     1065                                packet->size = trace->packet.size;
     1066                                memcpy(packet->buffer,trace->packet.buffer,trace->packet.size);
     1067
     1068                                free(trace->packet.buffer);
     1069                                trace->packet.buffer = 0;
    10761070                                return TRACE_EVENT_PACKET;
    10771071                        }
     
    10881082 * @author Daniel Lawson
    10891083 */
    1090 struct libtrace_filter_t *libtrace_bpf_setfilter(const char *filterstring) {
     1084struct libtrace_filter_t *trace_bpf_setfilter(const char *filterstring) {
    10911085        struct libtrace_filter_t *filter = malloc(sizeof(struct libtrace_filter_t));
    10921086        filter->filterstring = strdup(filterstring);
     
    11031097 * @author Daniel Lawson
    11041098 */
    1105 int libtrace_bpf_filter(struct libtrace_t *libtrace,
    1106                         struct libtrace_filter_t *filter,
    1107                         void *buffer,
    1108                         int buflen) {
     1099int trace_bpf_filter(struct libtrace_filter_t *filter,
     1100                        struct libtrace_packet_t *packet) {
    11091101       
    1110         int linktype = get_link_type(libtrace,buffer,buflen);
    1111         void *linkptr = get_link(libtrace,buffer,buflen);       
    1112         int clen = get_capture_length(libtrace,buffer,buflen);
    1113         assert(libtrace);
     1102        void *linkptr = 0;
     1103        int clen = 0;
    11141104        assert(filter);
    1115         assert(buffer);
     1105        assert(packet);
     1106        linkptr = trace_get_link(packet);       
    11161107        assert(linkptr);
     1108        clen = trace_get_capture_length(packet);
    11171109       
    11181110
     
    11211113                struct bpf_program bpfprog;
    11221114
    1123                 switch (linktype) {
     1115                switch (trace_get_link_type(packet)) {
    11241116                        case TRACE_TYPE_ETH:
    11251117                                pcap = pcap_open_dead(DLT_EN10MB, 1500);
     
    11521144 * @author Daniel Lawson
    11531145 */
    1154 int8_t get_direction(struct libtrace_t *libtrace,
    1155                       void *buffer,
    1156                       int buflen) {
     1146int8_t trace_get_direction(struct libtrace_packet_t *packet) {
    11571147       
    11581148        int8_t direction;
    11591149        dag_record_t *erfptr = 0;
    1160         assert(libtrace);
    1161         assert(buffer);
    1162 
    1163         switch(libtrace->format) {
     1150        assert(packet);
     1151
     1152        switch(packet->trace->format) {
    11641153                case DAG:
    11651154                case ERF:
    11661155                case RTCLIENT:
    1167                         erfptr = (dag_record_t *)buffer;
     1156                        erfptr = (dag_record_t *)packet->buffer;
    11681157                        direction = erfptr->flags.iface;
    11691158                        break;
Note: See TracChangeset for help on using the changeset viewer.