Changeset 9bc4689


Ignore:
Timestamp:
09/06/07 01:07:07 (14 years ago)
Author:
Perry Lorier <perry@…>
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:
fbc4342
Parents:
180f095
Message:

Move everything over to using the newer API's

Location:
lib
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • lib/format_pcap.c

    r708f9ae r9bc4689  
    313313{
    314314        struct pcap_pkthdr pcap_pkt_hdr;
     315        void *link;
     316        libtrace_linktype_t linktype;
     317        uint32_t remaining;
     318
     319        link = trace_get_packet_buffer(packet,&linktype,&remaining);
    315320
    316321        /* If this packet cannot be converted to a pcap linktype then
    317322         * pop off the top header until it can be converted
    318323         */
    319         while (libtrace_to_pcap_linktype(trace_get_link_type(packet))==~0U) {
     324        while (libtrace_to_pcap_linktype(linktype)==~0U) {
    320325                if (!demote_packet(packet)) {
    321326                        trace_set_err_out(libtrace,
     
    324329                        return -1;
    325330                }
     331
     332                link = trace_get_packet_buffer(packet,&linktype,&remaining);
    326333        }
    327334
     
    346353
    347354        /* Corrupt packet, or other "non data" packet, so skip it */
    348         if (trace_get_link(packet) == NULL) {
     355        if (link == NULL) {
    349356                /* Return "success", but nothing written */
    350357                return 0;
     
    363370                pcap_pkt_hdr.ts.tv_sec = ts.tv_sec;
    364371                pcap_pkt_hdr.ts.tv_usec = ts.tv_usec;
    365                 pcap_pkt_hdr.caplen = trace_get_capture_length(packet);
     372                pcap_pkt_hdr.caplen = remaining;
    366373                /* trace_get_wire_length includes FCS, while pcap doesn't */
    367374                if (trace_get_link_type(packet)==TRACE_TYPE_ETH)
     
    442449                {
    443450                        libtrace_sll_header_t *sll;
    444                         sll = trace_get_link(packet);
     451                        sll = trace_get_packet_buffer(packet, NULL, NULL);
     452                        /* TODO: should check remaining>=sizeof(*sll) */
    445453                        if (!sll) {
    446454                                trace_set_err(packet->trace,
     
    471479                {
    472480                        libtrace_pflog_header_t *pflog;
    473                         pflog = trace_get_link(packet);
     481                        pflog = trace_get_packet_buffer(packet, NULL, NULL);
     482                        /* TODO: should check remaining >= sizeof(*pflog) */
    474483                        if (!pflog) {
    475484                                trace_set_err(packet->trace,
     
    518527                return pcapptr->len+4; /* Include the missing FCS */
    519528        else if (packet->type==pcap_linktype_to_rt(TRACE_DLT_IEEE802_11_RADIO)) {
     529                libtrace_linktype_t linktype;
     530                void *link = trace_get_packet_buffer(packet,&linktype,NULL);
    520531                /* If the packet is Radiotap and the flags field indicates
    521532                 * that the FCS is not included in the 802.11 frame, then
     
    523534                 */
    524535                uint8_t flags;
    525                 trace_get_wireless_flags(trace_get_link(packet),
    526                                 trace_get_link_type(packet), &flags);
     536                trace_get_wireless_flags(link,
     537                                linktype, &flags);
    527538                if ((flags & TRACE_RADIOTAP_F_FCS) == 0)
    528539                        return pcapptr->len + 4;
  • lib/format_pcapfile.c

    r646aca1 r9bc4689  
    281281        int numbytes;
    282282        int ret;
     283        void *ptr;
     284        uint32_t remaining;
     285        libtrace_linktype_t linktype;
     286
     287        ptr = trace_get_packet_buffer(packet,&linktype,&remaining);
    283288
    284289        /* If this packet cannot be converted to a pcap linktype then
    285290         * pop off the top header until it can be converted
    286291         */
    287         while (libtrace_to_pcap_linktype(trace_get_link_type(packet))==~0U) {
     292        while (libtrace_to_pcap_linktype(linktype)==~0U) {
    288293                if (!demote_packet(packet)) {
    289294                        trace_set_err_out(out,
     
    292297                        return -1;
    293298                }
     299
     300                ptr = trace_get_packet_buffer(packet,&linktype,&remaining);
    294301        }
    295302
     
    314321                pcaphdr.snaplen = 65536;
    315322                pcaphdr.network =
    316                         libtrace_to_pcap_linktype(trace_get_link_type(packet));
    317 
    318                 libtrace_io_write(DATAOUT(out)->file, &pcaphdr, sizeof(pcaphdr));
     323                        libtrace_to_pcap_linktype(linktype);
     324
     325                libtrace_io_write(DATAOUT(out)->file,
     326                                &pcaphdr, sizeof(pcaphdr));
    319327        }
    320328
     
    323331        hdr.caplen = trace_get_capture_length(packet);
    324332        /* PCAP doesn't include the FCS, we do */
    325         if (trace_get_link_type(packet)==TRACE_TYPE_ETH)
     333        if (linktype==TRACE_TYPE_ETH)
    326334                if (trace_get_wire_length(packet) >= 4) {
    327                         hdr.wirelen =
    328                                         trace_get_wire_length(packet)-4;
     335                        hdr.wirelen = trace_get_wire_length(packet)-4;
    329336                }
    330337                else {
     
    342349
    343350        ret=libtrace_io_write(DATAOUT(out)->file,
    344                         trace_get_link(packet),
    345                         trace_get_capture_length(packet));
    346 
    347         if (ret!=(int)trace_get_capture_length(packet))
     351                        link,
     352                        remaining);
     353
     354        if (ret!=(int)remaining)
    348355                return -1;
    349356
     
    371378                {
    372379                        libtrace_sll_header_t *sll;
    373                         sll = (libtrace_sll_header_t*)trace_get_link(packet);
     380                        libtrace_linktype_t linktype;
     381
     382                        sll = (libtrace_sll_header_t*)trace_get_packet_buffer(
     383                                        packet,
     384                                        &linktype,
     385                                        NULL);
    374386                        if (!sll) {
    375387                                trace_set_err(packet->trace,
     
    400412                {
    401413                        libtrace_pflog_header_t *pflog;
    402                         pflog=(libtrace_pflog_header_t*)trace_get_link(packet);
     414                        libtrace_linktype_t linktype;
     415
     416                        pflog=(libtrace_pflog_header_t*)trace_get_packet_buffer(
     417                                        packet,&linktype,NULL);
    403418                        if (!pflog) {
    404419                                trace_set_err(packet->trace,
     
    455470                 */
    456471                uint8_t flags;
    457                 trace_get_wireless_flags(trace_get_link(packet),
    458                                 trace_get_link_type(packet), &flags);
     472                void *link;
     473                libtrace_linktype_t linktype;
     474                link = trace_get_packet_buffer(packet, &linktype, NULL);
     475                trace_get_wireless_flags(link, linktype, &flags);
    459476                if ((flags & TRACE_RADIOTAP_F_FCS) == 0)
    460477                        return swapl(packet->trace,pcapptr->wirelen)+4;
  • lib/libtrace.h.in

    r180f095 r9bc4689  
    397397    int16_t  ip_id;                     /**< Identification */
    398398#if BYTE_ORDER == LITTLE_ENDIAN
    399     LT_BITFIELD16 ip_off:12;            /**< Fragment Offset */
     399    LT_BITFIELD16 ip_off:13;            /**< Fragment Offset */
    400400    LT_BITFIELD16 ip_mf:1;              /**< More Fragments Flag */
    401401    LT_BITFIELD16 ip_df:1;              /**< Dont Fragment Flag */
     
    405405    LT_BITFIELD16 ip_df:1;              /**< More Fragments Flag */
    406406    LT_BITFIELD16 ip_mf:1;              /**< Dont Fragment Flag */
    407     LT_BITFIELD16 ip_off:12;            /**< Reserved Fragment Flag */
     407    LT_BITFIELD16 ip_off:13;            /**< Reserved Fragment Flag */
    408408#else
    409409#   error "Adjust your <bits/endian.h> defines"
     
    10631063                uint32_t *remaining);
    10641064
     1065/** Gets a pointer to the next header given a pointer to a layer2 header
     1066 *
     1067 * @param l2                    The pointer to the current layer2 header
     1068 * @param linktype              The type of the layer2 header
     1069 * @param[out] ethertype        An optional output variable of the ethernet type
     1070 * @param[in,out] remaining     Optionally updated with the length remaining
     1071 *
     1072 * @return a pointer to the transport layer header, or NULL if header isn't
     1073 * present.
     1074 *
     1075 * type may be NULL if not needed.
     1076 *
     1077 * Remaining may be NULL.  If Remaining is not NULL it must point to the number
     1078 * of bytes captured of the layer2 header and beyond.  It will be updated after
     1079 * this function to the number of bytes remaining after the layer2 header
     1080 * was removed.
     1081 *
     1082 */
     1083DLLEXPORT void *trace_get_payload_from_layer2(void *l2,
     1084                libtrace_linktype_t linktype,
     1085                uint16_t *ethertype,
     1086                uint32_t *remaining);
     1087
     1088
    10651089/** Get a pointer to the layer 3 header.
    10661090 * @param packet                The packet opaque pointer
     
    10741098 */
    10751099DLLEXPORT SIMPLE_FUNCTION
    1076 void *trace_get_layer3(libtrace_packet_t *packet,
     1100void *trace_get_layer3(const libtrace_packet_t *packet,
    10771101                uint16_t *ethertype, uint32_t *remaining);
    10781102
     
    10851109 * @note proto may be NULL if proto is unneeded.
    10861110 */
    1087 DLLEXPORT void *trace_get_transport(libtrace_packet_t *packet, uint8_t *proto,
     1111DLLEXPORT void *trace_get_transport(const libtrace_packet_t *packet, uint8_t *proto,
    10881112                uint32_t *remaining);
    10891113
     
    14261450 */
    14271451DLLEXPORT SIMPLE_FUNCTION
    1428 size_t trace_get_capture_length(libtrace_packet_t *packet);
     1452size_t trace_get_capture_length(const libtrace_packet_t *packet);
    14291453
    14301454/** Get the size of the packet as it was seen on the wire.
  • lib/libtrace_int.h

    r3512119 r9bc4689  
    373373bool demote_packet(libtrace_packet_t *packet);
    374374
    375 void *trace_get_payload_from_linux_sll(void *, uint16_t *, uint32_t *);
     375void *trace_get_payload_from_linux_sll(const void *, uint16_t *, uint32_t *);
    376376void *trace_get_payload_from_pos(void *, uint16_t *, uint32_t *);
    377377DLLEXPORT void *trace_get_payload_from_atm(void *, uint8_t *, uint32_t *);
  • lib/linktypes.c

    re1fdc05 r9bc4689  
    210210                switch(pcap_linktype_to_libtrace(rt_to_pcap_linktype(packet->type))) {
    211211                        case TRACE_TYPE_NONE:
    212                                 trace_get_payload_from_link(
    213                                         trace_get_link(packet),
    214                                         trace_get_link_type(packet),
    215                                         &hdr->protocol,
    216                                         NULL);
     212                                trace_get_layer3(packet, &hdr->protocol, NULL);
    217213                                hdr->hatype = htons(ARPHRD_PPP);
    218214                                hdr->protocol=htons(hdr->protocol);
  • lib/protocols.c

    r180f095 r9bc4689  
    156156
    157157/* NB: type is returned as an ARPHRD_ type for SLL*/
    158 void *trace_get_payload_from_linux_sll(void *link,
     158void *trace_get_payload_from_linux_sll(const void *link,
    159159                uint16_t *type, uint32_t *remaining)
    160160{
     
    257257
    258258/* Returns the 'payload' of the prism header, which is the 802.11 frame */
    259 static void *trace_get_payload_from_prism (void *link,
    260                 uint16_t *type, uint32_t *remaining)
     259static void *trace_get_payload_from_prism (const void *link,
     260                libtrace_linktype_t *type, uint32_t *remaining)
    261261{
    262262        if (remaining) {
     
    272272
    273273/* Returns the 'payload' of the radiotap header, which is the 802.11 frame */
    274 static void *trace_get_payload_from_radiotap (void *link,
    275                 uint16_t *type, uint32_t *remaining)
     274static void *trace_get_payload_from_radiotap (const void *link,
     275                libtrace_linktype_t *type, uint32_t *remaining)
    276276{
    277277        struct libtrace_radiotap_t *rtap = (struct libtrace_radiotap_t*)link;
     
    296296        switch(linktype) {
    297297                case TRACE_TYPE_80211_PRISM:
    298                         l = trace_get_payload_from_prism(link,type,remaining);
     298                        l = trace_get_payload_from_prism(link,&linktype,remaining);
    299299                        return (l ? trace_get_payload_from_link(l, TRACE_TYPE_80211, type, remaining) : NULL);
    300300                case TRACE_TYPE_80211_RADIO:
    301                         l = trace_get_payload_from_radiotap(link,type,remaining);
     301                        l = trace_get_payload_from_radiotap(link,&linktype,remaining);
    302302                        return (l ? trace_get_payload_from_link(l, TRACE_TYPE_80211, type, remaining) : NULL);
    303303                case TRACE_TYPE_80211:
     
    446446                uint32_t *remaining)
    447447{
    448         uint32_t dummyrem = trace_get_capture_length(packet);
     448        uint32_t dummyrem;
    449449
    450450        assert(packet != NULL);
     
    474474                        return NULL;
    475475        }
     476
     477        /* Shouldn't get here */
     478        return NULL;
    476479}
    477480
     
    519522                        return NULL;
    520523        }
     524        /* Shouldn't get here */
     525        return NULL;
    521526}
    522527
     
    553558}
    554559
    555 DLLEXPORT void *trace_get_layer3(libtrace_packet_t *packet,
     560DLLEXPORT void *trace_get_payload_from_layer2(void *link,
     561                libtrace_linktype_t linktype,
     562                uint16_t *ethertype,
     563                uint32_t *remaining)
     564{
     565        void *l;
     566        switch(linktype) {
     567                /* Packet Metadata headers, not layer2 headers */
     568                case TRACE_TYPE_80211_PRISM:
     569                case TRACE_TYPE_80211_RADIO:
     570                case TRACE_TYPE_LINUX_SLL:
     571                        return NULL;
     572
     573                /* duck packets have no payload! */
     574                case TRACE_TYPE_DUCK:
     575                        return NULL;
     576
     577                /* The payload is in these packets does
     578                   not correspond to a genuine link-layer
     579                   */
     580                case TRACE_TYPE_METADATA:
     581                        return NULL;
     582
     583                case TRACE_TYPE_80211:
     584                        return trace_get_payload_from_80211(link,ethertype,remaining);
     585                case TRACE_TYPE_ETH:
     586                        return trace_get_payload_from_ethernet(link,ethertype,remaining);
     587                case TRACE_TYPE_NONE:
     588                        if ((*(char*)link&0xF0) == 0x40)
     589                                *ethertype=0x0800;
     590                        else if ((*(char*)link&0xF0) == 0x60)
     591                                *ethertype=0x86DD;
     592                        return link; /* I love the simplicity */
     593                case TRACE_TYPE_PFLOG:
     594                        return trace_get_payload_from_pflog(link,ethertype,remaining);
     595                case TRACE_TYPE_PPP:
     596                        return trace_get_payload_from_ppp(link,ethertype,remaining);
     597                case TRACE_TYPE_ATM:
     598                        l=trace_get_payload_from_atm(link,NULL,remaining);
     599                        /* FIXME: We shouldn't skip llcsnap here, we should return
     600                         * an ethertype for it (somehow)
     601                         */
     602                        return (l ? trace_get_payload_from_llcsnap(l,
     603                                                ethertype, remaining):NULL);
     604                case TRACE_TYPE_LLCSNAP:
     605                        return trace_get_payload_from_llcsnap(link,ethertype,remaining);
     606
     607                /* TODO: Unsupported */
     608                case TRACE_TYPE_HDLC_POS:
     609                case TRACE_TYPE_POS:
     610                case TRACE_TYPE_AAL5:
     611                        return NULL;
     612        }
     613        return NULL;
     614
     615}
     616
     617DLLEXPORT void *trace_get_layer3(const libtrace_packet_t *packet,
    556618                uint16_t *ethertype,
    557619                uint32_t *remaining)
     
    561623        void *link;
    562624        uint32_t dummy_remaining;
     625        libtrace_linktype_t linktype;
     626
     627        if (!ethertype) ethertype=&dummy_ethertype;
     628
     629        if (!remaining) remaining=&dummy_remaining;
    563630
    564631        /* use l3 cache */
    565632        if (packet->l3_header)
    566633        {
     634                link = trace_get_packet_buffer(packet,&linktype,remaining);
     635
     636                if (!link)
     637                        return NULL;
     638
    567639                *ethertype = packet->l3_ethertype;
    568                 *remaining -= (packet->l3_header - trace_get_link(packet));
     640                *remaining -= (packet->l3_header - link);
     641
    569642                return packet->l3_header;
    570643        }
    571644
    572         if (!ethertype) ethertype=&dummy_ethertype;
    573 
    574         if (!remaining) remaining=&dummy_remaining;
    575 
    576         *remaining = trace_get_capture_length(packet);
    577 
    578         link=trace_get_link(packet);
    579 
    580         if (!link)
    581                 return NULL;
    582 
    583         iphdr = trace_get_payload_from_link(
     645        link = trace_get_layer2(packet,&linktype,remaining);
     646
     647        iphdr = trace_get_payload_from_layer2(
    584648                        link,
    585                         trace_get_link_type(packet),
     649                        linktype,
    586650                        ethertype,
    587651                        remaining);
     
    613677
    614678        /* Store values in the cache for later */
    615         packet->l3_ethertype = *ethertype;
    616         packet->l3_header = iphdr;
     679        /* Cast away constness, nasty, but this is just a cache */
     680        ((libtrace_packet_t*)packet)->l3_ethertype = *ethertype;
     681        ((libtrace_packet_t*)packet)->l3_header = iphdr;
    617682
    618683        return iphdr;
    619684}
    620685
    621 DLLEXPORT void *trace_get_transport(libtrace_packet_t *packet,
     686DLLEXPORT void *trace_get_transport(const libtrace_packet_t *packet,
    622687                uint8_t *proto,
    623688                uint32_t *remaining
     
    632697
    633698        if (!remaining) remaining=&dummy_remaining;
    634 
    635         *remaining = trace_get_capture_length(packet);
    636699
    637700        transport = trace_get_layer3(packet,&ethertype,remaining);
     
    829892}
    830893
    831 static
    832 uint8_t *__trace_get_source_mac(void *link, libtrace_linktype_t *linktype, uint32_t *rem) {
    833         libtrace_ether_t *ethptr = (libtrace_ether_t *) link;
    834         uint16_t arphrd;
     894DLLEXPORT uint8_t *trace_get_source_mac(libtrace_packet_t *packet) {
     895        void *link;
     896        uint32_t remaining;
     897        libtrace_linktype_t linktype;
     898        assert(packet);
     899        link = trace_get_layer2(packet,&linktype,&remaining);
     900
    835901        if (!link)
    836902                return NULL;
    837903       
    838         switch (*linktype) {
     904        switch (linktype) {
    839905                case TRACE_TYPE_ETH:
    840                         return (uint8_t *)&ethptr->ether_shost;
     906                        return (uint8_t *)&(((libtrace_ether_t*)link)->ether_shost);
    841907                case TRACE_TYPE_80211:
    842908                        return get_source_mac_from_wifi(link);
    843                 case TRACE_TYPE_80211_RADIO:
    844                         link = trace_get_payload_from_radiotap(
    845                                         link, linktype, rem);
    846                         return __trace_get_source_mac(link, linktype, rem);
    847                 case TRACE_TYPE_80211_PRISM:
    848                         link = trace_get_payload_from_prism(
    849                                         link, linktype, rem);
    850                         return __trace_get_source_mac(link, linktype, rem);
    851                 case TRACE_TYPE_LINUX_SLL:
    852                         link = trace_get_payload_from_linux_sll(
    853                                         link, &arphrd, rem);
    854                         *linktype = arphrd_type_to_libtrace(arphrd);
    855                         return __trace_get_source_mac(link, linktype, rem);
     909                /* These packets don't have MAC addresses */
    856910                case TRACE_TYPE_POS:
    857911                case TRACE_TYPE_NONE:
     
    861915                case TRACE_TYPE_DUCK:
    862916                case TRACE_TYPE_METADATA:
    863                         return NULL;
    864                 default:
     917                case TRACE_TYPE_AAL5:
     918                case TRACE_TYPE_LLCSNAP:
     919                case TRACE_TYPE_PPP:
     920                        return NULL;
     921
     922                /* Metadata headers should already be skipped */
     923                case TRACE_TYPE_LINUX_SLL:
     924                case TRACE_TYPE_80211_PRISM:
     925                case TRACE_TYPE_80211_RADIO:
     926                        assert(!"Metadata headers should already be skipped");
    865927                        break;
    866928        }
    867         fprintf(stderr,"%s not implemented for linktype %i\n", __func__, *linktype);
     929        fprintf(stderr,"%s not implemented for linktype %i\n", __func__, linktype);
    868930        assert(0);
    869931        return NULL;
    870932}
    871933
    872 DLLEXPORT uint8_t *trace_get_source_mac(libtrace_packet_t *packet) {
    873         if (packet == NULL)
    874                 return NULL;
    875         void *link = trace_get_link(packet);
    876         uint32_t len = trace_get_capture_length(packet);
    877         libtrace_linktype_t lt = trace_get_link_type(packet);
    878         return __trace_get_source_mac(link, &lt, &len);
    879 }
    880 
    881 DLLEXPORT uint8_t *trace_get_destination_mac(libtrace_packet_t *packet) {
    882         void *link = trace_get_link(packet);
     934DLLEXPORT uint8_t *trace_get_destination_mac(libtrace_packet_t *packet)
     935{
     936        void *link;
     937        libtrace_linktype_t linktype;
     938        uint32_t remaining;
     939
     940        link = trace_get_layer2(packet,&linktype,&remaining);
     941
    883942        libtrace_80211_t *wifi;
    884943        libtrace_ether_t *ethptr = (libtrace_ether_t*)link;
     944
     945
    885946        if (!link)
    886947                return NULL;
    887         switch (trace_get_link_type(packet)) {
     948
     949        switch (linktype) {
    888950                case TRACE_TYPE_80211:
    889951                        wifi=(libtrace_80211_t*)link;
     
    928990                addr=(struct sockaddr*)&dummy;
    929991
    930         remaining = trace_get_capture_length(packet);
    931 
    932992        l3 = trace_get_layer3(packet,&ethertype,&remaining);
    933993
     
    9811041        if (!addr)
    9821042                addr=(struct sockaddr*)&dummy;
    983 
    984         remaining = trace_get_capture_length(packet);
    9851043
    9861044        l3 = trace_get_layer3(packet,&ethertype,&remaining);
  • lib/trace.c

    r180f095 r9bc4689  
    646646                (libtrace_packet_t *)malloc(sizeof(libtrace_packet_t));
    647647        dest->trace=packet->trace;
    648         dest->buffer=malloc(
    649                         trace_get_framing_length(packet)
    650                         +trace_get_capture_length(packet));
     648        dest->buffer=malloc(65536);
    651649        dest->header=dest->buffer;
    652650        dest->payload=(void*)
     
    869867}
    870868
    871 DLLEXPORT size_t trace_get_capture_length(libtrace_packet_t *packet)
     869DLLEXPORT size_t trace_get_capture_length(const libtrace_packet_t *packet)
    872870{
    873871        /* Cache the capture length */
     
    875873                if (!packet->trace->format->get_capture_length)
    876874                        return ~0U;
    877                 packet->capture_length =
     875                /* Cast away constness because this is "just" a cache */
     876                ((libtrace_packet_t*)packet)->capture_length =
    878877                        packet->trace->format->get_capture_length(packet);
    879878        }
     
    10021001#ifdef HAVE_BPF
    10031002        void *linkptr = 0;
     1003        libtrace_linktype_t linktype;
    10041004        assert(filter);
    10051005
    10061006        /* If this isn't a real packet, then fail */
    1007         linkptr = trace_get_link(packet);
     1007        linkptr = trace_get_packet_buffer(packet,&linktype,NULL);
    10081008        if (!linkptr) {
    10091009                trace_set_err(packet->trace,
     
    10141014        if (filter->filterstring && ! filter->flag) {
    10151015                pcap_t *pcap = NULL;
    1016                 libtrace_linktype_t linktype=trace_get_link_type(packet);
    10171016                if (linktype==(libtrace_linktype_t)-1) {
    10181017                        trace_set_err(packet->trace,
     
    10561055#ifdef HAVE_BPF
    10571056        void *linkptr = 0;
    1058         unsigned int clen = 0;
     1057        uint32_t clen = 0;
    10591058        bool free_packet_needed = false;
    10601059        int ret;
     
    10841083        }
    10851084       
    1086         linkptr = trace_get_link(packet_copy);
     1085        linkptr = trace_get_packet_buffer(packet_copy,NULL,&clen);
    10871086        if (!linkptr) {
    10881087                if (free_packet_needed) {
     
    11021101        }
    11031102
    1104         clen = trace_get_capture_length(packet_copy);
    1105 
    11061103        assert(filter->flag);
    1107         ret=bpf_filter(filter->filter.bf_insns,(u_char*)linkptr,clen,clen);
     1104        ret=bpf_filter(filter->filter.bf_insns,(u_char*)linkptr,(unsigned int)clen,(unsigned int)clen);
    11081105        if (free_packet_needed) {
    11091106                trace_destroy_packet(packet_copy);
Note: See TracChangeset for help on using the changeset viewer.