Changeset 25a3255


Ignore:
Timestamp:
11/23/18 17:11:33 (2 years ago)
Author:
Jacob Van Walraven <jcv9@…>
Branches:
develop
Children:
2ceec6a
Parents:
89cc0cc
Message:

More assertion cleanup

Location:
lib
Files:
17 edited

Legend:

Unmodified
Added
Removed
  • lib/format_dpdkndag.c

    r2725318 r25a3255  
    8989        if (!libtrace->format_data) {
    9090                trace_set_err(libtrace, TRACE_ERR_INIT_FAILED, "Unable to allocate memory dpdknday_init_input()");
    91                 return 1;
     91                return -1;
    9292        }
    9393
  • lib/format_helper.c

    rde060a8 r25a3255  
    6969        struct timeval tv;
    7070
    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
    7482        FD_ZERO(&rfds);
    7583        FD_ZERO(&rfds_param);
     
    290298        va_list va;
    291299        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        }
    293305        trace->err.err_num=errcode;
    294306        if (errcode>0) {
     
    313325        va_list va;
    314326        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        }
    316332        trace->err.err_num=errcode;
    317333        if (errcode>0) {
  • lib/format_legacy.c

    r32ee9b2 r25a3255  
    258258                        break;
    259259                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;
    261263        }
    262264
     
    392394static int legacypos_get_wire_length(const libtrace_packet_t *packet) {
    393395        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        }
    395401        return ntohl(lpos->wlen);
    396402}
  • lib/format_linux_int.c

    r32ee9b2 r25a3255  
    451451
    452452        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        }
    454458        if (size > trace_get_capture_length(packet)) {
    455459                /* We should avoid making a packet larger */
  • lib/format_linux_ring.c

    rebed638 r25a3255  
    149149
    150150        /* 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        }
    156171}
    157172
     
    448463                                           size_t size)
    449464{
    450         assert(packet);
     465        /*assert(packet);*/
     466        if (!packet) {
     467                fprintf(stderr, "NULL packet passed into linuxring_set_capture_length()\n");
     468                return;
     469        }
    451470        if (size > trace_get_capture_length(packet)) {
    452471                /* We should avoid making a packet larger */
     
    506525        packet->buf_control = TRACE_CTRL_EXTERNAL;
    507526        packet->type = TRACE_RT_DATA_LINUX_RING;
    508        
     527
    509528        /* Fetch the current frame */
    510529        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        }
    512535
    513536        /* TP_STATUS_USER means that we can use the frame.
     
    655678        if (packet->buffer == NULL)
    656679                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        }
    658685
    659686        /* If we own the packet (i.e. it's not a copy), we need to free it */
  • lib/format_ndag.c

    r2725318 r25a3255  
    658658        ssock->nextts = 0;
    659659
    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        }
    661665
    662666        if (ssock->nextread - ssock->saved[nr] >= ssock->savedsize[nr]) {
     
    685689                uint32_t flags UNUSED) {
    686690
    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");
    688693        return 0;
    689694
     
    868873        }
    869874#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        }
    871880        ssock->singlemsg.msg_iov->iov_base = ssock->saved[wind];
    872881        ssock->singlemsg.msg_iov->iov_len = ENCAP_BUFSIZE;
     
    903912        ssock->bufavail --;
    904913
    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        }
    906919        if (ssock->nextwriteind >= ENCAP_BUFFERS) {
    907920                ssock->nextwriteind = 0;
     
    12861299                src->bufavail += src->bufwaiting;
    12871300                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                }
    12891306        }
    12901307
     
    13751392                src->bufavail += src->bufwaiting;
    13761393                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                }
    13781399        }
    13791400
  • lib/format_pcap.c

    r2725318 r25a3255  
    178178                        return -1;
    179179        }
    180         assert(0);
     180        /*assert(0);*/
     181        return -1;
    181182}
    182183
     
    260261                        return -1;
    261262        }
    262         assert(0);
     263        /*assert(0);*/
     264        return -1;
    263265}
    264266
     
    443445        int linktype;
    444446        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        }
    447453        linktype = pcap_datalink(DATA(libtrace)->input.pcap);
    448454        packet->type = pcap_linktype_to_rt(linktype);
     
    511517                libtrace_packet_t *packet)
    512518{
     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
    513529        struct pcap_pkthdr pcap_pkt_hdr;
    514530        void *link;
     
    595611                        pcap_pkt_hdr.len = trace_get_wire_length(packet);
    596612
    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                }
    599623
    600624                pcap_dump((u_char*)OUTPUT.trace.dump, &pcap_pkt_hdr, packet->payload);
     
    690714
    691715static 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        }
    692720        struct pcap_pkthdr *pcapptr = 0;
    693721        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        }
    695727
    696728        return pcapptr->caplen;
     
    724756static size_t pcap_set_capture_length(libtrace_packet_t *packet,size_t size) {
    725757        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        }
    727763        if (size > trace_get_capture_length(packet)) {
    728764                /* Can't make a packet larger */
     
    737773
    738774static 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        }
    741784        return pcap_fileno(DATA(trace)->input.pcap);
    742785}
  • lib/format_pcapfile.c

    r2725318 r25a3255  
    194194        if (!DATA(libtrace)->started) {
    195195
    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()");
    197198                        return -1;
     199                }
    198200
    199201                err=wandio_read(libtrace->io,
     
    202204
    203205                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
    206212                if (err<1) {
    207213                        trace_set_err(libtrace, TRACE_ERR_INIT_FAILED,
     
    209215                        return -1;
    210216                }
    211        
     217
    212218                if (err != (int)sizeof(DATA(libtrace)->header)) {
    213219                        trace_set_err(libtrace, TRACE_ERR_INIT_FAILED,
     
    346352        size_t bytes_to_read = 0;
    347353
    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        }
    349360
    350361        packet->type = pcap_linktype_to_rt(swapl(libtrace,
     
    356367
    357368        flags |= TRACE_PREP_OWN_BUFFER;
    358        
     369
    359370        err=wandio_read(libtrace->io,
    360371                        packet->buffer,
     
    380391                return -1;
    381392        }
    382 
    383         assert(bytes_to_read < LIBTRACE_PACKET_BUFSIZE);
    384393
    385394        /* If there is no payload to read, do not ask wandio_read to try and
     
    447456                                TRACE_ERR_NO_CONVERSION,
    448457                                "pcap does not support this format");
    449                         assert(0);
     458                        /*assert(0);*/
    450459                        return -1;
    451460                }
     
    488497        hdr.ts_usec = (uint32_t)tv.tv_usec;
    489498        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        }
    491504        /* PCAP doesn't include the FCS in its wire length value, but we do */
    492505        if (linktype==TRACE_TYPE_ETH) {
     
    560573        libtrace_pcapfile_pkt_hdr_t *hdr;
    561574        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
    565586        hdr = (libtrace_pcapfile_pkt_hdr_t*)packet->header;
    566587        ts.tv_sec = swapl(packet->trace,hdr->ts_sec);
     
    578599        libtrace_pcapfile_pkt_hdr_t *hdr;
    579600        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
    583612        hdr = (libtrace_pcapfile_pkt_hdr_t*)packet->header;
    584613        ts.tv_sec = swapl(packet->trace,hdr->ts_sec);
     
    595624        libtrace_pcapfile_pkt_hdr_t *pcapptr;
    596625
    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        }
    598635        pcapptr = (libtrace_pcapfile_pkt_hdr_t *)packet->header;
    599636
     
    604641        libtrace_pcapfile_pkt_hdr_t *pcapptr;
    605642
    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        }
    607652
    608653        pcapptr = (libtrace_pcapfile_pkt_hdr_t *)packet->header;
     
    643688static size_t pcapfile_set_capture_length(libtrace_packet_t *packet,size_t size) {
    644689        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        }
    647700        if (size > trace_get_capture_length(packet)) {
    648701                /* Can't make a packet larger */
  • lib/format_pcapng.c

    r2725318 r25a3255  
    302302        }
    303303
    304         assert((char *)blockhdr < *pktbuf);
     304        /*assert((char *)blockhdr < *pktbuf);*/
     305        if (!((char *)blockhdr < *pktbuf)) {
     306                return NULL;
     307        }
    305308        // Check if we have reached the end of the block, +4 for trailing block-size
    306309        // We cannot assume a endofopt, so we add one
     
    456459        }
    457460
    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        }
    459466
    460467        if (sechdr->ordering == 0x1A2B3C4D) {
     
    531538
    532539        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                }
    534545                newint->snaplen = byteswap32(inthdr->snaplen);
    535546                newint->linktype = byteswap16(inthdr->linktype);
    536547        } 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                }
    538553                newint->snaplen = inthdr->snaplen;
    539554                newint->linktype = inthdr->linktype;
     
    606621        /* Read the rest of the packet into the buffer */
    607622        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                }
    609628        } 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                }
    611634        }
    612635
     
    640663        /* Read the rest of the packet into the buffer */
    641664        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                }
    644672        } 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                }
    647680        }
    648681
     
    677710        /* Read the rest of the packet into the buffer */
    678711        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                }
    680717                ifaceid = byteswap32(hdr->interfaceid);
    681718                timestamp = ((uint64_t)(byteswap32(hdr->timestamp_high)) << 32) + byteswap32(hdr->timestamp_low);
    682719        } 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                }
    684725                ifaceid = hdr->interfaceid;
    685726                timestamp = ((uint64_t)(hdr->timestamp_high) << 32) +
     
    776817        /* Read the rest of the packet into the buffer */
    777818        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                }
    779824                caplen = byteswap32(hdr->blocklen) - sizeof(pcapng_spkt_t) - 4;
    780825                         /* account for trailing length field */
    781826        } 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                }
    783831                caplen = hdr->blocklen - sizeof(pcapng_spkt_t) - 4;
    784832                         /* account for trailing length field */
     
    826874        /* Read the rest of the packet into the buffer */
    827875        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                }
    829881                caplen = byteswap32(hdr->caplen);
    830882                ifaceid = byteswap32(hdr->interfaceid);
    831883        } 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                }
    833889                caplen = hdr->caplen;
    834890                ifaceid = hdr->interfaceid;
     
    899955        int gotpacket = 0;
    900956
     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
    901967        /* 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        }
    904978
    905979        if (!packet->buffer || packet->buf_control == TRACE_CTRL_EXTERNAL) {
     
    10421116        pcapng_interface_t *interface;
    10431117
    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        }
    10451127
    10461128        ts.tv_sec = 0;
  • lib/format_rt.c

    r2725318 r25a3255  
    611611        packet->payload = RT_INFO->buf_read + sizeof(rt_header_t);
    612612        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        }
    614618        packet->srcbucket = RT_INFO->bucket;
    615619        packet->buf_control = TRACE_CTRL_EXTERNAL;
     
    756760        libtrace_err_t read_err;
    757761
    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
    761773        if (trace->format->get_fd) {
    762774                event.fd = trace->format->get_fd(trace);
  • lib/libtrace.h.in

    r89cc0cc r25a3255  
    326326        /** Unable to create deadtrace **/
    327327        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,
    328334};
    329335
     
    419425        TRACE_FORMAT_DPDK_NDAG       =20,    /**< DAG multicast over a network, received via DPDK */
    420426        TRACE_FORMAT_ETSILIVE     =21,  /**< ETSI LI over a network */
     427        TRACE_FORMAT_UNKNOWN      =22,  /** Unknown format */
    421428};
    422429
     
    15461553 *
    15471554 */
    1548 DLLEXPORT int trace_destroy(libtrace_t *trace);
     1555DLLEXPORT void trace_destroy(libtrace_t *trace);
    15491556
    15501557/** Close a dummy trace file, freeing up any resources it may have been using
    15511558 * @param trace         The dummy trace to be destroyed
    15521559 */
    1553 DLLEXPORT int trace_destroy_dead(libtrace_t *trace);
     1560DLLEXPORT void trace_destroy_dead(libtrace_t *trace);
    15541561
    15551562/** Close an output trace, freeing up any resources it may have been using
    15561563 * @param trace         The output trace to be destroyed
    15571564 */
    1558 DLLEXPORT int trace_destroy_output(libtrace_out_t *trace);
     1565DLLEXPORT void trace_destroy_output(libtrace_out_t *trace);
    15591566
    15601567/** Flush an output trace, forcing any buffered packets to be written
  • lib/linktypes.c

    r91bd90e r25a3255  
    162162
    163163        fprintf(stderr, "Error: RT type %u cannot be converted to a pcap DLT\n", rt_type);
    164         assert(false);
     164        /*assert(false);*/
    165165        return 0;       /* satisfy warnings */
    166166}
  • lib/protocols_l2.c

    rfe4940e r25a3255  
    194194 */
    195195void *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
    200204        if ((((char*)ethernet)[2]&0x01)==0) {
    201205                /* The MPLS Stack bit is set */
     
    327331void *trace_get_payload_from_pppoe(void *link, uint16_t *type,
    328332                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
    331340        if (remaining) {
    332341                if (*remaining < sizeof(libtrace_pppoe_t)) {
     
    437446        uint32_t dummyrem;
    438447        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        }
    442459
    443460        if (remaining == NULL)
     
    668685
    669686DLLEXPORT 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
    670693        void *link;
    671694        uint32_t remaining;
    672695        libtrace_linktype_t linktype;
    673         assert(packet);
    674696        link = trace_get_layer2(packet,&linktype,&remaining);
    675697
     
    705727                case TRACE_TYPE_80211_RADIO:
    706728                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;
    709732        }
    710733        fprintf(stderr,"%s not implemented for linktype %i\n", __func__, linktype);
    711         assert(0);
     734        /*assert(0);*/
    712735        return NULL;
    713736}
    714737
    715 DLLEXPORT uint8_t *trace_get_destination_mac(libtrace_packet_t *packet)
    716 {
     738DLLEXPORT 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
    717745        void *link;
    718746        libtrace_linktype_t linktype;
     
    757785                case TRACE_TYPE_80211_RADIO:
    758786                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;
    761790        }
    762791        fprintf(stderr,"Not implemented\n");
    763         assert(0);
     792        /*assert(0);*/
    764793        return NULL;
    765794}
  • lib/protocols_l3.c

    r6654714 r25a3255  
    103103        void *trans_ptr = 0;
    104104
    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
    107111        /* Er? IPv5? */
    108112        if (ipptr->ip_v != 4)
     
    137141
    138142void *trace_get_payload_from_ip6(libtrace_ip6_t *ipptr, uint8_t *prot,
    139                 uint32_t *remaining)
    140 {
     143                uint32_t *remaining) {
    141144        void *payload = (char*)ipptr+sizeof(libtrace_ip6_t);
    142145        uint8_t nxt;
    143146        uint16_t len;
    144147
    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;
    147155        if (remaining) {
    148156                if (*remaining<sizeof(libtrace_ip6_t)) {
     
    342350                        return 1;
    343351        }
    344         assert(0);
     352        /*assert(0);*/
    345353}
    346354
     
    348356                int spacelen) {
    349357
    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
    353373        if (addrptr->sa_family == AF_INET) {
    354374                struct sockaddr_in *v4 = (struct sockaddr_in *)addrptr;
  • lib/protocols_ospf.c

    ree6e802 r25a3255  
    4141                remaining = &dummy_rem;
    4242
    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        }
    4452
    4553        ospf = trace_get_transport(packet, &proto, remaining);
     
    6270        char *ptr;
    6371
    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        }
    6581
    6682        if (!ospf_type)
    6783                ospf_type = &dummy_type;
    6884
    69         if (!header || *remaining < sizeof(libtrace_ospf_v2_t)) {
     85        if (*remaining < sizeof(libtrace_ospf_v2_t)) {
    7086                *ospf_type = 0;
    7187                *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");
    7289                return NULL;
    7390        }
     
    87104
    88105        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");
    93119                return NULL;
    94120        }
     
    106132        unsigned char *lsa_ptr = NULL;
    107133
    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");
    112147                return NULL;
    113148        }
     
    125160        unsigned char *lsa_ptr = NULL;
    126161
    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");
    131175                return NULL;
    132176        }
     
    143187        uint32_t metric = 0;
    144188
    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        }
    146194
    147195        metric = as_lsa->metric_a << 16;
     
    157205        uint32_t metric = 0;
    158206
    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        }
    160212
    161213        metric = sum_lsa->metric_a << 16;
  • lib/protocols_pktmeta.c

    r37ee856 r25a3255  
    156156        uint32_t dummyrem;
    157157        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)
    162170                remaining = &dummyrem;
    163        
     171
    164172        pktbuf = trace_get_packet_buffer(packet, linktype, remaining);
    165173        switch (*linktype) {
     
    198206                uint32_t *remaining)
    199207{
    200         void *nexthdr; 
     208        void *nexthdr;
    201209        uint16_t arphrd = 0;
    202210        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
    208228        switch(*linktype) {
    209229                case TRACE_TYPE_LINUX_SLL:
  • lib/trace.c

    r89cc0cc r25a3255  
    122122        char *ret=(char*)malloc(n+1);
    123123        if (ret==NULL) {
    124                 fprintf(stderr,"Out of memory");
     124                fprintf(stderr,"Out of memory\n");
    125125                exit(EXIT_FAILURE);
    126126        }
     
    248248
    249249        if (!libtrace) {
    250                 /* Out of memory */
     250                fprintf(stderr, "Unable to allocate memory in trace_create()\n");
    251251                return NULL;
    252252        }
     
    254254        /*assert(uri && "Passing NULL to trace_create makes me a very sad program");*/
    255255        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()");
    257257                return libtrace;
    258258        }
     
    276276        libtrace->accepted_packets = 0;
    277277        libtrace->last_packet = NULL;
    278        
     278
    279279        /* Parallel inits */
    280280        ASSERT_RET(pthread_mutex_init(&libtrace->libtrace_lock, NULL), == 0);
     
    509509
    510510        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;
    520517                }
    521518        } else {
     
    541538        /*assert(libtrace);*/
    542539        if(!libtrace) {
     540                fprintf(stderr, "NULL trace passed to trace_start()\n");
    543541                return TRACE_ERR_NULL_TRACE;
    544542        }
     
    562560        /*assert(libtrace);*/
    563561        if(!libtrace) {
     562                fprintf(stderr, "NULL trace passed to trace_start_output()\n");
    564563                return TRACE_ERR_NULL_TRACE;
    565564        }
     
    579578        /*assert(libtrace);*/
    580579        if(!libtrace) {
     580                fprintf(stderr, "NULL trace passed to trace_pause()\n");
    581581                return TRACE_ERR_NULL_TRACE;
    582582        }
     
    731731 *
    732732 */
    733 DLLEXPORT int trace_destroy(libtrace_t *libtrace) {
     733DLLEXPORT void trace_destroy(libtrace_t *libtrace) {
    734734        int i;
    735735
    736736        /*assert(libtrace);*/
    737737        if(!libtrace) {
    738                 return TRACE_ERR_NULL_TRACE;
     738                fprintf(stderr, "NULL trace passed to trace_destory()\n");
     739                return;
    739740        }
    740741
     
    761762        if (libtrace->last_packet != NULL) {
    762763                trace_set_err(libtrace, TRACE_ERR_PAUSE_FIN, "Unable to remove all data stored against trace in trace_destroy()");
    763                 return -1;
     764                return;
    764765        }
    765766
     
    826827
    827828        free(libtrace);
    828 
    829         return 0;
    830 }
    831 
    832 
    833 DLLEXPORT int trace_destroy_dead(libtrace_t *libtrace) {
     829}
     830
     831
     832DLLEXPORT void trace_destroy_dead(libtrace_t *libtrace) {
    834833        /*assert(libtrace);*/
    835834        if(!libtrace) {
    836                 return TRACE_ERR_NULL_TRACE;
     835                fprintf(stderr, "NULL trace passed to trace_destory_dead()\n");
     836                return;
    837837        }
    838838
     
    847847                free(libtrace->format_data);
    848848        free(libtrace);
    849 
    850         return 0;
    851849}
    852850/* Close an output trace file, freeing up any resources it may have been using
     
    854852 * @param libtrace      the output trace file to be destroyed
    855853 */
    856 DLLEXPORT int trace_destroy_output(libtrace_out_t *libtrace) {
     854DLLEXPORT void trace_destroy_output(libtrace_out_t *libtrace) {
    857855        /*assert(libtrace);*/
    858856        if(!libtrace) {
    859                 return TRACE_ERR_NULL_TRACE;
     857                fprintf(stderr, "NULL trace passed to trace_destroy_output()\n");
     858                return;
    860859        }
    861860        if (libtrace->format && libtrace->format->fin_output)
     
    864863                free(libtrace->uridata);
    865864        free(libtrace);
    866 
    867         return 0;
    868865}
    869866
    870867DLLEXPORT int trace_flush_output(libtrace_out_t *libtrace) {
    871868        if (!libtrace) {
     869                fprintf(stderr, "NULL trace passed to trace_flush_output()\n");
    872870                return TRACE_ERR_NULL_TRACE;
    873871        }
     
    875873                return libtrace->format->flush_output(libtrace);
    876874        }
    877         return 0;
     875
     876        return 0;
    878877}
    879878
     
    10051004        /*assert(libtrace && "You called trace_read_packet() with a NULL libtrace parameter!\n");*/
    10061005        if (!libtrace) {
     1006                fprintf(stderr, "NULL trace passed to trace_read_packet()\n");
    10071007                return TRACE_ERR_NULL_TRACE;
    10081008        }
    10091009
    10101010        if (trace_is_err(libtrace))
     1011                /*trace_set_err(libtrace, TRACE_ERR_BAD_STATE, "Trace is in an error state trace_read_packet()");*/
    10111012                return -1;
    10121013
    10131014        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()");
    10151016                return -1;
    10161017        }
     
    10181019        /*assert(packet);*/
    10191020        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()");
    10211022                return -1;
    10221023        }
     
    10241025        if (!(packet->buf_control==TRACE_CTRL_PACKET
    10251026                    || 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");
    10271028                return -1;
    10281029        }
     
    11101111        /*assert(trace);*/
    11111112        if (!trace) {
     1113                fprintf(stderr, "NULL trace passed into trace_prepare_packet()\n");
    11121114                return TRACE_ERR_NULL_TRACE;
    11131115        }
     
    11151117        /*assert(packet);*/
    11161118        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()");
    11181120                return -1;
    11191121        }
    11201122
    11211123        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()");
    11231125                return -1;
    11241126        }
    11251127
    11261128        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");
    11281130                return -1;
    11291131        }
     
    11401142        }
    11411143        trace_set_err(trace, TRACE_ERR_UNSUPPORTED,
    1142                         "This format does not support preparing packets\n");
     1144                        "This format does not support preparing packets");
    11431145        return -1;
    11441146
     
    11541156        /*assert(libtrace);*/
    11551157        if (!libtrace) {
     1158                fprintf(stderr, "NULL trace passed into trace_write_packet()\n");
    11561159                return TRACE_ERR_NULL_TRACE;
    11571160        }
    11581161        /*assert(packet);*/
    11591162        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()");
    11611164                return -1;
    11621165        }
     
    11911194        /*assert(packet != NULL);*/
    11921195        if (!packet) {
     1196                fprintf(stderr, "NULL packet passed into trace_get_packet_buffer()\n");
    11931197                return NULL;
    11941198        }
     
    12261230                /*assert(cap_len >= 0);*/
    12271231                if (!(cap_len >= 0)) {
     1232                        fprintf(stderr, "Was expecting capture length of atleast 0 in trace_get_packet_buffer()\n");
    12281233                        return NULL;
    12291234                }
     
    14191424        }
    14201425
    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        }
    14221432
    14231433        return packet->capture_length;
     
    14441454        }
    14451455
    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        }
    14471462        return packet->wire_length;
    14481463
     
    15091524        libtrace_eventobj_t event = {TRACE_EVENT_IOWAIT,0,0.0,0};
    15101525
     1526
     1527        /*assert(trace && "You called trace_event() with a NULL trace object!");*/
    15111528        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!");*/
    15151533        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        }
    15211537
    15221538        /* Free the last packet */
     
    16221638
    16231639        if (!packet) {
     1640                fprintf(stderr, "NULL packet passed into trace_bpf_compile()");
    16241641                return TRACE_ERR_NULL_PACKET;
    16251642        }
    16261643
    1627         /*assert(filter);*/
     1644        /*assert(filter && "You called trace_bpf_compile() with a NULL filter");*/
    16281645        if (!filter) {
    16291646                trace_set_err(packet->trace,
     
    16641681                                1500U);
    16651682                /* build filter */
    1666                 /*assert(pcap);*/
     1683                /*assert(pcap && "Unable to open pcap_t for compiling filters trace_bpf_compile()");*/
    16671684                if (!pcap) {
    16681685                        trace_set_err(packet->trace, TRACE_ERR_BAD_FILTER,
     
    17081725#endif
    17091726
    1710         /*assert(packet);*/
     1727        /*assert(packet && "You called trace_apply_filter() with a NULL packet");*/
    17111728        if (!packet) {
     1729                fprintf(stderr, "NULL packet passed into trace_apply_filter()\n");
    17121730                return TRACE_ERR_NULL_PACKET;
    17131731        }
    1714         /*assert(filter);*/
     1732        /*assert(filter && "You called trace_apply_filter() with a NULL filter");*/
    17151733        if (!filter) {
    17161734                trace_set_err(packet->trace, TRACE_ERR_NULL_FILTER,
    1717                         "Filter is NULL trace_apply_filter()");
     1735                        "NULL filter passed into trace_apply_filter()");
    17181736                return -1;
    17191737        }
     
    17901808        if (!filter->flag) {
    17911809                trace_set_err(packet->trace, TRACE_ERR_BAD_FILTER,
    1792                         "Cannot apply a bad filter trace_apply_filter()");
     1810                        "Bad filter passed into trace_apply_filter()");
    17931811                return -1;
    17941812        }
     
    18211839        /*assert(packet);*/
    18221840        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;
    18261843        }
    18271844        if (packet->trace->format->set_direction) {
     
    18431860        /*assert(packet);*/
    18441861        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");
    18471863                return (libtrace_direction_t)~0U;
    18481864        }
     
    19852001        /*assert(packet);*/
    19862002        if (!packet) {
     2003                fprintf(stderr, "NULL packet passed into trace_set_capture_length()\n");
    19872004                return ~0U;
    19882005        }
     
    20282045enum base_format_t trace_get_format(libtrace_packet_t *packet) {
    20292046        /* 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        }
    20312052
    20322053        return packet->trace->format->type;
     
    22672288        /*assert(deadtrace);*/
    22682289        if (!deadtrace) {
     2290                fprintf(stderr, "Unable to create dead trace trace_construct_packet()\n");
    22692291                return TRACE_ERR_CREATE_DEADTRACE;
    22702292        }
     
    22982320uint64_t trace_get_received_packets(libtrace_t *trace)
    22992321{
    2300         assert(trace);
    23012322        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        }
    23022330
    23032331        if (trace->format->get_received_packets) {
     
    23212349uint64_t trace_get_filtered_packets(libtrace_t *trace)
    23222350{
    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        }
    23242356        int i = 0;
    23252357        uint64_t lib_filtered = trace->filtered_packets;
     
    23522384uint64_t trace_get_dropped_packets(libtrace_t *trace)
    23532385{
    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        }
    23552391        uint64_t ret;
    23562392
     
    23752411uint64_t trace_get_accepted_packets(libtrace_t *trace)
    23762412{
    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        }
    23782418        int i = 0;
    23792419        uint64_t ret = 0;
     
    23932433        uint64_t ret = 0;
    23942434        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        }
    23962440        if (stat == NULL) {
    23972441                if (trace->stats == NULL)
     
    23992443                stat = trace->stats;
    24002444        }
    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        }
    24032451
    24042452        /* If the trace has paused or finished get the cached results */
     
    24482496        /*assert(trace && stat);*/
    24492497        if (!trace) {
     2498                fprintf(stderr, "NULL trace passed into trace_get_thread_statistics()\n");
    24502499                return TRACE_ERR_NULL_TRACE;
    24512500        }
     
    24582507        if (!(stat->magic == LIBTRACE_STAT_MAGIC)) {
    24592508                trace_set_err(trace, TRACE_ERR_STAT,
    2460                         "Use trace_create_statistics() to allocate statistics in trave_get_thread_statistics()");
     2509                        "Use trace_create_statistics() to allocate statistics in trace_get_thread_statistics()");
    24612510                return -1;
    24622511        }
     
    24982547                || !(b->magic == LIBTRACE_STAT_MAGIC)
    24992548                || !(c->magic == LIBTRACE_STAT_MAGIC)) {
     2549                fprintf(stderr, "Use trace_create_statistics() to allocate statistics in trace_subtract_statistics()\n");
    25002550                return TRACE_ERR_STAT;
    25012551        }
     
    25252575                || !(b->magic == LIBTRACE_STAT_MAGIC)
    25262576                || !(c->magic == LIBTRACE_STAT_MAGIC)) {
     2577                fprintf(stderr, "Use trace_create_statistics() to allocate statistics in trace_add_statistics()\n");
    25272578                return TRACE_ERR_STAT;
    25282579        }
     
    25512602               "trace_create_statistics() to allocate statistics");*/
    25522603        if (!(s->magic == LIBTRACE_STAT_MAGIC)) {
     2604                fprintf(stderr, "Use trace_create_statistics() to allocate statistics in trace_print_statistics\n");
    25532605                return TRACE_ERR_STAT;
    25542606        }
     
    25912643
    25922644void 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        }
    25942650        f->next=formats_list;
    25952651        formats_list=f;
Note: See TracChangeset for help on using the changeset viewer.