Changeset 2137b49 for lib/trace.c


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

File:
1 edited

Legend:

Unmodified
Added
Removed
  • 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.