Changeset 43aec21 for lib


Ignore:
Timestamp:
11/14/18 11:18:51 (2 years ago)
Author:
Jacob Van Walraven <jcv9@…>
Branches:
develop
Children:
4d1d3a3
Parents:
3b206d8 (diff), 4819d75 (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 'master' of https://github.com/libtraceteam/libtrace

Location:
lib
Files:
16 edited

Legend:

Unmodified
Added
Removed
  • 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

    rdc62550 r43aec21  
    349349
    350350/** Enumeration of link layer types supported by libtrace */
    351 typedef enum {
     351typedef enum {
     352       TRACE_TYPE_CONTENT_INVALID = -2, /**< Packet contents are not valid */
    352353       TRACE_TYPE_UNKNOWN = -1,         /**< Unable to determine link type */
    353354    /* TRACE_TYPE_LEGACY = 0            Obsolete */
     
    552553        int wire_length;                /**< Cached wire length */
    553554        int payload_length;             /**< Cached payload length */
     555        int framing_length;             /**< Cached framing length */
    554556        void *l2_header;                /**< Cached link header */
    555557        libtrace_linktype_t link_type;  /**< Cached link type */
     
    569571        pthread_mutex_t ref_lock;       /**< Lock for reference counter */
    570572        int refcount;                 /**< Reference counter */
     573        int which_trace_start;          /**< Used to match packet to a started instance of the parent trace */
    571574
    572575} 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

    rdc62550 r43aec21  
    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;
     
    541543                }
    542544        }
    543 
     545        libtrace->startcount ++;
    544546        libtrace->started=true;
    545547        return 0;
     
    847849
    848850        packet->buf_control=TRACE_CTRL_PACKET;
     851        packet->which_trace_start = 0;
    849852        pthread_mutex_init(&(packet->ref_lock), NULL);
    850853        trace_clear_cache(packet);
     
    853856
    854857DLLEXPORT libtrace_packet_t *trace_copy_packet(const libtrace_packet_t *packet) {
    855         libtrace_packet_t *dest =
    856                 (libtrace_packet_t *)calloc((size_t)1, sizeof(libtrace_packet_t));
     858        libtrace_packet_t *dest;
     859
     860        if (packet->which_trace_start != packet->trace->startcount) {
     861                return NULL;
     862        }
     863
     864        dest = (libtrace_packet_t *)calloc((size_t)1, sizeof(libtrace_packet_t));
    857865        if (!dest) {
    858866                printf("Out of memory constructing packet\n");
     
    873881        dest->hash = packet->hash;
    874882        dest->error = packet->error;
     883        dest->which_trace_start = packet->which_trace_start;
    875884        /* Reset the cache - better to recalculate than try to convert
    876885         * the values over to the new packet */
     
    985994                         * structure */
    986995                        packet->trace = libtrace;
     996                        packet->which_trace_start = libtrace->startcount;
    987997                        ret=libtrace->format->read_packet(libtrace,packet);
    988998                        if (ret==(size_t)READ_MESSAGE ||
     
    10151025                                ++libtrace->accepted_packets;
    10161026                        }
    1017                         trace_packet_set_order(packet, libtrace->sequence_number);
     1027                        if (packet->order == 0) {
     1028                                trace_packet_set_order(packet, libtrace->sequence_number);
     1029                        }
    10181030                        ++libtrace->sequence_number;
    10191031                        if (!libtrace_parallel && packet->trace == libtrace)
     
    11101122        int cap_len;
    11111123        int wire_len;
     1124        libtrace_linktype_t ltype;
    11121125
    11131126        assert(packet != NULL);
    1114         if (linktype) *linktype = trace_get_link_type(packet);
     1127        ltype = trace_get_link_type(packet);
     1128
     1129        if (linktype) {
     1130                *linktype = ltype;
     1131        }
     1132
     1133        if (ltype == TRACE_TYPE_CONTENT_INVALID) {
     1134                if (remaining) {
     1135                        *remaining = 0;
     1136                }
     1137                return NULL;
     1138        }
     1139
    11151140        if (remaining) {
    11161141                /* I think we should choose the minimum of the capture and
     
    11651190 */
    11661191DLLEXPORT uint64_t trace_get_erf_timestamp(const libtrace_packet_t *packet) {
     1192        if (packet->which_trace_start != packet->trace->startcount) {
     1193                return (uint64_t)0;
     1194        }
     1195
    11671196        if (packet->trace->format->get_erf_timestamp) {
    11681197                /* timestamp -> timestamp */
     
    12011230        struct timeval tv;
    12021231        uint64_t ts = 0;
    1203         if (packet->trace->format->get_timeval) {
     1232
     1233        if (packet->which_trace_start != packet->trace->startcount) {
     1234                tv.tv_sec=-1;
     1235                tv.tv_usec=-1;
     1236        } else if (packet->trace->format->get_timeval) {
    12041237                /* timeval -> timeval */
    12051238                tv = packet->trace->format->get_timeval(packet);
     
    12341267        struct timespec ts;
    12351268
    1236         if (packet->trace->format->get_timespec) {
     1269        if (packet->which_trace_start != packet->trace->startcount) {
     1270                ts.tv_sec=-1;
     1271                ts.tv_nsec=-1;
     1272        } else if (packet->trace->format->get_timespec) {
    12371273                return packet->trace->format->get_timespec(packet);
    12381274        } else if (packet->trace->format->get_erf_timestamp) {
     
    12451281                        ts.tv_sec += 1;
    12461282                }
    1247                 return ts;
    12481283        } else if (packet->trace->format->get_timeval) {
    12491284                /* timeval -> timespec */
     
    12511286                ts.tv_sec = tv.tv_sec;
    12521287                ts.tv_nsec = tv.tv_usec*1000;
    1253                 return ts;
    12541288        } else if (packet->trace->format->get_seconds) {
    12551289                /* seconds -> timespec */
     
    12571291                ts.tv_sec = (uint32_t)seconds;
    12581292                ts.tv_nsec = (long)(((seconds - ts.tv_sec) * 1000000000)/UINT_MAX);
    1259                 return ts;
    12601293        }
    12611294        else {
    12621295                ts.tv_sec=-1;
    12631296                ts.tv_nsec=-1;
    1264                 return ts;
    1265         }
     1297        }
     1298        return ts;
    12661299}
    12671300
     
    12731306DLLEXPORT double trace_get_seconds(const libtrace_packet_t *packet) {
    12741307        double seconds = 0.0;
     1308
     1309        if (packet->which_trace_start != packet->trace->startcount) {
     1310                return 0.0;
     1311        }
    12751312
    12761313        if (packet->trace->format->get_seconds) {
     
    13001337{
    13011338        /* Cache the capture length */
     1339        if (packet->which_trace_start != packet->trace->startcount) {
     1340                return ~0U;
     1341        }
    13021342        if (packet->capture_length == -1) {
    13031343                if (!packet->trace->format->get_capture_length)
     
    13221362DLLEXPORT size_t trace_get_wire_length(const libtrace_packet_t *packet){
    13231363
     1364        if (packet->which_trace_start != packet->trace->startcount) {
     1365                return ~0U;
     1366        }
     1367
    13241368        if (packet->wire_length == -1) {
    13251369                if (!packet->trace->format->get_wire_length)
     
    13421386DLLEXPORT SIMPLE_FUNCTION
    13431387size_t trace_get_framing_length(const libtrace_packet_t *packet) {
     1388        if (packet->which_trace_start != packet->trace->startcount) {
     1389                return ~0U;
     1390        }
     1391
     1392        if (packet->framing_length >= 0) {
     1393                return packet->framing_length;
     1394        }
     1395
    13441396        if (packet->trace->format->get_framing_length) {
    1345                 return packet->trace->format->get_framing_length(packet);
     1397                ((libtrace_packet_t *)packet)->framing_length =
     1398                       packet->trace->format->get_framing_length(packet);
     1399                return packet->framing_length;
    13461400        }
    13471401        return ~0U;
     
    13541408 */
    13551409DLLEXPORT libtrace_linktype_t trace_get_link_type(const libtrace_packet_t *packet ) {
     1410
     1411        if (packet->which_trace_start != packet->trace->startcount) {
     1412                return TRACE_TYPE_CONTENT_INVALID;
     1413        }
    13561414
    13571415        if (packet->link_type == 0) {
     
    16711729{
    16721730        assert(packet);
     1731        if (packet->which_trace_start != packet->trace->startcount) {
     1732                return (libtrace_direction_t)~0U;
     1733        }
    16731734        if (packet->trace->format->get_direction) {
    16741735                return packet->trace->format->get_direction(packet);
     
    23562417        packet->capture_length = -1;
    23572418        packet->wire_length = -1;
     2419        packet->framing_length = -1;
    23582420        packet->payload_length = -1;
    23592421        packet->l2_remaining = 0;
     
    23612423        packet->l4_remaining = 0;
    23622424        packet->refcount = 0;
    2363 
    23642425}
    23652426
  • 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.