- Timestamp:
- 11/14/18 11:18:51 (2 years ago)
- 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. - Location:
- lib
- Files:
-
- 16 edited
Legend:
- Unmodified
- Added
- Removed
-
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
rdc62550 r43aec21 349 349 350 350 /** Enumeration of link layer types supported by libtrace */ 351 typedef enum { 351 typedef enum { 352 TRACE_TYPE_CONTENT_INVALID = -2, /**< Packet contents are not valid */ 352 353 TRACE_TYPE_UNKNOWN = -1, /**< Unable to determine link type */ 353 354 /* TRACE_TYPE_LEGACY = 0 Obsolete */ … … 552 553 int wire_length; /**< Cached wire length */ 553 554 int payload_length; /**< Cached payload length */ 555 int framing_length; /**< Cached framing length */ 554 556 void *l2_header; /**< Cached link header */ 555 557 libtrace_linktype_t link_type; /**< Cached link type */ … … 569 571 pthread_mutex_t ref_lock; /**< Lock for reference counter */ 570 572 int refcount; /**< Reference counter */ 573 int which_trace_start; /**< Used to match packet to a started instance of the parent trace */ 571 574 572 575 } 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
rdc62550 r43aec21 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; … … 541 543 } 542 544 } 543 545 libtrace->startcount ++; 544 546 libtrace->started=true; 545 547 return 0; … … 847 849 848 850 packet->buf_control=TRACE_CTRL_PACKET; 851 packet->which_trace_start = 0; 849 852 pthread_mutex_init(&(packet->ref_lock), NULL); 850 853 trace_clear_cache(packet); … … 853 856 854 857 DLLEXPORT 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)); 857 865 if (!dest) { 858 866 printf("Out of memory constructing packet\n"); … … 873 881 dest->hash = packet->hash; 874 882 dest->error = packet->error; 883 dest->which_trace_start = packet->which_trace_start; 875 884 /* Reset the cache - better to recalculate than try to convert 876 885 * the values over to the new packet */ … … 985 994 * structure */ 986 995 packet->trace = libtrace; 996 packet->which_trace_start = libtrace->startcount; 987 997 ret=libtrace->format->read_packet(libtrace,packet); 988 998 if (ret==(size_t)READ_MESSAGE || … … 1015 1025 ++libtrace->accepted_packets; 1016 1026 } 1017 trace_packet_set_order(packet, libtrace->sequence_number); 1027 if (packet->order == 0) { 1028 trace_packet_set_order(packet, libtrace->sequence_number); 1029 } 1018 1030 ++libtrace->sequence_number; 1019 1031 if (!libtrace_parallel && packet->trace == libtrace) … … 1110 1122 int cap_len; 1111 1123 int wire_len; 1124 libtrace_linktype_t ltype; 1112 1125 1113 1126 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 1115 1140 if (remaining) { 1116 1141 /* I think we should choose the minimum of the capture and … … 1165 1190 */ 1166 1191 DLLEXPORT 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 1167 1196 if (packet->trace->format->get_erf_timestamp) { 1168 1197 /* timestamp -> timestamp */ … … 1201 1230 struct timeval tv; 1202 1231 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) { 1204 1237 /* timeval -> timeval */ 1205 1238 tv = packet->trace->format->get_timeval(packet); … … 1234 1267 struct timespec ts; 1235 1268 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) { 1237 1273 return packet->trace->format->get_timespec(packet); 1238 1274 } else if (packet->trace->format->get_erf_timestamp) { … … 1245 1281 ts.tv_sec += 1; 1246 1282 } 1247 return ts;1248 1283 } else if (packet->trace->format->get_timeval) { 1249 1284 /* timeval -> timespec */ … … 1251 1286 ts.tv_sec = tv.tv_sec; 1252 1287 ts.tv_nsec = tv.tv_usec*1000; 1253 return ts;1254 1288 } else if (packet->trace->format->get_seconds) { 1255 1289 /* seconds -> timespec */ … … 1257 1291 ts.tv_sec = (uint32_t)seconds; 1258 1292 ts.tv_nsec = (long)(((seconds - ts.tv_sec) * 1000000000)/UINT_MAX); 1259 return ts;1260 1293 } 1261 1294 else { 1262 1295 ts.tv_sec=-1; 1263 1296 ts.tv_nsec=-1; 1264 return ts;1265 } 1297 } 1298 return ts; 1266 1299 } 1267 1300 … … 1273 1306 DLLEXPORT double trace_get_seconds(const libtrace_packet_t *packet) { 1274 1307 double seconds = 0.0; 1308 1309 if (packet->which_trace_start != packet->trace->startcount) { 1310 return 0.0; 1311 } 1275 1312 1276 1313 if (packet->trace->format->get_seconds) { … … 1300 1337 { 1301 1338 /* Cache the capture length */ 1339 if (packet->which_trace_start != packet->trace->startcount) { 1340 return ~0U; 1341 } 1302 1342 if (packet->capture_length == -1) { 1303 1343 if (!packet->trace->format->get_capture_length) … … 1322 1362 DLLEXPORT size_t trace_get_wire_length(const libtrace_packet_t *packet){ 1323 1363 1364 if (packet->which_trace_start != packet->trace->startcount) { 1365 return ~0U; 1366 } 1367 1324 1368 if (packet->wire_length == -1) { 1325 1369 if (!packet->trace->format->get_wire_length) … … 1342 1386 DLLEXPORT SIMPLE_FUNCTION 1343 1387 size_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 1344 1396 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; 1346 1400 } 1347 1401 return ~0U; … … 1354 1408 */ 1355 1409 DLLEXPORT 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 } 1356 1414 1357 1415 if (packet->link_type == 0) { … … 1671 1729 { 1672 1730 assert(packet); 1731 if (packet->which_trace_start != packet->trace->startcount) { 1732 return (libtrace_direction_t)~0U; 1733 } 1673 1734 if (packet->trace->format->get_direction) { 1674 1735 return packet->trace->format->get_direction(packet); … … 2356 2417 packet->capture_length = -1; 2357 2418 packet->wire_length = -1; 2419 packet->framing_length = -1; 2358 2420 packet->payload_length = -1; 2359 2421 packet->l2_remaining = 0; … … 2361 2423 packet->l4_remaining = 0; 2362 2424 packet->refcount = 0; 2363 2364 2425 } 2365 2426 -
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.