Changeset 25a3255
- Timestamp:
- 11/23/18 17:11:33 (2 years ago)
- Branches:
- develop
- Children:
- 2ceec6a
- Parents:
- 89cc0cc
- Location:
- lib
- Files:
-
- 17 edited
Legend:
- Unmodified
- Added
- Removed
-
lib/format_dpdkndag.c
r2725318 r25a3255 89 89 if (!libtrace->format_data) { 90 90 trace_set_err(libtrace, TRACE_ERR_INIT_FAILED, "Unable to allocate memory dpdknday_init_input()"); 91 return 1;91 return -1; 92 92 } 93 93 -
lib/format_helper.c
rde060a8 r25a3255 69 69 struct timeval tv; 70 70 71 assert(trace != NULL); 72 assert(packet != NULL); 73 71 /*assert(trace != NULL);*/ 72 if (!trace) { 73 fprintf(stderr, "NULL trace passed into trace_event_device()\n"); 74 return; 75 } 76 /*assert(packet != NULL);*/ 77 if (!packet) { 78 trace_set_err(trace, TRACE_ERR_NULL_PACKET, "NULL packet passed into trace_event_device()"); 79 return; 80 } 81 74 82 FD_ZERO(&rfds); 75 83 FD_ZERO(&rfds_param); … … 290 298 va_list va; 291 299 va_start(va,msg); 292 assert(errcode != 0 && "An error occurred, but it is unknown what it is"); 300 /*assert(errcode != 0 && "An error occurred, but it is unknown what it is");*/ 301 if (errcode == 0) { 302 fprintf(stderr, "An error occurred, but it is unknown what it is"); 303 return; 304 } 293 305 trace->err.err_num=errcode; 294 306 if (errcode>0) { … … 313 325 va_list va; 314 326 va_start(va,msg); 315 assert(errcode != 0 && "An error occurred, but it is unknown what it is"); 327 /*assert(errcode != 0 && "An error occurred, but it is unknown what it is");*/ 328 if (errcode == 0) { 329 fprintf(stderr, "An error occurred, but is is unknown what is is"); 330 return; 331 } 316 332 trace->err.err_num=errcode; 317 333 if (errcode>0) { -
lib/format_legacy.c
r32ee9b2 r25a3255 258 258 break; 259 259 default: 260 assert(0); 260 /*assert(0);*/ 261 trace_set_err(libtrace, TRACE_ERR_BAD_FORMAT, "Invalid trace format type in legacy_read_packet()"); 262 return -1; 261 263 } 262 264 … … 392 394 static int legacypos_get_wire_length(const libtrace_packet_t *packet) { 393 395 legacy_pos_t *lpos = (legacy_pos_t *)packet->header; 394 assert(ntohl(lpos->wlen)>0); 396 /*assert(ntohl(lpos->wlen)>0);*/ 397 if (ntohl(lpos->wlen) <= 0) { 398 trace_set_err(packet->trace, TRACE_ERR_BAD_PACKET, "Packet wire length is less than 0 in legacypos_get_wire_length()"); 399 return -1; 400 } 395 401 return ntohl(lpos->wlen); 396 402 } -
lib/format_linux_int.c
r32ee9b2 r25a3255 451 451 452 452 struct libtrace_linuxnative_header *linux_hdr = NULL; 453 assert(packet); 453 /*assert(packet);*/ 454 if (!packet) { 455 fprintf(stderr, "NULL packet passed into linuxnative_set_capture_length()\n"); 456 return; 457 } 454 458 if (size > trace_get_capture_length(packet)) { 455 459 /* We should avoid making a packet larger */ -
lib/format_linux_ring.c
rebed638 r25a3255 149 149 150 150 /* In case we have some silly values*/ 151 assert(req->tp_block_size); 152 assert(req->tp_block_nr); 153 assert(req->tp_frame_size); 154 assert(req->tp_frame_nr); 155 assert(req->tp_block_size % req->tp_frame_size == 0); 151 /*assert(req->tp_block_size);*/ 152 if (!req->tp_block_size) { 153 fprintf(stderr, "Unexpected value req->tp_block_size in calculate_buffers()\n"); 154 } 155 /*assert(req->tp_block_nr);*/ 156 if (!req->tp_block_nr) { 157 fprintf(stderr, "Unexpected value req->tp_block_nr in calculate_buffers()\n"); 158 } 159 /*assert(req->tp_frame_size);*/ 160 if (!req->tp_frame_size) { 161 fprintf(stderr, "Unexpected value req->tp_frame_size in calculate_buffers()\n"); 162 } 163 /*assert(req->tp_frame_nr);*/ 164 if (!req->tp_frame_nr) { 165 fprintf(stderr, "Unexpected value req->tp_frame_nr in calculate_buffers()\n"); 166 } 167 /*assert(req->tp_block_size % req->tp_frame_size == 0);*/ 168 if (req->tp_block_size % req->tp_frame_size != 0) { 169 fprintf(stderr, "Unexpected value req->tp_block_size % req->tp_frame_size in calculate_buffers()\n"); 170 } 156 171 } 157 172 … … 448 463 size_t size) 449 464 { 450 assert(packet); 465 /*assert(packet);*/ 466 if (!packet) { 467 fprintf(stderr, "NULL packet passed into linuxring_set_capture_length()\n"); 468 return; 469 } 451 470 if (size > trace_get_capture_length(packet)) { 452 471 /* We should avoid making a packet larger */ … … 506 525 packet->buf_control = TRACE_CTRL_EXTERNAL; 507 526 packet->type = TRACE_RT_DATA_LINUX_RING; 508 527 509 528 /* Fetch the current frame */ 510 529 header = GET_CURRENT_BUFFER(stream); 511 assert((((unsigned long) header) & (pagesize - 1)) == 0); 530 /*assert((((unsigned long) header) & (pagesize - 1)) == 0);*/ 531 if ((((unsigned long) header) & (pagesize - 1)) != 0) { 532 trace_set_err(libtrace, TRACE_ERR_BAD_IO, "Header of pagesize-1 is not zero in linux_read_string()"); 533 return -1; 534 } 512 535 513 536 /* TP_STATUS_USER means that we can use the frame. … … 655 678 if (packet->buffer == NULL) 656 679 return; 657 assert(packet->trace); 680 /*assert(packet->trace);*/ 681 if (!packet->trace) { 682 fprintf(stderr, "Packet contains a NULL trace in linuxring_fin_packet()\n"); 683 return; 684 } 658 685 659 686 /* If we own the packet (i.e. it's not a copy), we need to free it */ -
lib/format_ndag.c
r2725318 r25a3255 658 658 ssock->nextts = 0; 659 659 660 assert(ssock->nextread - ssock->saved[nr] <= ssock->savedsize[nr]); 660 /*assert(ssock->nextread - ssock->saved[nr] <= ssock->savedsize[nr]);*/ 661 if (ssock->nextread - ssock->saved[nr] > ssock->savedsize[nr]) { 662 trace_set_err(libtrace, TRACE_ERR_INIT_FAILED, "Failed to prepare packet stream in ndag_prepare_packet_stream()"); 663 return -1; 664 } 661 665 662 666 if (ssock->nextread - ssock->saved[nr] >= ssock->savedsize[nr]) { … … 685 689 uint32_t flags UNUSED) { 686 690 687 assert(0 && "Sending nDAG records over RT doesn't make sense! Please stop."); 691 /*assert(0 && "Sending nDAG records over RT doesn't make sense! Please stop.");*/ 692 fprintf(stderr, "Sending nDAG records over RT doesn't make sense! Please stop\n"); 688 693 return 0; 689 694 … … 868 873 } 869 874 #else 870 assert(required > 0); 875 /*assert(required > 0);*/ 876 if (required <= 0) { 877 fprintf(stderr, "You are required to have atleast 1 receiver in init_reveivers\n"); 878 return TRACE_ERR_INIT_FAILED; 879 } 871 880 ssock->singlemsg.msg_iov->iov_base = ssock->saved[wind]; 872 881 ssock->singlemsg.msg_iov->iov_len = ENCAP_BUFSIZE; … … 903 912 ssock->bufavail --; 904 913 905 assert(ssock->bufavail >= 0); 914 /*assert(ssock->bufavail >= 0);*/ 915 if (ssock->bufavail < 0) { 916 fprintf(stderr, "No space in buffer in check_ndag_received()\n"); 917 return -1; 918 } 906 919 if (ssock->nextwriteind >= ENCAP_BUFFERS) { 907 920 ssock->nextwriteind = 0; … … 1286 1299 src->bufavail += src->bufwaiting; 1287 1300 src->bufwaiting = 0; 1288 assert(src->bufavail >= 0 && src->bufavail <= ENCAP_BUFFERS); 1301 /*assert(src->bufavail >= 0 && src->bufavail <= ENCAP_BUFFERS);*/ 1302 if (src->bufavail < 0 && src->bufavail > ENCAP_BUFFERS) { 1303 trace_set_err(libtrace, TRACE_ERR_BAD_IO, "Not enough buffer space in ndag_pread_packets()"); 1304 return -1; 1305 } 1289 1306 } 1290 1307 … … 1375 1392 src->bufavail += src->bufwaiting; 1376 1393 src->bufwaiting = 0; 1377 assert(src->bufavail >= 0 && src->bufavail <= ENCAP_BUFFERS); 1394 /*assert(src->bufavail >= 0 && src->bufavail <= ENCAP_BUFFERS);*/ 1395 if (src->bufavail < 0 && src->bufavail > ENCAP_BUFFERS) { 1396 trace_set_err(libtrace, TRACE_ERR_BAD_IO, "Not enough buffer space in trace_event_ndag()"); 1397 break; /* breaking here cause error above also does? */ 1398 } 1378 1399 } 1379 1400 -
lib/format_pcap.c
r2725318 r25a3255 178 178 return -1; 179 179 } 180 assert(0); 180 /*assert(0);*/ 181 return -1; 181 182 } 182 183 … … 260 261 return -1; 261 262 } 262 assert(0); 263 /*assert(0);*/ 264 return -1; 263 265 } 264 266 … … 443 445 int linktype; 444 446 uint32_t flags = 0; 445 446 assert(libtrace->format_data); 447 448 /*assert(libtrace->format_data);*/ 449 if (!libtrace->format_data) { 450 trace_set_err(libtrace, TRACE_ERR_BAD_FORMAT, "Trace format data missing, call init_input() before calling pcap_read_packet()"); 451 return -1; 452 } 447 453 linktype = pcap_datalink(DATA(libtrace)->input.pcap); 448 454 packet->type = pcap_linktype_to_rt(linktype); … … 511 517 libtrace_packet_t *packet) 512 518 { 519 520 if (!libtrace) { 521 fprintf(stderr, "NULL trace passed into pcap_write_packet()\n"); 522 return TRACE_ERR_NULL_TRACE; 523 } 524 if (!packet) { 525 trace_set_err_out(libtrace, TRACE_ERR_NULL_PACKET, "NULL packet passed into pcap_write_packet()\n"); 526 return -1; 527 } 528 513 529 struct pcap_pkthdr pcap_pkt_hdr; 514 530 void *link; … … 595 611 pcap_pkt_hdr.len = trace_get_wire_length(packet); 596 612 597 assert(pcap_pkt_hdr.caplen<65536); 598 assert(pcap_pkt_hdr.len<65536); 613 /*assert(pcap_pkt_hdr.caplen<65536);*/ 614 if (pcap_pkt_hdr.caplen >= 65536) { 615 trace_set_err_out(libtrace, TRACE_ERR_BAD_HEADER, "Header capture length is larger than it should be in pcap_write_packet()"); 616 return -1; 617 } 618 /*assert(pcap_pkt_hdr.len<65536);*/ 619 if (pcap_pkt_hdr.len >= 65536) { 620 trace_set_err_out(libtrace, TRACE_ERR_BAD_HEADER, "Header wire length is larger than it should be pcap_write_packet()"); 621 return -1; 622 } 599 623 600 624 pcap_dump((u_char*)OUTPUT.trace.dump, &pcap_pkt_hdr, packet->payload); … … 690 714 691 715 static int pcap_get_capture_length(const libtrace_packet_t *packet) { 716 if (!packet) { 717 fprintf(stderr, "NULL packet passed into pcapng_get_capture_length()\n"); 718 return TRACE_ERR_NULL_PACKET; 719 } 692 720 struct pcap_pkthdr *pcapptr = 0; 693 721 pcapptr = (struct pcap_pkthdr *)packet->header; 694 assert(pcapptr->caplen<=65536); 722 /*assert(pcapptr->caplen<=65536);*/ 723 if (pcapptr->caplen > 65536) { 724 trace_set_err(packet->trace, TRACE_ERR_BAD_PACKET, "Capture length is to large, Packet may be corrupt in pcap_get_capture_length()"); 725 return -1; 726 } 695 727 696 728 return pcapptr->caplen; … … 724 756 static size_t pcap_set_capture_length(libtrace_packet_t *packet,size_t size) { 725 757 struct pcap_pkthdr *pcapptr = 0; 726 assert(packet); 758 /*assert(packet);*/ 759 if (!packet) { 760 fprintf(stderr, "NULL packet passed to pcap_set_capture_length()\n"); 761 return TRACE_ERR_NULL_PACKET; 762 } 727 763 if (size > trace_get_capture_length(packet)) { 728 764 /* Can't make a packet larger */ … … 737 773 738 774 static int pcap_get_fd(const libtrace_t *trace) { 739 740 assert(trace->format_data); 775 if (!trace) { 776 fprintf(stderr, "NULL trace passed to pcap_get_fd()\n"); 777 return TRACE_ERR_NULL_TRACE; 778 } 779 /*assert(trace->format_data);*/ 780 if (!trace->format_data) { 781 trace_set_err(trace, TRACE_ERR_BAD_FORMAT, "Trace format data missing, call init_input() before calling pcap_get_fd()"); 782 return -1; 783 } 741 784 return pcap_fileno(DATA(trace)->input.pcap); 742 785 } -
lib/format_pcapfile.c
r2725318 r25a3255 194 194 if (!DATA(libtrace)->started) { 195 195 196 if (!libtrace->io) 196 if (!libtrace->io) { 197 trace_set_err(libtrace, TRACE_ERR_BAD_IO, "Trace cannot start IO in pcapfile_start_input()"); 197 198 return -1; 199 } 198 200 199 201 err=wandio_read(libtrace->io, … … 202 204 203 205 DATA(libtrace)->started = true; 204 assert(sizeof(DATA(libtrace)->header) > 0); 205 206 /*assert(sizeof(DATA(libtrace)->header) > 0);*/ 207 if (!(sizeof(DATA(libtrace)->header) > 0)) { 208 trace_set_err(libtrace, TRACE_ERR_INIT_FAILED, "Trace is missing header in pcapfile_start_input()"); 209 return -1; 210 } 211 206 212 if (err<1) { 207 213 trace_set_err(libtrace, TRACE_ERR_INIT_FAILED, … … 209 215 return -1; 210 216 } 211 217 212 218 if (err != (int)sizeof(DATA(libtrace)->header)) { 213 219 trace_set_err(libtrace, TRACE_ERR_INIT_FAILED, … … 346 352 size_t bytes_to_read = 0; 347 353 348 assert(libtrace->format_data); 354 /*assert(libtrace->format_data);*/ 355 if (!libtrace->format_data) { 356 trace_set_err(libtrace, TRACE_ERR_BAD_FORMAT, 357 "Trace format data missing, call init_input() before calling pcapfile_read_packet()"); 358 return -1; 359 } 349 360 350 361 packet->type = pcap_linktype_to_rt(swapl(libtrace, … … 356 367 357 368 flags |= TRACE_PREP_OWN_BUFFER; 358 369 359 370 err=wandio_read(libtrace->io, 360 371 packet->buffer, … … 380 391 return -1; 381 392 } 382 383 assert(bytes_to_read < LIBTRACE_PACKET_BUFSIZE);384 393 385 394 /* If there is no payload to read, do not ask wandio_read to try and … … 447 456 TRACE_ERR_NO_CONVERSION, 448 457 "pcap does not support this format"); 449 assert(0);458 /*assert(0);*/ 450 459 return -1; 451 460 } … … 488 497 hdr.ts_usec = (uint32_t)tv.tv_usec; 489 498 hdr.caplen = trace_get_capture_length(packet); 490 assert(hdr.caplen < LIBTRACE_PACKET_BUFSIZE); 499 /*assert(hdr.caplen < LIBTRACE_PACKET_BUFSIZE);*/ 500 if (hdr.caplen >= LIBTRACE_PACKET_BUFSIZE) { 501 trace_set_err_out(out, TRACE_ERR_BAD_PACKET, "Capture length is greater than buffer size in pcap_write_packet()"); 502 return -1; 503 } 491 504 /* PCAP doesn't include the FCS in its wire length value, but we do */ 492 505 if (linktype==TRACE_TYPE_ETH) { … … 560 573 libtrace_pcapfile_pkt_hdr_t *hdr; 561 574 struct timeval ts; 562 563 assert(packet->header); 564 575 576 if (!packet) { 577 fprintf(stderr, "NULL packet passed to pcapfile_get_timeval()\n"); 578 return; 579 } 580 /*assert(packet->header);*/ 581 if (!packet->header) { 582 trace_set_err(packet->trace, TRACE_ERR_BAD_HEADER, "Trace with NULL header passed to pcapfile_get_timeval()"); 583 return; 584 } 585 565 586 hdr = (libtrace_pcapfile_pkt_hdr_t*)packet->header; 566 587 ts.tv_sec = swapl(packet->trace,hdr->ts_sec); … … 578 599 libtrace_pcapfile_pkt_hdr_t *hdr; 579 600 struct timespec ts; 580 581 assert(packet->header); 582 601 602 if (!packet) { 603 fprintf(stderr, "NULL packet passed to pcapfile_get_timespec()"); 604 return; 605 } 606 /*assert(packet->header);*/ 607 if (!packet->header) { 608 trace_set_err(packet->trace, TRACE_ERR_BAD_HEADER, "Trace with NULL header passed to pcapfile_get_timespec()"); 609 return; 610 } 611 583 612 hdr = (libtrace_pcapfile_pkt_hdr_t*)packet->header; 584 613 ts.tv_sec = swapl(packet->trace,hdr->ts_sec); … … 595 624 libtrace_pcapfile_pkt_hdr_t *pcapptr; 596 625 597 assert(packet->header); 626 if (!packet) { 627 fprintf(stderr, "NULL packet passed to pcapfile_get_capture_length()\n"); 628 return TRACE_ERR_NULL_PACKET; 629 } 630 /*assert(packet->header);*/ 631 if (!packet->header) { 632 trace_set_err(packet->trace, TRACE_ERR_BAD_HEADER, "Trace with NULL header passed to pcapfile_get_capture_length()"); 633 return -1; 634 } 598 635 pcapptr = (libtrace_pcapfile_pkt_hdr_t *)packet->header; 599 636 … … 604 641 libtrace_pcapfile_pkt_hdr_t *pcapptr; 605 642 606 assert(packet->header); 643 if (!packet) { 644 fprintf(stderr, "NULL packet passed to pcapfile_get_wire_length()\n"); 645 return TRACE_ERR_NULL_PACKET; 646 } 647 /*assert(packet->header); */ 648 if (!packet->header) { 649 trace_set_err(packet->trace, TRACE_ERR_BAD_HEADER, "Trace with NULL header passed to pcapfile_get_wire_length()"); 650 return -1; 651 } 607 652 608 653 pcapptr = (libtrace_pcapfile_pkt_hdr_t *)packet->header; … … 643 688 static size_t pcapfile_set_capture_length(libtrace_packet_t *packet,size_t size) { 644 689 libtrace_pcapfile_pkt_hdr_t *pcapptr = 0; 645 assert(packet); 646 assert(packet->header); 690 /*assert(packet);*/ 691 if (!packet) { 692 fprintf(stderr, "NULL packet passed into pcapfile_set_capture_length\n"); 693 return; 694 } 695 /*assert(packet->header);*/ 696 if (!packet->header) { 697 trace_set_err(packet->trace, TRACE_ERR_BAD_HEADER, "Trace with NULL header passed to pcapfile_set_capture_length()"); 698 return; 699 } 647 700 if (size > trace_get_capture_length(packet)) { 648 701 /* Can't make a packet larger */ -
lib/format_pcapng.c
r2725318 r25a3255 302 302 } 303 303 304 assert((char *)blockhdr < *pktbuf); 304 /*assert((char *)blockhdr < *pktbuf);*/ 305 if (!((char *)blockhdr < *pktbuf)) { 306 return NULL; 307 } 305 308 // Check if we have reached the end of the block, +4 for trailing block-size 306 309 // We cannot assume a endofopt, so we add one … … 456 459 } 457 460 458 assert(sechdr->blocktype == PCAPNG_SECTION_TYPE); 461 /*assert(sechdr->blocktype == PCAPNG_SECTION_TYPE);*/ 462 if (sechdr->blocktype != PCAPNG_SECTION_TYPE) { 463 trace_set_err(libtrace, TRACE_ERR_BAD_PACKET, "Section is not a pcapng section type"); 464 return -1; 465 } 459 466 460 467 if (sechdr->ordering == 0x1A2B3C4D) { … … 531 538 532 539 if (DATA(libtrace)->byteswapped) { 533 assert(byteswap32(inthdr->blocktype) == PCAPNG_INTERFACE_TYPE); 540 /*assert(byteswap32(inthdr->blocktype) == PCAPNG_INTERFACE_TYPE);*/ 541 if (byteswap32(inthdr->blocktype) != PCAPNG_INTERFACE_TYPE) { 542 trace_set_err(libtrace, TRACE_ERR_BAD_PACKET, "Interface is not a pcapng type"); 543 return -1; 544 } 534 545 newint->snaplen = byteswap32(inthdr->snaplen); 535 546 newint->linktype = byteswap16(inthdr->linktype); 536 547 } else { 537 assert(inthdr->blocktype == PCAPNG_INTERFACE_TYPE); 548 /*assert(inthdr->blocktype == PCAPNG_INTERFACE_TYPE);*/ 549 if (inthdr->blocktype != PCAPNG_INTERFACE_TYPE) { 550 trace_set_err(libtrace, TRACE_ERR_BAD_PACKET, "Interface is not a pcapng type"); 551 return -1; 552 } 538 553 newint->snaplen = inthdr->snaplen; 539 554 newint->linktype = inthdr->linktype; … … 606 621 /* Read the rest of the packet into the buffer */ 607 622 if (DATA(libtrace)->byteswapped) { 608 assert(byteswap32(hdr->blocktype) == PCAPNG_NAME_RESOLUTION_TYPE); 623 /*assert(byteswap32(hdr->blocktype) == PCAPNG_NAME_RESOLUTION_TYPE);*/ 624 if (byteswap32(hdr->blocktype) != PCAPNG_NAME_RESOLUTION_TYPE) { 625 trace_set_err(libtrace, TRACE_ERR_BAD_PACKET, "Blocktype is not a pcapng name resolution type"); 626 return -1; 627 } 609 628 } else { 610 assert(hdr->blocktype == PCAPNG_NAME_RESOLUTION_TYPE); 629 /*assert(hdr->blocktype == PCAPNG_NAME_RESOLUTION_TYPE);*/ 630 if (hdr->blocktype != PCAPNG_NAME_RESOLUTION_TYPE) { 631 trace_set_err(libtrace, TRACE_ERR_BAD_PACKET, "Blocktype is not a pcapng name resolution type"); 632 return -1; 633 } 611 634 } 612 635 … … 640 663 /* Read the rest of the packet into the buffer */ 641 664 if (DATA(libtrace)->byteswapped) { 642 assert(byteswap32(hdr->blocktype) == PCAPNG_CUSTOM_TYPE || 643 byteswap32(hdr->blocktype) == PCAPNG_CUSTOM_NONCOPY_TYPE); 665 /*assert(byteswap32(hdr->blocktype) == PCAPNG_CUSTOM_TYPE || 666 byteswap32(hdr->blocktype) == PCAPNG_CUSTOM_NONCOPY_TYPE);*/ 667 if (byteswap32(hdr->blocktype) != PCAPNG_CUSTOM_TYPE || 668 byteswap32(hdr->blocktype) != PCAPNG_CUSTOM_NONCOPY_TYPE) { 669 trace_set_err(libtrace, TRACE_ERR_BAD_PACKET, "Blocktype is not pcapng custom type"); 670 return -1; 671 } 644 672 } else { 645 assert(hdr->blocktype == PCAPNG_CUSTOM_TYPE || 646 hdr->blocktype == PCAPNG_CUSTOM_NONCOPY_TYPE); 673 /*assert(hdr->blocktype == PCAPNG_CUSTOM_TYPE || 674 hdr->blocktype == PCAPNG_CUSTOM_NONCOPY_TYPE);*/ 675 if (hdr->blocktype != PCAPNG_CUSTOM_TYPE || 676 hdr->blocktype != PCAPNG_CUSTOM_NONCOPY_TYPE) { 677 trace_set_err(libtrace, TRACE_ERR_BAD_PACKET, "Blocktype is not pcapng custom type"); 678 return -1; 679 } 647 680 } 648 681 … … 677 710 /* Read the rest of the packet into the buffer */ 678 711 if (DATA(libtrace)->byteswapped) { 679 assert(byteswap32(hdr->blocktype) == PCAPNG_INTERFACE_STATS_TYPE); 712 /*assert(byteswap32(hdr->blocktype) == PCAPNG_INTERFACE_STATS_TYPE);*/ 713 if (byteswap32(hdr->blocktype) != PCAPNG_INTERFACE_STATS_TYPE) { 714 trace_set_err(libtrace, TRACE_ERR_BAD_PACKET, "Blocktype is not a pcapng stats type"); 715 return -1; 716 } 680 717 ifaceid = byteswap32(hdr->interfaceid); 681 718 timestamp = ((uint64_t)(byteswap32(hdr->timestamp_high)) << 32) + byteswap32(hdr->timestamp_low); 682 719 } else { 683 assert(hdr->blocktype == PCAPNG_INTERFACE_STATS_TYPE); 720 /*assert(hdr->blocktype == PCAPNG_INTERFACE_STATS_TYPE);*/ 721 if (hdr->blocktype != PCAPNG_INTERFACE_STATS_TYPE) { 722 trace_set_err(libtrace, TRACE_ERR_BAD_PACKET, "Blocktype is not a pcapng stats type"); 723 return -1; 724 } 684 725 ifaceid = hdr->interfaceid; 685 726 timestamp = ((uint64_t)(hdr->timestamp_high) << 32) + … … 776 817 /* Read the rest of the packet into the buffer */ 777 818 if (DATA(libtrace)->byteswapped) { 778 assert(byteswap32(hdr->blocktype) == PCAPNG_SIMPLE_PACKET_TYPE); 819 /*assert(byteswap32(hdr->blocktype) == PCAPNG_SIMPLE_PACKET_TYPE);*/ 820 if (byteswap32(hdr->blocktype) != PCAPNG_SIMPLE_PACKET_TYPE) { 821 trace_set_err(libtrace, TRACE_ERR_BAD_PACKET, "Blocktype is not a pcapng simple type"); 822 return -1; 823 } 779 824 caplen = byteswap32(hdr->blocklen) - sizeof(pcapng_spkt_t) - 4; 780 825 /* account for trailing length field */ 781 826 } else { 782 assert(hdr->blocktype == PCAPNG_SIMPLE_PACKET_TYPE); 827 /*assert(hdr->blocktype == PCAPNG_SIMPLE_PACKET_TYPE);*/ 828 if (hdr->blocktype != PCAPNG_SIMPLE_PACKET_TYPE) { 829 trace_set_err(libtrace, TRACE_ERR_BAD_PACKET, "Blocktype is not a pcapng simple type"); 830 } 783 831 caplen = hdr->blocklen - sizeof(pcapng_spkt_t) - 4; 784 832 /* account for trailing length field */ … … 826 874 /* Read the rest of the packet into the buffer */ 827 875 if (DATA(libtrace)->byteswapped) { 828 assert(byteswap32(hdr->blocktype) == PCAPNG_ENHANCED_PACKET_TYPE); 876 /*assert(byteswap32(hdr->blocktype) == PCAPNG_ENHANCED_PACKET_TYPE);*/ 877 if (byteswap32(hdr->blocktype) != PCAPNG_ENHANCED_PACKET_TYPE) { 878 trace_set_err(libtrace, TRACE_ERR_BAD_PACKET, "Blocktype is not a pcapng enhanced type"); 879 return -1; 880 } 829 881 caplen = byteswap32(hdr->caplen); 830 882 ifaceid = byteswap32(hdr->interfaceid); 831 883 } else { 832 assert(hdr->blocktype == PCAPNG_ENHANCED_PACKET_TYPE); 884 /*assert(hdr->blocktype == PCAPNG_ENHANCED_PACKET_TYPE);*/ 885 if (hdr->blocktype != PCAPNG_ENHANCED_PACKET_TYPE) { 886 trace_set_err(libtrace, TRACE_ERR_BAD_PACKET, "Blocktype is not a pcapng enhanced type"); 887 return -1; 888 } 833 889 caplen = hdr->caplen; 834 890 ifaceid = hdr->interfaceid; … … 899 955 int gotpacket = 0; 900 956 957 /* Ensure trace and packet are not NULL */ 958 if (!libtrace) { 959 fprintf(stderr, "NULL trace passed into pcapng_read_packet()\n"); 960 return TRACE_ERR_NULL_TRACE; 961 } 962 if (!packet) { 963 trace_set_err(libtrace, TRACE_ERR_NULL_PACKET, "NULL packet passed into pcapng_read_packet()\n"); 964 return -1; 965 } 966 901 967 /* Peek to get next block type */ 902 assert(libtrace->format_data); 903 assert(libtrace->io); 968 /*assert(libtrace->format_data);*/ 969 if (!libtrace->format_data) { 970 trace_set_err(libtrace, TRACE_ERR_BAD_FORMAT, "Trace has no format data in pcapng_read_packet()"); 971 return -1; 972 } 973 /*assert(libtrace->io);*/ 974 if (!libtrace->io) { 975 trace_set_err(libtrace, TRACE_ERR_BAD_IO, "Trace has no IO associated with it in pcapng_read_packet()"); 976 return -1; 977 } 904 978 905 979 if (!packet->buffer || packet->buf_control == TRACE_CTRL_EXTERNAL) { … … 1042 1116 pcapng_interface_t *interface; 1043 1117 1044 assert(packet->header); 1118 if (!packet) { 1119 fprintf(stderr, "NULL packet passed into pcapng_get_timespec()"); 1120 return; 1121 } 1122 /*assert(packet->header);*/ 1123 if (!packet->header) { 1124 trace_set_err(packet->trace, TRACE_ERR_BAD_PACKET, "NULL header in packet in pcapng_get_timespec()"); 1125 return; 1126 } 1045 1127 1046 1128 ts.tv_sec = 0; -
lib/format_rt.c
r2725318 r25a3255 611 611 packet->payload = RT_INFO->buf_read + sizeof(rt_header_t); 612 612 packet->internalid = libtrace_push_into_bucket(RT_INFO->bucket); 613 assert(packet->internalid != 0); 613 /*assert(packet->internalid != 0);*/ 614 if (!packet->internalid) { 615 trace_set_err(libtrace, TRACE_ERR_RT_FAILURE, "packet->internalid is 0 in rt_get_next_packet()"); 616 return -1; 617 } 614 618 packet->srcbucket = RT_INFO->bucket; 615 619 packet->buf_control = TRACE_CTRL_EXTERNAL; … … 756 760 libtrace_err_t read_err; 757 761 758 assert(trace); 759 assert(packet); 760 762 /*assert(trace);*/ 763 if (!trace) { 764 fprintf(stderr, "NULL trace passed into trace_event_rt()\n"); 765 return; 766 } 767 /*assert(packet);*/ 768 if (!packet) { 769 trace_set_err(trace, TRACE_ERR_NULL_PACKET, "NULL packet passed into trace_event_rt()"); 770 return; 771 } 772 761 773 if (trace->format->get_fd) { 762 774 event.fd = trace->format->get_fd(trace); -
lib/libtrace.h.in
r89cc0cc r25a3255 326 326 /** Unable to create deadtrace **/ 327 327 TRACE_ERR_CREATE_DEADTRACE = -21, 328 /** Bad linktype **/ 329 TRACE_ERR_BAD_LINKTYPE = -22, 330 /** Bad IO for the trace **/ 331 TRACE_ERR_BAD_IO = -23, 332 /** Trace has bad header **/ 333 TRACE_ERR_BAD_HEADER = -24, 328 334 }; 329 335 … … 419 425 TRACE_FORMAT_DPDK_NDAG =20, /**< DAG multicast over a network, received via DPDK */ 420 426 TRACE_FORMAT_ETSILIVE =21, /**< ETSI LI over a network */ 427 TRACE_FORMAT_UNKNOWN =22, /** Unknown format */ 421 428 }; 422 429 … … 1546 1553 * 1547 1554 */ 1548 DLLEXPORT inttrace_destroy(libtrace_t *trace);1555 DLLEXPORT void trace_destroy(libtrace_t *trace); 1549 1556 1550 1557 /** Close a dummy trace file, freeing up any resources it may have been using 1551 1558 * @param trace The dummy trace to be destroyed 1552 1559 */ 1553 DLLEXPORT inttrace_destroy_dead(libtrace_t *trace);1560 DLLEXPORT void trace_destroy_dead(libtrace_t *trace); 1554 1561 1555 1562 /** Close an output trace, freeing up any resources it may have been using 1556 1563 * @param trace The output trace to be destroyed 1557 1564 */ 1558 DLLEXPORT inttrace_destroy_output(libtrace_out_t *trace);1565 DLLEXPORT void trace_destroy_output(libtrace_out_t *trace); 1559 1566 1560 1567 /** Flush an output trace, forcing any buffered packets to be written -
lib/linktypes.c
r91bd90e r25a3255 162 162 163 163 fprintf(stderr, "Error: RT type %u cannot be converted to a pcap DLT\n", rt_type); 164 assert(false);164 /*assert(false);*/ 165 165 return 0; /* satisfy warnings */ 166 166 } -
lib/protocols_l2.c
rfe4940e r25a3255 194 194 */ 195 195 void *trace_get_payload_from_mpls(void *ethernet, uint16_t *type, 196 uint32_t *remaining) 197 { 198 199 assert(type); 196 uint32_t *remaining) { 197 /* Ensure supplied type is not NULL */ 198 /*assert(type);*/ 199 if (!type) { 200 fprintf(stderr, "NULL type passed into trace_get_payload_from_mpls()\n"); 201 return NULL; 202 } 203 200 204 if ((((char*)ethernet)[2]&0x01)==0) { 201 205 /* The MPLS Stack bit is set */ … … 327 331 void *trace_get_payload_from_pppoe(void *link, uint16_t *type, 328 332 uint32_t *remaining) { 329 assert(type); 330 333 /* Ensure type supplied is not NULL */ 334 /*assert(type);*/ 335 if (!type) { 336 fprintf(stderr, "NULL type passed into trace_get_payload_from_pppoe()\n"); 337 return NULL; 338 } 339 331 340 if (remaining) { 332 341 if (*remaining < sizeof(libtrace_pppoe_t)) { … … 437 446 uint32_t dummyrem; 438 447 void *meta = NULL; 439 440 assert(packet != NULL); 441 assert(linktype != NULL); 448 449 /*assert(packet != NULL);*/ 450 if (!packet) { 451 fprintf(stderr, "NULL packet passed into trace_get_layer2()\n"); 452 return NULL; 453 } 454 /*assert(linktype != NULL);*/ 455 if (!linktype) { 456 fprintf(stderr, "NULL linktype passed into trace_get_layer2()\n"); 457 return NULL; 458 } 442 459 443 460 if (remaining == NULL) … … 668 685 669 686 DLLEXPORT uint8_t *trace_get_source_mac(libtrace_packet_t *packet) { 687 /* Ensure the supplied packet is not NULL */ 688 if (!packet) { 689 fprintf(stderr, "NULL packet passed into trace_get_source_mac()\n"); 690 return NULL; 691 } 692 670 693 void *link; 671 694 uint32_t remaining; 672 695 libtrace_linktype_t linktype; 673 assert(packet);674 696 link = trace_get_layer2(packet,&linktype,&remaining); 675 697 … … 705 727 case TRACE_TYPE_80211_RADIO: 706 728 case TRACE_TYPE_ETSILI: 707 assert(!"Metadata headers should already be skipped"); 708 break; 729 /*assert(!"Metadata headers should already be skipped");*/ 730 fprintf(stderr, "Metadata headers should already be skipped in trace_get_source_mac()\n"); 731 return NULL; 709 732 } 710 733 fprintf(stderr,"%s not implemented for linktype %i\n", __func__, linktype); 711 assert(0);734 /*assert(0);*/ 712 735 return NULL; 713 736 } 714 737 715 DLLEXPORT uint8_t *trace_get_destination_mac(libtrace_packet_t *packet) 716 { 738 DLLEXPORT uint8_t *trace_get_destination_mac(libtrace_packet_t *packet) { 739 /* Ensure the supplied packet is not NULL */ 740 if (!packet) { 741 fprintf(stderr, "NULL packet passed into trace_get_destination_mac()\n"); 742 return NULL; 743 } 744 717 745 void *link; 718 746 libtrace_linktype_t linktype; … … 757 785 case TRACE_TYPE_80211_RADIO: 758 786 case TRACE_TYPE_ETSILI: 759 assert(!"Metadata headers should already be skipped"); 760 break; 787 /*assert(!"Metadata headers should already be skipped");*/ 788 fprintf(stderr, "Metadata headers should already be skipped in trace_get_destination_mac()\n"); 789 return NULL; 761 790 } 762 791 fprintf(stderr,"Not implemented\n"); 763 assert(0);792 /*assert(0);*/ 764 793 return NULL; 765 794 } -
lib/protocols_l3.c
r6654714 r25a3255 103 103 void *trans_ptr = 0; 104 104 105 assert(ipptr != NULL); 106 105 /*assert(ipptr != NULL);*/ 106 if (!ipptr) { 107 fprintf(stderr, "NULL libtrace_ip_t pointer passed into trace_get_payload_from_ip()\n"); 108 return NULL; 109 } 110 107 111 /* Er? IPv5? */ 108 112 if (ipptr->ip_v != 4) … … 137 141 138 142 void *trace_get_payload_from_ip6(libtrace_ip6_t *ipptr, uint8_t *prot, 139 uint32_t *remaining) 140 { 143 uint32_t *remaining) { 141 144 void *payload = (char*)ipptr+sizeof(libtrace_ip6_t); 142 145 uint8_t nxt; 143 146 uint16_t len; 144 147 145 assert (ipptr != NULL); 146 nxt = ipptr->nxt; 148 /*assert (ipptr != NULL);*/ 149 if (!ipptr) { 150 fprintf(stderr, "NULL libtrace_ip6_t passed into trace_get_payload_from_ip6()\n"); 151 return NULL; 152 } 153 154 nxt = ipptr->nxt; 147 155 if (remaining) { 148 156 if (*remaining<sizeof(libtrace_ip6_t)) { … … 342 350 return 1; 343 351 } 344 assert(0);352 /*assert(0);*/ 345 353 } 346 354 … … 348 356 int spacelen) { 349 357 350 assert(addrptr && space); 351 assert(spacelen > 0); 352 358 /*assert(addrptr && space);*/ 359 if (!addrptr) { 360 fprintf(stderr, "NULL sockaddr passed into sockaddr_to_string()\n"); 361 return NULL; 362 } 363 if (!space) { 364 fprintf(stderr, "NULL space passed into sockaddr_to_string()\n"); 365 return NULL; 366 } 367 /*assert(spacelen > 0);*/ 368 if (spacelen <= 0) { 369 fprintf(stderr, "Spacelen must be greater than 0 when passed into sockaddr_to_string()\n"); 370 return NULL; 371 } 372 353 373 if (addrptr->sa_family == AF_INET) { 354 374 struct sockaddr_in *v4 = (struct sockaddr_in *)addrptr; -
lib/protocols_ospf.c
ree6e802 r25a3255 41 41 remaining = &dummy_rem; 42 42 43 assert(version != NULL && "version may not be NULL when calling trace_get_ospf_header!"); 43 if (!packet) { 44 fprintf(stderr, "NULL packet passed into trace_get_ospf_version()\n"); 45 return NULL; 46 } 47 /*assert(version != NULL && "version may not be NULL when calling trace_get_ospf_header!");*/ 48 if (!version) { 49 fprintf(stderr, "NULL version passed into trace_get_ospf_version()\n"); 50 return NULL; 51 } 44 52 45 53 ospf = trace_get_transport(packet, &proto, remaining); … … 62 70 char *ptr; 63 71 64 assert(remaining != NULL && "remaining may not be NULL when calling trace_get_ospf_contents!"); 72 /*assert(remaining != NULL && "remaining may not be NULL when calling trace_get_ospf_contents!");*/ 73 if (!remaining) { 74 fprintf(stderr, "Remaining may not be NULL when calling trace_get_ospf_contents()\n"); 75 return NULL; 76 } 77 if (!header) { 78 fprintf(stderr, "Header may not be NULL when calling trace_get_ospf_contents()\n"); 79 return NULL; 80 } 65 81 66 82 if (!ospf_type) 67 83 ospf_type = &dummy_type; 68 84 69 if ( !header ||*remaining < sizeof(libtrace_ospf_v2_t)) {85 if (*remaining < sizeof(libtrace_ospf_v2_t)) { 70 86 *ospf_type = 0; 71 87 *remaining = 0; 88 fprintf(stderr, "Remaining may not be less than the size of libtrace_ospf_v2_t when calling trace_get_ospf_contents()\n"); 72 89 return NULL; 73 90 } … … 87 104 88 105 unsigned char *link_ptr = NULL; 89 assert(remaining != NULL && "remaining may not be NULL when calling trace_get_first_link_from_router_lsa_v2!"); 90 91 if (!lsa || *remaining < sizeof(libtrace_ospf_router_lsa_v2_t)) { 92 *remaining = 0; 106 /*assert(remaining != NULL && "remaining may not be NULL when calling trace_get_first_link_from_router_lsa_v2!");*/ 107 if (!remaining) { 108 fprintf(stderr, "Remaining may not be NULL when calling trace_get_first_link_from_router_lsa_v2()\n"); 109 return NULL; 110 } 111 if (!lsa) { 112 fprintf(stderr, "NULL lsa passed into trace_get_first_link_from_router_lsa_v2()\n"); 113 return NULL; 114 } 115 116 if (*remaining < sizeof(libtrace_ospf_router_lsa_v2_t)) { 117 *remaining = 0; 118 fprintf(stderr, "Remaining may not be less than the size of libtrace_ospf_router_lsa_v2_t when calling trace_get_first_ospf_link_from_router_lsa_v2()\n"); 93 119 return NULL; 94 120 } … … 106 132 unsigned char *lsa_ptr = NULL; 107 133 108 assert(remaining != NULL && "remaining may not be NULL when calling trace_get_first_ospf_v2_lsa!"); 109 110 if (!db_desc || *remaining < sizeof(libtrace_ospf_db_desc_v2_t)) { 111 *remaining = 0; 134 /*assert(remaining != NULL && "remaining may not be NULL when calling trace_get_first_ospf_v2_lsa!");*/ 135 if (!remaining) { 136 fprintf(stderr, "Remaining may not be NULL when calling trace_get_first_ospf_v2_lsa()\n"); 137 return NULL; 138 } 139 if (!db_desc) { 140 fprintf(stderr, "db_desc may not be NULL when calling trace_get_first_ospf_v2_lsa()\n"); 141 return NULL; 142 } 143 144 if (*remaining < sizeof(libtrace_ospf_db_desc_v2_t)) { 145 *remaining = 0; 146 fprintf(stderr, "Remaining may not be less than the size of libtrace_ospf_db_desc_v2_t when calling trace_get_first_ospf_lsa_from_db_desc_v2()\n"); 112 147 return NULL; 113 148 } … … 125 160 unsigned char *lsa_ptr = NULL; 126 161 127 assert(remaining != NULL && "remaining may not be NULL when calling trace_get_first_ospf_v2_lsa!"); 128 129 if (!ls_update || *remaining < sizeof(libtrace_ospf_ls_update_t)) { 130 *remaining = 0; 162 /*assert(remaining != NULL && "remaining may not be NULL when calling trace_get_first_ospf_v2_lsa!");*/ 163 if (!remaining) { 164 fprintf(stderr, "Remaining may not be NULL when calling trace_get_first_ospf_v2_lsa()\n"); 165 return NULL; 166 } 167 if (!ls_update) { 168 fprintf(stderr, "ls_update may not be NULL when calling trace_get_first_ospf_v2_lsa()\n"); 169 return NULL; 170 } 171 172 if (*remaining < sizeof(libtrace_ospf_ls_update_t)) { 173 *remaining = 0; 174 fprintf(stderr, "Remaining may not be less than the size of an ls_update when calling trace_get_first_ospf_v2_lsa()\n"); 131 175 return NULL; 132 176 } … … 143 187 uint32_t metric = 0; 144 188 145 assert(as_lsa); 189 /*assert(as_lsa);*/ 190 if (!as_lsa) { 191 fprintf(stderr, "NULL as_lsa passed into trace_get_ospf_metric_from_as_external_lsa_v2()\n"); 192 return; 193 } 146 194 147 195 metric = as_lsa->metric_a << 16; … … 157 205 uint32_t metric = 0; 158 206 159 assert(sum_lsa); 207 /*assert(sum_lsa);*/ 208 if (!sum_lsa) { 209 fprintf(stderr, "NULL sum_lsa passed into trace_get_ospf_metric_from_summary_lsa_v2()\n"); 210 return; 211 } 160 212 161 213 metric = sum_lsa->metric_a << 16; -
lib/protocols_pktmeta.c
r37ee856 r25a3255 156 156 uint32_t dummyrem; 157 157 void *pktbuf = NULL; 158 assert(packet != NULL); 159 assert(linktype != NULL); 160 161 if (remaining == NULL) 158 /*assert(packet != NULL);*/ 159 if (!packet) { 160 fprintf(stderr, "NULL packet passed into trace_get_packet_meta()"); 161 return NULL; 162 } 163 /*assert(linktype != NULL);*/ 164 if (!linktype) { 165 fprintf(stderr, "NULL linkype passed into trace_get_packet_meta()"); 166 return NULL; 167 } 168 169 if (remaining == NULL) 162 170 remaining = &dummyrem; 163 171 164 172 pktbuf = trace_get_packet_buffer(packet, linktype, remaining); 165 173 switch (*linktype) { … … 198 206 uint32_t *remaining) 199 207 { 200 void *nexthdr; 208 void *nexthdr; 201 209 uint16_t arphrd = 0; 202 210 uint16_t next = 0; 203 204 assert(meta != NULL); 205 assert(linktype != NULL); 206 assert(remaining != NULL); 207 211 212 /*assert(meta != NULL);*/ 213 if (!meta) { 214 fprintf(stderr, "NULL meta passed into trace_get_payload_from_meta()"); 215 return NULL; 216 } 217 /*assert(linktype != NULL);*/ 218 if (!linktype) { 219 fprintf(stderr, "NULL linktype passed into trace_get_payload_from_meta()"); 220 return NULL; 221 } 222 /*assert(remaining != NULL);*/ 223 if (!remaining) { 224 fprintf(stderr, "NULL remaining passed into trace_get_payload_from_meta()"); 225 return NULL; 226 } 227 208 228 switch(*linktype) { 209 229 case TRACE_TYPE_LINUX_SLL: -
lib/trace.c
r89cc0cc r25a3255 122 122 char *ret=(char*)malloc(n+1); 123 123 if (ret==NULL) { 124 fprintf(stderr,"Out of memory ");124 fprintf(stderr,"Out of memory\n"); 125 125 exit(EXIT_FAILURE); 126 126 } … … 248 248 249 249 if (!libtrace) { 250 /* Out of memory */250 fprintf(stderr, "Unable to allocate memory in trace_create()\n"); 251 251 return NULL; 252 252 } … … 254 254 /*assert(uri && "Passing NULL to trace_create makes me a very sad program");*/ 255 255 if(!uri) { 256 trace_set_err(libtrace, TRACE_ERR_URI_NULL, " Passing NULL to trace_create makes me a very sad program");256 trace_set_err(libtrace, TRACE_ERR_URI_NULL, "NULL uri passed to trace_create()"); 257 257 return libtrace; 258 258 } … … 276 276 libtrace->accepted_packets = 0; 277 277 libtrace->last_packet = NULL; 278 278 279 279 /* Parallel inits */ 280 280 ASSERT_RET(pthread_mutex_init(&libtrace->libtrace_lock, NULL), == 0); … … 509 509 510 510 if (libtrace->format->init_output) { 511 /* 0 on success, -1 on failure */ 512 switch(libtrace->format->init_output(libtrace)) { 513 case -1: /* failure */ 514 return libtrace; 515 case 0: /* success */ 516 break; 517 default: 518 /* Should never get here */ 519 assert(!"Internal error: init_output() should return -1 for failure, or 0 for success"); 511 int err = libtrace->format->init_output(libtrace); 512 if (err == -1) { 513 /* init_output should call trace_set_err to set the 514 * error message 515 */ 516 return libtrace; 520 517 } 521 518 } else { … … 541 538 /*assert(libtrace);*/ 542 539 if(!libtrace) { 540 fprintf(stderr, "NULL trace passed to trace_start()\n"); 543 541 return TRACE_ERR_NULL_TRACE; 544 542 } … … 562 560 /*assert(libtrace);*/ 563 561 if(!libtrace) { 562 fprintf(stderr, "NULL trace passed to trace_start_output()\n"); 564 563 return TRACE_ERR_NULL_TRACE; 565 564 } … … 579 578 /*assert(libtrace);*/ 580 579 if(!libtrace) { 580 fprintf(stderr, "NULL trace passed to trace_pause()\n"); 581 581 return TRACE_ERR_NULL_TRACE; 582 582 } … … 731 731 * 732 732 */ 733 DLLEXPORT inttrace_destroy(libtrace_t *libtrace) {733 DLLEXPORT void trace_destroy(libtrace_t *libtrace) { 734 734 int i; 735 735 736 736 /*assert(libtrace);*/ 737 737 if(!libtrace) { 738 return TRACE_ERR_NULL_TRACE; 738 fprintf(stderr, "NULL trace passed to trace_destory()\n"); 739 return; 739 740 } 740 741 … … 761 762 if (libtrace->last_packet != NULL) { 762 763 trace_set_err(libtrace, TRACE_ERR_PAUSE_FIN, "Unable to remove all data stored against trace in trace_destroy()"); 763 return -1;764 return; 764 765 } 765 766 … … 826 827 827 828 free(libtrace); 828 829 return 0; 830 } 831 832 833 DLLEXPORT int trace_destroy_dead(libtrace_t *libtrace) { 829 } 830 831 832 DLLEXPORT void trace_destroy_dead(libtrace_t *libtrace) { 834 833 /*assert(libtrace);*/ 835 834 if(!libtrace) { 836 return TRACE_ERR_NULL_TRACE; 835 fprintf(stderr, "NULL trace passed to trace_destory_dead()\n"); 836 return; 837 837 } 838 838 … … 847 847 free(libtrace->format_data); 848 848 free(libtrace); 849 850 return 0;851 849 } 852 850 /* Close an output trace file, freeing up any resources it may have been using … … 854 852 * @param libtrace the output trace file to be destroyed 855 853 */ 856 DLLEXPORT inttrace_destroy_output(libtrace_out_t *libtrace) {854 DLLEXPORT void trace_destroy_output(libtrace_out_t *libtrace) { 857 855 /*assert(libtrace);*/ 858 856 if(!libtrace) { 859 return TRACE_ERR_NULL_TRACE; 857 fprintf(stderr, "NULL trace passed to trace_destroy_output()\n"); 858 return; 860 859 } 861 860 if (libtrace->format && libtrace->format->fin_output) … … 864 863 free(libtrace->uridata); 865 864 free(libtrace); 866 867 return 0;868 865 } 869 866 870 867 DLLEXPORT int trace_flush_output(libtrace_out_t *libtrace) { 871 868 if (!libtrace) { 869 fprintf(stderr, "NULL trace passed to trace_flush_output()\n"); 872 870 return TRACE_ERR_NULL_TRACE; 873 871 } … … 875 873 return libtrace->format->flush_output(libtrace); 876 874 } 877 return 0; 875 876 return 0; 878 877 } 879 878 … … 1005 1004 /*assert(libtrace && "You called trace_read_packet() with a NULL libtrace parameter!\n");*/ 1006 1005 if (!libtrace) { 1006 fprintf(stderr, "NULL trace passed to trace_read_packet()\n"); 1007 1007 return TRACE_ERR_NULL_TRACE; 1008 1008 } 1009 1009 1010 1010 if (trace_is_err(libtrace)) 1011 /*trace_set_err(libtrace, TRACE_ERR_BAD_STATE, "Trace is in an error state trace_read_packet()");*/ 1011 1012 return -1; 1012 1013 1013 1014 if (!libtrace->started) { 1014 trace_set_err(libtrace,TRACE_ERR_BAD_STATE,"You must call libtrace_start() before trace_read_packet() \n");1015 trace_set_err(libtrace,TRACE_ERR_BAD_STATE,"You must call libtrace_start() before trace_read_packet()"); 1015 1016 return -1; 1016 1017 } … … 1018 1019 /*assert(packet);*/ 1019 1020 if (!packet) { 1020 trace_set_err(libtrace, TRACE_ERR_NULL_PACKET, " Packet passed into trace_read_packet() is NULL");1021 trace_set_err(libtrace, TRACE_ERR_NULL_PACKET, "NULL packet passed into trace_read_packet()"); 1021 1022 return -1; 1022 1023 } … … 1024 1025 if (!(packet->buf_control==TRACE_CTRL_PACKET 1025 1026 || packet->buf_control==TRACE_CTRL_EXTERNAL)) { 1026 trace_set_err(libtrace,TRACE_ERR_BAD_STATE,"Packet passed to trace_read_packet() is invalid \n");1027 trace_set_err(libtrace,TRACE_ERR_BAD_STATE,"Packet passed to trace_read_packet() is invalid"); 1027 1028 return -1; 1028 1029 } … … 1110 1111 /*assert(trace);*/ 1111 1112 if (!trace) { 1113 fprintf(stderr, "NULL trace passed into trace_prepare_packet()\n"); 1112 1114 return TRACE_ERR_NULL_TRACE; 1113 1115 } … … 1115 1117 /*assert(packet);*/ 1116 1118 if (!packet) { 1117 trace_set_err(trace, TRACE_ERR_NULL_TRACE, " Packet passed into trace_prepare_packet() is NULL");1119 trace_set_err(trace, TRACE_ERR_NULL_TRACE, "NULL packet passed into trace_prepare_packet()"); 1118 1120 return -1; 1119 1121 } 1120 1122 1121 1123 if (!buffer) { 1122 trace_set_err(trace, TRACE_ERR_NULL_BUFFER, " Buffer passed into trace_prepare_packet() is NULL");1124 trace_set_err(trace, TRACE_ERR_NULL_BUFFER, "NULL buffer passed into trace_prepare_packet()"); 1123 1125 return -1; 1124 1126 } 1125 1127 1126 1128 if (!(packet->buf_control==TRACE_CTRL_PACKET || packet->buf_control==TRACE_CTRL_EXTERNAL)) { 1127 trace_set_err(trace,TRACE_ERR_BAD_STATE,"Packet passed to trace_read_packet() is invalid \n");1129 trace_set_err(trace,TRACE_ERR_BAD_STATE,"Packet passed to trace_read_packet() is invalid"); 1128 1130 return -1; 1129 1131 } … … 1140 1142 } 1141 1143 trace_set_err(trace, TRACE_ERR_UNSUPPORTED, 1142 "This format does not support preparing packets \n");1144 "This format does not support preparing packets"); 1143 1145 return -1; 1144 1146 … … 1154 1156 /*assert(libtrace);*/ 1155 1157 if (!libtrace) { 1158 fprintf(stderr, "NULL trace passed into trace_write_packet()\n"); 1156 1159 return TRACE_ERR_NULL_TRACE; 1157 1160 } 1158 1161 /*assert(packet);*/ 1159 1162 if (!packet) { 1160 trace_set_err_out(libtrace, TRACE_ERR_NULL_PACKET, " Packet passed into trace_write_packet() is NULL");1163 trace_set_err_out(libtrace, TRACE_ERR_NULL_PACKET, "NULL trace passed into trace_write_packet()"); 1161 1164 return -1; 1162 1165 } … … 1191 1194 /*assert(packet != NULL);*/ 1192 1195 if (!packet) { 1196 fprintf(stderr, "NULL packet passed into trace_get_packet_buffer()\n"); 1193 1197 return NULL; 1194 1198 } … … 1226 1230 /*assert(cap_len >= 0);*/ 1227 1231 if (!(cap_len >= 0)) { 1232 fprintf(stderr, "Was expecting capture length of atleast 0 in trace_get_packet_buffer()\n"); 1228 1233 return NULL; 1229 1234 } … … 1419 1424 } 1420 1425 1421 assert(packet->capture_length < LIBTRACE_PACKET_BUFSIZE); 1426 /*assert(packet->capture_length < LIBTRACE_PACKET_BUFSIZE);*/ 1427 if (!(packet->capture_length < LIBTRACE_PACKET_BUFSIZE)) { 1428 fprintf(stderr, "Capture length is greater than the buffer size in trace_get_capture_length()\n"); 1429 return 0; 1430 /* should we be returning ~OU here? */ 1431 } 1422 1432 1423 1433 return packet->capture_length; … … 1444 1454 } 1445 1455 1446 assert(packet->wire_length < LIBTRACE_PACKET_BUFSIZE); 1456 /*assert(packet->wire_length < LIBTRACE_PACKET_BUFSIZE);*/ 1457 if (!(packet->wire_length < LIBTRACE_PACKET_BUFSIZE)) { 1458 fprintf(stderr, "Wire length is greater than the buffer size in trace_get_wire_length()\n"); 1459 return 0; 1460 /* should we be returning ~OU here? */ 1461 } 1447 1462 return packet->wire_length; 1448 1463 … … 1509 1524 libtrace_eventobj_t event = {TRACE_EVENT_IOWAIT,0,0.0,0}; 1510 1525 1526 1527 /*assert(trace && "You called trace_event() with a NULL trace object!");*/ 1511 1528 if (!trace) { 1512 fprintf(stderr,"You called trace_event() with a NULL trace object!\n"); 1513 assert(trace); 1514 } 1529 fprintf(stderr, "NULL trace passed into trace_event()"); 1530 return; 1531 } 1532 /*assert(packet && "You called trace_event() with a NULL packet object!");*/ 1515 1533 if (!packet) { 1516 fprintf(stderr, "You called trace_event() with a NULL packet object!\n"); 1517 assert(packet); 1518 } 1519 /*assert(trace);*/ 1520 /*assert(packet);*/ 1534 trace_set_err(trace, TRACE_ERR_NULL_PACKET, "NULL packet passed into trace_event()"); 1535 return; 1536 } 1521 1537 1522 1538 /* Free the last packet */ … … 1622 1638 1623 1639 if (!packet) { 1640 fprintf(stderr, "NULL packet passed into trace_bpf_compile()"); 1624 1641 return TRACE_ERR_NULL_PACKET; 1625 1642 } 1626 1643 1627 /*assert(filter );*/1644 /*assert(filter && "You called trace_bpf_compile() with a NULL filter");*/ 1628 1645 if (!filter) { 1629 1646 trace_set_err(packet->trace, … … 1664 1681 1500U); 1665 1682 /* build filter */ 1666 /*assert(pcap );*/1683 /*assert(pcap && "Unable to open pcap_t for compiling filters trace_bpf_compile()");*/ 1667 1684 if (!pcap) { 1668 1685 trace_set_err(packet->trace, TRACE_ERR_BAD_FILTER, … … 1708 1725 #endif 1709 1726 1710 /*assert(packet );*/1727 /*assert(packet && "You called trace_apply_filter() with a NULL packet");*/ 1711 1728 if (!packet) { 1729 fprintf(stderr, "NULL packet passed into trace_apply_filter()\n"); 1712 1730 return TRACE_ERR_NULL_PACKET; 1713 1731 } 1714 /*assert(filter );*/1732 /*assert(filter && "You called trace_apply_filter() with a NULL filter");*/ 1715 1733 if (!filter) { 1716 1734 trace_set_err(packet->trace, TRACE_ERR_NULL_FILTER, 1717 " Filter is NULLtrace_apply_filter()");1735 "NULL filter passed into trace_apply_filter()"); 1718 1736 return -1; 1719 1737 } … … 1790 1808 if (!filter->flag) { 1791 1809 trace_set_err(packet->trace, TRACE_ERR_BAD_FILTER, 1792 " Cannot apply a bad filtertrace_apply_filter()");1810 "Bad filter passed into trace_apply_filter()"); 1793 1811 return -1; 1794 1812 } … … 1821 1839 /*assert(packet);*/ 1822 1840 if (!packet) { 1823 /* Cannot return direction of a null packet so just 1824 * return unknown */ 1825 return (libtrace_direction_t)~0U; 1841 fprintf(stderr, "NULL packet passed into trace_set_direction()\n"); 1842 return (libtrace_direction_t)~0U; 1826 1843 } 1827 1844 if (packet->trace->format->set_direction) { … … 1843 1860 /*assert(packet);*/ 1844 1861 if (!packet) { 1845 /* Cannot return direction of a null packet so just 1846 * return unknown */ 1862 fprintf(stderr, "NULL packet passed into trace_set_direction()\n"); 1847 1863 return (libtrace_direction_t)~0U; 1848 1864 } … … 1985 2001 /*assert(packet);*/ 1986 2002 if (!packet) { 2003 fprintf(stderr, "NULL packet passed into trace_set_capture_length()\n"); 1987 2004 return ~0U; 1988 2005 } … … 2028 2045 enum base_format_t trace_get_format(libtrace_packet_t *packet) { 2029 2046 /* Not sure what to do here, can we add a new trace_format for errors? */ 2030 assert(packet); 2047 /*assert(packet);*/ 2048 if (!packet) { 2049 fprintf(stderr, "NULL packet passed into trace_get_format()\n"); 2050 return TRACE_FORMAT_UNKNOWN; 2051 } 2031 2052 2032 2053 return packet->trace->format->type; … … 2267 2288 /*assert(deadtrace);*/ 2268 2289 if (!deadtrace) { 2290 fprintf(stderr, "Unable to create dead trace trace_construct_packet()\n"); 2269 2291 return TRACE_ERR_CREATE_DEADTRACE; 2270 2292 } … … 2298 2320 uint64_t trace_get_received_packets(libtrace_t *trace) 2299 2321 { 2300 assert(trace);2301 2322 uint64_t ret; 2323 2324 /*assert(trace);*/ 2325 if (!trace) { 2326 fprintf(stderr, "NULL trace passed to trace_get_received_packets()\n"); 2327 /* When the number of received packets is not known we return UINT64_MAX */ 2328 return UINT64_MAX; 2329 } 2302 2330 2303 2331 if (trace->format->get_received_packets) { … … 2321 2349 uint64_t trace_get_filtered_packets(libtrace_t *trace) 2322 2350 { 2323 assert(trace); 2351 /*assert(trace);*/ 2352 if (!trace) { 2353 fprintf(stderr, "NULL trace passed to trace_get_filtered_packets()\n"); 2354 return UINT64_MAX; 2355 } 2324 2356 int i = 0; 2325 2357 uint64_t lib_filtered = trace->filtered_packets; … … 2352 2384 uint64_t trace_get_dropped_packets(libtrace_t *trace) 2353 2385 { 2354 assert(trace); 2386 /*assert(trace);*/ 2387 if (!trace) { 2388 fprintf(stderr, "NULL trace passed into trace_get_dropped_packets()\n"); 2389 return UINT64_MAX; 2390 } 2355 2391 uint64_t ret; 2356 2392 … … 2375 2411 uint64_t trace_get_accepted_packets(libtrace_t *trace) 2376 2412 { 2377 assert(trace); 2413 /*assert(trace);*/ 2414 if (!trace) { 2415 fprintf(stderr, "NULL trace passed into trace_get_accepted_packets()\n"); 2416 return UINT64_MAX; 2417 } 2378 2418 int i = 0; 2379 2419 uint64_t ret = 0; … … 2393 2433 uint64_t ret = 0; 2394 2434 int i; 2395 assert(trace); 2435 /*assert(trace);*/ 2436 if (!trace) { 2437 fprintf(stderr, "NULL trace passed into trace_get_statistics()\n"); 2438 return NULL; 2439 } 2396 2440 if (stat == NULL) { 2397 2441 if (trace->stats == NULL) … … 2399 2443 stat = trace->stats; 2400 2444 } 2401 assert(stat->magic == LIBTRACE_STAT_MAGIC && "Please use" 2402 "trace_create_statistics() to allocate statistics"); 2445 /*assert(stat->magic == LIBTRACE_STAT_MAGIC && "Please use" 2446 "trace_create_statistics() to allocate statistics");*/ 2447 if (!(stat->magic == LIBTRACE_STAT_MAGIC)) { 2448 trace_set_err(trace, TRACE_ERR_STAT, "Use trace_create_statistics() to allocate statistics in trace_get_statistics()"); 2449 return NULL; 2450 } 2403 2451 2404 2452 /* If the trace has paused or finished get the cached results */ … … 2448 2496 /*assert(trace && stat);*/ 2449 2497 if (!trace) { 2498 fprintf(stderr, "NULL trace passed into trace_get_thread_statistics()\n"); 2450 2499 return TRACE_ERR_NULL_TRACE; 2451 2500 } … … 2458 2507 if (!(stat->magic == LIBTRACE_STAT_MAGIC)) { 2459 2508 trace_set_err(trace, TRACE_ERR_STAT, 2460 "Use trace_create_statistics() to allocate statistics in tra ve_get_thread_statistics()");2509 "Use trace_create_statistics() to allocate statistics in trace_get_thread_statistics()"); 2461 2510 return -1; 2462 2511 } … … 2498 2547 || !(b->magic == LIBTRACE_STAT_MAGIC) 2499 2548 || !(c->magic == LIBTRACE_STAT_MAGIC)) { 2549 fprintf(stderr, "Use trace_create_statistics() to allocate statistics in trace_subtract_statistics()\n"); 2500 2550 return TRACE_ERR_STAT; 2501 2551 } … … 2525 2575 || !(b->magic == LIBTRACE_STAT_MAGIC) 2526 2576 || !(c->magic == LIBTRACE_STAT_MAGIC)) { 2577 fprintf(stderr, "Use trace_create_statistics() to allocate statistics in trace_add_statistics()\n"); 2527 2578 return TRACE_ERR_STAT; 2528 2579 } … … 2551 2602 "trace_create_statistics() to allocate statistics");*/ 2552 2603 if (!(s->magic == LIBTRACE_STAT_MAGIC)) { 2604 fprintf(stderr, "Use trace_create_statistics() to allocate statistics in trace_print_statistics\n"); 2553 2605 return TRACE_ERR_STAT; 2554 2606 } … … 2591 2643 2592 2644 void register_format(struct libtrace_format_t *f) { 2593 assert(f->next==NULL); /* Can't register a format twice */ 2645 /*assert(f->next==NULL);*/ /* Can't register a format twice */ 2646 if (!(f->next==NULL)) { 2647 fprintf(stderr, "You cannot register a format twice in register_format()"); 2648 return; 2649 } 2594 2650 f->next=formats_list; 2595 2651 formats_list=f;
Note: See TracChangeset
for help on using the changeset viewer.