Changeset 4819d75


Ignore:
Timestamp:
11/09/18 13:17:10 (2 years ago)
Author:
Shane Alcock <salcock@…>
Branches:
develop, master
Children:
43aec21, 89609d0, 9aa5d7d
Parents:
442fbd6 (diff), 857729e (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.5'

Conflicts:

debian/control

Files:
20 edited

Legend:

Unmodified
Added
Removed

  • README

    r096851a rbc86030  
    1 libtrace 4.0.4
     1libtrace 4.0.5
    22
    33---------------------------------------------------------------------------

  • configure.in

    r31111c7 rbc86030  
    44# and in the README
    55
    6 AC_INIT([libtrace],[4.0.4],[contact@wand.net.nz],[libtrace])
     6AC_INIT([libtrace],[4.0.5],[contact@wand.net.nz],[libtrace])
    77
    88LIBTRACE_MAJOR=4
    99LIBTRACE_MID=0
    10 LIBTRACE_MINOR=4
     10LIBTRACE_MINOR=5
    1111
    1212# OpenSolaris hides libraries like libncurses in /usr/gnu/lib, which is not

  • debian/control

    rdd48bb5 r4819d75  
    55 libpcap-dev, zlib1g-dev, flex, bison, doxygen, liblzma-dev, graphviz,
    66 libncurses5-dev, libbz2-dev, libssl-dev, libwandio1-dev, libwandder1-dev,
    7  libdpdk-dev, libnuma-dev
     7 dpdk-dev, libnuma-dev
    88Standards-Version: 4.1.3
    99Section: libs

  • debian/rules

    rdd48bb5 r4819d75  
    3030        ./configure $(CONFFLAGS) \
    3131                   --prefix=/usr \
     32                   --with-dpdk=yes \
    3233                   --mandir=\$${prefix}/share/man \
    3334                   --infodir=\$${prefix}/share/info

  • lib/Makefile.am

    r823d8e1 rdab79f2  
    3535
    3636if HAVE_DPDK
    37 NATIVEFORMATS+= format_dpdk.c format_dpdkndag.c
     37NATIVEFORMATS+= format_dpdk.c format_dpdkndag.c format_dpdk.h
    3838# So we also make libtrace.mk in dpdk otherwise automake tries to expand
    3939# it too early which I cannot seem to stop unless we use a path that

  • lib/format_erf.c

    r32ee9b2 rbccdffc  
    469469                packet->payload = NULL;
    470470        } else {
    471                 packet->payload = (char*)packet->buffer + erf_get_framing_length(packet);
     471                packet->payload = ((char*)packet->buffer) + trace_get_framing_length(packet);
    472472        }
    473473
    … …  
    765765        dag_record_t *erfptr = 0;
    766766        int caplen;
     767        size_t framinglen;
     768        uint16_t wlen, rlen;
     769
    767770        if (packet->payload == NULL)
    768                 return 0; 
    769        
     771                return 0;
     772
    770773        erfptr = (dag_record_t *)packet->header;
    771         caplen = ntohs(erfptr->rlen) - erf_get_framing_length(packet);
    772         if (ntohs(erfptr->wlen) < caplen)
    773                 return ntohs(erfptr->wlen);
    774 
    775         return (ntohs(erfptr->rlen) - erf_get_framing_length(packet));
     774        framinglen = trace_get_framing_length(packet);
     775        rlen = ntohs(erfptr->rlen);
     776        wlen = ntohs(erfptr->wlen);
     777
     778        caplen = rlen - framinglen;
     779        if (wlen < caplen)
     780                return wlen;
     781
     782        return caplen;
    776783}
    777784
    … …  
    788795size_t erf_set_capture_length(libtrace_packet_t *packet, size_t size) {
    789796        dag_record_t *erfptr = 0;
     797        uint16_t wlen;
     798
    790799        assert(packet);
    791800        erfptr = (dag_record_t *)packet->header;
    … …  
    800809         * return the wrong value. */
    801810        packet->capture_length = -1;
    802         erfptr->rlen = htons(size + erf_get_framing_length(packet));
    803         return trace_get_capture_length(packet);
     811        erfptr->rlen = htons(size + trace_get_framing_length(packet));
     812        wlen = ntohs(erfptr->wlen);
     813
     814        if (wlen < size) {
     815                return wlen;
     816        }
     817
     818        return size;
    804819}
    805820

  • lib/format_etsilive.c

    r32ee9b2 r2044185  
    8383        etsithread_t *receivers;
    8484        int nextthreadid;
     85        wandder_etsispec_t *shareddec;
    8586} etsilive_format_data_t;
    8687
    … …  
    227228        FORMAT_DATA->listenport = strdup(scan + 1);
    228229
     230        FORMAT_DATA->shareddec = wandder_create_etsili_decoder();
     231
    229232        return 0;
    230233}
    … …  
    240243        if (FORMAT_DATA->listenport) {
    241244                free(FORMAT_DATA->listenport);
     245        }
     246        if (FORMAT_DATA->shareddec) {
     247                wandder_free_etsili_decoder(FORMAT_DATA->shareddec);
    242248        }
    243249        free(libtrace->format_data);
    … …  
    522528        packet->wire_length = esock->cached.length;
    523529        packet->capture_length = esock->cached.length;
    524 
    525         /*
    526         for (j = 0; j < packet->wire_length; j++) {
    527                 printf("%02x ", *(((uint8_t *)packet->buffer) + j));
    528                 if ((j % 16) == 15) printf("\n");
    529         }
    530         printf("\n");
    531         */
    532530
    533531        /* Advance the read pointer for this buffer
    … …  
    589587
    590588        /* Should never get here because cache is set when packet is read */
    591         wandder_etsispec_t *dec;
    592589        size_t reclen;
     590        libtrace_t *libtrace = packet->trace;
     591
     592        assert(libtrace);
     593        assert(FORMAT_DATA->shareddec);
    593594
    594595        /* 0 should be ok here for quickly evaluating the first length
    595596         * field... */
    596         dec = wandder_create_etsili_decoder();
    597         wandder_attach_etsili_buffer(dec, packet->buffer, 0, false);
    598         reclen = (size_t)wandder_etsili_get_pdu_length(dec);
    599         wandder_free_etsili_decoder(dec);
     597        wandder_attach_etsili_buffer(FORMAT_DATA->shareddec, packet->buffer,
     598                        0, false);
     599        reclen = (size_t)wandder_etsili_get_pdu_length(
     600                        FORMAT_DATA->shareddec);
    600601
    601602        return reclen;
    … …  
    607608}
    608609
    609 static struct timeval etsilive_get_timeval(const libtrace_packet_t *packet) {
    610         /* TODO add cached timestamps to libtrace so we don't have to look
    611          * this up again. */
    612         struct timeval tv;
    613         wandder_etsispec_t *dec;
    614 
    615         tv.tv_sec = 0;
    616         tv.tv_usec = 0;
    617 
    618 
    619         dec = wandder_create_etsili_decoder();
    620         wandder_attach_etsili_buffer(dec, packet->buffer, 0, false);
    621         tv = wandder_etsili_get_header_timestamp(dec);
    622         wandder_free_etsili_decoder(dec);
    623         return tv;
     610static uint64_t etsilive_get_erf_timestamp(const libtrace_packet_t *packet) {
     611        return packet->order;
    624612}
    625613
    … …  
    652640        NULL,                           /* get_direction */
    653641        NULL,                           /* set_direction */
    654         NULL,                           /* get_erf_timestamp */
    655         etsilive_get_timeval,           /* get_timeval */
     642        etsilive_get_erf_timestamp,     /* get_erf_timestamp */
     643        NULL,                           /* get_timeval */
    656644        NULL,                           /* get_timespec */
    657645        NULL,                           /* get_seconds */

  • lib/format_linux_common.c

    r47d4f8c rebed638  
    232232                close(stream->fd);
    233233        stream->fd = -1;
    234         if (stream->rx_ring != MAP_FAILED)
    235                 munmap(stream->rx_ring,
    236                        stream->req.tp_block_size *
    237                        stream->req.tp_block_nr);
    238         stream->rx_ring = MAP_FAILED;
    239         stream->rxring_offset = 0;
    240234        FORMAT_DATA->dev_stats.if_name[0] = 0;
     235
     236        /* Don't munmap the rx_ring here -- keep it around as long as
     237         * possible to ensure that any packets that the user is still
     238         * holding references to remain valid.
     239         *
     240         * Don't worry, linuxring will munmap the rx_ring as soon as
     241         * someone either destroys or restarts the trace. At that point,
     242         * any remaining packets from the old ring will be recognisable
     243         * as invalid.
     244         */
    241245}
    242246

  • lib/format_linux_ring.c

    r8a63abd rebed638  
    252252        char error[2048];
    253253
     254        /* Unmap any previous ring buffers associated with this stream. */
     255        if (stream->rx_ring != MAP_FAILED) {
     256                munmap(stream->rx_ring, stream->req.tp_block_size *
     257                                stream->req.tp_block_nr);
     258                stream->rx_ring = MAP_FAILED;
     259                stream->rxring_offset = 0;
     260        }
     261
     262
    254263        /* We set the socket up the same and then convert it to PACKET_MMAP */
    255264        if (linuxcommon_start_input_stream(libtrace, stream) < 0)
    … …  
    274283        return 0;
    275284}
     285
     286static int linuxring_fin_input(libtrace_t *libtrace) {
     287        size_t i;
     288
     289        if (libtrace->format_data) {
     290                for (i = 0; i < libtrace_list_get_size(FORMAT_DATA->per_stream); ++i) {
     291                        struct linux_per_stream_t *stream;
     292                        stream = libtrace_list_get_index(
     293                                FORMAT_DATA->per_stream, i)->data;
     294                        if (stream->rx_ring != MAP_FAILED) {
     295                                munmap(stream->rx_ring,
     296                                                stream->req.tp_block_size *
     297                                                stream->req.tp_block_nr);
     298                        }
     299                }
     300
     301                if (FORMAT_DATA->filter != NULL)
     302                        free(FORMAT_DATA->filter);
     303
     304                if (FORMAT_DATA->per_stream)
     305                        libtrace_list_deinit(FORMAT_DATA->per_stream);
     306
     307                free(libtrace->format_data);
     308        }
     309
     310        return 0;
     311}
     312
    276313
    277314static int linuxring_start_input(libtrace_t *libtrace)
    … …  
    622659        /* If we own the packet (i.e. it's not a copy), we need to free it */
    623660        if (packet->buf_control == TRACE_CTRL_EXTERNAL) {
    624                 /* Started should always match the existence of the rx_ring
    625                  * in the parallel case still just check the first ring */
    626                 assert(!!FORMAT_DATA_FIRST->rx_ring ==
    627                        !!packet->trace->started);
    628661                /* If we don't have a ring its already been destroyed */
    629662                if (FORMAT_DATA_FIRST->rx_ring != MAP_FAILED)
    … …  
    742775        NULL,                           /* config_output */
    743776        linuxring_start_output,         /* start_ouput */
    744         linuxcommon_fin_input,          /* fin_input */
     777        linuxring_fin_input,            /* fin_input */
    745778        linuxring_fin_output,           /* fin_output */
    746779        linuxring_read_packet,          /* read_packet */

  • lib/format_ndag.c

    rb135888 r857729e  
    187187        char pstr[16];
    188188        struct group_req greq;
    189         int bufsize;
     189        int bufsize, val;
    190190
    191191        int sock;
    … …  
    226226                fprintf(stderr,
    227227                        "Failed to create multicast socket for %s:%s -- %s\n",
     228                                groupaddr, portstr, strerror(errno));
     229                goto sockcreateover;
     230        }
     231
     232        val = 1;
     233        if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(val)) < 0) {
     234                fprintf(stderr,
     235                        "Failed to set REUSEADDR socket option for %s:%s -- %s\n",
    228236                                groupaddr, portstr, strerror(errno));
    229237                goto sockcreateover;
    … …  
    542550#endif
    543551
    544                 close(src.sock);
     552                if (src.sock != -1) {
     553                        close(src.sock);
     554                }
    545555        }
    546556        if (receiver->knownmonitors) {
    … …  
    716726        ssock = &(rt->sources[rt->sourcecount]);
    717727
    718         ssock->sock = join_multicast_group(src.groupaddr, src.localiface,
    719                         NULL, src.port, &(ssock->srcaddr));
    720 
    721         if (ssock->sock < 0) {
    722                 return -1;
    723         }
    724 
    725728        for (i = 0; i < rt->monitorcount; i++) {
    726729                if (rt->knownmonitors[i].monitorid == src.monitor) {
    … …  
    748751                ssock->savedsize[i] = 0;
    749752        }
     753
     754        ssock->sock = join_multicast_group(src.groupaddr, src.localiface,
     755                        NULL, src.port, &(ssock->srcaddr));
     756
     757        if (ssock->sock < 0) {
     758                return -1;
     759        }
     760
     761        if (ssock->sock > rt->maxfd) {
     762                rt->maxfd = ssock->sock;
     763        }
    750764
    751765#if HAVE_DECL_RECVMMSG
    … …  
    761775        }
    762776#else
    763         ssock->singlemsg.msg_iov = (struct iovec *) malloc(sizeof(struct iovec));
     777        ssock->singlemsg.msg_iov = (struct iovec *) calloc(1, sizeof(struct iovec));
    764778#endif
    765779
    … …  
    769783        ssock->recordcount = 0;
    770784        rt->sourcecount += 1;
    771         if (ssock->sock > rt->maxfd) {
    772                 rt->maxfd = ssock->sock;
    773         }
    774785
    775786        fprintf(stderr, "Added new stream %s:%u to thread %d\n",
    … …  
    947958                        MSG_DONTWAIT, NULL);
    948959#else
     960        if (avail != 1) {
     961                return 0;
     962        }
     963
    949964        ret = recvmsg(ssock->sock, &(ssock->singlemsg), MSG_DONTWAIT);
    950965#endif

  • lib/format_pcap.c

    r32ee9b2 r37ee856  
    500500        /* Silently discard RT metadata packets and packets with an
    501501         * unknown linktype. */
    502         if (linktype == TRACE_TYPE_NONDATA || linktype == TRACE_TYPE_UNKNOWN || linktype == TRACE_TYPE_ERF_META) {
     502        if (linktype == TRACE_TYPE_NONDATA || linktype == TRACE_TYPE_UNKNOWN || linktype == TRACE_TYPE_ERF_META || linktype == TRACE_TYPE_CONTENT_INVALID) {
    503503                return 0;
    504504        }
    … …  
    595595        /* Silently discard RT metadata packets and packets with an
    596596         * unknown linktype. */
    597         if (linktype == TRACE_TYPE_NONDATA || linktype == TRACE_TYPE_UNKNOWN || linktype == TRACE_TYPE_ERF_META) {
     597        if (linktype == TRACE_TYPE_NONDATA || linktype == TRACE_TYPE_UNKNOWN || linktype == TRACE_TYPE_ERF_META || linktype == TRACE_TYPE_CONTENT_INVALID) {
    598598                return 0;
    599599        }

  • lib/format_pcapfile.c

    r32ee9b2 r37ee856  
    432432        /* Silently discard RT metadata packets and packets with an
    433433         * unknown linktype. */
    434         if (linktype == TRACE_TYPE_NONDATA || linktype == TRACE_TYPE_UNKNOWN || linktype == TRACE_TYPE_ERF_META) {
     434        if (linktype == TRACE_TYPE_NONDATA || linktype == TRACE_TYPE_UNKNOWN || linktype == TRACE_TYPE_ERF_META || linktype == TRACE_TYPE_CONTENT_INVALID) {
    435435                return 0;
    436436        }

  • lib/libtrace.h.in

    r47d4f8c rfe4940e  
    347347
    348348/** Enumeration of link layer types supported by libtrace */
    349 typedef enum {
     349typedef enum {
     350       TRACE_TYPE_CONTENT_INVALID = -2, /**< Packet contents are not valid */
    350351       TRACE_TYPE_UNKNOWN = -1,         /**< Unable to determine link type */
    351352    /* TRACE_TYPE_LEGACY = 0            Obsolete */
    … …  
    550551        int wire_length;                /**< Cached wire length */
    551552        int payload_length;             /**< Cached payload length */
     553        int framing_length;             /**< Cached framing length */
    552554        void *l2_header;                /**< Cached link header */
    553555        libtrace_linktype_t link_type;  /**< Cached link type */
    … …  
    567569        pthread_mutex_t ref_lock;       /**< Lock for reference counter */
    568570        int refcount;                 /**< Reference counter */
     571        int which_trace_start;          /**< Used to match packet to a started instance of the parent trace */
    569572
    570573} libtrace_packet_t;

  • lib/libtrace_int.h

    r823d8e1 r37ee856  
    337337        /** Boolean flag indicating whether the trace has been started */
    338338        bool started;
     339        /** Number of times this trace has been started */
     340        int startcount;
    339341        /** Synchronise writes/reads across this format object and attached threads etc */
    340342        pthread_mutex_t libtrace_lock;

  • lib/linktypes.c

    rb663d33 r91bd90e  
    112112                        break;
    113113                case TRACE_TYPE_UNKNOWN:
     114                case TRACE_TYPE_CONTENT_INVALID:
    114115                        break;
    115116        }
    … …  
    214215                case TRACE_TYPE_ETSILI:
    215216                case TRACE_TYPE_UNKNOWN:
     217                case TRACE_TYPE_CONTENT_INVALID:
    216218                        break;
    217219        }
    … …  
    333335        struct timeval tv;
    334336        static libtrace_t *trace = NULL;
     337
    335338        switch(trace_get_link_type(packet)) {
    336339                case TRACE_TYPE_ATM:
    … …  
    371374                        }
    372375
     376                        trace->startcount = packet->trace->startcount;
    373377                        packet->trace=trace;
    374378

  • lib/protocols_l2.c

    rfa555ec rfe4940e  
    174174        }
    175175
    176         if (nextpayload != NULL) {
     176        if (nextpayload != NULL && removed > 0) {
    177177
    178178                ethernet->ether_type = ntohs(finalethertype);
    … …  
    486486                        break;
    487487                case TRACE_TYPE_UNKNOWN:
     488                case TRACE_TYPE_CONTENT_INVALID:
    488489                        return NULL;
    489490        }
    … …  
    523524                                        break;
    524525                                case TRACE_TYPE_UNKNOWN:
     526                                case TRACE_TYPE_CONTENT_INVALID:
    525527                                        return NULL;
    526528                        }
    … …  
    565567        void *l;
    566568
    567         if (linktype == TRACE_TYPE_UNKNOWN) {
     569        if (linktype == TRACE_TYPE_UNKNOWN ||
     570                        linktype == TRACE_TYPE_CONTENT_INVALID) {
    568571                fprintf(stderr, "Unable to determine linktype for packet\n");
    569572                return NULL;
    … …  
    589592                case TRACE_TYPE_NONDATA:
    590593                case TRACE_TYPE_ERF_META:
     594                case TRACE_TYPE_CONTENT_INVALID:
    591595                case TRACE_TYPE_UNKNOWN:
    592596                        return NULL;
    … …  
    693697                case TRACE_TYPE_ERF_META:
    694698                case TRACE_TYPE_UNKNOWN:
     699                case TRACE_TYPE_CONTENT_INVALID:
    695700                        return NULL;
    696701
    … …  
    744749                case TRACE_TYPE_ERF_META:
    745750                case TRACE_TYPE_UNKNOWN:
     751                case TRACE_TYPE_CONTENT_INVALID:
    746752                        /* No MAC address */
    747753                        return NULL;

  • lib/protocols_pktmeta.c

    r59b2ed8 r37ee856  
    186186                case TRACE_TYPE_OPENBSD_LOOP:
    187187                case TRACE_TYPE_UNKNOWN:
     188                case TRACE_TYPE_CONTENT_INVALID:
    188189                        return NULL;
    189190        }
    … …  
    249250                case TRACE_TYPE_ERF_META:
    250251                case TRACE_TYPE_UNKNOWN:
     252                case TRACE_TYPE_CONTENT_INVALID:
    251253                        /* In this case, the pointer passed in does not point
    252254                         * to a metadata header and so we cannot get the

  • lib/protocols_transport.c

    r6654714 r54a76f2  
    6262        libtrace_tcp_t *tcp;
    6363        size_t len = 0;
     64        uint8_t iplenzero = 0;
    6465
    6566        /* Just use the cached length if we can */
    … …  
    7879                        if (rem < sizeof(libtrace_ip_t))
    7980                                return 0;
     81                        if (ntohs(ip->ip_len) == 0) {
     82                                iplenzero = 1;
     83                                break;
     84                        }
    8085                        len = ntohs(ip->ip_len) - (4 * ip->ip_hl);
    8186               
    … …  
    9095                                return 0;
    9196                        len = ntohs(ip6->plen);
     97                        if (len == 0) {
     98                                iplenzero = 1;
     99                        }
    92100                        break;
    93101                default:
    94102                        return 0;
    95103        }
     104
     105        if (iplenzero) {
     106                /* deal with cases where IP length is zero due to
     107                 * hardware segmentation offload */
     108                uint8_t *iplayer, *pktstart;
     109                libtrace_linktype_t linktype;
     110                uint32_t rem;
     111
     112                iplayer = (uint8_t *)layer;
     113                pktstart = (uint8_t *)trace_get_packet_buffer(packet, &linktype, &rem);
     114
     115                len = rem - (iplayer - pktstart);
     116                if (ethertype == TRACE_ETHERTYPE_IP) {
     117                        ip = (libtrace_ip_t *)layer;
     118                        len -= (4 * ip->ip_hl);
     119                } else {
     120                        len -= sizeof(libtrace_ip6_t);
     121                }
     122        }
    96123
    97124        layer = trace_get_transport(packet, &proto, &rem);

  • lib/trace.c

    r47d4f8c r0bb8d49  
    131131
    132132/* call all the constructors if they haven't yet all been called */
     133__attribute__((constructor))
    133134static void trace_init(void)
    134135{
    … …  
    265266        libtrace->replayspeedup = 1;
    266267        libtrace->started=false;
     268        libtrace->startcount=0;
    267269        libtrace->uridata = NULL;
    268270        libtrace->io = NULL;
    … …  
    534536                }
    535537        }
    536 
     538        libtrace->startcount ++;
    537539        libtrace->started=true;
    538540        return 0;
    … …  
    840842
    841843        packet->buf_control=TRACE_CTRL_PACKET;
     844        packet->which_trace_start = 0;
    842845        pthread_mutex_init(&(packet->ref_lock), NULL);
    843846        trace_clear_cache(packet);
    … …  
    846849
    847850DLLEXPORT libtrace_packet_t *trace_copy_packet(const libtrace_packet_t *packet) {
    848         libtrace_packet_t *dest =
    849                 (libtrace_packet_t *)calloc((size_t)1, sizeof(libtrace_packet_t));
     851        libtrace_packet_t *dest;
     852
     853        if (packet->which_trace_start != packet->trace->startcount) {
     854                return NULL;
     855        }
     856
     857        dest = (libtrace_packet_t *)calloc((size_t)1, sizeof(libtrace_packet_t));
    850858        if (!dest) {
    851859                printf("Out of memory constructing packet\n");
    … …  
    866874        dest->hash = packet->hash;
    867875        dest->error = packet->error;
     876        dest->which_trace_start = packet->which_trace_start;
    868877        /* Reset the cache - better to recalculate than try to convert
    869878         * the values over to the new packet */
    … …  
    978987                         * structure */
    979988                        packet->trace = libtrace;
     989                        packet->which_trace_start = libtrace->startcount;
    980990                        ret=libtrace->format->read_packet(libtrace,packet);
    981991                        if (ret==(size_t)READ_MESSAGE ||
    … …  
    10081018                                ++libtrace->accepted_packets;
    10091019                        }
    1010                         trace_packet_set_order(packet, libtrace->sequence_number);
     1020                        if (packet->order == 0) {
     1021                                trace_packet_set_order(packet, libtrace->sequence_number);
     1022                        }
    10111023                        ++libtrace->sequence_number;
    10121024                        if (!libtrace_parallel && packet->trace == libtrace)
    … …  
    11031115        int cap_len;
    11041116        int wire_len;
     1117        libtrace_linktype_t ltype;
    11051118
    11061119        assert(packet != NULL);
    1107         if (linktype) *linktype = trace_get_link_type(packet);
     1120        ltype = trace_get_link_type(packet);
     1121
     1122        if (linktype) {
     1123                *linktype = ltype;
     1124        }
     1125
     1126        if (ltype == TRACE_TYPE_CONTENT_INVALID) {
     1127                if (remaining) {
     1128                        *remaining = 0;
     1129                }
     1130                return NULL;
     1131        }
     1132
    11081133        if (remaining) {
    11091134                /* I think we should choose the minimum of the capture and
    … …  
    11581183 */
    11591184DLLEXPORT uint64_t trace_get_erf_timestamp(const libtrace_packet_t *packet) {
     1185        if (packet->which_trace_start != packet->trace->startcount) {
     1186                return (uint64_t)0;
     1187        }
     1188
    11601189        if (packet->trace->format->get_erf_timestamp) {
    11611190                /* timestamp -> timestamp */
    … …  
    11941223        struct timeval tv;
    11951224        uint64_t ts = 0;
    1196         if (packet->trace->format->get_timeval) {
     1225
     1226        if (packet->which_trace_start != packet->trace->startcount) {
     1227                tv.tv_sec=-1;
     1228                tv.tv_usec=-1;
     1229        } else if (packet->trace->format->get_timeval) {
    11971230                /* timeval -> timeval */
    11981231                tv = packet->trace->format->get_timeval(packet);
    … …  
    12271260        struct timespec ts;
    12281261
    1229         if (packet->trace->format->get_timespec) {
     1262        if (packet->which_trace_start != packet->trace->startcount) {
     1263                ts.tv_sec=-1;
     1264                ts.tv_nsec=-1;
     1265        } else if (packet->trace->format->get_timespec) {
    12301266                return packet->trace->format->get_timespec(packet);
    12311267        } else if (packet->trace->format->get_erf_timestamp) {
    … …  
    12381274                        ts.tv_sec += 1;
    12391275                }
    1240                 return ts;
    12411276        } else if (packet->trace->format->get_timeval) {
    12421277                /* timeval -> timespec */
    … …  
    12441279                ts.tv_sec = tv.tv_sec;
    12451280                ts.tv_nsec = tv.tv_usec*1000;
    1246                 return ts;
    12471281        } else if (packet->trace->format->get_seconds) {
    12481282                /* seconds -> timespec */
    … …  
    12501284                ts.tv_sec = (uint32_t)seconds;
    12511285                ts.tv_nsec = (long)(((seconds - ts.tv_sec) * 1000000000)/UINT_MAX);
    1252                 return ts;
    12531286        }
    12541287        else {
    12551288                ts.tv_sec=-1;
    12561289                ts.tv_nsec=-1;
    1257                 return ts;
    1258         }
     1290        }
     1291        return ts;
    12591292}
    12601293
    … …  
    12661299DLLEXPORT double trace_get_seconds(const libtrace_packet_t *packet) {
    12671300        double seconds = 0.0;
     1301
     1302        if (packet->which_trace_start != packet->trace->startcount) {
     1303                return 0.0;
     1304        }
    12681305
    12691306        if (packet->trace->format->get_seconds) {
    … …  
    12931330{
    12941331        /* Cache the capture length */
     1332        if (packet->which_trace_start != packet->trace->startcount) {
     1333                return ~0U;
     1334        }
    12951335        if (packet->capture_length == -1) {
    12961336                if (!packet->trace->format->get_capture_length)
    … …  
    13151355DLLEXPORT size_t trace_get_wire_length(const libtrace_packet_t *packet){
    13161356
     1357        if (packet->which_trace_start != packet->trace->startcount) {
     1358                return ~0U;
     1359        }
     1360
    13171361        if (packet->wire_length == -1) {
    13181362                if (!packet->trace->format->get_wire_length)
    … …  
    13351379DLLEXPORT SIMPLE_FUNCTION
    13361380size_t trace_get_framing_length(const libtrace_packet_t *packet) {
     1381        if (packet->which_trace_start != packet->trace->startcount) {
     1382                return ~0U;
     1383        }
     1384
     1385        if (packet->framing_length >= 0) {
     1386                return packet->framing_length;
     1387        }
     1388
    13371389        if (packet->trace->format->get_framing_length) {
    1338                 return packet->trace->format->get_framing_length(packet);
     1390                ((libtrace_packet_t *)packet)->framing_length =
     1391                       packet->trace->format->get_framing_length(packet);
     1392                return packet->framing_length;
    13391393        }
    13401394        return ~0U;
    … …  
    13471401 */
    13481402DLLEXPORT libtrace_linktype_t trace_get_link_type(const libtrace_packet_t *packet ) {
     1403
     1404        if (packet->which_trace_start != packet->trace->startcount) {
     1405                return TRACE_TYPE_CONTENT_INVALID;
     1406        }
    13491407
    13501408        if (packet->link_type == 0) {
    … …  
    16641722{
    16651723        assert(packet);
     1724        if (packet->which_trace_start != packet->trace->startcount) {
     1725                return (libtrace_direction_t)~0U;
     1726        }
    16661727        if (packet->trace->format->get_direction) {
    16671728                return packet->trace->format->get_direction(packet);
    … …  
    23492410        packet->capture_length = -1;
    23502411        packet->wire_length = -1;
     2412        packet->framing_length = -1;
    23512413        packet->payload_length = -1;
    23522414        packet->l2_remaining = 0;
    … …  
    23542416        packet->l4_remaining = 0;
    23552417        packet->refcount = 0;
    2356 
    23572418}
    23582419

  • lib/trace_parallel.c

    rc95ef4a r37ee856  
    13451345                                return -1;
    13461346                        }
     1347                        packets[i]->which_trace_start = libtrace->startcount;
    13471348                }
    13481349                do {
    … …  
    14601461        if (err == 0) {
    14611462                libtrace->started = true;
     1463                libtrace->startcount ++;
    14621464                libtrace_change_state(libtrace, STATE_RUNNING, false);
    14631465        }
    … …  
    17771779        }
    17781780
    1779         if (ret != 0) {
     1781        if (ret < 0) {
    17801782                goto cleanup_none;
    17811783        }
    … …  
    18631865        /* Threads don't start */
    18641866        libtrace->started = true;
     1867        libtrace->startcount ++;
    18651868        libtrace_change_state(libtrace, STATE_RUNNING, false);
    18661869
Note: See TracChangeset for help on using the changeset viewer.