Changeset c876f29


Ignore:
Timestamp:
02/05/19 09:50:43 (20 months ago)
Author:
Jacob Van Walraven <jcv9@…>
Branches:
develop
Children:
5e5b6ca
Parents:
db919d5 (diff), 1c3f8d2 (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:

Resolve merge conflict attempt 2

Files:
2 added
37 edited

Legend:

Unmodified
Added
Removed
  • .gitlab-ci.yml

    rdd48bb5 reeea305  
    22  - build
    33  - deploy
     4  - upload
    45
    56build-debian-jessie:
     
    112113  only:
    113114    - tags
     115
     116upload-packages:
     117  stage: upload
     118  image: ubuntu:bionic
     119  script:
     120    - ./bintray-upload.sh
     121  only:
     122    - tags
     123
  • README

    rbc86030 r91600c7  
    1 libtrace 4.0.5
     1libtrace 4.0.6
    22
    33---------------------------------------------------------------------------
    4 Copyright (c) 2007-2018 The University of Waikato, Hamilton, New Zealand.
     4Copyright (c) 2007-2019 The University of Waikato, Hamilton, New Zealand.
    55All rights reserved.
    66
  • configure.in

    r1dc033a r95ba467  
    44# and in the README
    55
    6 AC_INIT([libtrace],[4.0.5],[contact@wand.net.nz],[libtrace])
     6AC_INIT([libtrace],[4.0.6],[contact@wand.net.nz],[libtrace])
    77
    88LIBTRACE_MAJOR=4
    99LIBTRACE_MID=0
    10 LIBTRACE_MINOR=5
     10LIBTRACE_MINOR=6
    1111
    1212# OpenSolaris hides libraries like libncurses in /usr/gnu/lib, which is not
     
    404404        # So instead simply check for existence
    405405        if test "$RTE_SDK" != ""; then
     406                AC_CHECK_FILE("$RTE_SDK/$RTE_TARGET/lib/libdpdk.so", dpdk_found="dpdk", dpdk_found=0)
     407        fi
     408        if test "$dpdk_found" = 0 -a "$RTE_SDK" != ""; then
    406409                AC_CHECK_FILE("$RTE_SDK/$RTE_TARGET/lib/libintel_dpdk.a", dpdk_found=":libintel_dpdk.a", dpdk_found=0)
    407410        fi
     
    409412        if test "$dpdk_found" = 0 -a "$RTE_SDK" != ""; then
    410413                AC_CHECK_FILE("$RTE_SDK/$RTE_TARGET/lib/libdpdk.a", dpdk_found=":libdpdk.a", dpdk_found=0)
    411         fi
    412         if test "$dpdk_found" = 0 -a "$RTE_SDK" != ""; then
    413                 AC_CHECK_FILE("$RTE_SDK/$RTE_TARGET/lib/libdpdk.so", dpdk_found="dpdk", dpdk_found=0)
    414414        fi
    415415        if test "$dpdk_found" = 0 -a "$RTE_SDK" != ""; then
     
    512512if test "$have_pthread" = 1; then
    513513        AC_DEFINE(HAVE_LIBPTHREAD, 1, [Set to 1 if pthreads are supported])
     514        LIBTRACE_LIBS="$LIBTRACE_LIBS -lpthread"
    514515fi
    515516
  • debian/changelog

    r78fe0d2 r6303155  
     1libtrace4 (4.0.6-2) unstable; urgency=low
     2
     3  * Fix bad dpdk dependencies in libtrace4 package
     4
     5 -- Shane Alcock <shane.alcock@waikato.ac.nz>  Wed, 16 Jan 2019 16:49:04 +1300
     6
     7libtrace4 (4.0.6-1) unstable; urgency=low
     8
     9  * New upstream release
     10
     11 -- Shane Alcock <shane.alcock@waikato.ac.nz>  Tue, 15 Jan 2019 11:50:06 +1300
     12
    113libtrace4 (4.0.0-1) unstable; urgency=medium
    214
  • debian/control

    r4819d75 r1c3f8d2  
    44Build-Depends: debhelper (>= 9), dh-autoreconf,
    55 libpcap-dev, zlib1g-dev, flex, bison, doxygen, liblzma-dev, graphviz,
    6  libncurses5-dev, libbz2-dev, libssl-dev, libwandio1-dev, libwandder1-dev,
    7  dpdk-dev, libnuma-dev
     6 libncurses5-dev, libbz2-dev, libssl-dev, libwandio1-dev (>= 4.0.0),
     7 libwandder1-dev, dpdk-dev, libnuma-dev
    88Standards-Version: 4.1.3
    99Section: libs
     
    1313Section: libdevel
    1414Architecture: any
    15 Depends: libtrace4 (= ${binary:Version}), ${shlibs:Depends}, ${misc:Depends}
     15Depends: libtrace4 (= ${binary:Version}), ${misc:Depends}
    1616Provides: libtrace-dev
    1717Conflicts: libtrace-dev, libpacketdump3-dev
     
    4646Section: libdevel
    4747Architecture: any
    48 Depends: libpacketdump4 (= ${binary:Version}), ${misc:Depends},
    49  ${shlibs:Depends}
     48Depends: libpacketdump4 (= ${binary:Version}), ${misc:Depends}
    5049Provides: libpacketdump-dev
    5150Conflicts: libpacketdump-dev
  • debian/rules

    r4819d75 r729bed4  
    9191        dh_gencontrol
    9292        dh_md5sums
    93         dh_builddeb
     93        dh_builddeb -- -Zgzip
    9494
    9595binary: binary-indep binary-arch
  • examples/parallel/network_capture.c

    r10553bf r0f5d4de  
    2121#include <string.h>
    2222
    23 static char *output = NULL;
     23static char *outputfile = NULL;
    2424
    2525static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
    2626static int count = 0;
    27 static libtrace_t *trace = NULL;
     27static libtrace_t *inptrace = NULL;
    2828
    2929static int compress_level=-1;
     
    3232static void stop(int signal UNUSED)
    3333{
    34         if (trace)
    35                 trace_pstop(trace);
     34        if (inptrace)
     35                trace_pstop(inptrace);
    3636}
    3737
     
    5757        const char * first_extension = NULL;
    5858
    59         file_index = strrchr(output, '/');
     59        file_index = strrchr(outputfile, '/');
    6060        if (file_index)
    6161                first_extension = strchr(file_index, '.');
     
    6464
    6565        if (first_extension) {
    66                 snprintf(name, sizeof(name), "%.*s-%d%s", (int) (first_extension - output), output, my_id, first_extension);
     66                snprintf(name, sizeof(name), "%.*s-%d%s", (int) (first_extension - outputfile), outputfile, my_id, first_extension);
    6767        } else {
    68                 snprintf(name, sizeof(name), "%s-%d", output, my_id);
     68                snprintf(name, sizeof(name), "%s-%d", outputfile, my_id);
    6969        }
    7070
     
    232232                return 1;
    233233        }
    234         trace = trace_create(argv[optind]);
    235         output = argv[optind+1];
    236 
    237         if (trace_is_err(trace)) {
    238                 trace_perror(trace,"Opening trace file");
     234        inptrace = trace_create(argv[optind]);
     235        outputfile = argv[optind+1];
     236
     237        if (trace_is_err(inptrace)) {
     238                trace_perror(inptrace,"Opening trace file");
    239239                return 1;
    240240        }
     
    247247
    248248        if (snaplen != -1)
    249                 trace_set_snaplen(trace, snaplen);
     249                trace_set_snaplen(inptrace, snaplen);
    250250        if(nb_threads != -1)
    251                 trace_set_perpkt_threads(trace, nb_threads);
     251                trace_set_perpkt_threads(inptrace, nb_threads);
    252252
    253253        /* We use a new version of trace_start(), trace_pstart()
    254254         * The reporter function argument is optional and can be NULL */
    255         if (trace_pstart(trace, NULL, processing, NULL)) {
    256                 trace_perror(trace,"Starting trace");
    257                 trace_destroy(trace);
     255        if (trace_pstart(inptrace, NULL, processing, NULL)) {
     256                trace_perror(inptrace,"Starting trace");
     257                trace_destroy(inptrace);
    258258                trace_destroy_callback_set(processing);
    259259                return 1;
     
    261261
    262262        /* Wait for the trace to finish */
    263         trace_join(trace);
    264 
    265         if (trace_is_err(trace)) {
    266                 trace_perror(trace,"Reading packets");
    267                 trace_destroy(trace);
     263        trace_join(inptrace);
     264
     265        if (trace_is_err(inptrace)) {
     266                trace_perror(inptrace,"Reading packets");
     267                trace_destroy(inptrace);
    268268                trace_destroy_callback_set(processing);
    269269                return 1;
     
    271271
    272272        /* Print stats before we destroy the trace */
    273         stats = trace_get_statistics(trace, NULL);
     273        stats = trace_get_statistics(inptrace, NULL);
    274274        fprintf(stderr, "Overall statistics\n");
    275275        trace_print_statistics(stats, stderr, "\t%s: %"PRIu64"\n");
    276276
    277277        trace_destroy_callback_set(processing);
    278         trace_destroy(trace);
     278        trace_destroy(inptrace);
    279279        return 0;
    280280}
  • examples/skeleton/parallel.c

    r389dd77 r0f5d4de  
    5353
    5454volatile int done = 0;
    55 libtrace_t *trace = NULL;
     55libtrace_t *inptrace = NULL;
    5656
    5757static void cleanup_signal(int sig) {
    5858        (void)sig;      /* avoid warnings about unused parameter */
    5959        done = 1;
    60         if (trace)
    61                 trace_pstop(trace);
     60        if (inptrace)
     61                trace_pstop(inptrace);
    6262}
    6363
     
    288288        for (i = optind; i < argc; i++) {
    289289
    290                 trace = trace_create(argv[i]);
    291 
    292                 if (trace_is_err(trace)) {
    293                         trace_perror(trace, "Opening trace file");
     290                inptrace = trace_create(argv[i]);
     291
     292                if (trace_is_err(inptrace)) {
     293                        trace_perror(inptrace, "Opening trace file");
    294294                        retcode = -1;
    295295                        break;
    296296                }
    297297
    298                 if (filter && trace_config(trace, TRACE_OPTION_FILTER, filter) == -1) {
    299                         trace_perror(trace, "trace_config(filter)");
     298                if (filter && trace_config(inptrace, TRACE_OPTION_FILTER, filter) == -1) {
     299                        trace_perror(inptrace, "trace_config(filter)");
    300300                        retcode = -1;
    301301                        break;
    302302                }
    303303
    304                 trace_set_perpkt_threads(trace, threads);
    305                 trace_set_combiner(trace, &combiner_ordered,
     304                trace_set_perpkt_threads(inptrace, threads);
     305                trace_set_combiner(inptrace, &combiner_ordered,
    306306                                (libtrace_generic_t) {0});
    307                 trace_set_hasher(trace, HASHER_BIDIRECTIONAL, NULL, NULL);
    308 
    309                 if (trace_pstart(trace, &global, processing, reporter)) {
    310                         trace_perror(trace, "Starting trace");
     307                trace_set_hasher(inptrace, HASHER_BIDIRECTIONAL, NULL, NULL);
     308
     309                if (trace_pstart(inptrace, &global, processing, reporter)) {
     310                        trace_perror(inptrace, "Starting trace");
    311311                        break;
    312312                }
    313313
    314314                /* Wait for all threads to stop */
    315                 trace_join(trace);
    316 
    317                 if (trace_is_err(trace)) {
    318                         trace_perror(trace, "Processing packets");
     315                trace_join(inptrace);
     316
     317                if (trace_is_err(inptrace)) {
     318                        trace_perror(inptrace, "Processing packets");
    319319                        retcode = -1;
    320320                        break;
     
    327327        if (filter)
    328328                trace_destroy_filter(filter);
    329         trace_destroy(trace);
     329        trace_destroy(inptrace);
    330330        trace_destroy_callback_set(processing);
    331331        trace_destroy_callback_set(reporter);
  • examples/stats/stats.c

    rb9009c2 redd0448  
    88
    99double lastts = 0.0;
    10 uint64_t v4=0;
    11 uint64_t v6=0;
    12 uint64_t udp=0;
    13 uint64_t tcp=0;
    14 uint64_t icmp=0;
    15 uint64_t ok=0;
     10uint64_t v4_packets=0;
     11uint64_t v6_packets=0;
     12uint64_t udp_packets=0;
     13uint64_t tcp_packets=0;
     14uint64_t icmp_packets=0;
     15uint64_t ok_packets=0;
    1616
    1717static void per_packet(libtrace_packet_t *packet)
     
    3434                ++lastts;
    3535                printf("%.03f,",lastts);
    36                 printf("%"PRIu64",%"PRIu64",",v4,v6);
    37                 printf("%"PRIu64",%"PRIu64",%"PRIu64,icmp,tcp,udp);
     36                printf("%"PRIu64",%"PRIu64",",v4_packets,v6_packets);
     37                printf("%"PRIu64",%"PRIu64",%"PRIu64,icmp_packets,tcp_packets,udp_packets);
    3838                printf("\n");
    39                 v4=v6=0;
    40                 icmp=tcp=udp=0;
     39                v4_packets=v6_packets=0;
     40                icmp_packets=tcp_packets=udp_packets=0;
    4141        }
    4242
     
    4747                return;
    4848
    49         /* Get the UDP/TCP/ICMP header from the IPv4/IPv6 packet */
     49        /* Get the UDP/TCP/ICMP header from the IPv4_packets/IPv6_packets packet */
    5050        switch (ethertype) {
    5151                case 0x0800:
     
    5656                        if (!transport)
    5757                                return;
    58                         ++v4;
     58                        ++v4_packets;
    5959                        break;
    6060                case 0x86DD:
     
    6565                        if (!transport)
    6666                                return;
    67                         ++v6;
     67                        ++v6_packets;
    6868                        break;
    6969                default:
     
    7171        }
    7272
    73         /* Parse the udp/tcp/icmp payload */
     73        /* Parse the udp_packets/tcp_packets/icmp_packets payload */
    7474        switch(proto) {
    7575                case 1:
    76                         ++icmp;
     76                        ++icmp_packets;
    7777                        return;
    7878                case 6:
     
    8383                                return;
    8484
    85                         ++tcp;
     85                        ++tcp_packets;
    8686                        break;
    8787                case 17:
     
    9292                        if (!payload)
    9393                                return;
    94                         ++udp;
     94                        ++udp_packets;
    9595                        break;
    9696                default:
    9797                        return;
    9898        }
    99         ++ok;
     99        ++ok_packets;
    100100}
    101101
     
    201201                trace_destroy(trace);
    202202        }
    203 
     203        if (filter) {
     204                trace_destroy_filter(filter);
     205        }
    204206        return 0;
    205207}
  • gitlab-build.sh

    rdd48bb5 r1c3f8d2  
    1111    apt-utils ssl-cert ca-certificates gnupg lsb-release debhelper git
    1212
    13 echo "deb https://packages.wand.net.nz $(lsb_release -sc) main" | tee /etc/apt/sources.list.d/wand.list
     13echo "deb https://dl.bintray.com/wand/general $(lsb_release -sc) main" | tee /etc/apt/sources.list.d/wand.list
     14echo "deb https://dl.bintray.com/wand/libtrace $(lsb_release -sc) main" | tee -a /etc/apt/sources.list.d/wand.list
    1415curl https://packages.wand.net.nz/keyring.gpg -o /etc/apt/trusted.gpg.d/wand.gpg
    1516
  • lib/format_dag25.c

    r8c5c550 rfce4572  
    174174 * many times or close a device that we're still using */
    175175struct dag_dev_t *open_dags = NULL;
     176
     177static bool dag_can_write(libtrace_packet_t *packet) {
     178        /* Get the linktype */
     179        libtrace_linktype_t ltype = trace_get_link_type(packet);
     180
     181        if (ltype == TRACE_TYPE_CONTENT_INVALID) {
     182                return false;
     183        }
     184
     185        /* TODO erf meta should definitely be writable, pcapng meta
     186         * could probably be converted into erf meta */
     187        if (ltype == TRACE_TYPE_ERF_META
     188                        || ltype == TRACE_TYPE_NONDATA
     189                        || ltype == TRACE_TYPE_PCAPNG_META) {
     190                return false;
     191        }
     192
     193        return true;
     194}
    176195
    177196/* Returns the amount of padding between the ERF header and the start of the
     
    11861205static int dag_write_packet(libtrace_out_t *libtrace, libtrace_packet_t *packet)
    11871206{
     1207        /* Check dag can write this type of packet */
     1208        if (!dag_can_write(packet)) {
     1209                return 0;
     1210        }
     1211
    11881212        /* This is heavily borrowed from erf_write_packet(). Yes, CnP
    11891213         * coding sucks, sorry about that.
     
    12001224                return -1;
    12011225        }
    1202 
    1203         if (trace_get_link_type(packet) == TRACE_TYPE_NONDATA)
    1204                 return 0;
    12051226
    12061227        pad = dag_get_padding(packet);
  • lib/format_dpdk.c

    r10fd24b r4d390c0  
    145145};
    146146
     147static bool dpdk_can_write(libtrace_packet_t *packet) {
     148        libtrace_linktype_t ltype = trace_get_link_type(packet);
     149
     150        if (ltype == TRACE_TYPE_CONTENT_INVALID) {
     151                return false;
     152        }
     153        if (ltype == TRACE_TYPE_NONDATA || ltype == TRACE_TYPE_ERF_META ||
     154                        ltype == TRACE_TYPE_PCAPNG_META) {
     155                return false;
     156        }
     157        return true;
     158}
     159
    147160/**
    148161 * We want to blacklist all devices except those on the whitelist
     
    255268        if((file = fopen(path, "r")) != NULL) {
    256269                int numa_node = -1;
    257                 fscanf(file, "%d", &numa_node);
     270                if (fscanf(file, "%d", &numa_node) != 1) {
     271                        numa_node = -1;
     272                }
    258273                fclose(file);
    259274                return numa_node;
     
    875890        if (port != format_data->port) {
    876891                fprintf(stderr, "Port does not match port in format data in dpdk_lsc_callback()\n");
    877                 return -1;
     892                #if RTE_VERSION >= RTE_VERSION_NUM(17, 8, 0, 1)
     893                return -1;
     894                #else
     895                return;
     896                #endif
    878897        }
    879898
     
    15571576static int dpdk_write_packet(libtrace_out_t *trace,
    15581577                             libtrace_packet_t *packet){
     1578
     1579        /* Check dpdk can write this type of packet */
     1580        if (!dpdk_can_write(packet)) {
     1581                return 0;
     1582        }
     1583
    15591584        struct rte_mbuf* m_buff[1];
    15601585
  • lib/format_erf.c

    rd439067 r2d16fc7  
    119119} erf_index_t;
    120120
     121static bool erf_can_write(libtrace_packet_t *packet) {
     122        /* Get the linktype */
     123        libtrace_linktype_t ltype = trace_get_link_type(packet);
     124
     125        if (ltype == TRACE_TYPE_CONTENT_INVALID) {
     126                return false;
     127        }
     128        if (ltype == TRACE_TYPE_PCAPNG_META
     129                || ltype == TRACE_TYPE_NONDATA) {
     130
     131                return false;
     132        }
     133
     134        return true;
     135}
     136
    121137/* Ethernet packets have a 2 byte padding before the packet
    122138 * so that the IP header is aligned on a 32 bit boundary.
     
    670686                libtrace_packet_t *packet)
    671687{
     688
     689        /* Check erf can write this type of packet */
     690        if (!erf_can_write(packet)) {
     691                return 0;
     692        }
     693
    672694        int numbytes = 0;
    673695        dag_record_t *dag_hdr = (dag_record_t *)packet->header;
     
    679701                return -1;
    680702        }
    681 
    682         if (trace_get_link_type(packet) == TRACE_TYPE_NONDATA)
    683                 return 0;
    684703
    685704        if (!packet->header) {
     
    770789        dag_record_t *erfptr = 0;
    771790        erfptr = (dag_record_t *)packet->header;
    772         uint8_t type = (erfptr->type & 0x7f);
     791        uint8_t type;
     792
     793        if (packet->header == NULL) {
     794                return ~0;
     795        }
     796
     797        type = (erfptr->type & 0x7f);
    773798        if (type != TYPE_LEGACY) {
    774799                /* The top-most bit is now used to indicate the presence of
     
    777802        }
    778803        else {
     804                if (trace_get_capture_length(packet) < 5 ||
     805                                packet->payload == NULL) {
     806                        return ~0;
     807                }
     808
    779809                /* Sigh, lets start wildly guessing */
    780810                if (((char*)packet->payload)[4]==0x45)
     
    787817        dag_record_t *erfptr = 0;
    788818        erfptr = (dag_record_t *)packet->header;
    789         return erfptr->flags.iface;
     819        if (packet->header) {
     820                return erfptr->flags.iface;
     821        }
     822        return TRACE_DIR_UNKNOWN;
    790823}
    791824
     
    793826        dag_record_t *erfptr = 0;
    794827        erfptr = (dag_record_t *)packet->header;
     828
     829        if (packet->header == NULL) {
     830                return TRACE_DIR_UNKNOWN;
     831        }
    795832        erfptr->flags.iface = direction;
    796833        return erfptr->flags.iface;
     
    800837        dag_record_t *erfptr = 0;
    801838        erfptr = (dag_record_t *)packet->header;
     839
     840        if (erfptr == NULL) {
     841                return 0;
     842        }
    802843        return bswap_le_to_host64(erfptr->ts);
    803844}
     
    809850        uint16_t wlen, rlen;
    810851
    811         if (packet->payload == NULL)
     852        if (packet->payload == NULL || packet->header == NULL)
    812853                return 0;
    813854
     
    828869        erfptr = (dag_record_t *)packet->header;
    829870
     871        if (packet->header == NULL) {
     872                return 0;
     873        }
     874
    830875        if ((erfptr->type & 0x7f) == TYPE_META)
    831876                return 0;
     
    843888        }
    844889        erfptr = (dag_record_t *)packet->header;
     890
     891        if (packet->header == NULL) {
     892                return ~0U;
     893        }
    845894
    846895        if(size > trace_get_capture_length(packet) || (erfptr->type & 0x7f) == TYPE_META) {
  • lib/format_etsilive.c

    rccabd47 rb359a11  
    362362                                sizeof(etsisocket_t) * (et->sourcealloc + 10));
    363363
     364                        for (i = et->sourcealloc; i < et->sourcealloc + 10;
     365                                        i++) {
     366                                et->sources[i].sock = -1;
     367                                et->sources[i].srcaddr = NULL;
     368                        }
    364369                        esock = &(et->sources[et->sourcealloc]);
    365370                        et->sourcealloc += 10;
  • lib/format_linux_common.c

    r509ee47 r5fe998b  
    7070        pcap_t *pcap;
    7171
    72         /* Take a copy of the filter object as it was passed in */
    73         f = (libtrace_filter_t *) malloc(sizeof(libtrace_filter_t));
    74         memcpy(f, filter, sizeof(libtrace_filter_t));
     72        /* Take a copy of the filter structure to prevent against
     73         * deletion causing the filter to no longer work */
     74        f = (libtrace_filter_t *) malloc(sizeof(libtrace_filter_t));
     75        memset(f, 0, sizeof(libtrace_filter_t));
     76        memcpy(f, filter, sizeof(libtrace_filter_t));
     77        f->filterstring = strdup(filter->filterstring);
    7578
    7679        /* If we are passed a filter with "flag" set to zero, then we must
     
    120123
    121124        if (FORMAT_DATA->filter != NULL)
    122                 free(FORMAT_DATA->filter);
     125                trace_destroy_filter(FORMAT_DATA->filter);
    123126
    124127        FORMAT_DATA->filter = f;
     
    498501        if (libtrace->format_data) {
    499502                if (FORMAT_DATA->filter != NULL)
    500                         free(FORMAT_DATA->filter);
     503                        trace_destroy_filter(FORMAT_DATA->filter);
    501504
    502505                if (FORMAT_DATA->per_stream)
  • lib/format_linux_int.c

    rd439067 re9fe6ac  
    5353#include "format_linux_common.h"
    5454
     55#define SLL_HEADER_LENGTH 6
    5556
    5657#ifdef HAVE_NETPACKET_PACKET_H
    5758
     59static bool linuxnative_can_write(libtrace_packet_t *packet) {
     60        /* Get the linktype */
     61        libtrace_linktype_t ltype = trace_get_link_type(packet);
     62
     63        if (ltype == TRACE_TYPE_NONDATA) {
     64                return false;
     65        }
     66        if (ltype == TRACE_TYPE_CONTENT_INVALID) {
     67                return false;
     68        }
     69        if (ltype == TRACE_TYPE_PCAPNG_META) {
     70                return false;
     71        }
     72        if (ltype == TRACE_TYPE_ERF_META) {
     73                return false;
     74        }
     75
     76        return true;
     77}
    5878
    5979static int linuxnative_start_input(libtrace_t *libtrace)
     
    336356                libtrace_packet_t *packet)
    337357{
     358        /* Check linuxnative can write this type of packet */
     359        if (!linuxnative_can_write(packet)) {
     360                return 0;
     361        }
     362
    338363        struct sockaddr_ll hdr;
    339364        int ret = 0;
    340 
    341         if (trace_get_link_type(packet) == TRACE_TYPE_NONDATA)
    342                 return 0;
    343365
    344366        hdr.sll_family = AF_PACKET;
     
    347369        hdr.sll_hatype = 0;
    348370        hdr.sll_pkttype = 0;
    349         hdr.sll_halen = htons(6); /* FIXME */
    350         memcpy(hdr.sll_addr,packet->payload,(size_t)ntohs(hdr.sll_halen));
     371        hdr.sll_halen = htons(SLL_HEADER_LENGTH); /* FIXME */
     372        memcpy(hdr.sll_addr,packet->payload,(size_t)SLL_HEADER_LENGTH);
    351373
    352374        /* This is pretty easy, just send the payload using sendto() (after
  • lib/format_linux_ring.c

    rd439067 rfce4572  
    7171static int pagesize = 0;
    7272
     73static bool linuxring_can_write(libtrace_packet_t *packet) {
     74        /* Get the linktype */
     75        libtrace_linktype_t ltype = trace_get_link_type(packet);
     76
     77        if (ltype == TRACE_TYPE_CONTENT_INVALID) {
     78                return false;
     79        }
     80        if (ltype == TRACE_TYPE_NONDATA) {
     81                return false;
     82        }
     83        if (ltype == TRACE_TYPE_PCAPNG_META) {
     84                return false;
     85        }
     86        if (ltype == TRACE_TYPE_ERF_META) {
     87                return false;
     88        }
     89
     90        return true;
     91}
    7392
    7493/*
     
    308327                }
    309328
    310                 if (FORMAT_DATA->filter != NULL)
    311                         free(FORMAT_DATA->filter);
     329                if (FORMAT_DATA->filter != NULL)
     330                        trace_destroy_filter(FORMAT_DATA->filter);
    312331
    313332                if (FORMAT_DATA->per_stream)
     
    709728                                  libtrace_packet_t *packet)
    710729{
     730        /* Check linuxring can write this type of packet */
     731        if (!linuxring_can_write(packet)) {
     732                return 0;
     733        }
     734
    711735        struct tpacket2_hdr *header;
    712736        struct pollfd pollset;
     
    715739        unsigned max_size;
    716740        void * off;
    717 
    718         if (trace_get_link_type(packet) == TRACE_TYPE_NONDATA)
    719                 return 0;
    720741
    721742        max_size = FORMAT_DATA_OUT->req.tp_frame_size -
  • lib/format_ndag.c

    r509ee47 r6514097  
    335335                default:
    336336                        trace_set_err(libtrace, TRACE_ERR_OPTION_UNAVAIL,
    337                                         "Unsupported option");
     337                                        "Unsupported option %d",
     338                                        option);
    338339                        return -1;
    339340        }
  • lib/format_pcap.c

    rd439067 r9a6bdbc  
    9797        } output;
    9898};
     99
     100static bool pcap_can_write(libtrace_packet_t *packet) {
     101        /* Get the linktype */
     102        libtrace_linktype_t ltype = trace_get_link_type(packet);
     103
     104        if (ltype == TRACE_TYPE_PCAPNG_META
     105                || ltype == TRACE_TYPE_CONTENT_INVALID
     106                || ltype == TRACE_TYPE_UNKNOWN
     107                || ltype == TRACE_TYPE_ERF_META
     108                || ltype == TRACE_TYPE_NONDATA) {
     109
     110                return false;
     111        }
     112
     113        return true;
     114}
    99115
    100116static int pcap_init_input(libtrace_t *libtrace) {
     
    521537{
    522538
     539        /* Check pcap can write this type of packet */
     540        if (!pcap_can_write(packet)) {
     541                return 0;
     542        }
     543
    523544        if (!libtrace) {
    524545                fprintf(stderr, "NULL trace passed into pcap_write_packet()\n");
     
    536557
    537558        link = trace_get_packet_buffer(packet,&linktype,&remaining);
    538 
    539         /* Silently discard RT metadata packets and packets with an
    540          * unknown linktype. */
    541         if (linktype == TRACE_TYPE_NONDATA || linktype == TRACE_TYPE_UNKNOWN || linktype == TRACE_TYPE_ERF_META || linktype == TRACE_TYPE_CONTENT_INVALID) {
    542                 return 0;
    543         }
    544559
    545560        /* We may have to convert this packet into a suitable PCAP packet */
  • lib/format_pcapfile.c

    rd439067 r5460603  
    6868#define MAGIC2_REV  0x4d3cb2a1
    6969
     70static bool pcapfile_can_write(libtrace_packet_t *packet) {
     71        /* Get the linktype */
     72        libtrace_linktype_t ltype = trace_get_link_type(packet);
     73
     74        if (ltype == TRACE_TYPE_PCAPNG_META
     75                || ltype == TRACE_TYPE_CONTENT_INVALID
     76                || ltype == TRACE_TYPE_UNKNOWN
     77                || ltype == TRACE_TYPE_ERF_META
     78                || ltype == TRACE_TYPE_NONDATA) {
     79
     80                return false;
     81        }
     82
     83        return true;
     84}
     85
    7086static inline int header_is_backwards_magic(pcapfile_header_t *header) {
    7187        return (header->magic_number == MAGIC1_REV || header->magic_number == MAGIC2_REV);
     
    175191        if (!DATA(libtrace))
    176192                return num;
    177        
     193
    178194        /* We can use the PCAP magic number to determine the byte order */
    179195        if (header_is_backwards_magic(&(DATA(libtrace)->header)))
     
    371387                        packet->buffer,
    372388                        sizeof(libtrace_pcapfile_pkt_hdr_t));
     389
    373390        if (err<0) {
    374391                trace_set_err(libtrace,TRACE_ERR_WANDIO_FAILED,"reading packet");
     
    387404        bytes_to_read = swapl(libtrace,((libtrace_pcapfile_pkt_hdr_t*)packet->buffer)->caplen);
    388405
    389         if (bytes_to_read >= LIBTRACE_PACKET_BUFSIZE) {
     406        if (bytes_to_read >= (LIBTRACE_PACKET_BUFSIZE -
     407                        sizeof(libtrace_pcapfile_pkt_hdr_t))) {
    390408                trace_set_err(libtrace, TRACE_ERR_BAD_PACKET, "Invalid caplen in pcap header (%u) - trace may be corrupt", (uint32_t)bytes_to_read);
    391409                return -1;
     
    432450                libtrace_packet_t *packet)
    433451{
     452
     453        /* Check pcapfile can write this type of packet */
     454        if (!pcapfile_can_write(packet)) {
     455                return 0;
     456        }
     457
    434458        struct libtrace_pcapfile_pkt_hdr_t hdr;
    435459        struct timeval tv = trace_get_timeval(packet);
     
    441465
    442466        ptr = trace_get_packet_buffer(packet,&linktype,&remaining);
    443        
    444         /* Silently discard RT metadata packets and packets with an
    445          * unknown linktype. */
    446         if (linktype == TRACE_TYPE_NONDATA || linktype == TRACE_TYPE_UNKNOWN || linktype == TRACE_TYPE_ERF_META || linktype == TRACE_TYPE_CONTENT_INVALID) {
    447                 return 0;
    448         }
    449467
    450468        /* If this packet cannot be converted to a pcap linktype then
     
    572590        struct timeval ts;
    573591
     592        memset(&ts, 0, sizeof(struct timeval));
     593
    574594        if (!packet) {
    575595                fprintf(stderr, "NULL packet passed to pcapfile_get_timeval()\n");
     
    601621        struct timespec ts;
    602622
     623        memset(&ts, 0, sizeof(struct timespec));
    603624        if (!packet) {
    604625                fprintf(stderr, "NULL packet passed to pcapfile_get_timespec()");
     
    655676                        "pcapfile_get_wire_length()");
    656677                return -1;
     678        }
     679
     680        if (packet->payload == NULL) {
     681                return 0;
    657682        }
    658683
  • lib/format_pcapng.c

    rd439067 r063d5dd  
    4848#define PCAPNG_CUSTOM_TYPE 0x00000BAD
    4949#define PCAPNG_CUSTOM_NONCOPY_TYPE 0x40000BAD
     50#define PCAPNG_DECRYPTION_SECRETS_TYPE 0x0000000A
     51
     52#define PCAPNG_NRB_RECORD_END 0x0000
     53#define PCAPNG_NRB_RECORD_IP4 0x0001
     54#define PCAPNG_NRB_RECORD_IP6 0x0002
     55
     56#define PCAPNG_CUSTOM_OPTION_UTF8 0xBAC
     57#define PCAPNG_CUSTOM_OPTION_BIN 0xBAD
     58#define PCAPNG_CUSTOM_OPTION_UTF8_NONCOPY 0x4BAC
     59#define PCAPNG_CUSTOM_OPTION_BIN_NONCOPY 0x4BAD
     60
     61#define PCAPNG_OPTION_END 0x0000
    5062
    5163#define PACKET_IS_ENHANCED (pcapng_get_record_type(packet) == PCAPNG_ENHANCED_PACKET_TYPE)
     
    5466
    5567#define PACKET_IS_OLD (pcapng_get_record_type(packet) == PCAPNG_OLD_PACKET_TYPE)
    56 
    5768
    5869#define PCAPNG_IFOPT_TSRESOL 9
     
    133144typedef struct pcapng_interface_t pcapng_interface_t;
    134145
     146struct pcapng_timestamp {
     147        uint32_t timehigh;
     148        uint32_t timelow;
     149};
     150
    135151struct pcapng_interface_t {
    136152
     
    160176        uint16_t allocatedinterfaces;
    161177        uint16_t nextintid;
     178
     179};
     180
     181struct pcapng_format_data_out_t {
     182        iow_t *file;
     183        int compress_level;
     184        int compress_type;
     185        int flag;
     186
     187        /* Section data */
     188        uint16_t sechdr_count;
     189        bool byteswapped;
     190
     191        /* Interface data */
     192        uint16_t nextintid;
     193        libtrace_linktype_t lastdlt;
    162194};
    163195
     
    167199};
    168200
     201struct pcapng_custom_optheader {
     202        uint16_t optcode;
     203        uint16_t optlen;
     204        uint32_t pen;
     205};
     206struct pcapng_nrb_record {
     207        uint16_t recordtype;
     208        uint16_t recordlen;
     209};
    169210struct pcapng_peeker {
    170211        uint32_t blocktype;
     
    174215typedef struct pcapng_peeker pcapng_hdr_t;
    175216
    176 
    177217#define DATA(x) ((struct pcapng_format_data_t *)((x)->format_data))
     218#define DATAOUT(x) ((struct pcapng_format_data_out_t*)((x)->format_data))
     219
     220static char *pcapng_parse_next_option(libtrace_t *libtrace, char **pktbuf,
     221                uint16_t *code, uint16_t *length, pcapng_hdr_t *blockhdr);
     222
     223static bool pcapng_can_write(libtrace_packet_t *packet) {
     224        /* Get the linktype */
     225        libtrace_linktype_t ltype = trace_get_link_type(packet);
     226
     227        /* TODO convert erf meta to pcapng meta? */
     228        if (ltype == TRACE_TYPE_CONTENT_INVALID
     229                || ltype == TRACE_TYPE_UNKNOWN
     230                || ltype == TRACE_TYPE_ERF_META
     231                || ltype == TRACE_TYPE_NONDATA) {
     232
     233                return false;
     234        }
     235
     236        return true;
     237}
    178238
    179239static pcapng_interface_t *lookup_interface(libtrace_t *libtrace,
    180240                uint32_t intid) {
    181241
    182 
    183         if (intid >= DATA(libtrace)->nextintid) {
    184                 return NULL;
    185         }
    186 
    187         return DATA(libtrace)->interfaces[intid];
    188 
     242        if (intid >= DATA(libtrace)->nextintid) {
     243                return NULL;
     244        }
     245
     246        return DATA(libtrace)->interfaces[intid];
    189247}
    190248
    191249static inline uint32_t pcapng_get_record_type(const libtrace_packet_t *packet) {
    192 
    193250        uint32_t *btype = (uint32_t *)packet->header;
    194251
    195         if (DATA(packet->trace)->byteswapped)
    196                 return byteswap32(*btype);
     252        /* only check for byteswapped if input format is pcapng */
     253        if (packet->trace->format->type == TRACE_FORMAT_PCAPNG) {
     254                if (DATA(packet->trace)->byteswapped)
     255                        return byteswap32(*btype);
     256        }
     257
    197258        return *btype;
     259}
     260
     261static inline uint32_t pcapng_swap32(libtrace_out_t *libtrace, uint32_t value) {
     262        if (DATAOUT(libtrace)->byteswapped) {
     263                return byteswap32(value);
     264        } else {
     265                return value;
     266        }
     267}
     268static inline uint32_t pcapng_swap16(libtrace_out_t *libtrace, uint32_t value) {
     269        if (DATAOUT(libtrace)->byteswapped) {
     270                return byteswap16(value);
     271        } else {
     272                return value;
     273        }
     274}
     275static inline uint32_t pcapng_get_blocklen(const libtrace_packet_t *packet) {
     276        struct pcapng_peeker *hdr = (struct pcapng_peeker *)packet->buffer;
     277
     278        /* only check for byteswapped if input format is pcapng */
     279        if (packet->trace->format->type == TRACE_FORMAT_PCAPNG) {
     280                if (DATA(packet->trace)->byteswapped)
     281                        return byteswap32(hdr->blocklen);
     282        }
     283
     284        return hdr->blocklen;
     285
     286}
     287
     288#if 0
     289static inline uint16_t pcapng_get_customdata_len(libtrace_packet_t *packet, char *ptr) {
     290        struct pcapng_custom_optheader *hdr = (struct pcapng_custom_optheader *)ptr;
     291
     292        if (DATA(packet->trace)->byteswapped) {
     293                return byteswap16(hdr->optlen);
     294        } else {
     295                return hdr->optlen;
     296        }
     297}
     298static inline uint16_t pcapng_get_customdata_optcode(libtrace_packet_t *packet, char *ptr) {
     299        struct pcapng_custom_optheader *hdr = (struct pcapng_custom_optheader *)ptr;
     300
     301        if (DATA(packet->trace)->byteswapped) {
     302                return byteswap16(hdr->optcode);
     303        } else {
     304                return hdr->optcode;
     305        }
     306}
     307#endif
     308
     309static inline uint16_t pcapng_get_nrb_record_type(libtrace_packet_t *packet, char *ptr) {
     310        struct pcapng_nrb_record *hdr = (struct pcapng_nrb_record *)ptr;
     311        if (DATA(packet->trace)->byteswapped) {
     312                return byteswap16(hdr->recordtype);
     313        } else {
     314                return hdr->recordtype;
     315        }
     316}
     317static inline uint16_t pcapng_get_nrb_record_len(libtrace_packet_t *packet, char *ptr) {
     318        struct pcapng_nrb_record *hdr = (struct pcapng_nrb_record *)ptr;
     319        if (DATA(packet->trace)->byteswapped) {
     320                return byteswap16(hdr->recordlen);
     321        } else {
     322                return hdr->recordlen;
     323        }
     324}
     325static uint32_t pcapng_output_options(libtrace_out_t *libtrace, libtrace_packet_t *packet,
     326        char *ptr) {
     327
     328        struct pcapng_optheader opthdr;
     329        uint16_t optcode, optlen;
     330        char *optval = NULL;
     331        char *bodyptr = NULL;
     332        int padding;
     333        void *padding_data;
     334        uint32_t len = 0;
     335
     336        bodyptr = ptr;
     337
     338        while ((optval = pcapng_parse_next_option(packet->trace, &bodyptr,
     339                        &optcode, &optlen, (pcapng_hdr_t *) packet->buffer))) {
     340
     341                /* pcapng_parse_next_option byteswaps the opcode and len for us */
     342                opthdr.optcode = optcode;
     343                opthdr.optlen = optlen;
     344
     345                /* output the header */
     346                wandio_wwrite(DATAOUT(libtrace)->file, &opthdr, sizeof(opthdr));
     347
     348                /* If this is a custom option */
     349                if (optcode == PCAPNG_CUSTOM_OPTION_UTF8 ||
     350                        optcode == PCAPNG_CUSTOM_OPTION_BIN ||
     351                        optcode == PCAPNG_CUSTOM_OPTION_UTF8_NONCOPY ||
     352                        optcode == PCAPNG_CUSTOM_OPTION_BIN_NONCOPY) {
     353                        /* flip the pen and output the option value */
     354                        //uint32_t pen = byteswap32((uint32_t)*optval);
     355                        wandio_wwrite(DATAOUT(libtrace)->file, optval, sizeof(uint32_t));
     356
     357                        /* the len for custom options include pen */
     358                        optval += sizeof(uint32_t);
     359                        optlen -= sizeof(uint32_t);
     360                }
     361
     362                /* output the rest of the data */
     363                wandio_wwrite(DATAOUT(libtrace)->file, &optval, optlen);
     364
     365                /* calculate any required padding */
     366                padding = optlen % 4;
     367                if (padding) { padding = 4 - padding; }
     368                padding_data = calloc(1, padding);
     369                /* output the padding */
     370                wandio_wwrite(DATAOUT(libtrace)->file, padding_data, padding);
     371                free(padding_data);
     372
     373                len += sizeof(opthdr) + optlen;
     374        }
     375
     376        return len;
     377}
     378static uint32_t pcapng_output_interface_packet(libtrace_out_t *libtrace, libtrace_packet_t *packet) {
     379        pcapng_int_t *cur = (pcapng_int_t *)packet->header;
     380        pcapng_int_t hdr;
     381        char *bodyptr = NULL;
     382
     383        /* If the input trace is not pcapng we have no way of finding the byteordering
     384         * this can occur if a packet is reconstructed with a deadtrace. Or if the packet
     385         * is in the correct byte ordering just output it */
     386        if ((packet->trace->format->type != TRACE_FORMAT_PCAPNG) ||
     387                (DATA(packet->trace)->byteswapped == DATAOUT(libtrace)->byteswapped)) {
     388                uint32_t len = pcapng_get_blocklen(packet);
     389                wandio_wwrite(DATAOUT(libtrace)->file, packet->buffer, len);
     390                return len;
     391        }
     392
     393        /* Byteswap the headers */
     394        hdr.blocktype = byteswap32(cur->blocktype);
     395        hdr.blocklen = byteswap32(cur->blocklen);
     396        hdr.linktype = byteswap16(cur->linktype);
     397        hdr.reserved = byteswap16(cur->reserved);
     398        hdr.snaplen = byteswap32(cur->snaplen);
     399
     400        wandio_wwrite(DATAOUT(libtrace)->file, &hdr, sizeof(hdr));
     401        /* output any options */
     402        bodyptr = (char *)packet->buffer + sizeof(hdr);
     403        pcapng_output_options(libtrace, packet, bodyptr);
     404        wandio_wwrite(DATAOUT(libtrace)->file, &hdr.blocklen, sizeof(hdr.blocklen));
     405
     406        return hdr.blocklen;
     407}
     408static uint32_t pcapng_output_simple_packet(libtrace_out_t *libtrace, libtrace_packet_t *packet) {
     409        pcapng_spkt_t *cur = (pcapng_spkt_t *)packet->header;
     410        pcapng_spkt_t hdr;
     411        uint32_t len;
     412        char *bodyptr = NULL;
     413
     414        /* If the input trace is not pcapng we have no way of finding the byteordering
     415         * this can occur if a packet is reconstructed with a deadtrace. Or if the packet
     416         * is in the correct byte ordering just output it */
     417        if ((packet->trace->format->type != TRACE_FORMAT_PCAPNG) ||
     418                (DATA(packet->trace)->byteswapped == DATAOUT(libtrace)->byteswapped)) {
     419                len = pcapng_get_blocklen(packet);
     420                wandio_wwrite(DATAOUT(libtrace)->file, packet->buffer, len);
     421                return len;
     422        }
     423
     424        hdr.blocktype = byteswap32(cur->blocktype);
     425        hdr.blocklen = byteswap32(cur->blocklen);
     426        hdr.wlen = byteswap32(cur->wlen);
     427
     428        wandio_wwrite(DATAOUT(libtrace)->file, &hdr, sizeof(hdr));
     429
     430        /* output the packet payload */
     431        bodyptr = (char *)packet->buffer + sizeof(hdr);
     432        len = pcapng_get_blocklen(packet) - sizeof(hdr) - sizeof(hdr.blocklen);
     433        wandio_wwrite(DATAOUT(libtrace)->file, bodyptr, len);
     434
     435        wandio_wwrite(DATAOUT(libtrace)->file, &hdr.blocklen, sizeof(hdr.blocklen));
     436
     437        return hdr.blocklen;
     438}
     439static uint32_t pcapng_output_old_packet(libtrace_out_t *libtrace, libtrace_packet_t *packet) {
     440        pcapng_opkt_t *cur = (pcapng_opkt_t *)packet->header;
     441        pcapng_opkt_t hdr;
     442        uint32_t len;
     443        char *bodyptr = NULL;
     444
     445        /* If the input trace is not pcapng we have no way of finding the byteordering
     446         * this can occur if a packet is reconstructed with a deadtrace. Or if the packet
     447         * is in the correct byte ordering just output it */
     448        if ((packet->trace->format->type != TRACE_FORMAT_PCAPNG) ||
     449                (DATA(packet->trace)->byteswapped == DATAOUT(libtrace)->byteswapped)) {
     450                len = pcapng_get_blocklen(packet);
     451                wandio_wwrite(DATAOUT(libtrace)->file, packet->buffer, len);
     452                return len;
     453        }
     454
     455        hdr.blocktype = byteswap32(cur->blocktype);
     456        hdr.blocklen = byteswap32(cur->blocklen);
     457        hdr.interfaceid = byteswap16(cur->interfaceid);
     458        hdr.drops = byteswap16(cur->drops);
     459        hdr.timestamp_high = byteswap32(cur->timestamp_high);
     460        hdr.timestamp_low = byteswap32(cur->timestamp_low);
     461        hdr.caplen = byteswap32(cur->caplen);
     462        hdr.wlen = byteswap32(cur->wlen);
     463
     464        wandio_wwrite(DATAOUT(libtrace)->file, &hdr, sizeof(hdr));
     465
     466        /* output the packet payload */
     467        bodyptr = (char *)packet->buffer + sizeof(hdr);
     468        len = pcapng_get_blocklen(packet) - sizeof(hdr) - sizeof(hdr.blocklen);
     469        wandio_wwrite(DATAOUT(libtrace)->file, bodyptr, len);
     470
     471        /* output any options if present */
     472        pcapng_output_options(libtrace, packet, bodyptr);
     473
     474        wandio_wwrite(DATAOUT(libtrace)->file, &hdr.blocklen, sizeof(hdr.blocklen));
     475
     476
     477        return hdr.blocklen;
     478}
     479static uint32_t pcapng_output_nameresolution_packet(libtrace_out_t *libtrace, libtrace_packet_t *packet) {
     480        pcapng_nrb_t *cur = (pcapng_nrb_t *)packet->buffer;
     481        pcapng_nrb_t hdr;
     482        char *bodyptr = NULL;
     483        int padding;
     484        void *padding_data;
     485
     486        /* If the input trace is not pcapng we have no way of finding the byteordering
     487         * this can occur if a packet is reconstructed with a deadtrace. Or if the packet
     488         * is in the correct byte ordering just output it */
     489        if ((packet->trace->format->type != TRACE_FORMAT_PCAPNG) ||
     490                (DATA(packet->trace)->byteswapped == DATAOUT(libtrace)->byteswapped)) {
     491                uint32_t len = pcapng_get_blocklen(packet);
     492                wandio_wwrite(DATAOUT(libtrace)->file, packet->buffer, len);
     493                return len;
     494        }
     495
     496        hdr.blocktype = byteswap32(cur->blocktype);
     497        hdr.blocklen = byteswap32(cur->blocklen);
     498
     499        /* output the header */
     500        wandio_wwrite(DATAOUT(libtrace)->file, &hdr, sizeof(hdr));
     501        bodyptr = (char *)packet->buffer + sizeof(hdr);
     502
     503        struct pcapng_nrb_record *nrbr = (struct pcapng_nrb_record *)bodyptr;
     504
     505        uint16_t record_type = pcapng_get_nrb_record_type(packet, bodyptr);
     506        while (record_type != PCAPNG_NRB_RECORD_END) {
     507
     508                struct pcapng_nrb_record nrb;
     509
     510                /* recordlen contains only the length of the record value without
     511                 * any padding */
     512                uint16_t recordlen = pcapng_get_nrb_record_len(packet, bodyptr);
     513
     514                nrb.recordtype = byteswap16(nrbr->recordtype);
     515                nrb.recordlen = byteswap16(nrbr->recordlen);
     516
     517                /* output the record header */
     518                wandio_wwrite(DATAOUT(libtrace)->file, &nrb, sizeof(nrb));
     519                bodyptr += sizeof(nrb);
     520
     521                /* output the record data */
     522                wandio_wwrite(DATAOUT(libtrace)->file, bodyptr, recordlen);
     523                bodyptr += recordlen;
     524
     525                /* calculate any required padding. record also contains the 8 byte header
     526                 * but we dont need to subtract it because it will be removed with % 4 */
     527                padding = recordlen % 4;
     528                if (padding) { padding = 4 - padding; }
     529                padding_data = calloc(1, padding);
     530                /* output the padding */
     531                wandio_wwrite(DATAOUT(libtrace)->file, padding_data, padding);
     532                free(padding_data);
     533                bodyptr += padding;
     534
     535                /* get the next record if it exists */
     536                nrbr = (struct pcapng_nrb_record *)bodyptr;
     537                record_type = pcapng_get_nrb_record_type(packet, bodyptr);
     538        }
     539
     540        /* output nrb record end block */
     541        struct pcapng_nrb_record nrbftr;
     542        nrbftr.recordtype = PCAPNG_NRB_RECORD_END;
     543        nrbftr.recordlen = 0;
     544        wandio_wwrite(DATAOUT(libtrace)->file, &nrbftr, sizeof(nrbftr));
     545        bodyptr += sizeof(nrbftr);
     546
     547        /* output any options if present */
     548        pcapng_output_options(libtrace, packet, bodyptr);
     549
     550        /* and print out rest of the header */
     551        wandio_wwrite(DATAOUT(libtrace)->file, &hdr.blocklen, sizeof(hdr.blocklen));
     552
     553        return hdr.blocklen;
     554}
     555static uint32_t pcapng_output_custom_packet(libtrace_out_t *libtrace, libtrace_packet_t *packet) {
     556        pcapng_custom_t *cur = (pcapng_custom_t *)packet->buffer;
     557        pcapng_custom_t hdr;
     558        char *bodyptr = (char *)packet->buffer;
     559
     560        /* If the input trace is not pcapng we have no way of finding the byteordering
     561         * this can occur if a packet is reconstructed with a deadtrace. Or if the packet
     562         * is in the correct byte ordering just output it */
     563        if ((packet->trace->format->type != TRACE_FORMAT_PCAPNG) ||
     564                (DATA(packet->trace)->byteswapped == DATAOUT(libtrace)->byteswapped)) {
     565                uint32_t len = pcapng_get_blocklen(packet);
     566                wandio_wwrite(DATAOUT(libtrace)->file, packet->buffer, len);
     567                return len;
     568        }
     569
     570        hdr.blocktype = byteswap32(cur->blocktype);
     571        hdr.blocklen = byteswap32(cur->blocklen);
     572        hdr.pen = byteswap32(cur->blocklen);
     573
     574        /* output the header */
     575        wandio_wwrite(DATAOUT(libtrace)->file, &hdr, sizeof(hdr));
     576        bodyptr += sizeof(hdr);
     577
     578        /* now print out any options */
     579        pcapng_output_options(libtrace, packet, bodyptr);
     580
     581        /* and print out rest of the header */
     582        wandio_wwrite(DATAOUT(libtrace)->file, &hdr.blocklen, sizeof(hdr.blocklen));
     583
     584        return hdr.blocklen;
     585}
     586static uint32_t pcapng_output_enhanced_packet(libtrace_out_t *libtrace, libtrace_packet_t *packet) {
     587        pcapng_epkt_t *cur = (pcapng_epkt_t *)packet->buffer;
     588        pcapng_epkt_t hdr;
     589        char *bodyptr = NULL;
     590        uint32_t len;
     591
     592        /* If the input trace is not pcapng we have no way of finding the byteordering
     593         * this can occur if a packet is reconstructed with a deadtrace. Or if the packet
     594         * is in the correct byte ordering just output it */
     595        if ((packet->trace->format->type != TRACE_FORMAT_PCAPNG) ||
     596                (DATA(packet->trace)->byteswapped == DATAOUT(libtrace)->byteswapped)) {
     597                len = pcapng_get_blocklen(packet);
     598                wandio_wwrite(DATAOUT(libtrace)->file, packet->buffer, len);
     599                return len;
     600        }
     601
     602        hdr.blocktype = byteswap32(cur->blocktype);
     603        hdr.blocklen = byteswap32(cur->blocklen);
     604        hdr.interfaceid = byteswap32(cur->interfaceid);
     605        hdr.timestamp_high = byteswap32(cur->timestamp_high);
     606        hdr.timestamp_low = byteswap32(cur->timestamp_low);
     607        hdr.caplen = byteswap32(cur->caplen);
     608        hdr.wlen = byteswap32(cur->wlen);
     609
     610        /* output beginning of header */
     611        wandio_wwrite(DATAOUT(libtrace)->file, &hdr, sizeof(hdr));
     612
     613        /* output the packet payload */
     614        bodyptr = (char *)packet->buffer + sizeof(hdr);
     615        len = pcapng_get_blocklen(packet) - sizeof(hdr) - sizeof(hdr.blocklen);
     616        wandio_wwrite(DATAOUT(libtrace)->file, bodyptr, len);
     617
     618        /* output any options */
     619        pcapng_output_options(libtrace, packet, bodyptr);
     620
     621        /* output end of header */
     622        wandio_wwrite(DATAOUT(libtrace)->file, &hdr.blocklen, sizeof(hdr.blocklen));
     623
     624        return hdr.blocklen;
     625}
     626static uint32_t pcapng_output_interfacestats_packet(libtrace_out_t *libtrace, libtrace_packet_t *packet) {
     627        pcapng_stats_t *cur = (pcapng_stats_t *)packet->header;
     628        pcapng_stats_t hdr;
     629        char *bodyptr = NULL;
     630
     631        /* If the input trace is not pcapng we have no way of finding the byteordering
     632         * this can occur if a packet is reconstructed with a deadtrace. Or if the packet
     633         * is in the correct byte ordering just output it */
     634        if ((packet->trace->format->type != TRACE_FORMAT_PCAPNG) ||
     635                (DATA(packet->trace)->byteswapped == DATAOUT(libtrace)->byteswapped)) {
     636                uint32_t len = pcapng_get_blocklen(packet);
     637                wandio_wwrite(DATAOUT(libtrace)->file, packet->buffer, len);
     638                return len;
     639        }
     640
     641        hdr.blocktype = byteswap32(cur->blocktype);
     642        hdr.blocklen = byteswap32(cur->blocklen);
     643        hdr.interfaceid = byteswap32(cur->interfaceid);
     644        hdr.timestamp_high = byteswap32(cur->timestamp_high);
     645        hdr.timestamp_low = byteswap32(cur->timestamp_low);
     646
     647        /* output interface stats header */
     648        wandio_wwrite(DATAOUT(libtrace)->file, &hdr, sizeof(hdr));
     649        /* output any options if present */
     650        bodyptr = (char *)packet->buffer + sizeof(hdr);
     651        pcapng_output_options(libtrace, packet, bodyptr);
     652        /* output rest of interface stats header */
     653        wandio_wwrite(DATAOUT(libtrace)->file, &hdr.blocklen, sizeof(hdr.blocklen));
     654
     655        return hdr.blocklen;
    198656}
    199657
     
    212670        }
    213671        return 0;
     672}
     673
     674static struct pcapng_timestamp pcapng_get_timestamp(libtrace_packet_t *packet) {
     675        struct timeval tv = trace_get_timeval(packet);
     676        uint64_t time = ((uint64_t)tv.tv_sec * (uint64_t)1000000) + tv.tv_usec;
     677
     678        struct pcapng_timestamp timestamp;
     679        timestamp.timehigh = time >> 32;
     680        timestamp.timelow = time & 0xFFFFFFFF;
     681
     682        return timestamp;
    214683}
    215684
     
    232701
    233702        return 0;
     703}
     704
     705static int pcapng_config_output(libtrace_out_t *libtrace, trace_option_output_t option,
     706        void *value) {
     707
     708        switch (option) {
     709                case TRACE_OPTION_OUTPUT_COMPRESS:
     710                        DATAOUT(libtrace)->compress_level = *(int *)value;
     711                        return 0;
     712                case TRACE_OPTION_OUTPUT_COMPRESSTYPE:
     713                        DATAOUT(libtrace)->compress_type = *(int *)value;
     714                        return 0;
     715                case TRACE_OPTION_OUTPUT_FILEFLAGS:
     716                        DATAOUT(libtrace)->flag = *(int *)value;
     717                        return 0;
     718                default:
     719                        trace_set_err_out(libtrace, TRACE_ERR_UNKNOWN_OPTION,
     720                                "Unknown option");
     721                        return -1;
     722        }
    234723}
    235724
     
    272761}
    273762
     763static int pcapng_init_output(libtrace_out_t *libtrace) {
     764        libtrace->format_data = malloc(sizeof(struct pcapng_format_data_out_t));
     765
     766        DATAOUT(libtrace)->file = NULL;
     767        DATAOUT(libtrace)->compress_level = 0;
     768        DATAOUT(libtrace)->compress_type = TRACE_OPTION_COMPRESSTYPE_NONE;
     769        DATAOUT(libtrace)->flag = O_CREAT|O_WRONLY;
     770
     771        DATAOUT(libtrace)->sechdr_count = 0;
     772        DATAOUT(libtrace)->byteswapped = false;
     773
     774        DATAOUT(libtrace)->nextintid = 0;
     775        DATAOUT(libtrace)->lastdlt = 0;
     776
     777        return 0;
     778}
     779
    274780static int pcapng_fin_input(libtrace_t *libtrace) {
    275781
     
    287793        free(libtrace->format_data);
    288794        return 0;
     795}
     796
     797static int pcapng_fin_output(libtrace_out_t *libtrace) {
     798        if (DATAOUT(libtrace)->file) {
     799                wandio_wdestroy(DATAOUT(libtrace)->file);
     800        }
     801        free(libtrace->format_data);
     802        libtrace->format_data = NULL;
     803        return 0;
    289804}
    290805
     
    432947}
    433948
     949static int pcapng_write_packet(libtrace_out_t *libtrace, libtrace_packet_t *packet) {
     950
     951        if (!libtrace) {
     952                fprintf(stderr, "NULL trace passed into pcapng_write_packet()\n");
     953                return TRACE_ERR_NULL_TRACE;
     954        }
     955        if (!packet) {
     956                trace_set_err_out(libtrace, TRACE_ERR_NULL_PACKET, "NULL packet passed "
     957                        "into pcapng_write_packet()\n");
     958                return -1;
     959        }
     960
     961        /* Check pcapng can write this type of packet */
     962        if (!pcapng_can_write(packet)) {
     963                return 0;
     964        }
     965
     966        libtrace_linktype_t linktype = trace_get_link_type(packet);
     967
     968        /* If the file is not open, open it */
     969        if (!DATAOUT(libtrace)->file) {
     970                DATAOUT(libtrace)->file = trace_open_file_out(libtrace,
     971                        DATAOUT(libtrace)->compress_type,
     972                        DATAOUT(libtrace)->compress_level,
     973                        DATAOUT(libtrace)->flag);
     974        }
     975
     976        /* If the packet is already encapsulated in a pcapng frame just output it */
     977        switch (pcapng_get_record_type(packet)) {
     978                case PCAPNG_SECTION_TYPE: {
     979                        /* If the section header passed in is byteswapped, everything we output
     980                         * till the next section header needs to be byteswapped. The next header
     981                         * will determine if we need to continue swapping bytes */
     982                        if (DATA(packet->trace)->byteswapped) {
     983                                DATAOUT(libtrace)->byteswapped = true;
     984                        } else {
     985                                DATAOUT(libtrace)->byteswapped = false;
     986                        }
     987
     988                        wandio_wwrite(DATAOUT(libtrace)->file, packet->buffer,
     989                                pcapng_get_blocklen(packet));
     990
     991                        DATAOUT(libtrace)->sechdr_count += 1;
     992
     993                        return pcapng_get_blocklen(packet);
     994                }
     995                case PCAPNG_INTERFACE_TYPE: {
     996                        /* increment the interface id */
     997                        DATAOUT(libtrace)->nextintid += 1;
     998
     999                        return pcapng_output_interface_packet(libtrace, packet);
     1000                }
     1001                case PCAPNG_OLD_PACKET_TYPE: {
     1002                        return pcapng_output_old_packet(libtrace, packet);
     1003                }
     1004                case PCAPNG_SIMPLE_PACKET_TYPE: {
     1005                        if (DATAOUT(libtrace)->nextintid == 0) {
     1006                                trace_set_err_out(libtrace, TRACE_ERR_BAD_PACKET,
     1007                                        "Cannot output simple packet before a interface "
     1008                                        "block has been output in pcapng_write_packet()\n");
     1009                                return -1;
     1010                        }
     1011                        return pcapng_output_simple_packet(libtrace, packet);
     1012                }
     1013                case PCAPNG_NAME_RESOLUTION_TYPE: {
     1014                        return pcapng_output_nameresolution_packet(libtrace, packet);
     1015                }
     1016                case PCAPNG_INTERFACE_STATS_TYPE: {
     1017                        if (DATAOUT(libtrace)->nextintid == 0) {
     1018                                trace_set_err_out(libtrace, TRACE_ERR_BAD_PACKET,
     1019                                        "Cannot output a interface statistics block before a "
     1020                                        "interface block has been output in pcapng_write_packet()\n");
     1021                                return -1;
     1022                        }
     1023                        return pcapng_output_interfacestats_packet(libtrace, packet);
     1024                }
     1025                case PCAPNG_ENHANCED_PACKET_TYPE: {
     1026                        if (DATAOUT(libtrace)->nextintid == 0) {
     1027                                trace_set_err_out(libtrace, TRACE_ERR_BAD_PACKET,
     1028                                        "Cannot output enhanced packet before a interface "
     1029                                        "block has been output in pcapng_write_packet()\n");
     1030                                return -1;
     1031                        }
     1032                        return pcapng_output_enhanced_packet(libtrace, packet);
     1033                }
     1034                case PCAPNG_CUSTOM_TYPE: {
     1035                        return pcapng_output_custom_packet(libtrace, packet);
     1036                }
     1037                case PCAPNG_DECRYPTION_SECRETS_TYPE: {
     1038                        return 0;
     1039                }
     1040                case PCAPNG_CUSTOM_NONCOPY_TYPE: {
     1041                        /* This custom block type is not ment to be copied */
     1042                        return 0;
     1043                }
     1044                default: {
     1045
     1046                        /* create section header if not already */
     1047                        if (DATAOUT(libtrace)->sechdr_count == 0) {
     1048                                /* Create section block */
     1049                                pcapng_sec_t sechdr;
     1050                                sechdr.blocktype = pcapng_swap32(libtrace, PCAPNG_SECTION_TYPE);
     1051                                sechdr.blocklen = pcapng_swap32(libtrace, 28);
     1052                                sechdr.ordering = pcapng_swap32(libtrace, 0x1A2B3C4D);
     1053                                sechdr.majorversion = pcapng_swap16(libtrace, 1);
     1054                                sechdr.minorversion = 0;
     1055                                sechdr.sectionlen = 0xFFFFFFFFFFFFFFFF;
     1056
     1057                                wandio_wwrite(DATAOUT(libtrace)->file, &sechdr, sizeof(sechdr));
     1058                                wandio_wwrite(DATAOUT(libtrace)->file, &sechdr.blocklen, sizeof(sechdr.blocklen));
     1059
     1060                                DATAOUT(libtrace)->sechdr_count += 1;
     1061                        }
     1062
     1063                        /* create interface header if not already or if the linktype has changed */
     1064                        if (DATAOUT(libtrace)->nextintid == 0
     1065                                || DATAOUT(libtrace)->lastdlt != linktype) {
     1066                                /* Create interface block*/
     1067                                pcapng_int_t inthdr;
     1068                                inthdr.blocktype = pcapng_swap32(libtrace, PCAPNG_INTERFACE_TYPE);
     1069                                inthdr.blocklen = pcapng_swap32(libtrace, 20);
     1070                                inthdr.linktype = pcapng_swap16(libtrace, libtrace_to_pcap_dlt(linktype));
     1071                                inthdr.reserved = 0;
     1072                                inthdr.snaplen = 0;
     1073
     1074                                wandio_wwrite(DATAOUT(libtrace)->file, &inthdr, sizeof(inthdr));
     1075                                wandio_wwrite(DATAOUT(libtrace)->file, &inthdr.blocklen, sizeof(inthdr.blocklen));
     1076
     1077                                /* increment the interface counter */
     1078                                DATAOUT(libtrace)->nextintid += 1;
     1079                                /* update the last linktype */
     1080                                DATAOUT(libtrace)->lastdlt = linktype;
     1081                        }
     1082
     1083                        break;
     1084                }
     1085        }
     1086
     1087        /* If we get this far the packet is not a pcapng type so we need to encapsulate it
     1088         * within a enhanced pcapng packet */
     1089        uint32_t remaining;
     1090        void *link;
     1091        uint32_t blocklen;
     1092        uint32_t padding;
     1093        uint32_t caplen;
     1094        uint32_t wirelen;
     1095        void *padding_data;
     1096        pcapng_epkt_t epkthdr;
     1097
     1098        link = trace_get_packet_buffer(packet, &linktype, &remaining);
     1099
     1100        wirelen = trace_get_wire_length(packet);
     1101        caplen = trace_get_capture_length(packet);
     1102
     1103        /* trace_get_wirelength includes FCS, while pcapng doesn't */
     1104        if (trace_get_link_type(packet)==TRACE_TYPE_ETH) {
     1105                if (wirelen >= 4) {
     1106                        wirelen -= 4;
     1107                } else {
     1108                        wirelen = 0;
     1109                }
     1110        }
     1111        /* capture length should always be less than the wirelength */
     1112        if (caplen > wirelen) {
     1113                caplen = wirelen;
     1114        }
     1115
     1116        /* calculate padding to 32bits */
     1117        padding = caplen % 4;
     1118        if (padding) { padding = 4 - padding; }
     1119        padding_data = calloc(1, padding);
     1120
     1121        /* get pcapng_timestamp */
     1122        struct pcapng_timestamp ts = pcapng_get_timestamp(packet);
     1123
     1124        /* calculate the block length */
     1125        blocklen = sizeof(epkthdr) + sizeof(epkthdr.blocklen) + caplen + padding;
     1126
     1127        /* construct the packet */
     1128        epkthdr.blocktype = pcapng_swap32(libtrace, PCAPNG_ENHANCED_PACKET_TYPE);
     1129        epkthdr.blocklen = pcapng_swap32(libtrace, blocklen);
     1130        epkthdr.interfaceid = pcapng_swap32(libtrace, DATAOUT(libtrace)->nextintid-1);
     1131        epkthdr.timestamp_high = pcapng_swap32(libtrace, ts.timehigh);
     1132        epkthdr.timestamp_low = pcapng_swap32(libtrace, ts.timelow);
     1133        epkthdr.wlen = pcapng_swap32(libtrace, wirelen);
     1134        epkthdr.caplen = pcapng_swap32(libtrace, caplen);
     1135
     1136        /* output enhanced packet header */
     1137        wandio_wwrite(DATAOUT(libtrace)->file, &epkthdr, sizeof(epkthdr));
     1138        /* output the packet */
     1139        wandio_wwrite(DATAOUT(libtrace)->file, link, (size_t)caplen);
     1140        /* output padding */
     1141        wandio_wwrite(DATAOUT(libtrace)->file, padding_data, (size_t)padding);
     1142        /* output rest of the enhanced packet */
     1143        wandio_wwrite(DATAOUT(libtrace)->file, &epkthdr.blocklen, sizeof(epkthdr.blocklen));
     1144
     1145        /* release padding memory */
     1146        free(padding_data);
     1147
     1148        return blocklen;
     1149}
     1150
     1151static int pcapng_flush_output(libtrace_out_t *libtrace) {
     1152        return wandio_wflush(DATAOUT(libtrace)->file);
     1153}
     1154
    4341155static int pcapng_read_section(libtrace_t *libtrace,
    4351156                libtrace_packet_t *packet, uint32_t flags) {
     
    4371158        pcapng_sec_t *sechdr;
    4381159        int err;
    439         uint32_t to_read;
     1160        uint32_t to_read, blocklen;
    4401161        char *bodyptr = NULL;
    4411162
     
    4811202                        return -1;
    4821203                }
    483                 to_read = byteswap32(sechdr->blocklen) - sizeof(pcapng_sec_t);
     1204                blocklen = byteswap32(sechdr->blocklen);
     1205
    4841206        } else {
    4851207                if (sechdr->majorversion != 1 && sechdr->minorversion != 0) {
     
    4881210                        return -1;
    4891211                }
    490                 to_read = sechdr->blocklen - sizeof(pcapng_sec_t);
    491         }
    492 
     1212                blocklen = sechdr->blocklen;
     1213        }
     1214
     1215        if (blocklen < sizeof(pcapng_sec_t)) {
     1216                trace_set_err(libtrace, TRACE_ERR_BAD_PACKET,
     1217                                "Block length in pcapng section header is invalid.");
     1218                return -1;
     1219        }
     1220        to_read = blocklen - sizeof(pcapng_sec_t);
    4931221        /* Read all of the options etc. -- we don't need them for now, but
    4941222         * we have to skip forward to the next useful header. */
    4951223        bodyptr = (char *) packet->buffer + sizeof(pcapng_sec_t);
     1224
     1225        if (to_read > LIBTRACE_PACKET_BUFSIZE) {
     1226                trace_set_err(libtrace, TRACE_ERR_BAD_PACKET,
     1227                                "Excessively large section header contents of %u bytes, likely a corrupt trace.", to_read);
     1228                return -1;
     1229        }
     1230
    4961231        err = pcapng_read_body(libtrace, bodyptr, to_read);
    4971232        if (err <= 0) {
     
    10921827}
    10931828
    1094 static libtrace_linktype_t pcapng_get_link_type(const libtrace_packet_t *packet)
    1095 {
     1829static libtrace_linktype_t pcapng_get_link_type(const libtrace_packet_t *packet) {
     1830
     1831        if (packet->type == TRACE_RT_PCAPNG_META) {
     1832                return TRACE_TYPE_PCAPNG_META;
     1833        }
    10961834
    10971835        return pcap_linktype_to_libtrace(rt_to_pcap_linktype(packet->type));
    1098 
    10991836}
    11001837
     
    11121849        uint32_t interfaceid = 0;
    11131850        pcapng_interface_t *interface;
     1851
     1852        memset(&ts, 0, sizeof(struct timespec));
    11141853
    11151854        if (!packet) {
     
    14362175        pcapng_start_input,             /* start_input */
    14372176        NULL,                           /* pause_input */
    1438         NULL,                           /* init_output */
    1439         NULL,                           /* config_output */
     2177        pcapng_init_output,             /* init_output */
     2178        pcapng_config_output,           /* config_output */
    14402179        NULL,                           /* start_output */
    14412180        pcapng_fin_input,               /* fin_input */
    1442         NULL,                           /* fin_output */
     2181        pcapng_fin_output,              /* fin_output */
    14432182        pcapng_read_packet,             /* read_packet */
    14442183        pcapng_prepare_packet,          /* prepare_packet */
    14452184        NULL,                           /* fin_packet */
    1446         NULL,                           /* write_packet */
    1447         NULL,                           /* flush_output */
     2185        pcapng_write_packet,            /* write_packet */
     2186        pcapng_flush_output,            /* flush_output */
    14482187        pcapng_get_link_type,           /* get_link_type */
    14492188        pcapng_get_direction,           /* get_direction */
     
    14742213        register_format(&pcapng);
    14752214}
    1476 
  • lib/libtrace.h.in

    rdb919d5 rc876f29  
    414414       TRACE_TYPE_OPENBSD_LOOP = 20,    /**< OpenBSD loopback */
    415415       TRACE_TYPE_ERF_META = 21, /**< ERF Provenance metadata record */
    416        TRACE_TYPE_ETSILI = 22   /**< ETSI Lawful Intercept */
     416       TRACE_TYPE_ETSILI = 22,  /**< ETSI Lawful Intercept */
     417       TRACE_TYPE_PCAPNG_META = 23,     /** PCAPNG meta packet */
    417418} libtrace_linktype_t;
    418419
  • lib/linktypes.c

    r2193905 r49f8ceb  
    110110                case TRACE_TYPE_ETSILI:
    111111                        break;
     112                case TRACE_TYPE_PCAPNG_META:
    112113                case TRACE_TYPE_UNKNOWN:
    113114                case TRACE_TYPE_CONTENT_INVALID:
     
    212213                case TRACE_TYPE_OPENBSD_LOOP:
    213214                case TRACE_TYPE_ETSILI:
     215                case TRACE_TYPE_PCAPNG_META:
    214216                case TRACE_TYPE_UNKNOWN:
    215217                case TRACE_TYPE_CONTENT_INVALID:
  • lib/protocols.h

    ree6e802 rbe1b03a  
    2424 *
    2525 */
     26
     27#ifndef LIBTRACE_PROTOCOLS_H_
     28#define LIBTRACE_PROTOCOLS_H_
    2629
    2730/** @file
     
    8184};
    8285
    83 
     86#endif
  • lib/protocols_l2.c

    r692bf9c rc876f29  
    690690         * calling trace_get_packet_buffer more than once like we used to.
    691691         */
    692        
    693692        meta = trace_get_packet_buffer(packet, linktype, remaining);
     693        if (meta == NULL) {
     694                return NULL;
     695        }
    694696
    695697        /* If there are no meta-data headers, we just return the start of the
     
    719721                case TRACE_TYPE_PFLOG:
    720722                case TRACE_TYPE_ERF_META:
     723                case TRACE_TYPE_PCAPNG_META:
    721724                case TRACE_TYPE_ETSILI:
    722725                        break;
     
    757760                                case TRACE_TYPE_PFLOG:
    758761                                case TRACE_TYPE_ERF_META:
     762                                case TRACE_TYPE_PCAPNG_META:
    759763                                case TRACE_TYPE_ETSILI:
    760764                                        break;
     
    808812                return NULL;
    809813        }
    810        
     814
     815        if (link == NULL) {
     816                return NULL;
     817        }
     818
    811819        switch(linktype) {
    812820                /* Packet Metadata headers, not layer2 headers */
     
    827835                case TRACE_TYPE_METADATA:
    828836                case TRACE_TYPE_NONDATA:
     837                case TRACE_TYPE_PCAPNG_META:
    829838                case TRACE_TYPE_ERF_META:
    830839                case TRACE_TYPE_CONTENT_INVALID:
     
    837846                        return trace_get_payload_from_ethernet(link,ethertype,remaining);
    838847                case TRACE_TYPE_NONE:
     848                        if (*remaining == 0) {
     849                                return NULL;
     850                        }
     851
    839852                        if ((*(char*)link&0xF0) == 0x40)
    840853                                *ethertype=TRACE_ETHERTYPE_IP;   /* IPv4 */
    841854                        else if ((*(char*)link&0xF0) == 0x60)
    842855                                *ethertype=TRACE_ETHERTYPE_IPV6; /* IPv6 */
     856                        else
     857                                return NULL;            /* No idea */
    843858                        return link; /* I love the simplicity */
    844859                case TRACE_TYPE_PPP:
     
    865880
    866881                case TRACE_TYPE_OPENBSD_LOOP:
     882                        if (*remaining <= 4) {
     883                                return NULL;
     884                        }
    867885                        link = link + 4; /* Loopback header is 4 bytes */
    868886                        if ((*(char*)link&0xF0) == 0x40)
     
    870888                        else if ((*(char*)link&0xF0) == 0x60)
    871889                                *ethertype=TRACE_ETHERTYPE_IPV6; /* IPv6 */
     890                        else
     891                                return NULL;
    872892                        return link; /* I love the simplicity */
    873893               
     
    937957                case TRACE_TYPE_OPENBSD_LOOP:
    938958                case TRACE_TYPE_ERF_META:
     959                case TRACE_TYPE_PCAPNG_META:
    939960                case TRACE_TYPE_UNKNOWN:
    940961                case TRACE_TYPE_CONTENT_INVALID:
     
    9931014                case TRACE_TYPE_OPENBSD_LOOP:
    9941015                case TRACE_TYPE_ERF_META:
     1016                case TRACE_TYPE_PCAPNG_META:
    9951017                case TRACE_TYPE_UNKNOWN:
    9961018                case TRACE_TYPE_CONTENT_INVALID:
  • lib/protocols_pktmeta.c

    r2193905 r49f8ceb  
    191191                case TRACE_TYPE_OPENBSD_LOOP:
    192192                case TRACE_TYPE_UNKNOWN:
     193                case TRACE_TYPE_PCAPNG_META:
    193194                case TRACE_TYPE_CONTENT_INVALID:
    194195                        return NULL;
     
    249250                        return nexthdr;
    250251
     252                case TRACE_TYPE_PCAPNG_META:
    251253                case TRACE_TYPE_HDLC_POS:
    252254                case TRACE_TYPE_ETH:
  • lib/trace.c

    rd439067 rd0941cc  
    14311431DLLEXPORT size_t trace_get_wire_length(const libtrace_packet_t *packet){
    14321432
     1433        size_t wiresub = 0;
     1434
    14331435        if (packet->which_trace_start != packet->trace->startcount) {
    14341436                return ~0U;
     
    14421444        }
    14431445
    1444         if (!(packet->cached.wire_length < LIBTRACE_PACKET_BUFSIZE)) {
    1445                 fprintf(stderr, "Wire length is greater than the buffer size in trace_get_wire_length()\n");
    1446                 return 0;
     1446        if (packet->type >= TRACE_RT_DATA_DLT && packet->type <=
     1447                        TRACE_RT_DATA_DLT_END) {
     1448
     1449                /* pcap wire lengths in libtrace include an extra four bytes
     1450                 * for the FCS (to be consistent with other formats that do
     1451                 * capture the FCS), but these bytes don't actually exist on
     1452                 * the wire. Therefore, we shouldn't get upset if our "wire"
     1453                 * length exceeds the max buffer size by four bytes or less.
     1454                 */
     1455                if (packet->cached.wire_length >= 4) {
     1456                        wiresub = 4;
     1457                } else {
     1458                        wiresub = packet->cached.wire_length;
     1459                }
     1460        } else {
     1461                wiresub = 0;
     1462        }
     1463
     1464        if (!(packet->cached.wire_length - wiresub < LIBTRACE_PACKET_BUFSIZE)) {
     1465                fprintf(stderr, "Wire length %zu exceeds expected maximum packet size of %d -- packet is likely corrupt.\n",
     1466                                packet->cached.wire_length - wiresub,
     1467                                LIBTRACE_PACKET_BUFSIZE);
     1468
    14471469                /* should we be returning ~OU here? */
    14481470        }
     
    15541576#else
    15551577        struct libtrace_filter_t *filter = (struct libtrace_filter_t *)
    1556                 malloc(sizeof(struct libtrace_filter_t));
     1578                calloc(1, sizeof(struct libtrace_filter_t));
    15571579        filter->filter.bf_insns = (struct bpf_insn *)
    15581580                malloc(sizeof(struct bpf_insn) * bf_len);
     
    15781600#ifdef HAVE_BPF
    15791601        libtrace_filter_t *filter = (libtrace_filter_t*)
    1580                                 malloc(sizeof(libtrace_filter_t));
     1602                                calloc(1, sizeof(libtrace_filter_t));
    15811603        filter->filterstring = strdup(filterstring);
    15821604        filter->jitfilter = NULL;
     
    17181740        linktype = trace_get_link_type(packet);
    17191741
    1720         if (linktype == TRACE_TYPE_NONDATA || linktype == TRACE_TYPE_ERF_META)
     1742        if (linktype == TRACE_TYPE_NONDATA || linktype == TRACE_TYPE_ERF_META
     1743                || linktype == TRACE_TYPE_PCAPNG_META)
    17211744                return 1;
    17221745
  • lib/trace_parallel.c

    r9c46b65 r6d2a120  
    22772277
    22782278        if (ret == -1) {
     2279                libtrace_err_t err UNUSED;
     2280
    22792281                /* We have to deal with this ourself */
     2282                /* If we succeed, clear any error state otherwise our caller
     2283                 * might assume an error occurred, even though we've resolved
     2284                 * the issue ourselves.
     2285                 */
    22802286                if (!hasher) {
    22812287                        switch (type)
     
    22832289                                case HASHER_CUSTOM:
    22842290                                case HASHER_BALANCE:
     2291                                        err = trace_get_err(trace);
    22852292                                        return 0;
    22862293                                case HASHER_BIDIRECTIONAL:
     
    22882295                                        trace->hasher_data = calloc(1, sizeof(toeplitz_conf_t));
    22892296                                        toeplitz_init_config(trace->hasher_data, 1);
     2297                                        err = trace_get_err(trace);
    22902298                                        return 0;
    22912299                                case HASHER_UNIDIRECTIONAL:
     
    22932301                                        trace->hasher_data = calloc(1, sizeof(toeplitz_conf_t));
    22942302                                        toeplitz_init_config(trace->hasher_data, 0);
     2303                                        err = trace_get_err(trace);
    22952304                                        return 0;
    22962305                        }
  • libpacketdump/bitbuffer.h

    ree6e802 rbe1b03a  
    2424 *
    2525 */
     26
     27#ifndef LIBPACKETDUMP_BITBUFFER_H_
     28#define LIBPACKETDUMP_BITBUFFER_H_
     29
    2630#include "grammar.h"
    2731#include <stdio.h>
     
    3539extern element_t *el_list;
    3640
     41#endif
  • test/Makefile

    r568a341 rec19a99  
    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 test-setcaplen $(BINS_DATASTRUCT) $(BINS_PARALLEL)
     21        test-live-snaplen test-vxlan test-setcaplen test-wlen \
     22        $(BINS_DATASTRUCT) $(BINS_PARALLEL)
    2223
    2324.PHONY: all clean distclean install depend test
  • test/do-tests.sh

    r43b773a rec19a99  
    7979echo \* Testing payload length
    8080do_test ./test-plen
     81
     82echo \* Testing wire length
     83echo \* ERF
     84do_test ./test-wlen erf
     85echo \* pcapfile
     86do_test ./test-wlen pcapfile
     87echo \* pcapfilens
     88do_test ./test-wlen pcapfilens
     89echo \* legacyatm
     90do_test ./test-wlen legacyatm
     91echo \* legacypos
     92do_test ./test-wlen legacypos
     93echo \* legacyeth
     94do_test ./test-wlen legacyeth
     95echo \* rawerf
     96do_test ./test-wlen rawerf
     97echo \* pcap
     98do_test ./test-wlen pcap
     99echo \* tsh
     100do_test ./test-wlen tsh
     101echo \* pcapng
     102do_test ./test-wlen pcapng
    81103
    82104echo \* Testing port numbers
     
    161183
    162184echo " * erf -> pcap"
     185rm -f traces/*.out.*
    163186do_test ./test-convert erf pcap
    164187
     188echo " * erf -> pcapfile"
     189rm -f traces/*.out.*
     190do_test ./test-convert erf pcapfile
     191
     192echo " * erf -> pcapng"
     193rm -f traces/*.out.*
     194do_test ./test-convert erf pcapng
     195
     196
     197echo " * pcap -> pcap"
     198rm -f traces/*.out.*
     199do_test ./test-convert pcap pcap
     200
    165201echo " * pcap -> erf"
    166202rm -f traces/*.out.*
    167203do_test ./test-convert pcap erf
    168204
     205echo " * pcap -> pcapfile"
     206rm -f traces/*.out.*
     207do_test ./test-convert pcap pcapfile
     208
     209echo " * pcap -> pcapng"
     210rm -f traces/*.out.*
     211do_test ./test-convert pcap pcapng
     212
     213
    169214echo " * pcapfile -> erf"
    170215rm -f traces/*.out.*
     
    175220do_test ./test-convert pcapfile pcapfile
    176221
     222echo " * pcapfile -> pcap"
     223rm -f traces/*.out.*
     224do_test ./test-convert pcapfile pcap
     225
     226echo " * pcapfile -> pcapng"
     227rm -f traces/*.out.*
     228do_test ./test-convert pcapfile pcapng
     229
     230
    177231echo " * pcapfilens -> pcapfile"
    178232rm -f traces/*.out.*
     
    183237do_test ./test-convert pcapfilens erf
    184238
    185 echo " * pcap -> pcapfile"
    186 rm -f traces/*.out.*
    187 do_test ./test-convert pcap pcapfile
    188 
    189 echo " * erf -> pcapfile"
    190 rm -f traces/*.out.*
    191 do_test ./test-convert erf pcapfile
    192239
    193240echo " * pcapng -> pcapfile"
     
    198245rm -f traces/*.out.*
    199246do_test ./test-convert pcapng erf
     247
     248echo " * pcapng -> pcap"
     249rm -f traces/*.out.*
     250do_test ./test-convert pcapng pcap
     251
     252echo " * pcapng -> pcapng"
     253rm -f traces/*.out.*
     254do_test ./test-convert pcapng pcapng
     255
    200256
    201257echo " * pcap (sll) -> erf    raw IP"
  • test/test-convert.c

    r568a341 r51276bd  
    112112        if (!strcmp(type,"duck"))
    113113                return "duck:traces/100_packets.out.duck";
     114        if (!strcmp(type,"pcapng"))
     115                return "pcapng:traces/100_packets.out.pcapng";
    114116        return "unknown";
    115117}
     
    198200        packet=trace_create_packet();
    199201        for (;;) {
     202
    200203                if ((psize = trace_read_packet(trace, packet)) <0) {
    201204                        error = 1;
    202205                        break;
    203206                }
     207
    204208                if (psize == 0) {
    205209                        error = 0;
     
    207211                }
    208212                if (trace_write_packet(outtrace,packet) > 0)
    209                         count ++;
     213                        if (!IS_LIBTRACE_META_PACKET(packet)) {
     214                                count ++;
     215                        }
    210216                iferrout(outtrace);
    211217                if (count>100)
     
    241247        count=0;
    242248        tcpcount=0;
     249
    243250        while(trace_read_packet(trace,packet)>0) {
    244251                int err;
     
    259266                /* The capture length might be snapped down to the wire length */
    260267                if (length_changed(packet, packet2)) {
     268
    261269                        printf("\t%s\t%s\n",
    262270                                trace1name,
     
    275283                        abort();
    276284                }
    277                
     285
    278286                if (time_changed(packet, packet2)) {
    279287                        error = 1;
    280288                        break;
    281289                }
    282        
     290
    283291                if (trace_get_tcp(packet)) {
    284292                        if (!trace_get_tcp(packet2)) {
  • tools/traceanon/traceanon.cc

    r8e11beb rab3ddbe  
    4646};
    4747
    48 bool enc_source = false;
    49 bool enc_dest   = false;
     48bool enc_source_opt = false;
     49bool enc_dest_opt   = false;
    5050enum enc_type_t enc_type = ENC_NONE;
    51 char *key = NULL;
     51char *enc_key = NULL;
    5252
    5353int level = -1;
    5454trace_option_compresstype_t compress_type = TRACE_OPTION_COMPRESSTYPE_NONE;
    5555
    56 struct libtrace_t *trace = NULL;
     56struct libtrace_t *inptrace = NULL;
    5757
    5858static void cleanup_signal(int signal)
     
    6060        (void)signal;
    6161        // trace_pstop isn't really signal safe because its got lots of locks in it
    62         trace_pstop(trace);
     62        trace_pstop(inptrace);
    6363}
    6464
     
    182182        ip6 = trace_get_ip6(packet);
    183183
    184         if (ipptr && (enc_source || enc_dest)) {
    185                 encrypt_ips(anon, ipptr,enc_source,enc_dest);
     184        if (ipptr && (enc_source_opt || enc_dest_opt)) {
     185                encrypt_ips(anon, ipptr,enc_source_opt,enc_dest_opt);
    186186                ipptr->ip_sum = 0;
    187         } else if (ip6 && (enc_source || enc_dest)) {
    188                 encrypt_ipv6(anon, ip6, enc_source, enc_dest);
     187        } else if (ip6 && (enc_source_opt || enc_dest_opt)) {
     188                encrypt_ipv6(anon, ip6, enc_source_opt, enc_dest_opt);
    189189        }
    190190
     
    197197
    198198        udp = trace_get_udp(packet);
    199         if (udp && (enc_source || enc_dest)) {
     199        if (udp && (enc_source_opt || enc_dest_opt)) {
    200200                udp->check = 0;
    201201        }
    202202
    203203        tcp = trace_get_tcp(packet);
    204         if (tcp && (enc_source || enc_dest)) {
     204        if (tcp && (enc_source_opt || enc_dest_opt)) {
    205205                tcp->check = 0;
    206206        }
    207207
    208208        icmp6 = trace_get_icmp6(packet);
    209         if (icmp6 && (enc_source || enc_dest)) {
     209        if (icmp6 && (enc_source_opt || enc_dest_opt)) {
    210210                icmp6->checksum = 0;
    211211        }
     
    221221{
    222222        if (enc_type == ENC_PREFIX_SUBSTITUTION) {
    223                 PrefixSub *sub = new PrefixSub(key, NULL);
     223                PrefixSub *sub = new PrefixSub(enc_key, NULL);
    224224                return sub;
    225225        }
    226226
    227227        if (enc_type == ENC_CRYPTOPAN) {
    228                 if (strlen(key) < 32) {
     228                if (strlen(enc_key) < 32) {
    229229                        fprintf(stderr, "ERROR: Key must be at least 32 "
    230230                        "characters long for CryptoPan anonymisation.\n");
     
    232232                }
    233233#ifdef HAVE_LIBCRYPTO               
    234                 CryptoAnon *anon = new CryptoAnon((uint8_t *)key,
    235                         (uint8_t)strlen(key), 20);
     234                CryptoAnon *anon = new CryptoAnon((uint8_t *)enc_key,
     235                        (uint8_t)strlen(enc_key), 20);
    236236                return anon;
    237237#else
     
    357357                        case 'Z': compress_type_str=optarg; break;         
    358358                        case 'z': level = atoi(optarg); break;
    359                         case 's': enc_source=true; break;
    360                         case 'd': enc_dest  =true; break;
     359                        case 's': enc_source_opt=true; break;
     360                        case 'd': enc_dest_opt  =true; break;
    361361                        case 'c':
    362                                   if (key!=NULL) {
     362                                  if (enc_key!=NULL) {
    363363                                          fprintf(stderr,"You can only have one encryption type and one key\n");
    364364                                          usage(argv[0]);
    365365                                  }
    366                                   key=strdup(optarg);
     366                                  enc_key=strdup(optarg);
    367367                                  enc_type = ENC_CRYPTOPAN;
    368368                                  break;
    369369                        case 'F': {
    370                                   if(key != NULL) {
     370                                  if(enc_key != NULL) {
    371371                                    fprintf(stderr,"You can only have one encryption type and one key\n");
    372372                                    usage(argv[0]);
     
    377377                                    return 1;
    378378                                  }
    379                                   key = (char *) malloc(sizeof(char *) * 32);
    380                                   if(fread(key,1,32,infile) != 32) {
     379                                  enc_key = (char *) malloc(sizeof(char *) * 32);
     380                                  if(fread(enc_key,1,32,infile) != 32) {
    381381                                    if(ferror(infile)) {
    382382                                      perror("Failed while reading cryptopan keyfile");
     
    391391                                  break;
    392392                        case 'p':
    393                                   if (key!=NULL) {
     393                                  if (enc_key!=NULL) {
    394394                                          fprintf(stderr,"You can only have one encryption type and one key\n");
    395395                                          usage(argv[0]);
    396396                                  }
    397                                   key=strdup(optarg);
     397                                  enc_key=strdup(optarg);
    398398                                  enc_type = ENC_PREFIX_SUBSTITUTION;
    399399                                  break;
     
    442442
    443443        /* open input uri */
    444         trace = trace_create(argv[optind]);
    445         if (trace_is_err(trace)) {
    446                 trace_perror(trace,"trace_create");
     444        inptrace = trace_create(argv[optind]);
     445        if (trace_is_err(inptrace)) {
     446                trace_perror(inptrace,"trace_create");
    447447                exitcode = 1;
    448448                goto exitanon;
     
    463463         * special case to have.
    464464         */
    465         trace_set_combiner(trace, &combiner_ordered, (libtrace_generic_t){0});
     465        trace_set_combiner(inptrace, &combiner_ordered, (libtrace_generic_t){0});
    466466
    467467        pktcbs = trace_create_callback_set();
     
    475475        trace_set_starting_cb(repcbs, init_output);
    476476
    477         trace_set_perpkt_threads(trace, maxthreads);
     477        trace_set_perpkt_threads(inptrace, maxthreads);
    478478
    479479        if (filterstring) {
     
    481481        }
    482482
    483         if (filter && trace_config(trace, TRACE_OPTION_FILTER, filter) == -1)
     483        if (filter && trace_config(inptrace, TRACE_OPTION_FILTER, filter) == -1)
    484484        {
    485                 trace_perror(trace, "Configuring input filter");
     485                trace_perror(inptrace, "Configuring input filter");
    486486                exitcode = 1;
    487487                goto exitanon;
    488488        }
    489489
    490         if (trace_pstart(trace, output, pktcbs, repcbs)==-1) {
    491                 trace_perror(trace,"trace_start");
     490        if (trace_pstart(inptrace, output, pktcbs, repcbs)==-1) {
     491                trace_perror(inptrace,"trace_start");
    492492                exitcode = 1;
    493493                goto exitanon;
     
    502502
    503503        // Wait for the trace to finish
    504         trace_join(trace);
     504        trace_join(inptrace);
    505505
    506506exitanon:
     
    509509        if (repcbs)
    510510                trace_destroy_callback_set(repcbs);
    511         if (trace)
    512                 trace_destroy(trace);
     511        if (inptrace)
     512                trace_destroy(inptrace);
    513513        return exitcode;
    514514}
  • tools/tracemerge/tracemerge.c

    r8e11beb rb2e3894  
    207207                input[i]=f;
    208208                packet[i]=p;
    209                 if (trace_read_packet(f,packet[i])>0)
     209                if (trace_read_packet(f,packet[i])>0){
    210210                        live[i]=true;
     211                }
    211212        }
    212213
     
    237238                        if (live[i]) {
    238239                                this_ts = trace_get_erf_timestamp(packet[i]);
     240
     241                                /* If the ts is 0 and its a meta packet just output it
     242                                 * and read new packets until we get one that has a ts */
     243                                while (this_ts == 0 && IS_LIBTRACE_META_PACKET(packet[i])) {
     244                                        trace_write_packet(output,packet[i]);
     245
     246                                        /* read another packet, break if reached EOF */
     247                                        if (trace_read_packet(input[i],packet[i])>0) {
     248                                                live[i] = true;
     249                                        } else { break; }
     250                                        this_ts = trace_get_erf_timestamp(packet[i]);
     251                                }
     252
    239253                                if (this_ts != 0 && (oldest==-1 ||
    240254                                                oldest_ts>this_ts)) {
  • tools/tracertstats/tracertstats.c

    r1800ee3 rbab946c  
    8080struct output_data_t *output = NULL;
    8181
    82 uint64_t count;
    83 uint64_t bytes;
     82uint64_t totalcount;
     83uint64_t totalbytes;
    8484
    8585struct libtrace_t *currenttrace;
     
    178178        }
    179179        while ((glob_last_ts >> 32) < (ts >> 32)) {
    180                 report_results(glob_last_ts >> 32, count, bytes, stats);
    181                 count = 0;
    182                 bytes = 0;
     180                report_results(glob_last_ts >> 32, totalcount, totalbytes,
     181                                stats);
     182                totalcount = 0;
     183                totalbytes = 0;
    183184                for (j = 0; j < filter_count; j++)
    184185                        filters[j].count = filters[j].bytes = 0;
    185186                glob_last_ts = ts;
    186187        }
    187         count += res->total.count;
     188        totalcount += res->total.count;
    188189        packets_seen += res->total.count;
    189         bytes += res->total.bytes;
     190        totalbytes += res->total.bytes;
    190191        for (j = 0; j < filter_count; j++) {
    191192                filters[j].count += res->filters[j].count;
     
    344345                stats = trace_get_statistics(trace, stats);
    345346        }
    346         report_results((glob_last_ts >> 32), count, bytes, stats);
     347        report_results((glob_last_ts >> 32), totalcount, totalbytes, stats);
    347348        if (trace_is_err(trace))
    348349                trace_perror(trace,"%s",uri);
  • tools/tracesplit/tracesplit.c

    r4c5bbfc rbab946c  
    5252uint64_t filescreated = 0;
    5353uint16_t snaplen = 0;
    54 int jump=0;
     54int jumpopt=0;
    5555int verbose=0;
    5656int compress_level=-1;
     
    324324
    325325        /* Support "jump"ping to the nth IP header. */
    326         if (jump) {
     326        if (jumpopt) {
    327327            /* Skip headers */
    328             struct libtrace_packet_t *newpacket = perform_jump(*packet, jump);
     328            struct libtrace_packet_t *newpacket = perform_jump(*packet, jumpopt);
    329329            if (newpacket) {
    330330                /* If an IP header was found on the nth layer down
     
    404404                        case 'i': interval=atoi(optarg);
    405405                                  break;
    406                         case 'j': jump=atoi(optarg);
     406                        case 'j': jumpopt=atoi(optarg);
    407407                                  break;
    408408                        case 'm': maxfiles=atoi(optarg);
  • tools/tracestats/tracestats.c

    r02d13cb rbab946c  
    5454#include <pthread.h>
    5555
    56 struct libtrace_t *trace = NULL;
     56struct libtrace_t *inptrace = NULL;
    5757
    5858static void cleanup_signal(int signal UNUSED)
    5959{
    60         if (trace)
    61                 trace_pstop(trace);
     60        if (inptrace)
     61                trace_pstop(inptrace);
    6262}
    6363
     
    196196        libtrace_callback_set_t *pktcbs, *rescbs;
    197197
    198         trace = trace_create(uri);
    199 
    200         if (trace_is_err(trace)) {
    201                 trace_perror(trace,"Failed to create trace");
     198        inptrace = trace_create(uri);
     199
     200        if (trace_is_err(inptrace)) {
     201                trace_perror(inptrace,"Failed to create trace");
    202202                return;
    203203        }
     
    214214
    215215        if (threadcount != 0)
    216                 trace_set_perpkt_threads(trace, threadcount);
     216                trace_set_perpkt_threads(inptrace, threadcount);
    217217
    218218        /* Start the trace as a parallel trace */
    219         if (trace_pstart(trace, NULL, pktcbs, rescbs)==-1) {
    220                 trace_perror(trace,"Failed to start trace");
     219        if (trace_pstart(inptrace, NULL, pktcbs, rescbs)==-1) {
     220                trace_perror(inptrace,"Failed to start trace");
    221221                return;
    222222        }
    223223
    224224        /* Wait for all threads to stop */
    225         trace_join(trace);
    226 
    227         if (trace_is_err(trace))
    228                 trace_perror(trace,"%s",uri);
    229 
    230         trace_destroy(trace);
     225        trace_join(inptrace);
     226
     227        if (trace_is_err(inptrace))
     228                trace_perror(inptrace,"%s",uri);
     229
     230        trace_destroy(inptrace);
    231231        trace_destroy_callback_set(pktcbs);
    232232        trace_destroy_callback_set(rescbs);
Note: See TracChangeset for help on using the changeset viewer.