Changeset 97d0351


Ignore:
Timestamp:
07/02/18 15:26:17 (2 years ago)
Author:
Shane Alcock <salcock@…>
Branches:
cachetimestamps, develop, master, ringdecrementfix, ringperformance
Children:
5864acd, b135888
Parents:
314239a (diff), c7a320a (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'rc-4.0.4'

Files:
4 added
45 edited

Legend:

Unmodified
Added
Removed
  • AUTHORS

    r92db9e4 r35de364  
    3636 * Anthony Coddington for adding ERF provenance support and fixing a number
    3737   of other ERF/DAG issues
     38 * Tim Dawson for fixing issues with building against musl libc
     39 * Hendrik Leppelsack for reporting and fixing some errors in the tool manpages
    3840 * Jamie Curtis for fixing a couple of bugs many many years ago
    3941 * Brendon Jones for creating the original Windows DLLs and writing bits of
  • README

    r0e8f8cb r096851a  
    1 libtrace 4.0.3
     1libtrace 4.0.4
    22
    33---------------------------------------------------------------------------
  • configure.in

    r0e8f8cb r47d64ce  
    44# and in the README
    55
    6 AC_INIT([libtrace],[4.0.3],[contact@wand.net.nz],[libtrace])
     6AC_INIT([libtrace],[4.0.4],[contact@wand.net.nz],[libtrace])
    77
    88LIBTRACE_MAJOR=4
    99LIBTRACE_MID=0
    10 LIBTRACE_MINOR=3
     10LIBTRACE_MINOR=4
    1111
    1212# OpenSolaris hides libraries like libncurses in /usr/gnu/lib, which is not
     
    8787AC_FUNC_REALLOC
    8888
    89 # *BSD doesn't have strndup. Currently provide our own.
    90 AC_REPLACE_FUNCS(strndup)
    91 
    92 
    9389# Checks for typedefs, structures, and compiler characteristics.
    9490AC_C_CONST
     
    126122
    127123# Fail if any of these functions are missing
    128 AC_CHECK_FUNCS(socket strdup strlcpy strcasecmp strncasecmp snprintf vsnprintf recvmmsg)
     124AC_CHECK_DECLS([socket, strdup, strlcpy, strcasecmp, strncasecmp, snprintf, vsnprintf, recvmmsg, strndup])
    129125
    130126AC_CHECK_SIZEOF([long int])
     
    202198
    203199# Check for libwandio (no longer bundled with libtrace)
    204 AC_CHECK_LIB(wandio,wandio_create,wandiofound=1,wandiofound=0)
     200AC_CHECK_LIB(wandio,wandio_wflush,wandiofound=1,wandiofound=0)
    205201if test "$wandiofound" = 0; then
    206         AC_MSG_ERROR(libwandio is required to compile libtrace. If you have installed it in a non-standard location please use LDFLAGS to specify the location of the library. WANDIO can be obtained from http://research.wand.net.nz/software/libwandio.php)
     202        AC_MSG_ERROR(libwandio 1.0.5 or better is required to compile this version of libtrace. If you have installed libwandio in a non-standard location please use LDFLAGS to specify the location of the library. WANDIO can be obtained from http://research.wand.net.nz/software/libwandio.php)
    207203else
    208204        LIBTRACE_LIBS="$LIBTRACE_LIBS -lwandio"
     
    212208
    213209AC_CHECK_LIB(crypto, EVP_EncryptInit_ex, cryptofound=1, cryptofound=0)
     210if test "$cryptofound" = 1; then
     211        AC_CHECK_HEADER(openssl/evp.h, cryptofound=1, cryptofound=0)
     212fi
     213AC_CHECK_LIB(tasn1, asn1_array2tree, asn1found=1, asn1found=0)
    214214
    215215# Check for libpcap
     
    455455AC_CHECK_LIB(numa, numa_node_to_cpus, have_numa=1, have_numa=0)
    456456
     457# Need libwandder for ETSI live decoding
     458AC_CHECK_LIB(wandder, init_wandder_decoder, have_wandder=1, have_wandder=0)
     459
    457460# Checks for various "optional" libraries
    458461AC_CHECK_LIB(pthread, pthread_create, have_pthread=1, have_pthread=0)
     
    482485        with_numa=yes
    483486else
    484         AC_DEFINE(HAVE_LIBNUMA, 0, [Set to 1 if libnuma is supported])
    485487        with_numa=no
     488fi
     489
     490if test "$have_wandder" = 1; then
     491        LIBTRACE_LIBS="$LIBTRACE_LIBS -lwandder"
     492        AC_DEFINE(HAVE_WANDDER, 1, [Set to 1 if libwandder is available])
     493        wandder_avail=yes
     494else
     495        wandder_avail=no
    486496fi
    487497
     
    533543        with_clock_gettime=yes
    534544else
    535         AC_DEFINE(HAVE_CLOCK_GETTIME, 0, [Set to 1 if clock_gettime is supported])
    536545        with_clock_gettime=no
    537546fi
    538547
     548
     549have_memfd_create=no
     550AC_RUN_IFELSE([AC_LANG_PROGRAM([
     551#include <sys/syscall.h>
     552],[
     553#ifndef __NR_memfd_create
     554exit(1)
     555#endif
     556])], [have_memfd_create=yes])
     557
     558if test "$have_memfd_create" = "yes"; then
     559        AC_DEFINE(HAVE_MEMFD_CREATE, 1, [Set to 1 if kernel supports memfd_create syscall])
     560fi
    539561
    540562# Stupid AC_SEARCH_LIB appends stuff to LIBS even when I don't want it to, so
     
    611633AM_CONDITIONAL([HAVE_DAG], [test "$libtrace_dag" = true])
    612634AM_CONDITIONAL([HAVE_DPDK], [test "$libtrace_dpdk" = true])
     635AM_CONDITIONAL([HAVE_WANDDER], [test "x$wandder_avail" = "xyes"])
    613636AM_CONDITIONAL([DAG2_4], [test "$libtrace_dag_version" = 24])
    614637AM_CONDITIONAL([DAG2_5], [test "$libtrace_dag_version" = 25])
     
    692715fi
    693716reportopt "Compiled with LLVM BPF JIT support" $JIT
     717reportopt "Compiled with live ETSI LI support (requires libwandder)" $wandder_avail
    694718reportopt "Building man pages/documentation" $libtrace_doxygen
    695719reportopt "Building tracetop (requires libncurses)" $with_ncurses
    696 reportopt "Building traceanon with CryptoPan (requires libcrypto)" $have_crypto
     720reportopt "Building traceanon with CryptoPan (requires libcrypto and openssl/evp.h)" $have_crypto
    697721
    698722# Report any errors relating to missing bison, flex, etc.
  • lib/Makefile.am

    r49969f2 r823d8e1  
    77        data-struct/deque.h data-struct/linked_list.h \
    88        data-struct/buckets.h data-struct/sliding_window.h \
    9         data-struct/message_queue.h hash_toeplitz.h
     9        data-struct/message_queue.h hash_toeplitz.h \
     10        data-struct/simple_circular_buffer.h
    1011
    1112AM_CFLAGS=@LIBCFLAGS@ @CFLAG_VISIBILITY@ -pthread
     
    5152endif
    5253
     54if HAVE_WANDDER
     55ETSISOURCES=format_etsilive.c
     56else
     57ETSISOURCES=
     58endif
     59
    5360libtrace_la_SOURCES = trace.c trace_parallel.c common.h \
    5461                format_erf.c format_pcap.c format_legacy.c \
     
    6370                protocols_application.c \
    6471                $(DAGSOURCE) format_erf.h format_ndag.c format_ndag.h \
    65                 $(BPFJITSOURCE) \
     72                $(BPFJITSOURCE) $(ETSISOURCES) \
    6673                libtrace_arphrd.h \
    6774                data-struct/ring_buffer.c data-struct/vector.c \
     
    6976                data-struct/sliding_window.c data-struct/object_cache.c \
    7077                data-struct/linked_list.c hash_toeplitz.c combiner_ordered.c \
    71                 data-struct/buckets.c \
     78                data-struct/buckets.c data-struct/simple_circular_buffer.c \
    7279                combiner_sorted.c combiner_unordered.c \
    73                 pthread_spinlock.c pthread_spinlock.h
     80                pthread_spinlock.c pthread_spinlock.h \
     81                strndup.c
    7482
    7583if DAG2_4
  • lib/format_atmhdr.c

    r2c457ec r32ee9b2  
    202202        NULL,                           /* fin_packet */
    203203        NULL,                           /* write_packet */
     204        NULL,                           /* flush_output */
    204205        atmhdr_get_link_type,           /* get_link_type */
    205206        NULL,                           /* get_direction */
  • lib/format_bpf.c

    r5e3f16c ra0f031b  
    371371                        /* TODO investigate hashing in BSD? */
    372372                        break;
    373 
     373                case TRACE_OPTION_REPLAY_SPEEDUP:
     374                        break;
    374375                /* Avoid default: so that future options will cause a warning
    375376                 * here to remind us to implement it, or flag it as
     
    616617        NULL,                   /* fin_packet */
    617618        NULL,                   /* write_packet */
     619        NULL,                   /* flush_output */
    618620        bpf_get_link_type,      /* get_link_type */
    619621        bpf_get_direction,      /* get_direction */
     
    666668        NULL,                   /* fin_packet */
    667669        NULL,                   /* write_packet */
     670        NULL,                   /* flush_output */
    668671        bpf_get_link_type,      /* get_link_type */
    669672        bpf_get_direction,      /* get_direction */
  • lib/format_dag24.c

    ree6e802 r32ee9b2  
    529529        NULL,                           /* fin_packet */
    530530        NULL,                           /* write_packet */
     531        NULL,                           /* flush_output */
    531532        erf_get_link_type,              /* get_link_type */
    532533        erf_get_direction,              /* get_direction */
  • lib/format_dag25.c

    ra857389 r32ee9b2  
    608608                return -1;
    609609        case TRACE_OPTION_EVENT_REALTIME:
     610        case TRACE_OPTION_REPLAY_SPEEDUP:
    610611                /* Live capture is always going to be realtime */
    611612                return -1;
     
    15631564        NULL,                           /* fin_packet */
    15641565        dag_write_packet,               /* write_packet */
     1566        NULL,                           /* flush_output */
    15651567        erf_get_link_type,              /* get_link_type */
    15661568        erf_get_direction,              /* get_direction */
  • lib/format_dpdk.c

    r8ed07df r3b94ef2  
    5757#include <math.h>
    5858
    59 #if HAVE_LIBNUMA
     59#ifdef HAVE_LIBNUMA
    6060#include <numa.h>
    6161#endif
     
    9090struct dpdk_format_data_t {
    9191        int8_t promisc; /* promiscuous mode - RX only */
    92         uint8_t port; /* Always 0 we only whitelist a single port - Shared TX & RX */
    93         uint8_t nb_ports; /* Total number of usable ports on system should be 1 */
    9492        uint8_t paused; /* See paused_state */
     93        portid_t port; /* Always 0 we only whitelist a single port - Shared TX & RX */
     94        portid_t nb_ports; /* Total number of usable ports on system should be 1 */
    9595        uint16_t link_speed; /* Link speed 10,100,1000,10000 etc. */
    9696        int snaplen; /* The snap length for the capture - RX only */
     
    214214        int matches;
    215215        assert(str);
     216#if RTE_VERSION >= RTE_VERSION_NUM(17, 8, 0, 1)
    216217        matches = sscanf(str, "%8"SCNx32":%2"SCNx8":%2"SCNx8".%2"SCNx8"-%ld",
    217218                         &addr->domain, &addr->bus, &addr->devid,
    218219                         &addr->function, core);
     220#else
     221        matches = sscanf(str, "%4"SCNx16":%2"SCNx8":%2"SCNx8".%2"SCNx8"-%ld",
     222                         &addr->domain, &addr->bus, &addr->devid,
     223                         &addr->function, core);
     224#endif
    219225        if (matches >= 4) {
    220226                return 0;
     
    454460        }
    455461
    456 #if HAVE_LIBNUMA
     462#ifdef HAVE_LIBNUMA
    457463        format_data->nic_numa_node = pci_to_numa(&use_addr);
    458464        if (my_cpu < 0) {
     
    696702        case TRACE_OPTION_META_FREQ:
    697703        case TRACE_OPTION_EVENT_REALTIME:
     704        case TRACE_OPTION_REPLAY_SPEEDUP:
    698705                break;
    699706        /* Avoid default: so that future options will cause a warning
     
    816823 * @param cb_arg The dpdk_format_data_t structure associated with the format
    817824 */
    818 static int dpdk_lsc_callback(uint16_t port, enum rte_eth_event_type event,
     825#if RTE_VERSION >= RTE_VERSION_NUM(17, 8, 0, 1)
     826static int dpdk_lsc_callback(portid_t port, enum rte_eth_event_type event,
    819827                              void *cb_arg, void *retparam UNUSED) {
     828#else
     829static void dpdk_lsc_callback(portid_t port, enum rte_eth_event_type event,
     830                              void *cb_arg) {
     831#endif
    820832        struct dpdk_format_data_t * format_data = cb_arg;
    821833        struct rte_eth_link link_info;
     
    852864        }
    853865#endif
     866#if RTE_VERSION >= RTE_VERSION_NUM(17, 8, 0, 1)
    854867        return 0;
     868#endif
    855869}
    856870
     
    878892         * these to any particular physical core */
    879893        if (real) {
    880 #if HAVE_LIBNUMA
     894#ifdef HAVE_LIBNUMA
    881895                for (i = 0; i < RTE_MAX_LCORE; ++i) {
    882896                        if (!rte_lcore_is_enabled(i) && numa_node_of_cpu(i) == socket) {
     
    11711185        if (ret < 0) {
    11721186                snprintf(err, errlen, "Intel DPDK - Cannot configure TX queue"
    1173                          " on port %"PRIu8" : %s", format_data->port,
     1187                         " on port %d : %s", (int)format_data->port,
    11741188                         strerror(-ret));
    11751189                return -1;
     
    12201234                if (ret < 0) {
    12211235                        snprintf(err, errlen, "Intel DPDK - Cannot configure"
    1222                                  " RX queue on port %"PRIu8" : %s",
    1223                                  format_data->port,
     1236                                 " RX queue on port %d : %s",
     1237                                 (int)format_data->port,
    12241238                                 strerror(-ret));
    12251239                        return -1;
     
    12901304}
    12911305
    1292 static inline size_t dpdk_get_max_rx_queues (uint8_t port_id) {
     1306static inline size_t dpdk_get_max_rx_queues (portid_t port_id) {
    12931307        struct rte_eth_dev_info dev_info;
    12941308        rte_eth_dev_info_get(port_id, &dev_info);
     
    15111525                memcpy(rte_pktmbuf_append(m_buff[0], caplen), packet->payload, caplen);
    15121526                do {
    1513                         ret = rte_eth_tx_burst(0 /*queue TODO*/, FORMAT(trace)->port, m_buff, 1);
     1527                        ret = rte_eth_tx_burst(FORMAT(trace)->port, 0 /*queue TODO*/, m_buff, 1);
    15141528                } while (ret != 1);
    15151529        }
     
    21462160        dpdk_fin_packet,                    /* fin_packet */
    21472161        dpdk_write_packet,                  /* write_packet */
     2162        NULL,                               /* flush_output */
    21482163        dpdk_get_link_type,                 /* get_link_type */
    21492164        dpdk_get_direction,                 /* get_direction */
  • lib/format_dpdk.h

    r8efa986 r6d17620  
    113113#define rte_mempool_in_use_count rte_mempool_free_count
    114114#endif
     115
     116/* 17.05-rc1 deprecated, 17.08 removed
     117 * rte_set_log_level -> rte_log_set_global_level
     118 */
     119#if RTE_VERSION < RTE_VERSION_NUM(17, 5, 0, 1)
     120#define rte_log_set_global_level rte_set_log_level
     121#endif
     122
     123/* 17.11-rc1 increases port size from 8 to 16bits
     124 */
     125#if RTE_VERSION >= RTE_VERSION_NUM(17, 11, 0, 1)
     126typedef uint16_t portid_t;
     127#else
     128typedef uint8_t portid_t;
     129#endif
     130
    115131
    116132#include <rte_per_lcore.h>
  • lib/format_dpdkndag.c

    re54bd5f r32ee9b2  
    733733        NULL,                   /* fin_packet */
    734734        NULL,                   /* write_packet */
     735        NULL,                   /* flush_output */
    735736        erf_get_link_type,      /* get_link_type */
    736737        erf_get_direction,      /* get_direction */
  • lib/format_duck.c

    ree6e802 r32ee9b2  
    337337        NULL,                           /* fin_packet */
    338338        duck_write_packet,              /* write_packet */
     339        NULL,                           /* flush_output */
    339340        duck_get_link_type,             /* get_link_type */
    340341        NULL,                           /* get_direction */
  • lib/format_erf.c

    r207e288 r32ee9b2  
    597597        }
    598598        return numbytes + framinglen;
     599}
     600
     601static int erf_flush_output(libtrace_out_t *libtrace) {
     602        return wandio_wflush(OUTPUT->file);
    599603}
    600604
     
    868872        NULL,                           /* fin_packet */
    869873        erf_write_packet,               /* write_packet */
     874        erf_flush_output,               /* flush_output */
    870875        erf_get_link_type,              /* get_link_type */
    871876        erf_get_direction,              /* get_direction */
     
    912917        NULL,                           /* fin_packet */
    913918        erf_write_packet,               /* write_packet */
     919        erf_flush_output,               /* flush_output */
    914920        erf_get_link_type,              /* get_link_type */
    915921        erf_get_direction,              /* get_direction */
  • lib/format_helper.c

    r633339d rde060a8  
    127127        double ts;
    128128        double now;
     129        double sincebeginnow = 0;
     130        double sincebegintrace = 0;
     131
    129132#ifdef WIN32
    130133        struct __timeb64 tstruct;
     
    182185
    183186       
    184         if (fabs(trace->event.tdelta)>1e-9) {
    185                 /* Subtract the tdelta from the walltime to get a suitable
     187        if (fabs(trace->event.first_ts)>1e-9) {
     188                /* Subtract the tdelta from the starting times to get a suitable
    186189                 * "relative" time */
    187                 now -= trace->event.tdelta;
     190                sincebeginnow = (now - trace->event.first_now);
     191                sincebegintrace = (ts - trace->event.first_ts);
    188192
    189193                /* If the trace timestamp is still in the future, return a
    190194                 * SLEEP event, otherwise return the packet */
    191                 if (ts > now) {
    192                         event.seconds = ts -
    193                                 trace->event.trace_last_ts;
    194                         trace->event.trace_last_ts = ts;
     195                if (sincebeginnow <= sincebegintrace / (double)trace->replayspeedup) {
     196                        event.seconds = ((sincebegintrace / (double)trace->replayspeedup) - sincebeginnow);
    195197                        event.type = TRACE_EVENT_SLEEP;
    196198                        trace->event.waiting = true;
     
    204206                 * trace file.
    205207                 */
    206                 trace->event.tdelta = now - ts;
     208                trace->event.first_now = (double)now;
     209                trace->event.first_ts = (double)ts;
    207210        }
    208211
     
    219222        event.type = TRACE_EVENT_PACKET;
    220223
    221         trace->event.trace_last_ts = ts;
    222224        trace->event.waiting = false;
    223225
  • lib/format_legacy.c

    r2c457ec r32ee9b2  
    523523        NULL,                           /* fin_packet */
    524524        NULL,                           /* write_packet */
     525        NULL,                           /* flush_output */
    525526        legacyatm_get_link_type,        /* get_link_type */
    526527        NULL,                           /* get_direction */
     
    567568        NULL,                           /* fin_packet */
    568569        NULL,                           /* write_packet */
     570        NULL,                           /* flush_output */
    569571        legacyeth_get_link_type,        /* get_link_type */
    570572        NULL,                           /* get_direction */
     
    611613        NULL,                           /* fin_packet */
    612614        NULL,                           /* write_packet */
     615        NULL,                           /* flush_output */
    613616        legacypos_get_link_type,        /* get_link_type */
    614617        NULL,                           /* get_direction */
     
    655658        NULL,                           /* fin_packet */
    656659        NULL,                           /* write_packet */
     660        NULL,                           /* flush_output */
    657661        legacynzix_get_link_type,       /* get_link_type */
    658662        NULL,                           /* get_direction */
  • lib/format_linux_common.c

    rd47ca18 r47d4f8c  
    4949
    5050#include "format_linux_common.h"
     51
     52unsigned int rand_seedp = 0;
    5153
    5254#ifdef HAVE_NETPACKET_PACKET_H
     
    8587                sock = socket(PF_INET, SOCK_STREAM, 0);
    8688                memset(&ifr, 0, sizeof(struct ifreq));
    87                 strncpy(ifr.ifr_name, libtrace->uridata, IF_NAMESIZE);
     89                strncpy(ifr.ifr_name, libtrace->uridata, IF_NAMESIZE - 1);
    8890                if (ioctl(sock, SIOCGIFHWADDR, &ifr) != 0) {
    8991                        perror("Can't get HWADDR for interface");
     
    164166                        /* Live captures are always going to be in trace time */
    165167                        break;
     168                case TRACE_OPTION_REPLAY_SPEEDUP:
     169                        break;
    166170                /* Avoid default: so that future options will cause a warning
    167171                 * here to remind us to implement it, or flag it as
     
    199203        /* Some examples use pid for the group however that would limit a single
    200204         * application to use only int/ring format, instead using rand */
    201         FORMAT_DATA->fanout_group = (uint16_t) rand();
     205        FORMAT_DATA->fanout_group = (uint16_t) (rand_r(&rand_seedp) % 65536);
    202206        return 0;
    203207}
  • lib/format_linux_common.h

    r4697684 rf9df20e  
    421421                                        struct linux_per_stream_t *stream)
    422422{
    423         int fanout_opt = ((int)FORMAT_DATA->fanout_flags << 16) |
    424                          (int)FORMAT_DATA->fanout_group;
    425         if (setsockopt(stream->fd, SOL_PACKET, PACKET_FANOUT,
    426                         &fanout_opt, sizeof(fanout_opt)) == -1) {
    427                 trace_set_err(libtrace, TRACE_ERR_INIT_FAILED,
     423        int fanout_opt;
     424        int attempts = 0;
     425        while (attempts < 5) {
     426                fanout_opt = ((int)FORMAT_DATA->fanout_flags << 16) |
     427                                 (int)FORMAT_DATA->fanout_group;
     428
     429                if (setsockopt(stream->fd, SOL_PACKET, PACKET_FANOUT,
     430                                &fanout_opt, sizeof(fanout_opt)) == -1) {
     431                        trace_set_err(libtrace, TRACE_ERR_INIT_FAILED,
    428432                              "Converting the fd to a socket fanout failed %s",
    429433                              libtrace->uridata);
    430                 return -1;
     434                        FORMAT_DATA->fanout_group ++;
     435                        attempts ++;
     436                        continue;
     437                }
     438                return 0;
    431439        }
    432         return 0;
     440        return -1;
    433441}
    434442#endif /* HAVE_NETPACKET_PACKET_H */
  • lib/format_linux_int.c

    rdb84bb2 r32ee9b2  
    496496        NULL,                           /* fin_packet */
    497497        linuxnative_write_packet,       /* write_packet */
     498        NULL,                           /* flush_output */
    498499        linuxnative_get_link_type,      /* get_link_type */
    499500        linuxnative_get_direction,      /* get_direction */
     
    556557        NULL,                           /* fin_packet */
    557558        NULL,                           /* write_packet */
     559        NULL,                           /* flush_output */
    558560        linuxnative_get_link_type,      /* get_link_type */
    559561        linuxnative_get_direction,      /* get_direction */
  • lib/format_linux_ring.c

    rdb84bb2 r8a63abd  
    6161        ((mac) > (hdrend) && (mac) < (net) ? (mac) : (net))
    6262
     63static pthread_mutex_t pagesize_mutex;
    6364#ifdef HAVE_NETPACKET_PACKET_H
    6465/* Get current frame in the ring buffer*/
     
    7071/* Cached page size, the page size shouldn't be changing */
    7172static int pagesize = 0;
     73
    7274
    7375/*
     
    8890        struct ifreq ifr;
    8991        unsigned max_frame = LIBTRACE_PACKET_BUFSIZE;
    90         pagesize = getpagesize();
     92        pthread_mutex_lock(&pagesize_mutex);
     93        if (pagesize == 0) {
     94                pagesize = getpagesize();
     95        }
     96        pthread_mutex_unlock(&pagesize_mutex);
    9197
    9298        strcpy(ifr.ifr_name, uri);
     
    461467        struct pollfd pollset[2];
    462468
    463         ring_release_frame(libtrace, packet);
    464        
    465469        packet->buf_control = TRACE_CTRL_EXTERNAL;
    466470        packet->type = TRACE_RT_DATA_LINUX_RING;
     
    547551
    548552        stream->last_timestamp = packet->order;
    549                
    550553
    551554        /* We just need to get prepare_packet to set all our packet pointers
     
    745748        linuxring_fin_packet,           /* fin_packet */
    746749        linuxring_write_packet,         /* write_packet */
     750        NULL,                           /* flush_output */
    747751        linuxring_get_link_type,        /* get_link_type */
    748752        linuxring_get_direction,        /* get_direction */
     
    807811        NULL,                           /* fin_packet */
    808812        NULL,                           /* write_packet */
     813        NULL,                           /* flush_output */
    809814        linuxring_get_link_type,        /* get_link_type */
    810815        linuxring_get_direction,        /* get_direction */
     
    837842void linuxring_constructor(void)
    838843{
     844        pthread_mutex_init(&pagesize_mutex, NULL);
    839845        register_format(&linuxring);
    840846}
  • lib/format_ndag.c

    r3004d6c r32ee9b2  
    114114        uint64_t received_packets;
    115115
    116         fd_set allsocks;
    117116        int maxfd;
    118117} recvstream_t;
     
    488487                FORMAT_DATA->receivers[i].received_packets = 0;
    489488                FORMAT_DATA->receivers[i].missing_records = 0;
    490                 FD_ZERO(&(FORMAT_DATA->receivers[i].allsocks));
    491489                FORMAT_DATA->receivers[i].maxfd = -1;
    492490
     
    771769        ssock->recordcount = 0;
    772770        rt->sourcecount += 1;
    773         FD_SET(ssock->sock, &(rt->allsocks));
    774771        if (ssock->sock > rt->maxfd) {
    775772                rt->maxfd = ssock->sock;
     
    881878                fprintf(stderr, "Received invalid record on the channel for %s:%u.\n",
    882879                                ssock->groupaddr, ssock->port);
    883                 FD_CLR(ssock->sock, &(rt->allsocks));
    884880                close(ssock->sock);
    885881                ssock->sock = -1;
     
    943939#if HAVE_RECVMMSG
    944940        int i;
    945 #endif
    946 
    947         if (ssock->sock == -1) {
    948                 return 0;
    949         }
    950 
    951 #if HAVE_RECVMMSG
    952         /* Plenty of full buffers, just use the packets in those */
    953         if (ssock->bufavail < RECV_BATCH_SIZE / 2) {
    954                 return 1;
    955         }
    956 #else
    957         if (ssock->bufavail == 0) {
    958                 return 1;
    959         }
    960941#endif
    961942
     
    987968                                        ssock->port);
    988969
    989                                 FD_CLR(ssock->sock, &(rt->allsocks));
    990970                                close(ssock->sock);
    991971                                ssock->sock = -1;
     
    997977                                ssock->groupaddr, ssock->port,
    998978                                strerror(errno));
    999                         FD_CLR(ssock->sock, &(rt->allsocks));
    1000979                        close(ssock->sock);
    1001980                        ssock->sock = -1;
     
    10351014        struct timeval tv;
    10361015        fd_set fds;
     1016        int maxfd = 0;
    10371017        struct timeval zerotv;
    10381018
     
    10401020        gottime = 0;
    10411021
    1042         fds = rt->allsocks;
     1022        FD_ZERO(&fds);
    10431023
    10441024        if (rt->maxfd == -1) {
     
    10491029        zerotv.tv_usec = 0;
    10501030
    1051         if (select(rt->maxfd + 1, &fds, NULL, NULL, &zerotv) == -1) {
     1031        for (i = 0; i < rt->sourcecount; i++) {
     1032                if (rt->sources[i].sock == -1) {
     1033                        continue;
     1034                }
     1035
     1036#if HAVE_RECVMMSG
     1037                /* Plenty of full buffers, just use the packets in those */
     1038                if (rt->sources[i].bufavail < RECV_BATCH_SIZE / 2) {
     1039                        readybufs ++;
     1040                        continue;
     1041                }
     1042#else
     1043                if (rt->sources[i].bufavail == 0) {
     1044                        readybufs ++;
     1045                        continue;
     1046                }
     1047#endif
     1048                FD_SET(rt->sources[i].sock, &fds);
     1049                if (maxfd < rt->sources[i].sock) {
     1050                        maxfd = rt->sources[i].sock;
     1051                }
     1052        }
     1053
     1054
     1055        if (maxfd <= 0) {
     1056                return readybufs;
     1057        }
     1058
     1059        if (select(maxfd + 1, &fds, NULL, NULL, &zerotv) == -1) {
    10521060                /* log the error? XXX */
    10531061                return -1;
     
    10561064        for (i = 0; i < rt->sourcecount; i++) {
    10571065                if (!FD_ISSET(rt->sources[i].sock, &fds)) {
     1066                        if (rt->sources[i].bufavail < ENCAP_BUFFERS) {
     1067                                readybufs ++;
     1068                        }
    10581069                        continue;
    10591070                }
     
    14231434        NULL,                   /* fin_packet */
    14241435        NULL,                   /* write_packet */
     1436        NULL,                   /* flush_output */
    14251437        erf_get_link_type,      /* get_link_type */
    14261438        erf_get_direction,      /* get_direction */
  • lib/format_pcap.c

    r5a70a80 r32ee9b2  
    583583}
    584584
     585static int pcap_flush_output(libtrace_out_t *libtrace) {
     586        return pcap_dump_flush(OUTPUT.trace.dump);
     587}
     588
    585589static int pcapint_write_packet(libtrace_out_t *libtrace,
    586590                libtrace_packet_t *packet)
     
    779783        NULL,                           /* fin_packet */
    780784        pcap_write_packet,              /* write_packet */
     785        pcap_flush_output,              /* flush_output */
    781786        pcap_get_link_type,             /* get_link_type */
    782787        pcapint_get_direction,          /* get_direction */
     
    823828        NULL,                           /* fin_packet */
    824829        pcapint_write_packet,           /* write_packet */
     830        NULL,                           /* flush_output */
    825831        pcap_get_link_type,             /* get_link_type */
    826832        pcapint_get_direction,          /* get_direction */
  • lib/format_pcapfile.c

    r5a70a80 r32ee9b2  
    257257                case TRACE_OPTION_FILTER:
    258258                case TRACE_OPTION_HASHER:
     259                case TRACE_OPTION_REPLAY_SPEEDUP:
    259260                        /* All these are either unsupported or handled
    260261                         * by trace_config */
     
    531532
    532533        return numbytes+ret;
     534}
     535
     536static int pcapfile_flush_output(libtrace_out_t *out) {
     537
     538        return wandio_wflush(DATAOUT(out)->file);
    533539}
    534540
     
    695701        NULL,                           /* fin_packet */
    696702        pcapfile_write_packet,          /* write_packet */
     703        pcapfile_flush_output,          /* flush_output */
    697704        pcapfile_get_link_type,         /* get_link_type */
    698705        pcapfile_get_direction,         /* get_direction */
  • lib/format_pcapng.c

    r2c457ec re9da777  
    173173};
    174174
     175typedef struct pcapng_peeker pcapng_hdr_t;
     176
    175177
    176178#define DATA(x) ((struct pcapng_format_data_t *)((x)->format_data))
     
    260262                case TRACE_OPTION_FILTER:
    261263                case TRACE_OPTION_HASHER:
     264                case TRACE_OPTION_REPLAY_SPEEDUP:
    262265                        break;
    263266        }
     
    286289
    287290static char *pcapng_parse_next_option(libtrace_t *libtrace, char **pktbuf,
    288                 uint16_t *code, uint16_t *length) {
     291                uint16_t *code, uint16_t *length, pcapng_hdr_t *blockhdr) {
    289292
    290293        struct pcapng_optheader *opthdr = (struct pcapng_optheader *)*pktbuf;
    291294        int to_skip;
    292295        int padding = 0;
     296        char *eob; //end of block
    293297        char *optval;
     298        if (DATA(libtrace)->byteswapped) {
     299                eob = ((char *) blockhdr) + byteswap32(blockhdr->blocklen);
     300        } else {
     301                eob = ((char *) blockhdr) + blockhdr->blocklen;
     302        }
     303
     304        assert((char *)blockhdr < *pktbuf);
     305        // Check if we have reached the end of the block, +4 for trailing block-size
     306        // We cannot assume a endofopt, so we add one
     307        if (eob == (*pktbuf) + 4) {
     308                *code = 0;
     309                *length = 0;
     310                return *pktbuf;
     311        }
     312        // If there is not enough space for another header we've encountered an error
     313        if (eob < (*pktbuf) + 4 + sizeof(struct pcapng_optheader)) {
     314                return NULL;
     315        }
    294316
    295317        if (DATA(libtrace)->byteswapped) {
     
    310332
    311333        to_skip = (*length) + padding;
     334        // Check the value we return is within the block length
     335        if (eob < optval + to_skip + 4) {
     336                return NULL;
     337        }
    312338        *pktbuf = optval + to_skip;
    313339
    314340        return optval;
    315 }
    316 
    317 static inline int skip_block(libtrace_t *libtrace, uint32_t toread) {
    318         int err;
    319 
    320         while (toread > 0) {
    321                 char buf[4096];
    322                 int nextread;
    323 
    324                 if (toread < 4096) {
    325                         nextread = toread;
    326                 } else {
    327                         nextread = 4096;
    328                 }
    329 
    330                 err = wandio_read(libtrace->io, buf, nextread);
    331                 if (err < 0) {
    332                         trace_set_err(libtrace, TRACE_ERR_WANDIO_FAILED,
    333                                 "Reading section header options");
    334                         return -1;
    335                 }
    336                 if (err == 0) {
    337                         return 0;
    338                 }
    339                 toread -= err;
    340         }
    341 
    342         return 1;
    343 
    344341}
    345342
     
    352349        if (err < 0) {
    353350                trace_set_err(libtrace, TRACE_ERR_WANDIO_FAILED,
    354                         "Failed to read pcapng interface options");
     351                        "Failed reading pcapng block");
    355352                return err;
    356353        }
     
    362359        if (err < (int)to_read) {
    363360                trace_set_err(libtrace, TRACE_ERR_BAD_PACKET,
    364                         "Incomplete pcapng interface header block");
     361                        "Incomplete pcapng block");
    365362                return -1;
    366363        }
     
    453450        }
    454451
    455         if (err < (int)(sizeof(sechdr))) {
     452        if (err < (int)(sizeof(pcapng_sec_t))) {
    456453                trace_set_err(libtrace, TRACE_ERR_BAD_PACKET,
    457454                        "Incomplete pcapng section header block");
     
    490487        /* Read all of the options etc. -- we don't need them for now, but
    491488         * we have to skip forward to the next useful header. */
    492         bodyptr = packet->buffer + sizeof(pcapng_sec_t);
     489        bodyptr = (char *) packet->buffer + sizeof(pcapng_sec_t);
    493490        err = pcapng_read_body(libtrace, bodyptr, to_read);
    494491        if (err <= 0) {
     
    506503
    507504static int pcapng_read_interface(libtrace_t *libtrace,
    508                 libtrace_packet_t *packet, uint32_t flags) {
     505                libtrace_packet_t *packet, uint32_t blocklen, uint32_t flags) {
    509506
    510507        pcapng_int_t *inthdr;
    511         int err;
    512         uint32_t to_read;
    513508        pcapng_interface_t *newint;
    514509        uint16_t optcode, optlen;
     
    516511        char *bodyptr = NULL;
    517512
    518         err = wandio_read(libtrace->io, packet->buffer, sizeof(pcapng_int_t));
    519 
    520         if (err < 0) {
    521                 trace_set_err(libtrace, TRACE_ERR_WANDIO_FAILED,
    522                         "Reading pcapng interface header block");
    523                 return -1;
    524         }
    525 
    526         if (err == 0) {
    527                 return 0;
    528         }
    529 
    530         if (err < (int)sizeof(inthdr)) {
     513        if (blocklen < sizeof(pcapng_int_t) + 4) {
    531514                trace_set_err(libtrace, TRACE_ERR_BAD_PACKET,
    532515                        "Incomplete pcapng interface header block");
     
    551534                newint->snaplen = byteswap32(inthdr->snaplen);
    552535                newint->linktype = byteswap16(inthdr->linktype);
    553                 to_read = byteswap32(inthdr->blocklen) - sizeof(pcapng_int_t);
    554536        } else {
    555537                assert(inthdr->blocktype == PCAPNG_INTERFACE_TYPE);
    556538                newint->snaplen = inthdr->snaplen;
    557539                newint->linktype = inthdr->linktype;
    558                 to_read = inthdr->blocklen - sizeof(pcapng_int_t);
    559540        }
    560541
     
    565546                        DATA(libtrace)->allocatedinterfaces * sizeof(
    566547                                pcapng_interface_t *));
    567 
    568                 /* Could memset the new memory to zero, if required */
     548                memset(&DATA(libtrace)->interfaces[DATA(libtrace)->nextintid], 0, sizeof(void *) * 10);
    569549        }
    570550
     
    572552        DATA(libtrace)->nextintid += 1;
    573553
    574         bodyptr = packet->buffer + sizeof(pcapng_int_t);
    575         err = pcapng_read_body(libtrace, bodyptr, to_read);
    576         if (err <= 0) {
    577                 return err;
    578         }
     554        bodyptr = (char *) packet->buffer + sizeof(pcapng_int_t);
    579555
    580556        packet->type = TRACE_RT_PCAPNG_META;
     
    587563        do {
    588564                optval = pcapng_parse_next_option(libtrace, &bodyptr,
    589                                 &optcode, &optlen);
     565                                &optcode, &optlen, (pcapng_hdr_t *) packet->buffer);
    590566                if (optval == NULL) {
    591567                        trace_set_err(libtrace, TRACE_ERR_BAD_PACKET,
     
    607583        } while (optcode != 0);
    608584
    609         return 1;
     585        return (int) blocklen;
    610586
    611587}
    612588
    613589static int pcapng_read_nrb(libtrace_t *libtrace, libtrace_packet_t *packet,
    614                 uint32_t flags) {
     590                uint32_t blocklen, uint32_t flags) {
    615591
    616592        /* Just read the NR records and pass them off to the caller. If
     
    619595         */
    620596        pcapng_nrb_t *hdr = NULL;
    621         int err;
    622         uint32_t to_read;
    623         char *bodyptr;
    624 
    625         err = wandio_read(libtrace->io, packet->buffer, sizeof(pcapng_nrb_t));
    626 
    627         if (err < 0) {
    628                 trace_set_err(libtrace, TRACE_ERR_WANDIO_FAILED, "reading pcapng name resolution block");
    629                 return -1;
    630         }
    631 
    632         if (err == 0) {
    633                 return 0;
    634         }
    635 
    636         if (err < (int)sizeof(pcapng_nrb_t)) {
     597
     598        if (blocklen < sizeof(pcapng_nrb_t) + 4) {
    637599                trace_set_err(libtrace, TRACE_ERR_BAD_PACKET,
    638600                                "Incomplete pcapng name resolution block");
     
    645607        if (DATA(libtrace)->byteswapped) {
    646608                assert(byteswap32(hdr->blocktype) == PCAPNG_NAME_RESOLUTION_TYPE);
    647                 to_read = byteswap32(hdr->blocklen) - sizeof(pcapng_nrb_t);
    648609        } else {
    649610                assert(hdr->blocktype == PCAPNG_NAME_RESOLUTION_TYPE);
    650                 to_read = hdr->blocklen - sizeof(pcapng_nrb_t);
    651         }
    652 
    653         bodyptr = packet->buffer + sizeof(pcapng_nrb_t);
    654         err = pcapng_read_body(libtrace, bodyptr, to_read);
    655         if (err <= 0) {
    656                 return err;
    657611        }
    658612
     
    663617        }
    664618
    665         return sizeof(pcapng_nrb_t) + to_read;
     619        return (int) blocklen;
    666620
    667621}
    668622
    669623static int pcapng_read_custom(libtrace_t *libtrace, libtrace_packet_t *packet,
    670                 uint32_t flags) {
     624                uint32_t blocklen, uint32_t flags) {
    671625
    672626        /* Just read the custom records and pass them off to the caller. If
     
    675629         */
    676630        pcapng_custom_t *hdr = NULL;
    677         int err;
    678         uint32_t to_read;
    679         char *bodyptr;
    680 
    681         err = wandio_read(libtrace->io, packet->buffer, sizeof(pcapng_custom_t));
    682 
    683         if (err < 0) {
    684                 trace_set_err(libtrace, TRACE_ERR_WANDIO_FAILED, "reading pcapng custom block");
    685                 return -1;
    686         }
    687 
    688         if (err == 0) {
    689                 return 0;
    690         }
    691 
    692         if (err < (int)sizeof(pcapng_custom_t)) {
     631
     632        if (blocklen < sizeof(pcapng_custom_t) + 4) {
    693633                trace_set_err(libtrace, TRACE_ERR_BAD_PACKET,
    694634                                "Incomplete pcapng custom block");
     
    702642                assert(byteswap32(hdr->blocktype) == PCAPNG_CUSTOM_TYPE ||
    703643                        byteswap32(hdr->blocktype) == PCAPNG_CUSTOM_NONCOPY_TYPE);
    704                 to_read = byteswap32(hdr->blocklen) - sizeof(pcapng_custom_t);
    705         } else {
    706                 assert(hdr->blocktype == PCAPNG_NAME_RESOLUTION_TYPE ||
     644        } else {
     645                assert(hdr->blocktype == PCAPNG_CUSTOM_TYPE ||
    707646                        hdr->blocktype == PCAPNG_CUSTOM_NONCOPY_TYPE);
    708                 to_read = hdr->blocklen - sizeof(pcapng_custom_t);
    709         }
    710 
    711         bodyptr = packet->buffer + sizeof(pcapng_custom_t);
    712         err = pcapng_read_body(libtrace, bodyptr, to_read);
    713         if (err <= 0) {
    714                 return err;
    715647        }
    716648
     
    721653        }
    722654
    723         return sizeof(pcapng_custom_t) + to_read;
     655        return (int) blocklen;
    724656
    725657}
    726658
    727659static int pcapng_read_stats(libtrace_t *libtrace, libtrace_packet_t *packet,
    728                 uint32_t flags) {
     660                uint32_t blocklen, uint32_t flags) {
    729661        pcapng_stats_t *hdr = NULL;
    730         int err;
    731         uint32_t to_read;
    732662        uint32_t ifaceid;
    733663        uint64_t timestamp;
     
    737667        char *bodyptr;
    738668
    739         err = wandio_read(libtrace->io, packet->buffer, sizeof(pcapng_stats_t));
    740 
    741         if (err < 0) {
    742                 trace_set_err(libtrace, TRACE_ERR_WANDIO_FAILED, "reading pcapng interface stats");
    743                 return -1;
    744         }
    745 
    746         if (err == 0) {
    747                 return 0;
    748         }
    749 
    750         if (err < (int)sizeof(pcapng_stats_t)) {
     669        if (blocklen < sizeof(pcapng_stats_t) + 4) {
    751670                trace_set_err(libtrace, TRACE_ERR_BAD_PACKET,
    752671                                "Incomplete pcapng interface stats header");
     
    759678        if (DATA(libtrace)->byteswapped) {
    760679                assert(byteswap32(hdr->blocktype) == PCAPNG_INTERFACE_STATS_TYPE);
    761                 to_read = byteswap32(hdr->blocklen) - sizeof(pcapng_stats_t);
    762680                ifaceid = byteswap32(hdr->interfaceid);
    763681                timestamp = ((uint64_t)(byteswap32(hdr->timestamp_high)) << 32) + byteswap32(hdr->timestamp_low);
    764682        } else {
    765683                assert(hdr->blocktype == PCAPNG_INTERFACE_STATS_TYPE);
    766                 to_read = hdr->blocklen - sizeof(pcapng_stats_t);
    767684                ifaceid = hdr->interfaceid;
    768685                timestamp = ((uint64_t)(hdr->timestamp_high) << 32) +
    769686                                hdr->timestamp_low;
    770         }
    771 
    772         bodyptr = packet->buffer + sizeof(pcapng_stats_t);
    773         err = pcapng_read_body(libtrace, bodyptr, to_read);
    774         if (err <= 0) {
    775                 return err;
    776687        }
    777688
     
    790701
    791702        if (timestamp < interface->laststats) {
    792                 return sizeof(pcapng_stats_t) + to_read;
     703                return (int) blocklen;
    793704        }
    794705
     
    798709        do {
    799710                optval = pcapng_parse_next_option(packet->trace, &bodyptr,
    800                                 &optcode, &optlen);
     711                                &optcode, &optlen, (pcapng_hdr_t *) packet->buffer);
    801712                if (optval == NULL) {
    802713                        trace_set_err(libtrace, TRACE_ERR_BAD_PACKET,
    803                                 "Failed to read options for pcapng enhanced packet");
     714                                "Failed to read options for pcapng interface stats");
    804715                        return -1;
    805716                }
     
    844755        interface->laststats = timestamp;
    845756
    846         return sizeof(pcapng_stats_t) + to_read;
     757        return (int) blocklen;
    847758
    848759}
    849760
    850761static int pcapng_read_simple(libtrace_t *libtrace, libtrace_packet_t *packet,
    851                 uint32_t flags) {
    852 
    853         int err;
    854         uint32_t to_read;
     762                uint32_t blocklen, uint32_t flags) {
     763
    855764        uint32_t caplen;
    856765        pcapng_spkt_t *hdr = NULL;
    857766        pcapng_interface_t *interface;
    858         char *bodyptr;
    859 
    860         err = wandio_read(libtrace->io, packet->buffer, sizeof(pcapng_spkt_t));
    861 
    862         if (err < 0) {
    863                 trace_set_err(libtrace, TRACE_ERR_WANDIO_FAILED, "reading pcapng simple packet");
    864                 return -1;
    865         }
    866 
    867         if (err == 0) {
    868                 return 0;
    869         }
    870 
    871         if (err < (int)sizeof(pcapng_spkt_t)) {
     767
     768        if (blocklen < sizeof(pcapng_spkt_t) + 4) {
    872769                trace_set_err(libtrace, TRACE_ERR_BAD_PACKET,
    873770                                "Incomplete pcapng simple packet header");
     
    880777        if (DATA(libtrace)->byteswapped) {
    881778                assert(byteswap32(hdr->blocktype) == PCAPNG_SIMPLE_PACKET_TYPE);
    882                 to_read = byteswap32(hdr->blocklen) - sizeof(pcapng_spkt_t);
    883                 caplen = to_read - 4;   /* account for trailing length field */
     779                caplen = byteswap32(hdr->blocklen) - sizeof(pcapng_spkt_t) - 4;
     780                         /* account for trailing length field */
    884781        } else {
    885782                assert(hdr->blocktype == PCAPNG_SIMPLE_PACKET_TYPE);
    886                 to_read = hdr->blocklen - sizeof(pcapng_spkt_t);
    887                 caplen = to_read - 4; /* account for trailing length field */
    888         }
    889 
    890         bodyptr = packet->buffer + sizeof(pcapng_spkt_t);
    891         err = pcapng_read_body(libtrace, bodyptr, to_read);
    892         if (err <= 0) {
    893                 return err;
     783                caplen = hdr->blocklen - sizeof(pcapng_spkt_t) - 4;
     784                         /* account for trailing length field */
    894785        }
    895786
     
    911802                return -1;
    912803        }
    913         return sizeof(pcapng_spkt_t) + to_read;
     804        return (int) blocklen;
    914805
    915806}
    916807
    917808static int pcapng_read_enhanced(libtrace_t *libtrace, libtrace_packet_t *packet,
    918                 uint32_t flags) {
     809                uint32_t blocklen, uint32_t flags) {
    919810        pcapng_epkt_t *hdr = NULL;
    920         int err;
    921         uint32_t to_read;
    922811        uint32_t caplen;
    923812        uint32_t ifaceid;
     
    927816        char *bodyptr;
    928817
    929         err = wandio_read(libtrace->io, packet->buffer, sizeof(pcapng_epkt_t));
    930 
    931         if (err < 0) {
    932                 trace_set_err(libtrace, TRACE_ERR_WANDIO_FAILED, "reading pcapng enhanced packet");
    933                 return -1;
    934         }
    935 
    936         if (err == 0) {
    937                 return 0;
    938         }
    939 
    940         if (err < (int)sizeof(pcapng_epkt_t)) {
     818        if (blocklen < (int)sizeof(pcapng_epkt_t) + 4) {
    941819                trace_set_err(libtrace, TRACE_ERR_BAD_PACKET,
    942820                                "Incomplete pcapng enhanced packet header");
     
    950828                assert(byteswap32(hdr->blocktype) == PCAPNG_ENHANCED_PACKET_TYPE);
    951829                caplen = byteswap32(hdr->caplen);
    952                 to_read = byteswap32(hdr->blocklen) - sizeof(pcapng_epkt_t);
    953830                ifaceid = byteswap32(hdr->interfaceid);
    954831        } else {
    955832                assert(hdr->blocktype == PCAPNG_ENHANCED_PACKET_TYPE);
    956833                caplen = hdr->caplen;
    957                 to_read = hdr->blocklen - sizeof(pcapng_epkt_t);
    958834                ifaceid = hdr->interfaceid;
    959835        }
    960836
    961         bodyptr = packet->buffer + sizeof(pcapng_epkt_t);
    962         err = pcapng_read_body(libtrace, bodyptr, to_read);
    963         if (err <= 0) {
    964                 return err;
    965         }
     837        bodyptr = (char *) packet->buffer + sizeof(pcapng_epkt_t);
    966838
    967839        /* Set packet type based on interface linktype */
     
    984856        /* Make sure to parse any useful options */
    985857        if ((caplen % 4) == 0) {
    986                 bodyptr = packet->payload + caplen;
    987         } else {
    988                 bodyptr = packet->payload + caplen + (4 - (caplen % 4));
     858                bodyptr = (char *) packet->payload + caplen;
     859        } else {
     860                bodyptr = (char *) packet->payload + caplen + (4 - (caplen % 4));
     861        }
     862        // Check the packet caplen actually fits within the block we read
     863        if ((char *) packet->buffer + blocklen < bodyptr + 4) {
     864                trace_set_err(libtrace, TRACE_ERR_BAD_PACKET,
     865                                "Incomplete pcapng enhanced packet header");
     866                return -1;
    989867        }
    990868
    991869        do {
    992870                optval = pcapng_parse_next_option(packet->trace, &bodyptr,
    993                                 &optcode, &optlen);
     871                                &optcode, &optlen, (pcapng_hdr_t *) packet->buffer);
    994872                if (optval == NULL) {
    995873                        trace_set_err(libtrace, TRACE_ERR_BAD_PACKET,
     
    1008886
    1009887        } while (optcode != 0);
    1010         return sizeof(pcapng_epkt_t) + to_read;
     888        return (int) blocklen;
    1011889
    1012890}
     
    1052930                }
    1053931
     932                // Warning: the byteorder might not be set yet, the section header sets this
    1054933                if (DATA(libtrace)->byteswapped) {
    1055934                        btype = byteswap32(peeker.blocktype);
     935                        to_read = byteswap32(peeker.blocklen);
    1056936                } else {
    1057937                        btype = peeker.blocktype;
     938                        to_read = peeker.blocklen;
     939                }
     940
     941                // Check we won't read off the end of the packet buffer. Assuming corruption.
     942                // Exclude the SECTION header, as this is used to identify the byteorder
     943                if (to_read > LIBTRACE_PACKET_BUFSIZE && btype != PCAPNG_SECTION_TYPE) {
     944                        trace_set_err(libtrace, TRACE_ERR_BAD_PACKET,
     945                                      "Oversized pcapng block found, is the trace corrupted?");
     946                        return -1;
     947                }
     948                if (btype != PCAPNG_SECTION_TYPE) {
     949                        // Read the entire block, unless it is a section as our byte ordering has
     950                        // not been set yet.
     951                        err = pcapng_read_body(libtrace, packet->buffer, to_read);
     952                        if (err <= 0) {
     953                                return err;
     954                        }
     955                        if (*((uint32_t *)((char *)packet->buffer+to_read-4)) != peeker.blocklen) {
     956                                trace_set_err(libtrace, TRACE_ERR_BAD_PACKET,
     957                                              "Mismatched pcapng block sizes found, trace is invalid.");
     958                                return -1;
     959                        }
    1058960                }
    1059961
     
    1067969                        /* Interface Header */
    1068970                        case PCAPNG_INTERFACE_TYPE:
    1069                                 err = pcapng_read_interface(libtrace, packet, flags);
     971                                err = pcapng_read_interface(libtrace, packet, to_read, flags);
    1070972                                gotpacket = 1;
    1071973                                break;
     
    1074976                        case PCAPNG_ENHANCED_PACKET_TYPE:
    1075977                                err = pcapng_read_enhanced(libtrace, packet,
    1076                                                 flags);
     978                                                to_read, flags);
    1077979                                gotpacket = 1;
    1078980                                break;
    1079981
    1080982                        case PCAPNG_SIMPLE_PACKET_TYPE:
    1081                                 err = pcapng_read_simple(libtrace, packet, flags);
     983                                err = pcapng_read_simple(libtrace, packet, to_read, flags);
    1082984                                gotpacket = 1;
    1083985                                break;
    1084986
    1085987                        case PCAPNG_INTERFACE_STATS_TYPE:
    1086                                 err = pcapng_read_stats(libtrace, packet, flags);
     988                                err = pcapng_read_stats(libtrace, packet, to_read, flags);
    1087989                                gotpacket = 1;
    1088990                                break;
    1089991
    1090992                        case PCAPNG_NAME_RESOLUTION_TYPE:
    1091                                 err = pcapng_read_nrb(libtrace, packet, flags);
     993                                err = pcapng_read_nrb(libtrace, packet, to_read, flags);
    1092994                                gotpacket = 1;
    1093995                                break;
     
    1095997                        case PCAPNG_CUSTOM_TYPE:
    1096998                        case PCAPNG_CUSTOM_NONCOPY_TYPE:
    1097                                 err = pcapng_read_custom(libtrace, packet, flags);
     999                                err = pcapng_read_custom(libtrace, packet, to_read, flags);
    10981000                                gotpacket = 1;
    10991001                                break;
     
    11051007                        /* Everything else -- don't care, skip it */
    11061008                        default:
    1107                                 if (DATA(libtrace)->byteswapped) {
    1108                                         to_read = byteswap32(peeker.blocklen);
    1109                                 } else {
    1110                                         to_read = peeker.blocklen;
    1111                                 }
    1112                                 err = skip_block(libtrace, to_read);
    11131009                                break;
    11141010                }
     
    11941090
    11951091        ts.tv_sec = (timestamp / interface->tsresol);
    1196         ts.tv_nsec = (uint64_t)(timestamp - (ts.tv_sec * interface->tsresol)) / interface->tsresol * 1000000000;
     1092        ts.tv_nsec = (uint64_t)(timestamp - (ts.tv_sec * interface->tsresol))
     1093                        / ((double)interface->tsresol) * 1000000000;
    11971094
    11981095        return ts;
     
    14681365        NULL,                           /* fin_packet */
    14691366        NULL,                           /* write_packet */
     1367        NULL,                           /* flush_output */
    14701368        pcapng_get_link_type,           /* get_link_type */
    14711369        pcapng_get_direction,           /* get_direction */
  • lib/format_rt.c

    ree6e802 r32ee9b2  
    845845        NULL,                           /* fin_packet */
    846846        NULL,                           /* write_packet */
     847        NULL,                           /* flush_output */
    847848        rt_get_link_type,               /* get_link_type */
    848849        NULL,                           /* get_direction */
  • lib/format_tsh.c

    r2c457ec r32ee9b2  
    245245        NULL,                           /* fin_packet */
    246246        NULL,                           /* write_packet */
     247        NULL,                           /* flush_output */
    247248        tsh_get_link_type,              /* get_link_type */
    248249        tsh_get_direction,              /* get_direction */
     
    294295        NULL,                           /* fin_packet */
    295296        NULL,                           /* write_packet */
     297        NULL,                           /* flush_output */
    296298        tsh_get_link_type,              /* get_link_type */
    297299        tsh_get_direction,              /* get_direction */
  • lib/libtrace.h.in

    r29cafc0 r47d4f8c  
    277277typedef struct trace_err_t{
    278278        int err_num;            /**< error code */
    279         char problem[255];      /**< the format, uri etc that caused the error for reporting purposes */
     279        char problem[1024];     /**< the format, uri etc that caused the error for reporting purposes */
    280280} libtrace_err_t;
    281281
     
    370370       TRACE_TYPE_NONDATA = 19,         /**< Not a data packet */
    371371       TRACE_TYPE_OPENBSD_LOOP = 20,    /**< OpenBSD loopback */
    372        TRACE_TYPE_ERF_META = 21 /**< ERF Provenance metadata record */
     372       TRACE_TYPE_ERF_META = 21, /**< ERF Provenance metadata record */
     373       TRACE_TYPE_ETSILI = 22   /**< ETSI Lawful Intercept */
    373374} libtrace_linktype_t;
    374375
     
    398399        TRACE_FORMAT_NDAG       =19,    /**< DAG multicast over a network */
    399400        TRACE_FORMAT_DPDK_NDAG       =20,    /**< DAG multicast over a network, received via DPDK */
     401        TRACE_FORMAT_ETSILIVE     =21,  /**< ETSI LI over a network */
    400402};
    401403
     
    453455        TRACE_RT_DATA_DPDK=TRACE_RT_DATA_SIMPLE+TRACE_FORMAT_DPDK,
    454456
     457        TRACE_RT_DATA_ETSILI = TRACE_RT_DATA_SIMPLE + TRACE_FORMAT_ETSILIVE,
     458
    455459        /** As PCAP does not store the linktype with the packet, we need to
    456460         * create a separate RT type for each supported DLT, starting from
     
    560564        uint64_t internalid;            /** Internal identifier for the pkt */
    561565        void *srcbucket;
     566
     567        pthread_mutex_t ref_lock;       /**< Lock for reference counter */
     568        int refcount;                 /**< Reference counter */
     569
    562570} libtrace_packet_t;
    563571
     
    13121320        /** The hasher function for a parallel libtrace. It is recommended to
    13131321         * access this option via trace_set_hasher(). */
    1314         TRACE_OPTION_HASHER
     1322        TRACE_OPTION_HASHER,
     1323
     1324        /** Speed up trace file replays (via trace_event()) by this factor */
     1325        TRACE_OPTION_REPLAY_SPEEDUP,
    13151326} trace_option_t;
    13161327
     
    15261537DLLEXPORT void trace_destroy_output(libtrace_out_t *trace);
    15271538
     1539/** Flush an output trace, forcing any buffered packets to be written
     1540 * @param libtrace      The output trace to be flushed
     1541 */
     1542DLLEXPORT int trace_flush_output(libtrace_out_t *libtrace);
     1543
    15281544/** Check (and clear) the current error state of an input trace
    15291545 * @param trace         The input trace to check the error state on
     
    17741790 */
    17751791DLLEXPORT void trace_destroy_packet(libtrace_packet_t *packet);
    1776 
    17771792
    17781793/** Read the next packet from an input trace
  • lib/libtrace_int.h

    re375e0f r823d8e1  
    9999#endif
    100100
    101 #ifndef HAVE_STRNDUP
     101#if !HAVE_DECL_STRNDUP
    102102char *strndup(const char *s, size_t size);
    103103#endif
    104104
    105 #ifndef HAVE_STRNCASECMP
     105#if !HAVE_DECL_STRNCASECMP
    106106# ifndef HAVE__STRNICMP
    107107/** A local implementation of strncasecmp (as some systems do not have it) */
     
    112112#endif
    113113
    114 #ifndef HAVE_SNPRINTF
     114#if !HAVE_DECL_SNPRINTF
    115115# ifndef HAVE_SPRINTF_S
    116116/** A local implementation of snprintf (as some systems do not have it) */
     
    152152//#define RP_BUFSIZE 65536U
    153153
     154#define LIBTRACE_MAX_REPLAY_SPEEDUP 1000
     155
    154156/** Data about the most recent event from a trace file */
    155157struct libtrace_event_status_t {
    156158        /** A libtrace packet to store the packet when a PACKET event occurs */
    157159        libtrace_packet_t *packet;
    158         /** Time between the timestamp for the current packet and the current
    159          * walltime */
    160         double tdelta;
    161         /** The timestamp of the previous PACKET event */
    162         double trace_last_ts;
     160
     161        /* The walltime when we processed the first packet from the trace */
     162        double first_now;
     163
     164        /* The tracetime of the first packet in the trace */
     165        double first_ts;
     166
    163167        /** The size of the current PACKET event */
    164168        int psize;
     
    313317         * used only if the capture format does not support snapping natively */
    314318        size_t snaplen;                 
     319        /** Speed up the packet rate when using trace_event() to process trace
     320         * files by this factor. */
     321        int replayspeedup;
    315322        /** Count of the number of packets returned to the libtrace user */
    316323        uint64_t accepted_packets;
     
    617624         */
    618625        int (*write_packet)(libtrace_out_t *libtrace, libtrace_packet_t *packet);
     626
     627        /** Flush any buffered output for an output trace.
     628         *
     629         * @param libtrace      The output trace to be flushed
     630         */
     631        int (*flush_output)(libtrace_out_t *libtrace);
     632
    619633        /** Returns the libtrace link type for a packet.
    620634         *
     
    12421256/** Constructor for the network DAG format module */
    12431257void ndag_constructor(void);
     1258/** Constructor for the live ETSI over TCP format module */
     1259void etsilive_constructor(void);
    12441260#ifdef HAVE_BPF
    12451261/** Constructor for the BPF format module */
  • lib/libtrace_parallel.h

    r5c07bfe rc22a4bb  
    731731/** Set the maximum number of perpkt threads to use in a trace.
    732732 *
     733 * Only valid on a new trace, that has not be started. Once started
     734 * the number of threads cannot be changed without destroying the trace.
     735 *
    733736 * @param[in] trace The parallel input trace
    734737 * @param[in] nb The number of threads to use. If set to 0, libtrace will
     
    12711274 */
    12721275DLLEXPORT void trace_free_packet(libtrace_t * libtrace, libtrace_packet_t * packet);
     1276
     1277/** Increments the internal reference counter for a packet.
     1278 * @param packet        The packet opaque pointer
     1279 *
     1280 * You may wish to use this function (and its decrementing counterpart)
     1281 * in situations where you are retaining multiple references to a packet
     1282 * outside of the core packet processing function. This will ensure that
     1283 * the packet is not released until there are no more outstanding references
     1284 * to the packet anywhere in your program.
     1285 */
     1286DLLEXPORT void trace_increment_packet_refcount(libtrace_packet_t *packet);
     1287
     1288/** Decrements the internal reference counter for a packet.
     1289 * @param packet        The packet opaque pointer
     1290 *
     1291 * If the reference counter goes below one, trace_fin_packet() will be
     1292 * called on the packet.
     1293 *
     1294 * You may wish to use this function (and its incrementing counterpart)
     1295 * in situations where you are retaining multiple references to a packet
     1296 * outside of the core packet processing function. This will ensure that
     1297 * the packet is not released until there are no more outstanding references
     1298 * to the packet anywhere in your program.
     1299 */
     1300DLLEXPORT void trace_decrement_packet_refcount(libtrace_packet_t *packet);
     1301
    12731302
    12741303/** Provides some basic information about a trace based on its input format.
  • lib/linktypes.c

    ra857389 rb663d33  
    109109                case TRACE_TYPE_METADATA:
    110110                case TRACE_TYPE_NONDATA:
     111                case TRACE_TYPE_ETSILI:
    111112                        break;
    112113                case TRACE_TYPE_UNKNOWN:
     
    211212                case TRACE_TYPE_NONDATA:
    212213                case TRACE_TYPE_OPENBSD_LOOP:
     214                case TRACE_TYPE_ETSILI:
    213215                case TRACE_TYPE_UNKNOWN:
    214216                        break;
  • lib/protocols_l2.c

    ra857389 rfa555ec  
    483483                case TRACE_TYPE_PFLOG:
    484484                case TRACE_TYPE_ERF_META:
     485                case TRACE_TYPE_ETSILI:
    485486                        break;
    486487                case TRACE_TYPE_UNKNOWN:
     
    519520                                case TRACE_TYPE_PFLOG:
    520521                                case TRACE_TYPE_ERF_META:
     522                                case TRACE_TYPE_ETSILI:
    521523                                        break;
    522524                                case TRACE_TYPE_UNKNOWN:
     
    574576                case TRACE_TYPE_PFLOG:
    575577                case TRACE_TYPE_LINUX_SLL:
     578                case TRACE_TYPE_ETSILI:
    576579                        return NULL;
    577580
     
    696699                case TRACE_TYPE_80211_PRISM:
    697700                case TRACE_TYPE_80211_RADIO:
     701                case TRACE_TYPE_ETSILI:
    698702                        assert(!"Metadata headers should already be skipped");
    699703                        break;
     
    746750                case TRACE_TYPE_80211_PRISM:
    747751                case TRACE_TYPE_80211_RADIO:
     752                case TRACE_TYPE_ETSILI:
    748753                        assert(!"Metadata headers should already be skipped");
    749754                        break;
  • lib/protocols_pktmeta.c

    ra857389 r59b2ed8  
    2828#include "protocols.h"
    2929#include <assert.h>
     30
     31#ifdef HAVE_WANDDER
     32#include <libwandder_etsili.h>
     33#endif
    3034
    3135/* This file contains all the protocol decoding functions for the meta-data
     
    121125}
    122126
     127static void *trace_get_payload_from_etsili(const void *link,
     128                libtrace_linktype_t *type, uint32_t *remaining) {
     129
     130#ifdef HAVE_WANDDER
     131        wandder_etsispec_t *dec;
     132        uint8_t *ccptr;
     133
     134        /* XXX Bit annoying to be creating and freeing this every time */
     135        dec = wandder_create_etsili_decoder();
     136        wandder_attach_etsili_buffer(dec, (uint8_t *)link, *remaining, false);
     137        ccptr = wandder_etsili_get_cc_contents(dec, remaining, NULL, 0);
     138        /* Assuming all CCs are IP for now */
     139        *type = TRACE_TYPE_NONE;
     140        wandder_free_etsili_decoder(dec);
     141        return ccptr;
     142
     143#else
     144        (void)link;
     145        (void)type;
     146        *remaining = 0;
     147        return NULL;
     148#endif
     149
     150}
     151
    123152DLLEXPORT void *trace_get_packet_meta(const libtrace_packet_t *packet,
    124153                libtrace_linktype_t *linktype,
     
    139168                case TRACE_TYPE_80211_PRISM:
    140169                case TRACE_TYPE_ERF_META:
     170                case TRACE_TYPE_ETSILI:
    141171                        return pktbuf;
    142172                /* Non metadata packets */
     
    199229                                        linktype, remaining);
    200230                        return nexthdr;
     231                case TRACE_TYPE_ETSILI:
     232                        nexthdr = trace_get_payload_from_etsili(meta,
     233                                        linktype, remaining);
     234                        return nexthdr;
     235
    201236                case TRACE_TYPE_HDLC_POS:
    202237                case TRACE_TYPE_ETH:
  • lib/strndup.c

    ree6e802 r823d8e1  
    2424 *
    2525 */
    26 #ifndef HAVE_STRNDUP
     26#include "config.h"
     27#if !HAVE_DECL_STRNDUP
    2728
    2829#include <stdlib.h>
  • lib/trace.c

    re375e0f r47d4f8c  
    107107 * will use our own one that does
    108108 */
    109 static void xstrncpy(char *dest, const char *src, size_t n)
    110 {
    111         strncpy(dest,src,n);
    112         dest[n]='\0';
     109static inline void xstrncpy(char *dest, const char *src, size_t n,
     110                size_t destlen)
     111{
     112        size_t slen = destlen - 1;
     113        if (n < slen) {
     114                slen = n;
     115        }
     116        strncpy(dest,src,slen);
     117        dest[slen]='\0';
    113118}
    114119
     
    120125                exit(EXIT_FAILURE);
    121126        }
    122         xstrncpy(ret,src,n);
     127        xstrncpy(ret,src,n,n+1);
    123128        return ret;
    124129}
     
    148153                rt_constructor();
    149154                ndag_constructor();
     155#ifdef HAVE_WANDDER
     156                etsilive_constructor();
     157#endif
    150158#ifdef HAVE_DAG
    151159                dag_constructor();
     
    248256        libtrace->format=NULL;
    249257
    250         libtrace->event.tdelta = 0.0;
    251258        libtrace->event.packet = NULL;
    252259        libtrace->event.psize = 0;
    253         libtrace->event.trace_last_ts = 0.0;
     260        libtrace->event.first_ts = 0.0;
     261        libtrace->event.first_now = 0.0;
    254262        libtrace->event.waiting = false;
    255263        libtrace->filter = NULL;
    256264        libtrace->snaplen = 0;
     265        libtrace->replayspeedup = 1;
    257266        libtrace->started=false;
    258267        libtrace->uridata = NULL;
     
    367376
    368377        if((uridata = strchr(uri,':')) == NULL) {
    369                 xstrncpy(scan, uri, strlen(uri));
     378                xstrncpy(scan, uri, strlen(uri), URI_PROTO_LINE);
    370379        } else {
    371                 xstrncpy(scan,uri, (size_t)(uridata - uri));
     380                xstrncpy(scan,uri, (size_t)(uridata - uri), URI_PROTO_LINE);
    372381        }
    373382
     
    375384        libtrace->format=NULL;
    376385
    377         libtrace->event.tdelta = 0.0;
    378386        libtrace->event.packet = NULL;
    379387        libtrace->event.psize = 0;
    380         libtrace->event.trace_last_ts = 0.0;
     388        libtrace->event.first_ts = 0;
     389        libtrace->event.first_now = 0;
    381390        libtrace->filter = NULL;
    382391        libtrace->snaplen = 0;
     
    592601         * deal with some options itself, so give that a go */
    593602        switch(option) {
     603                case TRACE_OPTION_REPLAY_SPEEDUP:
     604                        /* Clear the error if there was one */
     605                        if (trace_is_err(libtrace)) {
     606                                trace_get_err(libtrace);
     607                        }
     608                        if (*(int*)value<1
     609                                || *(int*)value>LIBTRACE_MAX_REPLAY_SPEEDUP) {
     610                                trace_set_err(libtrace,TRACE_ERR_BAD_STATE,
     611                                        "Invalid replay speed");
     612                        }
     613                        libtrace->replayspeedup=*(int*)value;
     614                        return 0;
     615
    594616                case TRACE_OPTION_SNAPLEN:
    595617                        /* Clear the error if there was one */
     
    724746                libtrace_ocache_destroy(&libtrace->packet_freelist);
    725747                for (i = 0; i < libtrace->perpkt_thread_count; ++i) {
    726                         libtrace_message_queue_destroy(&libtrace->perpkt_threads[i].messages);
    727                 }
    728                 libtrace_message_queue_destroy(&libtrace->hasher_thread.messages);
    729                 libtrace_message_queue_destroy(&libtrace->keepalive_thread.messages);
    730                 libtrace_message_queue_destroy(&libtrace->reporter_thread.messages);
     748                        libtrace_message_queue_destroy(&libtrace->perpkt_threads[i].messages);
     749                }
     750                if (libtrace->hasher_thread.type == THREAD_HASHER)
     751                        libtrace_message_queue_destroy(&libtrace->hasher_thread.messages);
     752                if (libtrace->keepalive_thread.type == THREAD_KEEPALIVE)
     753                        libtrace_message_queue_destroy(&libtrace->keepalive_thread.messages);
     754                if (libtrace->reporter_thread.type == THREAD_REPORTER)
     755                        libtrace_message_queue_destroy(&libtrace->reporter_thread.messages);
    731756
    732757
     
    796821}
    797822
     823DLLEXPORT int trace_flush_output(libtrace_out_t *libtrace) {
     824        if (!libtrace) {
     825                return -1;
     826        }
     827        if (libtrace->format && libtrace->format->flush_output) {
     828                return libtrace->format->flush_output(libtrace);
     829        }
     830        return 0;
     831}
     832
    798833DLLEXPORT libtrace_packet_t *trace_create_packet(void)
    799834{
     
    805840
    806841        packet->buf_control=TRACE_CTRL_PACKET;
     842        pthread_mutex_init(&(packet->ref_lock), NULL);
    807843        trace_clear_cache(packet);
    808844        return packet;
     
    856892                free(packet->buffer);
    857893        }
     894        pthread_mutex_destroy(&(packet->ref_lock));
    858895        packet->buf_control=(buf_control_t)'\0';
    859896                                /* A "bad" value to force an assert
     
    15381575                                trace_set_err(packet->trace,
    15391576                                                TRACE_ERR_NO_CONVERSION,
    1540                                                 "pcap does not support this format");
     1577                                                "pcap does not support this linktype so cannot apply BPF filters");
    15411578                                if (free_packet_needed) {
    15421579                                        trace_destroy_packet(packet_copy);
     
    23162353        packet->l3_remaining = 0;
    23172354        packet->l4_remaining = 0;
     2355        packet->refcount = 0;
    23182356
    23192357}
  • lib/trace_parallel.c

    re375e0f rc95ef4a  
    690690                        if (!trace->pread) {
    691691                                assert(packets[0]);
    692                                 ASSERT_RET(pthread_mutex_lock(&trace->libtrace_lock), == 0);
    693692                                nb_packets = trace_read_packet(trace, packets[0]);
    694                                 ASSERT_RET(pthread_mutex_unlock(&trace->libtrace_lock), == 0);
    695693                                packets[0]->error = nb_packets;
    696694                                if (nb_packets > 0)
     
    10481046        ASSERT_RET(pthread_spin_unlock(&libtrace->first_packets.lock), == 0);
    10491047
     1048        memset(&mesg, 0, sizeof(libtrace_message_t));
    10501049        mesg.code = MESSAGE_FIRST_PACKET;
    10511050        trace_message_reporter(libtrace, &mesg);
     
    11951194
    11961195        gettimeofday(&prev, NULL);
     1196        memset(&message, 0, sizeof(libtrace_message_t));
    11971197        message.code = MESSAGE_TICK_INTERVAL;
    11981198
     
    15461546                       const char *name) {
    15471547#ifdef __linux__
    1548         pthread_attr_t attrib;
    15491548        cpu_set_t cpus;
    15501549        int i;
     
    15641563        for (i = 0; i < get_nb_cores(); i++)
    15651564                CPU_SET(i, &cpus);
    1566         pthread_attr_init(&attrib);
    1567         pthread_attr_setaffinity_np(&attrib, sizeof(cpus), &cpus);
    1568         ret = pthread_create(&t->tid, &attrib, start_routine, (void *) trace);
    1569         pthread_attr_destroy(&attrib);
     1565
     1566        ret = pthread_create(&t->tid, NULL, start_routine, (void *) trace);
     1567        if( ret == 0 ) {
     1568                ret = pthread_setaffinity_np(t->tid, sizeof(cpus), &cpus);
     1569        }
     1570
    15701571#else
    15711572        ret = pthread_create(&t->tid, NULL, start_routine, (void *) trace);
     
    20042005        }
    20052006        if (!libtrace->started || libtrace->state != STATE_RUNNING) {
     2007                ASSERT_RET(pthread_mutex_unlock(&libtrace->libtrace_lock), == 0);
    20062008                trace_set_err(libtrace,TRACE_ERR_BAD_STATE, "You must call trace_start() before calling trace_ppause()");
    20072009                return -1;
     
    24022404
    24032405DLLEXPORT int trace_set_perpkt_threads(libtrace_t *trace, int nb) {
    2404         if (!trace_is_configurable(trace)) return -1;
     2406        // Only supported on new traces not paused traces
     2407        if (trace->state != STATE_NEW) return -1;
    24052408
    24062409        /* TODO consider allowing an offset from the total number of cores i.e.
     
    26012604}
    26022605
     2606DLLEXPORT void trace_increment_packet_refcount(libtrace_packet_t *packet) {
     2607        pthread_mutex_lock(&(packet->ref_lock));
     2608        if (packet->refcount < 0) {
     2609                packet->refcount = 1;
     2610        } else {
     2611                packet->refcount ++;
     2612        }
     2613        pthread_mutex_unlock(&(packet->ref_lock));
     2614}
     2615
     2616DLLEXPORT void trace_decrement_packet_refcount(libtrace_packet_t *packet) {
     2617        pthread_mutex_lock(&(packet->ref_lock));
     2618        packet->refcount --;
     2619
     2620        if (packet->refcount <= 0) {
     2621                trace_free_packet(packet->trace, packet);
     2622        }
     2623        pthread_mutex_unlock(&(packet->ref_lock));
     2624}
     2625
     2626
    26032627DLLEXPORT libtrace_info_t *trace_get_information(libtrace_t * libtrace) {
    26042628        if (libtrace->format)
  • libpacketdump/Makefile.am

    r3a333e2 r055a2c9  
    6060# 17: PPP
    6161TXT_PROTOCOLS+=link_17.protocol
     62
     63# 22: ETSI LI
     64if HAVE_WANDDER
     65BIN_PROTOCOLS+=link_22.la
     66endif
    6267
    6368# Decoders for various ethertypes (in decimal)
     
    135140link_11_la_LDFLAGS=$(modflags)
    136141link_15_la_LDFLAGS=$(modflags)
     142if HAVE_WANDDER
     143link_22_la_LDFLAGS=$(modflags)
     144endif
    137145eth_0_la_LDFLAGS=$(modflags)
    138146eth_2048_la_LDFLAGS=$(modflags)
  • libpacketdump/eth_2054.c

    ree6e802 r47d4f8c  
    4747static char *format_hrd(const struct arphdr *arp, const char *hrd) {
    4848        static char buffer[1024] = {0,};
    49         int i;
     49        int i, ret;
     50        size_t bufused;
    5051
    5152        if (!hrd) {
     
    5960                        break;
    6061                default:
     62                        bufused = 0;
    6163                        for (i=0;i<arp->ar_hln;i++) {
    62                                 snprintf(buffer,sizeof(buffer),"%s %02x",
    63                                                 buffer,(unsigned char)hrd[i]);
     64                                if (bufused >= sizeof(buffer)) {
     65                                        break;
     66                                }
     67                                ret = snprintf(buffer + bufused,
     68                                                sizeof(buffer) - bufused,
     69                                                "%02x ",
     70                                                (unsigned char)hrd[i]);
     71                                if (ret > 0) {
     72                                        bufused += ret;
     73                                }
    6474                        }
    6575                        break;
     
    7787static char *format_pro(const struct arphdr *arp, const char *pro) {
    7888        static char buffer[1024] = {0,};
    79         int i;
     89        int i, ret;
     90        size_t bufused;
    8091       
    8192        if (!pro) {
     
    91102                default:
    92103                        snprintf(buffer, sizeof(buffer), "%s", " (");
     104                        bufused = 2;
    93105                        for (i=0;i<arp->ar_pln;i++) {
    94                                 snprintf(buffer,sizeof(buffer),"%s %02x",
    95                                                 buffer,(unsigned char)pro[i]);
     106                                if (bufused >= sizeof(buffer)) {
     107                                        break;
     108                                }
     109                                ret = snprintf(buffer + bufused,
     110                                                sizeof(buffer) - bufused,
     111                                                "%02x ",
     112                                                (unsigned char)pro[i]);
     113                                if (ret > 0) {
     114                                        bufused += ret;
     115                                }
    96116                        }
    97                         strncat(buffer,")",sizeof(buffer) - strlen(buffer) - 1);
     117                        if (bufused < sizeof(buffer)) {
     118                                snprintf(buffer + bufused,
     119                                                sizeof(buffer) - bufused,
     120                                                ")");
     121                        }
    98122                        break;
    99123        }
  • test/do-test-build-dpdk.sh

    rcaf7841 r6d17620  
    2323}
    2424
    25 # Versions to check
     25# Old kernel version jessie 3.16
    2626declare -a dpdk_versions=(
    2727        "dpdk-1.7.1.tar.gz"
     
    3131        "dpdk-2.2.0.tar.gz"
    3232        "dpdk-16.04.tar.gz"
    33         "dpdk-16.07.tar.gz"
    34         "dpdk-16.11.tar.gz"
     33        "dpdk-16.07.2.tar.gz"
     34        "dpdk-16.11.6.tar.gz"
    3535        )
     36# Versions to check stretch linux 4.9
     37declare -a dpdk_versions=(
     38        "dpdk-2.2.0.tar.gz"
     39        "dpdk-16.04.tar.gz"
     40        "dpdk-16.07.2.tar.gz"
     41        "dpdk-16.11.6.tar.gz"
     42        "dpdk-17.02.1.tar.gz"
     43        "dpdk-17.05.2.tar.gz"
     44        "dpdk-17.08.2.tar.gz"
     45        "dpdk-17.11.2.tar.gz"
     46        "dpdk-18.02.1.tar.gz"
     47        )
     48
    3649
    3750mkdir "$DOWNLOAD_DIR" > /dev/null 2>&1
     
    6073# Build the DPDK libraries
    6174# We try to not overwrite these, so that a rebuild is faster
     75# We build DPDK without KNI, as most kernel dependent code is there
     76#   - also excluding makes the build faster
     77# We also disable error on warning, to improve forwards compiler compatibility
    6278cd "$DOWNLOAD_DIR"
    6379for dpdk_build in $(ls -d */)
     
    6783        do_test make install T=x86_64-native-linuxapp-gcc \
    6884                             CONFIG_RTE_BUILD_COMBINE_LIBS=y \
    69                              EXTRA_CFLAGS="-fPIC" -j $BUILD_THREADS \
     85                             CONFIG_RTE_LIBRTE_KNI=n \
     86                             CONFIG_RTE_KNI_KMOD=n \
     87                             EXTRA_CFLAGS="-fPIC -w" -j $BUILD_THREADS \
    7088                             > build_stdout.txt 2> build_stderr.txt
    7189        cd ..
  • tools/traceanon/traceanon.1

    r5765044 r264f286c  
    101101.BI \-\^\-compress-type=method
    102102compress the output trace using the compression algorithm "method". Possible
    103 algorithms are "gzip", "bzip2", "lzo", "xz" and "none". Default is "none".
     103algorithms are "gz", "bz", "lzo", "xz" and "no". Default is "no".
    104104
    105105.TP
  • tools/tracemerge/tracemerge.1

    r17f954f r264f286c  
    5353.BI \-\^\-compress-type method
    5454Describes the compression algorithm to be used when writing the output trace.
    55 Possible methods are "gzip", "bzip2", "lzo", "xz" and "none". Defaults to
    56 "none".
     55Possible methods are "gz", "bz", "lzo", "xz" and "no". Defaults to
     56"no".
    5757
    5858
  • tools/tracepktdump/tracepktdump.cc

    ree6e802 rf35a853  
    113113                                /* Ignore RT messages */
    114114                                continue;
     115                        if (trace_is_err(trace)) {
     116                                break;
     117                        }
    115118                        trace_dump_packet(packet);
    116119
  • tools/tracereplay/tracereplay.1

    rd6dc0f6 r1e0a804  
    44.SH SYNOPSIS
    55.B tracereplay
    6 [\-b | \-\^\-broadcast] [-s \-\^\-snaplength [ snaplength] ] 
    7 [\-f | \-\^\-filter [ filter string ] ]
     6[\-b | \-\^\-broadcast] [-s \-\^\-snaplength [ snaplength] ]
     7[\-f | \-\^\-filter [ filter string ] ] [\-X | \-\^\-speedup [ factor] ]
    88inputuri outputuri
    99.SH DESCRPTION
     
    2323.TP
    2424.PD 0
    25 .BI \-s [snaplength]
     25.BI \-s " snaplength"
    2626.TP
    2727.PD
    28 .BI \-\^\-snaplength [snaplength]
     28.BI \-\^\-snaplength " snaplength"
    2929Truncate the packets to the length specified. This only makes a difference
    3030if the inputuri is a capture device. The value should be > 0. Inappropriate
     
    3333.TP
    3434.PD 0
    35 .BI \-f [ filter string ]
     35.BI \-f " filterstring"
    3636.TP
    3737.PD
    38 .BI \-\^\-filter [ filter ]
     38.BI \-\^\-filter " filterstring"
    3939Apply a filter to the inputuri.
     40
     41.TP
     42.PD 0
     43.BI \-X " factor"
     44.TP
     45.PD
     46.BI \-\^\-speedup " factor"
     47Decrease the gaps between packets by the specified factor. This will accelerate
     48the rate at which the replay is performed. By default, the factor is 1 (i.e.
     49no acceleration).
    4050
    4151.SH LINKS
  • tools/tracereplay/tracereplay.c

    r8e11beb r1e0a804  
    9898        if (IS_LIBTRACE_META_PACKET(packet))
    9999                return NULL;
     100        if (trace_get_wire_length(packet) == 0)
     101                return NULL;
    100102
    101103        pkt_buffer = trace_get_packet_buffer(packet,&linktype,&remaining);
     
    194196        fprintf(stderr, " --broadcast\n");
    195197        fprintf(stderr, "\t\tSend ethernet frames to broadcast address\n");
     198        fprintf(stderr, " -X\n");
     199        fprintf(stderr, " --speedup\n");
     200        fprintf(stderr, "\t\tSpeed up replay by a factor of <speedup>\n");
    196201
    197202}
     
    207212        libtrace_packet_t * new;
    208213        int snaplen = 0;
     214        int speedup = 1;
    209215
    210216
     
    216222                        { "snaplen",    1, 0, 's'},
    217223                        { "broadcast",  0, 0, 'b'},
     224                        { "speedup",    1, 0, 'X'},
    218225                        { NULL,         0, 0, 0}
    219226                };
    220227
    221                 int c = getopt_long(argc, argv, "bhs:f:",
     228                int c = getopt_long(argc, argv, "bhs:f:X:",
    222229                                long_options, &option_index);
    223230
     
    232239                                snaplen = atoi(optarg);
    233240                                break;
    234 
     241                        case 'X':
     242                                speedup = atoi(optarg);
     243                                break;
    235244                        case 'b':
    236245                                broadcast = 1;
     
    257266        }
    258267
     268        if (speedup < 1) {
     269                speedup = 1;
     270        }
     271
    259272        uri = strdup(argv[optind]);
    260273
     
    279292                }
    280293        }
     294
     295        if (trace_config(trace, TRACE_OPTION_REPLAY_SPEEDUP, &speedup)) {
     296                trace_perror(trace, "error setting replay speedup factor");
     297                return 1;
     298        }
    281299
    282300        /* Starting the trace */
  • tools/tracereport/misc_report.c

    r8e11beb r47d4f8c  
    6767{
    6868        static char ret[1024];
    69         char tmp[1024];
     69        char tmp[128];
    7070        ret[0]='\0';
    7171        if (ts == 0)
  • tools/tracesplit/tracesplit.1

    r7affaae r264f286c  
    6969\fB-Z\fR compression-method
    7070Compress the data using the specified compression algorithm. Accepted methods
    71 are "gzip", "bzip2", "lzo", "xz" or "none". Default value is none unless a
     71are "gz", "bz", "lzo", "xz" or "no". Default value is "no" unless a
    7272compression level is specified, in which case gzip will be used.
    7373
  • tools/tracesplit/tracesplit.c

    r92cf299 r47d4f8c  
    6161static char *strdupcat(char *str,char *app)
    6262{
    63         str=realloc(str,strlen(str)+strlen(app)+1);
    64         strncat(str,app,strlen(str) + strlen(app));
     63        int newsize = strlen(str)+strlen(app)+1;
     64        str=realloc(str,newsize);
     65        strncat(str,app,newsize - strlen(str) - 1);
    6566        return str;
    6667}
Note: See TracChangeset for help on using the changeset viewer.