Changeset 4819d75
- Timestamp:
- 11/09/18 13:17:10 (2 years ago)
- 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. - Files:
-
- 20 edited
Legend:
- Unmodified
- Added
- Removed
-
README
r096851a rbc86030 1 libtrace 4.0. 41 libtrace 4.0.5 2 2 3 3 --------------------------------------------------------------------------- -
configure.in
r31111c7 rbc86030 4 4 # and in the README 5 5 6 AC_INIT([libtrace],[4.0. 4],[contact@wand.net.nz],[libtrace])6 AC_INIT([libtrace],[4.0.5],[contact@wand.net.nz],[libtrace]) 7 7 8 8 LIBTRACE_MAJOR=4 9 9 LIBTRACE_MID=0 10 LIBTRACE_MINOR= 410 LIBTRACE_MINOR=5 11 11 12 12 # OpenSolaris hides libraries like libncurses in /usr/gnu/lib, which is not -
debian/control
rdd48bb5 r4819d75 5 5 libpcap-dev, zlib1g-dev, flex, bison, doxygen, liblzma-dev, graphviz, 6 6 libncurses5-dev, libbz2-dev, libssl-dev, libwandio1-dev, libwandder1-dev, 7 libdpdk-dev, libnuma-dev7 dpdk-dev, libnuma-dev 8 8 Standards-Version: 4.1.3 9 9 Section: libs -
debian/rules
rdd48bb5 r4819d75 30 30 ./configure $(CONFFLAGS) \ 31 31 --prefix=/usr \ 32 --with-dpdk=yes \ 32 33 --mandir=\$${prefix}/share/man \ 33 34 --infodir=\$${prefix}/share/info -
lib/Makefile.am
r823d8e1 rdab79f2 35 35 36 36 if HAVE_DPDK 37 NATIVEFORMATS+= format_dpdk.c format_dpdkndag.c 37 NATIVEFORMATS+= format_dpdk.c format_dpdkndag.c format_dpdk.h 38 38 # So we also make libtrace.mk in dpdk otherwise automake tries to expand 39 39 # it too early which I cannot seem to stop unless we use a path that -
lib/format_erf.c
r32ee9b2 rbccdffc 469 469 packet->payload = NULL; 470 470 } else { 471 packet->payload = ( char*)packet->buffer + erf_get_framing_length(packet);471 packet->payload = ((char*)packet->buffer) + trace_get_framing_length(packet); 472 472 } 473 473 … … 765 765 dag_record_t *erfptr = 0; 766 766 int caplen; 767 size_t framinglen; 768 uint16_t wlen, rlen; 769 767 770 if (packet->payload == NULL) 768 return 0; 769 771 return 0; 772 770 773 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; 776 783 } 777 784 … … 788 795 size_t erf_set_capture_length(libtrace_packet_t *packet, size_t size) { 789 796 dag_record_t *erfptr = 0; 797 uint16_t wlen; 798 790 799 assert(packet); 791 800 erfptr = (dag_record_t *)packet->header; … … 800 809 * return the wrong value. */ 801 810 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; 804 819 } 805 820 -
lib/format_etsilive.c
r32ee9b2 r2044185 83 83 etsithread_t *receivers; 84 84 int nextthreadid; 85 wandder_etsispec_t *shareddec; 85 86 } etsilive_format_data_t; 86 87 … … 227 228 FORMAT_DATA->listenport = strdup(scan + 1); 228 229 230 FORMAT_DATA->shareddec = wandder_create_etsili_decoder(); 231 229 232 return 0; 230 233 } … … 240 243 if (FORMAT_DATA->listenport) { 241 244 free(FORMAT_DATA->listenport); 245 } 246 if (FORMAT_DATA->shareddec) { 247 wandder_free_etsili_decoder(FORMAT_DATA->shareddec); 242 248 } 243 249 free(libtrace->format_data); … … 522 528 packet->wire_length = esock->cached.length; 523 529 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 */532 530 533 531 /* Advance the read pointer for this buffer … … 589 587 590 588 /* Should never get here because cache is set when packet is read */ 591 wandder_etsispec_t *dec;592 589 size_t reclen; 590 libtrace_t *libtrace = packet->trace; 591 592 assert(libtrace); 593 assert(FORMAT_DATA->shareddec); 593 594 594 595 /* 0 should be ok here for quickly evaluating the first length 595 596 * 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); 600 601 601 602 return reclen; … … 607 608 } 608 609 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; 610 static uint64_t etsilive_get_erf_timestamp(const libtrace_packet_t *packet) { 611 return packet->order; 624 612 } 625 613 … … 652 640 NULL, /* get_direction */ 653 641 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 */ 656 644 NULL, /* get_timespec */ 657 645 NULL, /* get_seconds */ -
lib/format_linux_common.c
r47d4f8c rebed638 232 232 close(stream->fd); 233 233 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;240 234 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 */ 241 245 } 242 246 -
lib/format_linux_ring.c
r8a63abd rebed638 252 252 char error[2048]; 253 253 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 254 263 /* We set the socket up the same and then convert it to PACKET_MMAP */ 255 264 if (linuxcommon_start_input_stream(libtrace, stream) < 0) … … 274 283 return 0; 275 284 } 285 286 static 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 276 313 277 314 static int linuxring_start_input(libtrace_t *libtrace) … … 622 659 /* If we own the packet (i.e. it's not a copy), we need to free it */ 623 660 if (packet->buf_control == TRACE_CTRL_EXTERNAL) { 624 /* Started should always match the existence of the rx_ring625 * in the parallel case still just check the first ring */626 assert(!!FORMAT_DATA_FIRST->rx_ring ==627 !!packet->trace->started);628 661 /* If we don't have a ring its already been destroyed */ 629 662 if (FORMAT_DATA_FIRST->rx_ring != MAP_FAILED) … … 742 775 NULL, /* config_output */ 743 776 linuxring_start_output, /* start_ouput */ 744 linux common_fin_input, /* fin_input */777 linuxring_fin_input, /* fin_input */ 745 778 linuxring_fin_output, /* fin_output */ 746 779 linuxring_read_packet, /* read_packet */ -
lib/format_ndag.c
rb135888 r857729e 187 187 char pstr[16]; 188 188 struct group_req greq; 189 int bufsize ;189 int bufsize, val; 190 190 191 191 int sock; … … 226 226 fprintf(stderr, 227 227 "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", 228 236 groupaddr, portstr, strerror(errno)); 229 237 goto sockcreateover; … … 542 550 #endif 543 551 544 close(src.sock); 552 if (src.sock != -1) { 553 close(src.sock); 554 } 545 555 } 546 556 if (receiver->knownmonitors) { … … 716 726 ssock = &(rt->sources[rt->sourcecount]); 717 727 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 725 728 for (i = 0; i < rt->monitorcount; i++) { 726 729 if (rt->knownmonitors[i].monitorid == src.monitor) { … … 748 751 ssock->savedsize[i] = 0; 749 752 } 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 } 750 764 751 765 #if HAVE_DECL_RECVMMSG … … 761 775 } 762 776 #else 763 ssock->singlemsg.msg_iov = (struct iovec *) malloc(sizeof(struct iovec));777 ssock->singlemsg.msg_iov = (struct iovec *) calloc(1, sizeof(struct iovec)); 764 778 #endif 765 779 … … 769 783 ssock->recordcount = 0; 770 784 rt->sourcecount += 1; 771 if (ssock->sock > rt->maxfd) {772 rt->maxfd = ssock->sock;773 }774 785 775 786 fprintf(stderr, "Added new stream %s:%u to thread %d\n", … … 947 958 MSG_DONTWAIT, NULL); 948 959 #else 960 if (avail != 1) { 961 return 0; 962 } 963 949 964 ret = recvmsg(ssock->sock, &(ssock->singlemsg), MSG_DONTWAIT); 950 965 #endif -
lib/format_pcap.c
r32ee9b2 r37ee856 500 500 /* Silently discard RT metadata packets and packets with an 501 501 * 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) { 503 503 return 0; 504 504 } … … 595 595 /* Silently discard RT metadata packets and packets with an 596 596 * 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) { 598 598 return 0; 599 599 } -
lib/format_pcapfile.c
r32ee9b2 r37ee856 432 432 /* Silently discard RT metadata packets and packets with an 433 433 * 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) { 435 435 return 0; 436 436 } -
lib/libtrace.h.in
r47d4f8c rfe4940e 347 347 348 348 /** Enumeration of link layer types supported by libtrace */ 349 typedef enum { 349 typedef enum { 350 TRACE_TYPE_CONTENT_INVALID = -2, /**< Packet contents are not valid */ 350 351 TRACE_TYPE_UNKNOWN = -1, /**< Unable to determine link type */ 351 352 /* TRACE_TYPE_LEGACY = 0 Obsolete */ … … 550 551 int wire_length; /**< Cached wire length */ 551 552 int payload_length; /**< Cached payload length */ 553 int framing_length; /**< Cached framing length */ 552 554 void *l2_header; /**< Cached link header */ 553 555 libtrace_linktype_t link_type; /**< Cached link type */ … … 567 569 pthread_mutex_t ref_lock; /**< Lock for reference counter */ 568 570 int refcount; /**< Reference counter */ 571 int which_trace_start; /**< Used to match packet to a started instance of the parent trace */ 569 572 570 573 } libtrace_packet_t; -
lib/libtrace_int.h
r823d8e1 r37ee856 337 337 /** Boolean flag indicating whether the trace has been started */ 338 338 bool started; 339 /** Number of times this trace has been started */ 340 int startcount; 339 341 /** Synchronise writes/reads across this format object and attached threads etc */ 340 342 pthread_mutex_t libtrace_lock; -
lib/linktypes.c
rb663d33 r91bd90e 112 112 break; 113 113 case TRACE_TYPE_UNKNOWN: 114 case TRACE_TYPE_CONTENT_INVALID: 114 115 break; 115 116 } … … 214 215 case TRACE_TYPE_ETSILI: 215 216 case TRACE_TYPE_UNKNOWN: 217 case TRACE_TYPE_CONTENT_INVALID: 216 218 break; 217 219 } … … 333 335 struct timeval tv; 334 336 static libtrace_t *trace = NULL; 337 335 338 switch(trace_get_link_type(packet)) { 336 339 case TRACE_TYPE_ATM: … … 371 374 } 372 375 376 trace->startcount = packet->trace->startcount; 373 377 packet->trace=trace; 374 378 -
lib/protocols_l2.c
rfa555ec rfe4940e 174 174 } 175 175 176 if (nextpayload != NULL ) {176 if (nextpayload != NULL && removed > 0) { 177 177 178 178 ethernet->ether_type = ntohs(finalethertype); … … 486 486 break; 487 487 case TRACE_TYPE_UNKNOWN: 488 case TRACE_TYPE_CONTENT_INVALID: 488 489 return NULL; 489 490 } … … 523 524 break; 524 525 case TRACE_TYPE_UNKNOWN: 526 case TRACE_TYPE_CONTENT_INVALID: 525 527 return NULL; 526 528 } … … 565 567 void *l; 566 568 567 if (linktype == TRACE_TYPE_UNKNOWN) { 569 if (linktype == TRACE_TYPE_UNKNOWN || 570 linktype == TRACE_TYPE_CONTENT_INVALID) { 568 571 fprintf(stderr, "Unable to determine linktype for packet\n"); 569 572 return NULL; … … 589 592 case TRACE_TYPE_NONDATA: 590 593 case TRACE_TYPE_ERF_META: 594 case TRACE_TYPE_CONTENT_INVALID: 591 595 case TRACE_TYPE_UNKNOWN: 592 596 return NULL; … … 693 697 case TRACE_TYPE_ERF_META: 694 698 case TRACE_TYPE_UNKNOWN: 699 case TRACE_TYPE_CONTENT_INVALID: 695 700 return NULL; 696 701 … … 744 749 case TRACE_TYPE_ERF_META: 745 750 case TRACE_TYPE_UNKNOWN: 751 case TRACE_TYPE_CONTENT_INVALID: 746 752 /* No MAC address */ 747 753 return NULL; -
lib/protocols_pktmeta.c
r59b2ed8 r37ee856 186 186 case TRACE_TYPE_OPENBSD_LOOP: 187 187 case TRACE_TYPE_UNKNOWN: 188 case TRACE_TYPE_CONTENT_INVALID: 188 189 return NULL; 189 190 } … … 249 250 case TRACE_TYPE_ERF_META: 250 251 case TRACE_TYPE_UNKNOWN: 252 case TRACE_TYPE_CONTENT_INVALID: 251 253 /* In this case, the pointer passed in does not point 252 254 * to a metadata header and so we cannot get the -
lib/protocols_transport.c
r6654714 r54a76f2 62 62 libtrace_tcp_t *tcp; 63 63 size_t len = 0; 64 uint8_t iplenzero = 0; 64 65 65 66 /* Just use the cached length if we can */ … … 78 79 if (rem < sizeof(libtrace_ip_t)) 79 80 return 0; 81 if (ntohs(ip->ip_len) == 0) { 82 iplenzero = 1; 83 break; 84 } 80 85 len = ntohs(ip->ip_len) - (4 * ip->ip_hl); 81 86 … … 90 95 return 0; 91 96 len = ntohs(ip6->plen); 97 if (len == 0) { 98 iplenzero = 1; 99 } 92 100 break; 93 101 default: 94 102 return 0; 95 103 } 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 } 96 123 97 124 layer = trace_get_transport(packet, &proto, &rem); -
lib/trace.c
r47d4f8c r0bb8d49 131 131 132 132 /* call all the constructors if they haven't yet all been called */ 133 __attribute__((constructor)) 133 134 static void trace_init(void) 134 135 { … … 265 266 libtrace->replayspeedup = 1; 266 267 libtrace->started=false; 268 libtrace->startcount=0; 267 269 libtrace->uridata = NULL; 268 270 libtrace->io = NULL; … … 534 536 } 535 537 } 536 538 libtrace->startcount ++; 537 539 libtrace->started=true; 538 540 return 0; … … 840 842 841 843 packet->buf_control=TRACE_CTRL_PACKET; 844 packet->which_trace_start = 0; 842 845 pthread_mutex_init(&(packet->ref_lock), NULL); 843 846 trace_clear_cache(packet); … … 846 849 847 850 DLLEXPORT 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)); 850 858 if (!dest) { 851 859 printf("Out of memory constructing packet\n"); … … 866 874 dest->hash = packet->hash; 867 875 dest->error = packet->error; 876 dest->which_trace_start = packet->which_trace_start; 868 877 /* Reset the cache - better to recalculate than try to convert 869 878 * the values over to the new packet */ … … 978 987 * structure */ 979 988 packet->trace = libtrace; 989 packet->which_trace_start = libtrace->startcount; 980 990 ret=libtrace->format->read_packet(libtrace,packet); 981 991 if (ret==(size_t)READ_MESSAGE || … … 1008 1018 ++libtrace->accepted_packets; 1009 1019 } 1010 trace_packet_set_order(packet, libtrace->sequence_number); 1020 if (packet->order == 0) { 1021 trace_packet_set_order(packet, libtrace->sequence_number); 1022 } 1011 1023 ++libtrace->sequence_number; 1012 1024 if (!libtrace_parallel && packet->trace == libtrace) … … 1103 1115 int cap_len; 1104 1116 int wire_len; 1117 libtrace_linktype_t ltype; 1105 1118 1106 1119 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 1108 1133 if (remaining) { 1109 1134 /* I think we should choose the minimum of the capture and … … 1158 1183 */ 1159 1184 DLLEXPORT 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 1160 1189 if (packet->trace->format->get_erf_timestamp) { 1161 1190 /* timestamp -> timestamp */ … … 1194 1223 struct timeval tv; 1195 1224 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) { 1197 1230 /* timeval -> timeval */ 1198 1231 tv = packet->trace->format->get_timeval(packet); … … 1227 1260 struct timespec ts; 1228 1261 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) { 1230 1266 return packet->trace->format->get_timespec(packet); 1231 1267 } else if (packet->trace->format->get_erf_timestamp) { … … 1238 1274 ts.tv_sec += 1; 1239 1275 } 1240 return ts;1241 1276 } else if (packet->trace->format->get_timeval) { 1242 1277 /* timeval -> timespec */ … … 1244 1279 ts.tv_sec = tv.tv_sec; 1245 1280 ts.tv_nsec = tv.tv_usec*1000; 1246 return ts;1247 1281 } else if (packet->trace->format->get_seconds) { 1248 1282 /* seconds -> timespec */ … … 1250 1284 ts.tv_sec = (uint32_t)seconds; 1251 1285 ts.tv_nsec = (long)(((seconds - ts.tv_sec) * 1000000000)/UINT_MAX); 1252 return ts;1253 1286 } 1254 1287 else { 1255 1288 ts.tv_sec=-1; 1256 1289 ts.tv_nsec=-1; 1257 return ts;1258 } 1290 } 1291 return ts; 1259 1292 } 1260 1293 … … 1266 1299 DLLEXPORT double trace_get_seconds(const libtrace_packet_t *packet) { 1267 1300 double seconds = 0.0; 1301 1302 if (packet->which_trace_start != packet->trace->startcount) { 1303 return 0.0; 1304 } 1268 1305 1269 1306 if (packet->trace->format->get_seconds) { … … 1293 1330 { 1294 1331 /* Cache the capture length */ 1332 if (packet->which_trace_start != packet->trace->startcount) { 1333 return ~0U; 1334 } 1295 1335 if (packet->capture_length == -1) { 1296 1336 if (!packet->trace->format->get_capture_length) … … 1315 1355 DLLEXPORT size_t trace_get_wire_length(const libtrace_packet_t *packet){ 1316 1356 1357 if (packet->which_trace_start != packet->trace->startcount) { 1358 return ~0U; 1359 } 1360 1317 1361 if (packet->wire_length == -1) { 1318 1362 if (!packet->trace->format->get_wire_length) … … 1335 1379 DLLEXPORT SIMPLE_FUNCTION 1336 1380 size_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 1337 1389 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; 1339 1393 } 1340 1394 return ~0U; … … 1347 1401 */ 1348 1402 DLLEXPORT 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 } 1349 1407 1350 1408 if (packet->link_type == 0) { … … 1664 1722 { 1665 1723 assert(packet); 1724 if (packet->which_trace_start != packet->trace->startcount) { 1725 return (libtrace_direction_t)~0U; 1726 } 1666 1727 if (packet->trace->format->get_direction) { 1667 1728 return packet->trace->format->get_direction(packet); … … 2349 2410 packet->capture_length = -1; 2350 2411 packet->wire_length = -1; 2412 packet->framing_length = -1; 2351 2413 packet->payload_length = -1; 2352 2414 packet->l2_remaining = 0; … … 2354 2416 packet->l4_remaining = 0; 2355 2417 packet->refcount = 0; 2356 2357 2418 } 2358 2419 -
lib/trace_parallel.c
rc95ef4a r37ee856 1345 1345 return -1; 1346 1346 } 1347 packets[i]->which_trace_start = libtrace->startcount; 1347 1348 } 1348 1349 do { … … 1460 1461 if (err == 0) { 1461 1462 libtrace->started = true; 1463 libtrace->startcount ++; 1462 1464 libtrace_change_state(libtrace, STATE_RUNNING, false); 1463 1465 } … … 1777 1779 } 1778 1780 1779 if (ret !=0) {1781 if (ret < 0) { 1780 1782 goto cleanup_none; 1781 1783 } … … 1863 1865 /* Threads don't start */ 1864 1866 libtrace->started = true; 1867 libtrace->startcount ++; 1865 1868 libtrace_change_state(libtrace, STATE_RUNNING, false); 1866 1869
Note: See TracChangeset
for help on using the changeset viewer.