Changeset 14b7489


Ignore:
Timestamp:
11/15/17 15:00:49 (3 years ago)
Author:
Shane Alcock <salcock@…>
Branches:
cachetimestamps, develop, dpdk-ndag, etsilive, master, rc-4.0.3, rc-4.0.4, ringdecrementfix, ringperformance
Children:
186a19e, 314239a
Parents:
6463f32 (diff), 21c7681 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'rc-4.0.2'

Files:
6 added
45 edited

Legend:

Unmodified
Added
Removed
  • .gitignore

    rcaf7841 r21c7681  
    7676test/test-plen
    7777test/test-ports
     78test/test-setcaplen
    7879test/test-time
    7980test/test-tracetime-parallel
     
    8182test/test-wireless
    8283test/test-write
     84test/*.dSYM/
    8385test/DPDK_source/
    8486test/DPDK_builds/
  • AUTHORS

    r6450950 r31da9bb  
    55 * Richard Sanger
    66
    7 Libtrace is currently maintained by Shane Alcock <salcock@waikato.ac.nz>.
     7Libtrace is currently maintained by the LibtraceTeam on Github:
     8https://github.com/LibtraceTeam.
    89
    9 However, we would also like to acknowledge a number of people who have 
     10However, we would also like to acknowledge a number of people who have
    1011generously contributed bug-fixes, extensions and other improvements over the
    1112years. It is contributions like these that help keep libtrace relevant and
     
    1516
    1617 * Matt Brown for getting us into Debian and keeping us up to date.
    17  * Brad Cowie for packaging libtrace4 for Debian and Ubuntu
    18  * Alistair King for reporting and suggesting fixes for numerous bugs, 
     18 * Brad Cowie for packaging libtrace4 for Debian and Ubuntu.
     19 * Alistair King for reporting and suggesting fixes for numerous bugs,
    1920   particularly in libwandio
    2021 * Simon Wadsworth for writing the original version of most of the OSPF code
     
    3637   code here and there
    3738
    38 Apologies to anyone that we've missed out or forgotten. If you're really
    39 offended, fire us an email and we'll add you to the list.
     39Apologies to anyone that we've missed out or forgotten. If you're really
     40offended, fire one of us an email and we'll make sure you are added to the
     41list.
  • README

    rd759ee1 re3fa533  
    1 libtrace 4.0.1
     1libtrace 4.0.2
    22
    33---------------------------------------------------------------------------
  • configure.in

    rd759ee1 r9993cde  
    44# and in the README
    55
    6 AC_INIT([libtrace],[4.0.1],[contact@wand.net.nz],[libtrace])
     6AC_INIT([libtrace],[4.0.2],[contact@wand.net.nz],[libtrace])
    77
    88LIBTRACE_MAJOR=4
    99LIBTRACE_MID=0
    10 LIBTRACE_MINOR=1
     10LIBTRACE_MINOR=2
    1111
    1212# OpenSolaris hides libraries like libncurses in /usr/gnu/lib, which is not
     
    126126
    127127# Fail if any of these functions are missing
    128 AC_CHECK_FUNCS(socket strdup strlcpy strcasecmp strncasecmp snprintf vsnprintf)
     128AC_CHECK_FUNCS(socket strdup strlcpy strcasecmp strncasecmp snprintf vsnprintf recvmmsg)
    129129
    130130AC_CHECK_SIZEOF([long int])
     
    250250        LIBTRACE_LIBS="$LIBTRACE_LIBS -lpcap"
    251251        AC_DEFINE([HAVE_LIBPCAP],1,[compile with libpcap support])
    252         AC_DEFINE([HAVE_BPF_FILTER],1,[compile with bpf filter support])
    253252
    254253        LIBS="-lpcap"
  • lib/Makefile.am

    r4db5b98 rea75ec2  
    5555                format_rt.c format_helper.c format_helper.h format_pcapfile.c \
    5656                format_duck.c format_tsh.c $(NATIVEFORMATS) $(BPFFORMATS) \
    57                 format_atmhdr.c \
     57                format_atmhdr.c format_pcapng.c \
    5858                libtrace_int.h lt_inttypes.h lt_bswap.h \
    5959                linktypes.c link_wireless.c byteswap.c \
     
    6262                protocols_transport.c protocols.h protocols_ospf.c \
    6363                protocols_application.c \
    64                 $(DAGSOURCE) format_erf.h \
     64                $(DAGSOURCE) format_erf.h format_ndag.c format_ndag.h \
    6565                $(BPFJITSOURCE) \
    6666                libtrace_arphrd.h \
  • lib/format_erf.c

    ree6e802 r0317e3c  
    126126static int erf_get_padding(const libtrace_packet_t *packet)
    127127{
    128         if (packet->trace->format->type==TRACE_FORMAT_ERF) {
     128        if (packet->trace->format->type==TRACE_FORMAT_ERF ||
     129                        packet->trace->format->type == TRACE_FORMAT_NDAG ||
     130                        packet->trace->format->type == TRACE_FORMAT_RAWERF) {
    129131                dag_record_t *erfptr = (dag_record_t *)packet->header;
    130132                switch((erfptr->type & 0x7f)) {
  • lib/format_helper.c

    ree6e802 r633339d  
    323323        va_end(va);
    324324}
     325
     326/** Attempts to determine the direction for a pcap (or pcapng) packet.
     327 *
     328 * @param packet        The packet in question.
     329 * @return A valid libtrace_direction_t describing the direction that the
     330 *         packet was travelling, if direction can be determined. Otherwise
     331 *         returns TRACE_DIR_UNKNOWN.
     332 * @internal
     333 *
     334 * Note that we can determine the direction for only certain types of packets
     335 * if they are captured using pcap/pcapng, specifically SLL and PFLOG captures.
     336 */
     337libtrace_direction_t pcap_get_direction(const libtrace_packet_t *packet) {
     338        libtrace_direction_t direction  = -1;
     339        switch(pcap_linktype_to_libtrace(rt_to_pcap_linktype(packet->type))) {
     340                /* We can only get the direction for PCAP packets that have
     341                 * been encapsulated in Linux SLL or PFLOG */
     342                case TRACE_TYPE_LINUX_SLL:
     343                {
     344                        libtrace_sll_header_t *sll;
     345                        libtrace_linktype_t linktype;
     346
     347                        sll = (libtrace_sll_header_t*)trace_get_packet_buffer(
     348                                        packet,
     349                                        &linktype,
     350                                        NULL);
     351                        if (!sll) {
     352                                trace_set_err(packet->trace,
     353                                        TRACE_ERR_BAD_PACKET,
     354                                                "Bad or missing packet");
     355                                return -1;
     356                        }
     357                        /* 0 == LINUX_SLL_HOST */
     358                        /* the Waikato Capture point defines "packets
     359                         * originating locally" (ie, outbound), with a
     360                         * direction of 0, and "packets destined locally"
     361                         * (ie, inbound), with a direction of 1.
     362                         * This is kind-of-opposite to LINUX_SLL.
     363                         * We return consistent values here, however
     364                         *
     365                         * Note that in recent versions of pcap, you can
     366                         * use "inbound" and "outbound" on ppp in linux
     367                         */
     368                        if (ntohs(sll->pkttype == 0)) {
     369                                direction = TRACE_DIR_INCOMING;
     370                        } else {
     371                                direction = TRACE_DIR_OUTGOING;
     372                        }
     373                        break;
     374
     375                }
     376               case TRACE_TYPE_PFLOG:
     377                {
     378                        libtrace_pflog_header_t *pflog;
     379                        libtrace_linktype_t linktype;
     380
     381                        pflog=(libtrace_pflog_header_t*)trace_get_packet_buffer(
     382                                        packet,&linktype,NULL);
     383                        if (!pflog) {
     384                                trace_set_err(packet->trace,
     385                                                TRACE_ERR_BAD_PACKET,
     386                                                "Bad or missing packet");
     387                                return -1;
     388                        }
     389                        /* enum    { PF_IN=0, PF_OUT=1 }; */
     390                        if (ntohs(pflog->dir==0)) {
     391
     392                                direction = TRACE_DIR_INCOMING;
     393                        }
     394                        else {
     395                                direction = TRACE_DIR_OUTGOING;
     396                        }
     397                        break;
     398                }
     399                default:
     400                        break;
     401        }       
     402        return direction;
     403}
     404
     405
  • lib/format_helper.h

    ree6e802 r633339d  
    8787                int level,
    8888                int filemode);
     89
     90
     91/** Attempts to determine the direction for a pcap (or pcapng) packet.
     92 *
     93 * @param packet        The packet in question.
     94 * @return A valid libtrace_direction_t describing the direction that the
     95 *         packet was travelling, if direction can be determined. Otherwise
     96 *         returns TRACE_DIR_UNKNOWN.
     97 *
     98 * Note that we can determine the direction for only certain types of packets
     99 * if they are captured using pcap/pcapng, specifically SLL and PFLOG captures.
     100 */
     101libtrace_direction_t pcap_get_direction(const libtrace_packet_t *packet);
     102
     103
     104
    89105#endif /* FORMAT_HELPER_H */
  • lib/format_linux_common.c

    rdb84bb2 rd47ca18  
    6161static int linuxnative_configure_bpf(libtrace_t *libtrace,
    6262                libtrace_filter_t *filter) {
    63 #ifdef HAVE_LIBPCAP
     63#if defined(HAVE_LIBPCAP) && defined(HAVE_BPF)
    6464        struct ifreq ifr;
    6565        unsigned int arphrd;
     
    125125        return 0;
    126126#else
    127         return -1
     127        return -1;
    128128#endif
    129129}
     
    404404         * pre-compiled.
    405405         */
     406#ifdef HAVE_BPF
    406407        if (filter != NULL) {
    407408                /* Check if the filter was successfully compiled. If not,
     
    424425                }
    425426        }
     427#endif
    426428
    427429        /* Consume any buffered packets that were received before the socket
  • lib/format_pcap.c

    r5e3f16c r4578626  
    128128
    129129        /* If a filter has been configured, compile and apply it */
     130#ifdef HAVE_BPF
    130131        if (DATA(libtrace)->filter) {
    131132                if (DATA(libtrace)->filter->flag == 0) {
     
    143144                }
    144145        }
     146#endif
    145147        return 0;
    146148}
     
    152154        switch(option) {
    153155                case TRACE_OPTION_FILTER:
     156#ifdef HAVE_BPF
    154157                        DATA(libtrace)->filter=data;
    155158                        return 0;
     159#else
     160                        return -1;
     161#endif
    156162                case TRACE_OPTION_SNAPLEN:
    157163                        /* Snapping isn't supported directly, so fall thru
     
    211217        switch(option) {
    212218                case TRACE_OPTION_FILTER:
     219#ifdef HAVE_BPF
    213220                        DATA(libtrace)->filter=(libtrace_filter_t*)data;
    214221                        return 0;
     222#else
     223                        return -1;
     224#endif
    215225                case TRACE_OPTION_SNAPLEN:
    216226                        DATA(libtrace)->snaplen=*(int*)data;
     
    298308#endif
    299309        /* Set a filter if one is defined */
     310#ifdef HAVE_BPF
    300311        if (DATA(libtrace)->filter) {
    301312                struct pcap_pkthdr *pcap_hdr = NULL;
     
    342353                        return -1;
    343354        }
     355#endif
    344356        return 0; /* success */
    345357}
     
    562574                pcap_dump((u_char*)OUTPUT.trace.dump, &pcap_pkt_hdr, packet->payload);
    563575        }
    564         return 0;
     576        return remaining;
    565577}
    566578
     
    628640}
    629641
    630 static libtrace_direction_t pcap_get_direction(const libtrace_packet_t *packet) {
    631         libtrace_direction_t direction  = -1;
    632         switch(pcap_get_link_type(packet)) {
    633                 /* Only packets encapsulated in Linux SLL or PFLOG have any
    634                  * direction information */
    635 
    636                 case TRACE_TYPE_LINUX_SLL:
    637                 {
    638                         libtrace_sll_header_t *sll;
    639                         sll = trace_get_packet_buffer(packet, NULL, NULL);
    640                         /* TODO: should check remaining>=sizeof(*sll) */
    641                         if (!sll) {
    642                                 trace_set_err(packet->trace,
    643                                         TRACE_ERR_BAD_PACKET,
    644                                                 "Bad or missing packet");
    645                                 return -1;
    646                         }
    647                         /* 0 == LINUX_SLL_HOST */
    648                         /* the Waikato Capture point defines "packets
    649                          * originating locally" (ie, outbound), with a
    650                          * direction of 0, and "packets destined locally"
    651                          * (ie, inbound), with a direction of 1.
    652                          * This is kind-of-opposite to LINUX_SLL.
    653                          * We return consistent values here, however
    654                          *
    655                          * Note that in recent versions of pcap, you can
    656                          * use "inbound" and "outbound" on ppp in linux
    657                          */
    658                         if (sll->pkttype == TRACE_SLL_OUTGOING) {
    659                                 direction = TRACE_DIR_OUTGOING;
    660                         } else {
    661                                 direction = TRACE_DIR_INCOMING;
    662                         }
    663                         break;
    664 
    665                 }
    666                 case TRACE_TYPE_PFLOG:
    667                 {
    668                         libtrace_pflog_header_t *pflog;
    669                         pflog = trace_get_packet_buffer(packet, NULL, NULL);
    670                         /* TODO: should check remaining >= sizeof(*pflog) */
    671                         if (!pflog) {
    672                                 trace_set_err(packet->trace,
    673                                                 TRACE_ERR_BAD_PACKET,
    674                                                 "Bad or missing packet");
    675                                 return -1;
    676                         }
    677                         /* enum    { PF_IN=0, PF_OUT=1 }; */
    678                         if (ntohs(pflog->dir==0)) {
    679 
    680                                 direction = TRACE_DIR_INCOMING;
    681                         }
    682                         else {
    683                                 direction = TRACE_DIR_OUTGOING;
    684                         }
    685                         break;
    686                 }
    687                 default:
    688                         break;
    689         }       
    690         return direction;
     642static libtrace_direction_t pcapint_get_direction(const libtrace_packet_t *packet) {
     643        /* This function is defined in format_helper.c */
     644        return pcap_get_direction(packet);
    691645}
    692646
     
    816770        pcap_write_packet,              /* write_packet */
    817771        pcap_get_link_type,             /* get_link_type */
    818         pcap_get_direction,             /* get_direction */
     772        pcapint_get_direction,          /* get_direction */
    819773        pcap_set_direction,             /* set_direction */
    820774        NULL,                           /* get_erf_timestamp */
     
    860814        pcapint_write_packet,           /* write_packet */
    861815        pcap_get_link_type,             /* get_link_type */
    862         pcap_get_direction,             /* get_direction */
     816        pcapint_get_direction,          /* get_direction */
    863817        pcap_set_direction,             /* set_direction */
    864818        NULL,                           /* get_erf_timestamp */
  • lib/format_pcapfile.c

    ree6e802 r633339d  
    541541static libtrace_direction_t pcapfile_get_direction(const libtrace_packet_t *packet)
    542542{
    543         libtrace_direction_t direction  = -1;
    544         switch(pcapfile_get_link_type(packet)) {
    545                 /* We can only get the direction for PCAP packets that have
    546                  * been encapsulated in Linux SLL or PFLOG */
    547                 case TRACE_TYPE_LINUX_SLL:
    548                 {
    549                         libtrace_sll_header_t *sll;
    550                         libtrace_linktype_t linktype;
    551 
    552                         sll = (libtrace_sll_header_t*)trace_get_packet_buffer(
    553                                         packet,
    554                                         &linktype,
    555                                         NULL);
    556                         if (!sll) {
    557                                 trace_set_err(packet->trace,
    558                                         TRACE_ERR_BAD_PACKET,
    559                                                 "Bad or missing packet");
    560                                 return -1;
    561                         }
    562                         /* 0 == LINUX_SLL_HOST */
    563                         /* the Waikato Capture point defines "packets
    564                          * originating locally" (ie, outbound), with a
    565                          * direction of 0, and "packets destined locally"
    566                          * (ie, inbound), with a direction of 1.
    567                          * This is kind-of-opposite to LINUX_SLL.
    568                          * We return consistent values here, however
    569                          *
    570                          * Note that in recent versions of pcap, you can
    571                          * use "inbound" and "outbound" on ppp in linux
    572                          */
    573                         if (ntohs(sll->pkttype == 0)) {
    574                                 direction = TRACE_DIR_INCOMING;
    575                         } else {
    576                                 direction = TRACE_DIR_OUTGOING;
    577                         }
    578                         break;
    579 
    580                 }
    581                 case TRACE_TYPE_PFLOG:
    582                 {
    583                         libtrace_pflog_header_t *pflog;
    584                         libtrace_linktype_t linktype;
    585 
    586                         pflog=(libtrace_pflog_header_t*)trace_get_packet_buffer(
    587                                         packet,&linktype,NULL);
    588                         if (!pflog) {
    589                                 trace_set_err(packet->trace,
    590                                                 TRACE_ERR_BAD_PACKET,
    591                                                 "Bad or missing packet");
    592                                 return -1;
    593                         }
    594                         /* enum    { PF_IN=0, PF_OUT=1 }; */
    595                         if (ntohs(pflog->dir==0)) {
    596 
    597                                 direction = TRACE_DIR_INCOMING;
    598                         }
    599                         else {
    600                                 direction = TRACE_DIR_OUTGOING;
    601                         }
    602                         break;
    603                 }
    604                 default:
    605                         break;
    606         }       
    607         return direction;
     543        /* This function can be found in format_helper.c */
     544        return pcap_get_direction(packet);
    608545}
    609546
  • lib/libtrace.h.in

    r317e903 rea75ec2  
    391391        TRACE_FORMAT_LINUX_RING   =15,  /**< Linux native interface capture PACKET_MMAP */
    392392        TRACE_FORMAT_RAWERF       =16,  /**< Special format for reading uncompressed ERF traces without checking for compression */
    393     TRACE_FORMAT_DPDK     =17, /**< The Intel Data Plane Development Kit format */
     393        TRACE_FORMAT_DPDK     =17, /**< The Intel Data Plane Development Kit format */
     394        TRACE_FORMAT_PCAPNG     =18,    /**< PCAP-NG trace file */
     395        TRACE_FORMAT_NDAG       =19,    /**< DAG multicast over a network */
    394396};
    395397
     
    417419        TRACE_RT_METADATA       =18,/**< Packet contains server meta-data */
    418420        TRACE_RT_DUCK_5_0       =19,/**< Dag 5.0 Duck */
     421        TRACE_RT_PCAPNG_META    =20,/**< Metadata for a PCAP NG input source */
    419422
    420423        /** Not actually used - all DATA types begin from this value */
     
    480483
    481484        TRACE_RT_DATA_BPF_END           = 3999,
     485
     486        TRACE_RT_DATA_PCAPNG            = 4000,
     487        TRACE_RT_DATA_PCAPNG_END        = 4499,
    482488        /** Unused value marking the end of the valid range for all RT packet
    483489         * types */
    484         TRACE_RT_LAST                   = 4000
     490        TRACE_RT_LAST                   = 4500
    485491} libtrace_rt_types_t;
    486492
     
    551557        void *srcbucket;
    552558} libtrace_packet_t;
     559
     560#define IS_LIBTRACE_META_PACKET(packet) (packet->type < TRACE_RT_DATA_SIMPLE)
    553561
    554562
     
    13921400        X(dropped) \
    13931401        X(captured) \
     1402        X(missing) \
    13941403        X(errors)
    13951404
     
    14101419         * was alloc'd by us. We can easily decrease the no. bits without
    14111420         * problems as long as we update any asserts as needed */
    1412         LT_BITFIELD64 reserved1: 26; /**< Bits reserved for future fields */
     1421        LT_BITFIELD64 reserved1: 25; /**< Bits reserved for future fields */
    14131422        LT_BITFIELD64 reserved2: 24; /**< Bits reserved for future fields */
    14141423        LT_BITFIELD64 magic: 8; /**< A number stored against the format to
     
    14621471         */
    14631472        uint64_t captured;
     1473
     1474        /** The number of packets (or aggregated records) that have been
     1475         *  lost between the original capture device and the current input
     1476         *  trace.
     1477         *
     1478         *  @note Only relevant for input formats that use a network to
     1479         *  transfer live captured packets from one host to another (e.g.
     1480         *  nDAG).
     1481         */
     1482        uint64_t missing;
    14641483
    14651484        /** The number of packets that have been discarded by the network card
  • lib/libtrace_int.h

    r5e3f16c rea75ec2  
    10811081libtrace_rt_types_t pcap_linktype_to_rt(libtrace_dlt_t linktype);
    10821082
     1083/** Converts a PCAP-NG DLT into an RT protocol type.
     1084 *
     1085 * @param linktype      The PCAP DLT to be converted
     1086 * @return The RT type that is equivalent to the provided DLT
     1087 */
     1088libtrace_rt_types_t pcapng_linktype_to_rt(libtrace_dlt_t linktype);
     1089
    10831090/** Converts a libtrace link type into a PCAP linktype.
    10841091 *
     
    12611268/** Constructor for the PCAP File format module */
    12621269void pcapfile_constructor(void);
     1270/** Constructor for the PCAP-NG File format module */
     1271void pcapng_constructor(void);
    12631272/** Constructor for the RT format module */
    12641273void rt_constructor(void);
     
    12671276/** Constructor for the ATM Header format module */
    12681277void atmhdr_constructor(void);
     1278/** Constructor for the network DAG format module */
     1279void ndag_constructor(void);
    12691280#ifdef HAVE_BPF
    12701281/** Constructor for the BPF format module */
  • lib/linktypes.c

    r4b64a045 red5b2ce  
    139139}
    140140
     141libtrace_rt_types_t pcapng_linktype_to_rt(libtrace_dlt_t linktype) {
     142
     143        return TRACE_RT_DATA_PCAPNG + pcap_dlt_to_pcap_linktype(linktype);
     144}
     145
    141146libtrace_dlt_t rt_to_pcap_linktype(libtrace_rt_types_t rt_type)
    142147{
    143        
     148
    144149        if (rt_type >= TRACE_RT_DATA_DLT && rt_type < TRACE_RT_DATA_DLT_END) {
    145150                /* RT type is in the pcap range */
    146151                return rt_type - TRACE_RT_DATA_DLT;
    147         } 
     152        }
    148153        else if (rt_type >= TRACE_RT_DATA_BPF && rt_type < TRACE_RT_DATA_BPF_END) {
    149154                return rt_type - TRACE_RT_DATA_BPF;
    150         }
    151        
     155        } else if (rt_type >= TRACE_RT_DATA_PCAPNG && rt_type < TRACE_RT_DATA_PCAPNG_END) {
     156                return rt_type - TRACE_RT_DATA_PCAPNG;
     157        }
     158
    152159        fprintf(stderr, "Error: RT type %u cannot be converted to a pcap DLT\n", rt_type);
    153         assert(rt_type >= TRACE_RT_DATA_DLT && rt_type < TRACE_RT_DATA_BPF_END);
     160        assert(false);
    154161        return 0;       /* satisfy warnings */
    155162}
  • lib/protocols_l3.c

    ree6e802 r6654714  
    682682        uint16_t ethertype;
    683683        uint32_t remaining;
    684         uint16_t *csum_ptr;
     684        char *csum_ptr;
    685685
    686686        uint8_t safety[65536];
     
    699699                        return NULL;
    700700
    701                 csum_ptr = &ip->ip_sum;
     701                csum_ptr = (char *)(&ip->ip_sum);
    702702
    703703                /* I hate memcpys, but this is the only truly safe way to
     
    716716                *csum = ntohs(*csum);
    717717               
    718                 return csum_ptr;
     718                return (uint16_t *)csum_ptr;
    719719        }
    720720
     
    752752        if (ethertype == TRACE_ETHERTYPE_IPV6) {
    753753                libtrace_ip6_t *ip6 = (libtrace_ip6_t *)l3;
    754                 void *payload = ip6++;
     754                void *payload = ip6 + 1;
    755755                uint8_t nxt = ip6->nxt;
    756756                uint16_t len;
  • lib/protocols_transport.c

    r317e903 r6654714  
    448448        uint32_t sum = 0;
    449449        uint8_t proto = 0;
    450         uint16_t *csum_ptr = NULL;
     450        char *csum_ptr = NULL;
    451451        int plen = 0;
    452452
     
    483483                header = trace_get_payload_from_tcp(tcp, &remaining);
    484484               
    485                 csum_ptr = &tcp->check;
     485                csum_ptr = (char *)(&tcp->check);
    486486
    487487                memcpy(ptr, tcp, tcp->doff * 4);
     
    498498                header = trace_get_payload_from_udp(udp, &remaining);
    499499               
    500                 csum_ptr = &udp->check;
     500                csum_ptr = (char *)(&udp->check);
    501501                memcpy(ptr, udp, sizeof(libtrace_udp_t));
    502502
     
    514514                header = trace_get_payload_from_icmp(icmp, &remaining);
    515515               
    516                 csum_ptr = &icmp->checksum;
     516                csum_ptr = (char *)(&icmp->checksum);
    517517                memcpy(ptr, icmp, sizeof(libtrace_icmp_t));
    518518
     
    543543        //assert(0);
    544544       
    545         return csum_ptr;
     545        return (uint16_t *)csum_ptr;
    546546}
    547547
  • lib/trace.c

    radb2c4c rea75ec2  
    145145                bpf_constructor();
    146146                pcapfile_constructor();
    147                 rt_constructor();
     147                pcapng_constructor();
     148                rt_constructor();
     149                ndag_constructor();
    148150#ifdef HAVE_DAG
    149151                dag_constructor();
     
    957959                                                libtrace->snaplen);
    958960                        }
     961                        if (!IS_LIBTRACE_META_PACKET(packet)) {
     962                                ++libtrace->accepted_packets;
     963                        }
    959964                        trace_packet_set_order(packet, libtrace->sequence_number);
    960                         ++libtrace->accepted_packets;
    961                         ++libtrace->sequence_number;
     965                        ++libtrace->sequence_number;
    962966                        if (!libtrace_parallel && packet->trace == libtrace)
    963967                                libtrace->last_packet = packet;
     
    10331037                return -1;
    10341038        }
     1039
     1040        /* Don't try to convert meta-packets across formats */
     1041        if (strcmp(libtrace->format->name, packet->trace->format->name) != 0 &&
     1042                        IS_LIBTRACE_META_PACKET(packet)) {
     1043                return 0;
     1044        }
    10351045
    10361046        if (libtrace->format->write_packet) {
     
    13501360trace_create_filter_from_bytecode(void *bf_insns, unsigned int bf_len)
    13511361{
    1352 #ifndef HAVE_BPF_FILTER
     1362#ifndef HAVE_BPF
    13531363        fprintf(stderr, "This version of libtrace does not have BPF support\n");
    13541364        return NULL;
     
    13771387 */
    13781388DLLEXPORT libtrace_filter_t *trace_create_filter(const char *filterstring) {
    1379 #ifdef HAVE_BPF_FILTER
     1389#ifdef HAVE_BPF
    13801390        libtrace_filter_t *filter = (libtrace_filter_t*)
    13811391                                malloc(sizeof(libtrace_filter_t));
     
    13921402DLLEXPORT void trace_destroy_filter(libtrace_filter_t *filter)
    13931403{
    1394 #ifdef HAVE_BPF_FILTER
     1404#ifdef HAVE_BPF
    13951405        free(filter->filterstring);
    13961406        if (filter->flag)
     
    14171427                void *linkptr,
    14181428                libtrace_linktype_t linktype    ) {
    1419 #ifdef HAVE_BPF_FILTER
     1429#ifdef HAVE_BPF
    14201430        /* It just so happens that the underlying libs used by pthread arn't
    14211431         * thread safe, namely lex/flex thingys, so single threaded compile
     
    14811491DLLEXPORT int trace_apply_filter(libtrace_filter_t *filter,
    14821492                        const libtrace_packet_t *packet) {
    1483 #ifdef HAVE_BPF_FILTER
     1493#ifdef HAVE_BPF
    14841494        void *linkptr = 0;
    14851495        uint32_t clen = 0;
  • lib/trace_parallel.c

    rdb84bb2 re8db2d4  
    343343                        (int) t->tid, prev_state, t->state);
    344344
    345         if (trace->perpkt_thread_states[THREAD_FINISHED] == trace->perpkt_thread_count)
     345        if (trace->perpkt_thread_states[THREAD_FINISHED] == trace->perpkt_thread_count) {
     346                /* Make sure we save our final stats in case someone wants
     347                 * them at the end of their program.
     348                 */
     349
     350                trace_get_statistics(trace, NULL);
    346351                libtrace_change_state(trace, STATE_FINISHED, false);
     352        }
    347353
    348354        pthread_cond_broadcast(&trace->perpkt_cond);
     
    473479                                return READ_MESSAGE;
    474480                }
    475                 t->accepted_packets++;
     481                if (!IS_LIBTRACE_META_PACKET((*packet))) {
     482                        t->accepted_packets++;
     483                }
    476484                if (trace->perpkt_cbs->message_packet)
    477485                        *packet = (*trace->perpkt_cbs->message_packet)(trace, t, trace->global_blob, t->user_data, *packet);
     
    608616        /* The offset to the first NULL packet upto offset */
    609617        int empty = 0;
     618        int j;
    610619
    611620        /* Wait until trace_pstart has been completed */
     
    692701                /* Handle error/message cases */
    693702                if (nb_packets > 0) {
    694                         /* Store the first packet */
    695                         if (packets[0]->error > 0) {
    696                                 store_first_packet(trace, packets[0], t);
     703                        /* Store the first non-meta packet */
     704                        for (j = 0; j < nb_packets; j++) {
     705                                if (t->recorded_first)
     706                                        break;
     707                                if (packets[j]->error > 0) {
     708                                        store_first_packet(trace, packets[j], t);
     709                                }
    697710                        }
    698711                        dispatch_packets(trace, t, packets, nb_packets, &empty,
     
    805818                                        break;
    806819                                case MESSAGE_DO_STOP:
     820                                        /* Either FINISHED or FINISHING */
    807821                                        assert(trace->started == false);
    808                                         assert(trace->state == STATE_FINISHED);
    809822                                        /* Mark the current packet as EOF */
    810823                                        packet->error = 0;
    811                                         break;
     824                                        goto hasher_eof;
    812825                                default:
    813826                                        fprintf(stderr, "Hasher thread didn't expect message code=%d\n", message.code);
     
    850863                }
    851864        }
    852 
     865hasher_eof:
    853866        /* Broadcast our last failed read to all threads */
    854867        for (i = 0; i < trace->perpkt_thread_count; i++) {
     
    862875                ASSERT_RET(pthread_mutex_lock(&trace->libtrace_lock), == 0);
    863876                if (trace->perpkt_threads[i].state != THREAD_FINISHED) {
    864                         // Unlock early otherwise we could deadlock
    865877                        libtrace_ringbuffer_write(&trace->perpkt_threads[i].rbuffer, bcast);
     878                } else {
     879                        libtrace_ocache_free(&trace->packet_freelist, (void **) &bcast, 1, 1);
    866880                }
    867881                ASSERT_RET(pthread_mutex_unlock(&trace->libtrace_lock), == 0);
     
    917931                        tick_hit = true;
    918932                }*/
    919         }
    920         // Doing this inside the lock ensures the first packet is always
    921         // recorded first
    922         if (packets[0]->error > 0) {
    923                 store_first_packet(libtrace, packets[0], t);
     933
     934                // Doing this inside the lock ensures the first packet is
     935                // always recorded first
     936                if (!t->recorded_first && packets[0]->error > 0) {
     937                        store_first_packet(libtrace, packets[0], t);
     938                }
    924939        }
    925940        ASSERT_RET(pthread_mutex_unlock(&libtrace->read_packet_lock), == 0);
     
    9931008void store_first_packet(libtrace_t *libtrace, libtrace_packet_t *packet, libtrace_thread_t *t)
    9941009{
    995         if (!t->recorded_first) {
    996                 libtrace_message_t mesg = {0, {.uint64=0}, NULL};
    997                 struct timeval tv;
    998                 libtrace_packet_t * dup;
    999 
    1000                 /* We mark system time against a copy of the packet */
    1001                 gettimeofday(&tv, NULL);
    1002                 dup = trace_copy_packet(packet);
    1003 
    1004                 ASSERT_RET(pthread_spin_lock(&libtrace->first_packets.lock), == 0);
    1005                 libtrace->first_packets.packets[t->perpkt_num].packet = dup;
    1006                 memcpy(&libtrace->first_packets.packets[t->perpkt_num].tv, &tv, sizeof(tv));
    1007                 libtrace->first_packets.count++;
    1008 
    1009                 /* Now update the first */
    1010                 if (libtrace->first_packets.count == 1) {
    1011                         /* We the first entry hence also the first known packet */
    1012                         libtrace->first_packets.first = t->perpkt_num;
    1013                 } else {
    1014                         /* Check if we are newer than the previous 'first' packet */
    1015                         size_t first = libtrace->first_packets.first;
    1016                         struct timeval cur_ts = trace_get_timeval(dup);
    1017                         struct timeval first_ts = trace_get_timeval(libtrace->first_packets.packets[first].packet);
    1018                         if (timercmp(&cur_ts, &first_ts, <))
    1019                                 libtrace->first_packets.first = t->perpkt_num;
    1020                 }
    1021                 ASSERT_RET(pthread_spin_unlock(&libtrace->first_packets.lock), == 0);
    1022 
    1023                 mesg.code = MESSAGE_FIRST_PACKET;
    1024                 trace_message_reporter(libtrace, &mesg);
    1025                 trace_message_perpkts(libtrace, &mesg);
    1026                 t->recorded_first = true;
    1027         }
     1010
     1011        libtrace_message_t mesg = {0, {.uint64=0}, NULL};
     1012        struct timeval tv;
     1013        libtrace_packet_t * dup;
     1014
     1015        if (t->recorded_first) {
     1016                return;
     1017        }
     1018
     1019        if (IS_LIBTRACE_META_PACKET(packet)) {
     1020                return;
     1021        }
     1022
     1023        /* We mark system time against a copy of the packet */
     1024        gettimeofday(&tv, NULL);
     1025        dup = trace_copy_packet(packet);
     1026
     1027        ASSERT_RET(pthread_spin_lock(&libtrace->first_packets.lock), == 0);
     1028        libtrace->first_packets.packets[t->perpkt_num].packet = dup;
     1029        memcpy(&libtrace->first_packets.packets[t->perpkt_num].tv, &tv, sizeof(tv));
     1030        libtrace->first_packets.count++;
     1031
     1032        /* Now update the first */
     1033        if (libtrace->first_packets.count == 1) {
     1034                /* We the first entry hence also the first known packet */
     1035                libtrace->first_packets.first = t->perpkt_num;
     1036        } else {
     1037                /* Check if we are newer than the previous 'first' packet */
     1038                size_t first = libtrace->first_packets.first;
     1039                struct timeval cur_ts = trace_get_timeval(dup);
     1040                struct timeval first_ts = trace_get_timeval(libtrace->first_packets.packets[first].packet);
     1041                if (timercmp(&cur_ts, &first_ts, <))
     1042                        libtrace->first_packets.first = t->perpkt_num;
     1043        }
     1044        ASSERT_RET(pthread_spin_unlock(&libtrace->first_packets.lock), == 0);
     1045
     1046        mesg.code = MESSAGE_FIRST_PACKET;
     1047        trace_message_reporter(libtrace, &mesg);
     1048        trace_message_perpkts(libtrace, &mesg);
     1049        t->recorded_first = true;
    10281050}
    10291051
     
    12201242                int64_t initial_offset;
    12211243                int stable = trace_get_first_packet(libtrace, NULL, &first_pkt, &sys_tv);
    1222                 assert(first_pkt);
     1244                if (!first_pkt)
     1245                        return 0;
    12231246                pkt_tv = trace_get_timeval(first_pkt);
    12241247                initial_offset = (int64_t)tv_to_usec(sys_tv) - (int64_t)tv_to_usec(&pkt_tv);
     
    16501673        int i;
    16511674        int ret = -1;
    1652         char name[16];
     1675        char name[24];
    16531676        sigset_t sig_before, sig_block_all;
    16541677        assert(libtrace);
     
    17241747        /* Try start the format - we prefer parallel over single threaded, as
    17251748         * these formats should support messages better */
     1749
    17261750        if (trace_supports_parallel(libtrace) &&
    17271751            !trace_has_dedicated_hasher(libtrace)) {
     
    17331757                        ret = libtrace->format->start_input(libtrace);
    17341758                }
    1735                 if (libtrace->perpkt_thread_count > 1)
     1759                if (libtrace->perpkt_thread_count > 1) {
    17361760                        libtrace->pread = trace_pread_packet_first_in_first_served;
    17371761                        /* Don't wait for a burst of packets if the format is
     
    17411765                                libtrace->config.burst_size = 1;
    17421766                        }
    1743                 else
     1767                }
     1768                else {
    17441769                        /* Use standard read_packet */
    17451770                        libtrace->pread = NULL;
     1771                }
    17461772        }
    17471773
  • libpacketdump/eth_34525.c

    ree6e802 rf398c61  
    3838{
    3939        libtrace_ip6_t *ip = (libtrace_ip6_t*)packet;
    40        
    4140        uint32_t tmp = ntohl(*(uint32_t*)ip);
    4241
    43         printf(" IPv6: Version %u\n", (tmp >> 28) & 0x000000f);
    44         printf(" IPv6: Class %u\n", (tmp >> 20) & 0x000000ff);
    45         printf(" IPv6: Flow Label %u\n", tmp & 0x000fffff);
    46         printf(" IPv6: Payload Length %u\n", ntohs(ip->plen));
    47         printf(" IPv6: Next Header %u\n", ip->nxt);
    48         printf(" IPv6: Hop Limit %u\n", ip->hlim);
     42        int truncated = 0;
     43        char ipstr[INET6_ADDRSTRLEN];
    4944
     45        do {
     46                if (len < 4) {
     47                        truncated = 1;
     48                        break;
     49                }
    5050
    51         char ipstr[INET6_ADDRSTRLEN];                             
    52         inet_ntop(AF_INET6, &(ip->ip_src), ipstr, INET6_ADDRSTRLEN);
     51                printf(" IPv6: Version %u\n", (tmp >> 28) & 0x000000f);
     52                printf(" IPv6: Class %u\n", (tmp >> 20) & 0x000000ff);
     53                printf(" IPv6: Flow Label %u\n", tmp & 0x000fffff);
    5354
    54         printf(" IPv6: Source IP %s\n", ipstr);
    55         inet_ntop(AF_INET6, &(ip->ip_dst), ipstr, INET6_ADDRSTRLEN);
    56         printf(" IPv6: Destination IP %s\n", ipstr);
     55                if (len < 6) {
     56                        truncated = 1;
     57                        break;
     58                }
     59                printf(" IPv6: Payload Length %u\n", ntohs(ip->plen));
     60
     61                if (len < 7) {
     62                        truncated = 1;
     63                        break;
     64                }
     65                printf(" IPv6: Next Header %u\n", ip->nxt);
     66                if (len < 8) {
     67                        truncated = 1;
     68                        break;
     69                }
     70                printf(" IPv6: Hop Limit %u\n", ip->hlim);
     71
     72                if (len < 24) {
     73                        truncated = 1;
     74                        break;
     75                }
     76
     77                inet_ntop(AF_INET6, &(ip->ip_src), ipstr, INET6_ADDRSTRLEN);
     78                printf(" IPv6: Source IP %s\n", ipstr);
     79
     80                if (len < 40) {
     81                        truncated = 1;
     82                        break;
     83                }
     84
     85                inet_ntop(AF_INET6, &(ip->ip_dst), ipstr, INET6_ADDRSTRLEN);
     86                printf(" IPv6: Destination IP %s\n", ipstr);
     87        } while (0);
     88
     89        if (truncated) {
     90                printf(" IPv6: [Truncated]\n");
     91                return;
     92        }
    5793
    5894        decode_next(packet+sizeof(libtrace_ip6_t),len-sizeof(libtrace_ip6_t),"ip",ip->nxt);
  • libpacketdump/ip_132.c

    ree6e802 red3a238  
    155155                int len = ntohs(ph->length) -
    156156                    sizeof(struct sctp_var_param_hdr);
    157                
     157
    158158                printf(" SCTP: Option Supported address types ");
    159                
     159
    160160                while(len) {
    161161                    printf("%hu ", ntohs(*p));
     
    181181    struct sctp_chunk_hdr *chunk;
    182182    int chunk_num = 1;
    183     int vlen;
     183    int vlen = 0;
     184    uint16_t chunklen = 0;
    184185
    185186    if(len < (signed)sizeof(struct sctp_common_hdr)) {
     
    198199
    199200    while(len > 0) {
     201        if (len < sizeof(struct sctp_chunk_hdr)) {
     202                printf(" SCTP: [Truncated]\n\n");
     203                break;
     204        }
     205
    200206        chunk = (struct sctp_chunk_hdr *)packet;
    201207
    202         chunk->length = ntohs(chunk->length);
     208        chunklen = ntohs(chunk->length);
    203209
    204210        printf(" SCTP: Chunk %d Type %s Flags %u Len %u\n",
    205211            chunk_num++,
    206             sctp_type_to_str(chunk->type), chunk->flags, chunk->length);
    207 
    208         if(chunk->length == 0) {
     212            sctp_type_to_str(chunk->type), chunk->flags, chunklen);
     213
     214        if(chunklen == 0) {
    209215            printf(" SCTP: Invalid chunk length, aborting.\n\n");
    210216            break;
     217        }
     218
     219        /* Stupid SCTP has padding that is not accounted for in either
     220         * the chunk length or the payload length fields */
     221        if ((chunklen % 4) != 0) {
     222                /* Pad to the next four byte boundary */
     223                chunklen += ( 4 - (chunklen % 4) );
     224        }
     225
     226        /* Truncate any ridiculous chunk lengths so that they don't
     227         * exceed the confines of the packet */
     228        if (chunklen > len) {
     229                chunklen = len;
    211230        }
    212231
     
    229248                struct sctp_init_ack *ack = (struct sctp_init_ack *)
    230249                    (chunk + 1);
    231                
     250
    232251                printf(" SCTP: Tag %u Credit %u Outbound %hu Inbound %hu "
    233252                        "TSN %u\n",
     
    238257                        ntohl(ack->init_tsn));
    239258
    240                 vlen = chunk->length - (sizeof(struct sctp_init_ack) +
     259                vlen = chunklen - (sizeof(struct sctp_init_ack) +
    241260                        sizeof(struct sctp_chunk_hdr) +
    242261                        sizeof(struct sctp_common_hdr)
     
    270289            break;
    271290        }
    272        
    273         packet += chunk->length;
    274         len -= chunk->length;
     291
     292        packet += chunklen;
     293        len -= chunklen;
    275294    }
    276295    printf("\n");
  • libpacketdump/libpacketdump.h

    ree6e802 r6654714  
    4747#define DISPLAYS(hdr,x,fmt) DISPLAY_EXP(hdr,x,fmt,htons(hdr->x))
    4848#define DISPLAYL(hdr,x,fmt) DISPLAY_EXP(hdr,x,fmt,htonl(hdr->x))
    49 #define DISPLAYIP(hdr,x,fmt) DISPLAY_EXP(hdr,x,fmt,inet_ntoa(*(struct in_addr*)&hdr->x))
     49#define DISPLAYIP(hdr,x,fmt) DISPLAY_EXP(hdr,x,fmt,inet_ntoa(*(struct in_addr*)(void *)(&hdr->x)))
    5050
    5151
  • libpacketdump/link_15.c

    ree6e802 r6654714  
    6969       
    7070        /* Check for extended bitmasks */
    71         ptr = (uint32_t *) &(rtap->it_present);
     71        ptr = (uint32_t *) (char *)(&(rtap->it_present));
    7272       
    7373        if ( (rtap_pres) & (1 << TRACE_RADIOTAP_EXT) )
  • libpacketdump/ospf2_1001.c

    ree6e802 r1de522d  
    3333DLLEXPORT void decode(int link_type UNUSED,const char *packet,unsigned len) {
    3434        unsigned char *link_ptr = NULL;
    35         libtrace_ospf_link_v2_t *link;
     35        libtrace_ospf_link_v2_t *link = NULL;
    3636        uint32_t link_len;
    3737        libtrace_ospf_router_lsa_v2_t *hdr;
     
    5858                return;
    5959        while (trace_get_next_ospf_link_v2(&link_ptr, &link, &len, &link_len) > 0) {
     60                if (!link) {
     61                        break;
     62                }
    6063                printf(" OSPF Router Link: Id %s ", inet_ntoa(link->link_id));
    6164                printf("Data %s\n", inet_ntoa(link->link_data));
  • libpacketdump/ospf2_4.c

    ree6e802 r1de522d  
    3434DLLEXPORT void decode(int link_type UNUSED,const char *packet,unsigned len) {
    3535        libtrace_ospf_ls_update_t *update = (libtrace_ospf_ls_update_t *)packet;
    36         unsigned char *lsa_ptr;
    37         uint8_t lsa_type;
    38         libtrace_ospf_lsa_v2_t *lsa_hdr;
    39         unsigned char *lsa_body;
     36        unsigned char *lsa_ptr = NULL;
     37        uint8_t lsa_type = 0;
     38        libtrace_ospf_lsa_v2_t *lsa_hdr = NULL;
     39        unsigned char *lsa_body = NULL;
    4040        int i = 0;
    4141        int max_lsas = 0;
    4242        uint32_t rem = len;
    43         uint16_t lsa_length;
     43        uint16_t lsa_length = 0;
    4444
    4545
  • test/Makefile

    r6c84681 r568a341  
    1919BINS = test-pcap-bpf test-event test-time test-dir test-wireless test-errors \
    2020        test-plen test-autodetect test-ports test-fragment test-live \
    21         test-live-snaplen test-vxlan $(BINS_DATASTRUCT) $(BINS_PARALLEL)
     21        test-live-snaplen test-vxlan test-setcaplen $(BINS_DATASTRUCT) $(BINS_PARALLEL)
    2222
    2323.PHONY: all clean distclean install depend test
  • test/do-live-tests.sh

    red18a6e rccef50c  
    1919
    2020libdir=../lib/.libs:../libpacketdump/.libs
    21 export LD_LIBRARY_PATH="$libdir"
     21export LD_LIBRARY_PATH="$libdir:/usr/local/lib/"
    2222export DYLD_LIBRARY_PATH="${libdir}"
    2323
  • test/do-tests-parallel.sh

    r01619eb rccef50c  
    1414
    1515libdir=../lib/.libs:../libpacketdump/.libs
    16 export LD_LIBRARY_PATH="$libdir"
     16export LD_LIBRARY_PATH="$libdir:/usr/local/lib/"
    1717export DYLD_LIBRARY_PATH="${libdir}"
    1818
     
    4545do_test ./test-format-parallel rawerf
    4646
     47echo \* Read pcapng
     48do_test ./test-format-parallel pcapng
     49
    4750echo \* Read testing hasher function
    4851do_test ./test-format-parallel-hasher erf
  • test/do-tests.sh

    r3fc3267 rccef50c  
    1414
    1515libdir=../lib/.libs:../libpacketdump/.libs
    16 export LD_LIBRARY_PATH="$libdir"
     16export LD_LIBRARY_PATH="$libdir:/usr/local/lib/"
    1717export DYLD_LIBRARY_PATH="${libdir}"
    1818echo SLL Decoder
     
    6565do_test ./test-format rawerf
    6666do_test ./test-decode rawerf
     67
     68echo \* Read pcapng
     69do_test ./test-format pcapng
     70do_test ./test-decode pcapng
    6771
    6872
     
    101105echo \* tsh
    102106do_test ./test-time tsh
     107echo \* pcapng
     108do_test ./test-time pcapng
    103109
    104110echo \* Testing directions
     
    181187rm -f traces/*.out.*
    182188do_test ./test-convert erf pcapfile
     189
     190echo " * pcapng -> pcapfile"
     191rm -f traces/*.out.*
     192do_test ./test-convert pcapng pcapfile
     193
     194echo " * pcapng -> erf"
     195rm -f traces/*.out.*
     196do_test ./test-convert pcapng erf
    183197
    184198echo " * pcap (sll) -> erf    raw IP"
     
    209223do_test ./test-convert legacypos pcapfile
    210224
    211 echo " * duck -> duck"
    212 rm -f traces/*.out.*
    213 do_test ./test-convert duck duck
     225# Don't bother with this anymore -- DUCK qualifies as 'meta' so
     226# doesn't get written at the moment.
     227#echo " * duck -> duck"
     228#rm -f traces/*.out.*
     229#do_test ./test-convert duck duck
    214230
    215231echo " * tsh -> pcapfile"
     
    220236rm -f traces/*.out.*
    221237do_test ./test-convert tsh pcap
     238
     239echo \* Testing packet truncation
     240echo " * pcap "
     241rm -f traces/*.out.*
     242do_test ./test-setcaplen pcap pcapfile
     243
     244echo " * pcapfile "
     245rm -f traces/*.out.*
     246do_test ./test-setcaplen pcapfile pcapfile
     247
     248echo " * erf "
     249rm -f traces/*.out.*
     250do_test ./test-setcaplen erf erf
     251
     252echo " * pcapng "
     253rm -f traces/*.out.*
     254do_test ./test-setcaplen pcapng pcapfile
     255
     256echo " * pcapfilens "
     257rm -f traces/*.out.*
     258do_test ./test-setcaplen pcapfilens pcapfile
     259
     260
    222261
    223262echo " * format autodetection - uncompressed"
  • test/test-convert.c

    r86bec15 r568a341  
    7474        if (!strcmp(type,"pcap"))
    7575                return "pcap:traces/100_packets.pcap";
     76        if (!strcmp(type,"pcapng"))
     77                return "pcapng:traces/100_packets.pcapng";
    7678        if (!strcmp(type,"wtf"))
    7779                return "wtf:traces/wed.wtf";
     
    204206                        break;
    205207                }
    206                 count ++;
    207                 trace_write_packet(outtrace,packet);
     208                if (trace_write_packet(outtrace,packet) > 0)
     209                        count ++;
    208210                iferrout(outtrace);
    209211                if (count>100)
     
    241243        while(trace_read_packet(trace,packet)>0) {
    242244                int err;
     245
     246                if (IS_LIBTRACE_META_PACKET(packet))
     247                        continue;
     248
    243249                ++count;
    244                 if ((err=trace_read_packet(trace2,packet2))<1) {
    245                         printf("premature EOF on destination, %i from %s, %i from %s\n",count,lookup_uri(argv[1]),count-1,lookup_out_uri(argv[2]));
    246                         iferr(trace2);
    247                         error=1;
    248                         break;
    249                 }
     250                do {
     251                        if ((err=trace_read_packet(trace2,packet2))<1) {
     252                                printf("premature EOF on destination, %i from %s, %i from %s\n",count,lookup_uri(argv[1]),count-1,lookup_out_uri(argv[2]));
     253                                iferr(trace2);
     254                                error=1;
     255                                break;
     256                        }
     257                } while (IS_LIBTRACE_META_PACKET(packet2));
     258
    250259                /* The capture length might be snapped down to the wire length */
    251260                if (length_changed(packet, packet2)) {
  • test/test-decode.c

    rbcb2402 r568a341  
    6868        if (!strcmp(type,"pcap"))
    6969                return "pcap:traces/100_packets.pcap";
     70        if (!strcmp(type,"pcapng"))
     71                return "pcap:traces/100_packets.pcapng";
    7072        if (!strcmp(type,"wtf"))
    7173                return "wtf:traces/wed.wtf";
  • test/test-format-parallel.c

    r135e3f6 r568a341  
    7070        if (!strcmp(type,"pcap"))
    7171                return "pcap:traces/100_packets.pcap";
     72        if (!strcmp(type,"pcapng"))
     73                return "pcap:traces/100_packets.pcapng";
    7274        if (!strcmp(type,"wtf"))
    7375                return "wtf:traces/wed.wtf";
  • test/test-format.c

    rbcb2402 r568a341  
    6767        if (!strcmp(type,"pcap"))
    6868                return "pcap:traces/100_packets.pcap";
     69        if (!strcmp(type,"pcapng"))
     70                return "pcap:traces/100_packets.pcapng";
    6971        if (!strcmp(type,"wtf"))
    7072                return "wtf:traces/wed.wtf";
  • test/test-time.c

    r6a38a7e r568a341  
    6060        if (!strcmp(type,"pcap"))
    6161                return "pcap:traces/100_packets.pcap";
     62        if (!strcmp(type,"pcapng"))
     63                return "pcap:traces/100_packets.pcapng";
    6264        if (!strcmp(type,"wtf"))
    6365                return "wtf:traces/wed.wtf";
  • tools/traceanon/Anon.cc

    ree6e802 rcb075c5  
    107107
    108108    this->cipher = EVP_aes_128_ecb();
    109     EVP_CIPHER_CTX_init(&this->ctx);
    110 
    111     EVP_EncryptInit_ex(&this->ctx, this->cipher, NULL, this->key, NULL);
     109    this->ctx = EVP_CIPHER_CTX_new();
     110    EVP_CIPHER_CTX_init(this->ctx);
     111
     112    EVP_EncryptInit_ex(this->ctx, this->cipher, NULL, this->key, NULL);
    112113
    113114    this->cachebits = cachebits;
     
    125126CryptoAnon::~CryptoAnon() {
    126127    delete(this->ipv4_cache);
    127     EVP_CIPHER_CTX_cleanup(&this->ctx);
     128    EVP_CIPHER_CTX_cleanup(this->ctx);
     129    EVP_CIPHER_CTX_free(this->ctx);
    128130}
    129131
     
    255257         * bit in the original address, we use the first bit of the resulting
    256258         * encrypted output as part of an XOR mask */
    257         EVP_EncryptUpdate(&this->ctx, (unsigned char *)rin_output, &outl,
     259        EVP_EncryptUpdate(this->ctx, (unsigned char *)rin_output, &outl,
    258260                (unsigned char *)rin_input, 16);
    259261
     
    290292        memcpy(rin_input, &input, 8);
    291293
    292         EVP_EncryptUpdate(&this->ctx, (unsigned char *)rin_output, &outl,
     294        EVP_EncryptUpdate(this->ctx, (unsigned char *)rin_output, &outl,
    293295                (unsigned char *)rin_input, 16);
    294296
  • tools/traceanon/Anon.h

    ree6e802 rcb075c5  
    8686    uint32_t recent_ipv4_cache[2][2];
    8787    const EVP_CIPHER *cipher;
    88     EVP_CIPHER_CTX ctx;
     88    EVP_CIPHER_CTX *ctx;
    8989
    9090    uint32_t encrypt32Bits(uint32_t orig, uint8_t start, uint8_t stop,
  • tools/traceanon/traceanon.cc

    ree6e802 r8e11beb  
    176176        libtrace_generic_t result;
    177177
     178        if (IS_LIBTRACE_META_PACKET(packet))
     179                return packet;
     180
    178181        ipptr = trace_get_ip(packet);
    179182        ip6 = trace_get_ip6(packet);
     
    223226
    224227        if (enc_type == ENC_CRYPTOPAN) {
     228                if (strlen(key) < 32) {
     229                        fprintf(stderr, "ERROR: Key must be at least 32 "
     230                        "characters long for CryptoPan anonymisation.\n");
     231                        exit(1);
     232                }
    225233#ifdef HAVE_LIBCRYPTO               
    226234                CryptoAnon *anon = new CryptoAnon((uint8_t *)key,
  • tools/traceends/traceends.cc

    ree6e802 r8e11beb  
    309309        c->src_pbytes += plen;
    310310        c->src_bytes += ip->ip_len;
    311         c->last_active = ts;
     311        if (ts != 0)
     312                c->last_active = ts;
    312313       
    313314        key = ip->ip_dst.s_addr;
     
    324325        c->dst_pbytes += plen;
    325326        c->dst_bytes += ip_len;
    326         c->last_active = ts;
     327        if (ts != 0)
     328                c->last_active = ts;
    327329}
    328330
     
    455457
    456458                while (trace_read_packet(input,packet)>0) {
     459                        if (IS_LIBTRACE_META_PACKET(packet))
     460                                continue;
    457461                        if (per_packet(packet) < 1)
    458462                                done = 1;
  • tools/tracemerge/tracemerge.c

    ree6e802 r8e11beb  
    213213        while(1) {
    214214                uint64_t oldest_ts=0;
     215                uint64_t this_ts = 0;
    215216                int oldest=-1;
    216217                int curr_dir;
     
    234235                                        live[i]=true;
    235236                        }
    236                         if (live[i] &&
    237                                 (oldest==-1 ||
    238                                  oldest_ts>trace_get_erf_timestamp(packet[i]))) {
    239                                 oldest=i;
    240                                 oldest_ts=trace_get_erf_timestamp(packet[i]);
    241                         }
     237                        if (live[i]) {
     238                                this_ts = trace_get_erf_timestamp(packet[i]);
     239                                if (this_ts != 0 && (oldest==-1 ||
     240                                                oldest_ts>this_ts)) {
     241                                        oldest=i;
     242                                        oldest_ts=this_ts;
     243                                }
     244                        }
    242245                }
    243246                /* We have run out of packets! */
  • tools/tracereplay/tracereplay.c

    ree6e802 r8e11beb  
    9696        int i;
    9797
     98        if (IS_LIBTRACE_META_PACKET(packet))
     99                return NULL;
     100
    98101        pkt_buffer = trace_get_packet_buffer(packet,&linktype,&remaining);
    99102        remaining = 0;
     
    307310                new = per_packet(packet);
    308311
     312                if (!new)
     313                        continue;
     314
    309315                if (trace_write_packet(output, new) < 0) {
    310316                        trace_perror_output(output, "Writing packet");
  • tools/tracereport/misc_report.c

    ree6e802 r8e11beb  
    4646{
    4747        double ts = trace_get_seconds(packet);
    48         if (!has_starttime || starttime > ts)
     48        if (ts != 0 && (!has_starttime || starttime > ts))
    4949                starttime = ts;
    50         if (!has_endtime || endtime < ts)
     50        if (ts != 0 && (!has_endtime || endtime < ts))
    5151                endtime = ts;
    5252        has_starttime = has_endtime = true;
  • tools/tracereport/tracereport.c

    ree6e802 r8e11beb  
    9393                        break;
    9494                }
     95                if (IS_LIBTRACE_META_PACKET(packet))
     96                        continue;
     97
    9598                if (reports_required & REPORT_TYPE_MISC)
    9699                        misc_per_packet(packet);
  • tools/tracertstats/tracertstats.c

    r0b4b388 r8e11beb  
    188188        thread_data_t *td = (thread_data_t *)tls;
    189189        int i;
     190
     191        if (IS_LIBTRACE_META_PACKET(packet)) {
     192                return packet;
     193        }
    190194
    191195        key = trace_get_erf_timestamp(packet);
  • tools/tracesplit/tracesplit.c

    ree6e802 r8e11beb  
    190190 */
    191191static int per_packet(libtrace_packet_t **packet) {
     192        if (IS_LIBTRACE_META_PACKET((*packet))) {
     193                return 1;
     194        }
    192195
    193196        if (trace_get_link_type(*packet) == -1) {
     
    210213        if (firsttime==0) {
    211214                time_t now = trace_get_seconds(*packet);
    212                 if (starttime != 0) {
     215                if (now != 0 && starttime != 0) {
    213216                        firsttime=now-((now - starttime)%interval);
    214217                }
    215                 else {
     218                else if (now != 0) {
    216219                        firsttime=now;
    217220                }
  • tools/tracestats/tracestats.c

    ree6e802 r8e11beb  
    155155        int i, wlen;
    156156
     157        if (IS_LIBTRACE_META_PACKET(pkt))
     158                return pkt;
     159
    157160        /* Apply filters to every packet note the result */
    158161        wlen = trace_get_wire_length(pkt);
  • tools/tracetop/tracetop.cc

    ree6e802 r8e11beb  
    261261        flows_t::iterator it;
    262262
     263        if (IS_LIBTRACE_META_PACKET(packet))
     264                return;
     265
    263266        if (trace_get_source_address(packet,(struct sockaddr*)&flowkey.sip)==NULL)
    264267                flowkey.sip.ss_family = AF_UNSPEC;
     
    467470                                if (trace_get_seconds(packet) - last_report >= interval) {
    468471                                        do_report();
    469                                                
    470472                                        last_report=trace_get_seconds(packet);
    471473                                }
Note: See TracChangeset for help on using the changeset viewer.