Changeset f6f3ae5


Ignore:
Timestamp:
11/26/18 16:50:48 (2 years ago)
Author:
Jacob Van Walraven <jcv9@…>
Branches:
develop
Children:
88b9798
Parents:
2ceec6a
Message:

Assertion cleanup

Location:
lib
Files:
19 edited

Legend:

Unmodified
Added
Removed
  • lib/combiner_ordered.c

    ree6e802 rf6f3ae5  
    3636static int init_combiner(libtrace_t *t, libtrace_combine_t *c) {
    3737        int i = 0;
    38         assert(trace_get_perpkt_threads(t) > 0);
     38        /*assert(trace_get_perpkt_threads(t) > 0);*/
     39        if (trace_get_perpkt_threads(t) <= 0) {
     40                trace_set_err(t, TRACE_ERR_INIT_FAILED, "You must have atleast 1 processing thread");
     41                return -1;
     42        }
    3943        libtrace_queue_t *queues;
    4044        c->queues = calloc(sizeof(libtrace_queue_t), trace_get_perpkt_threads(t));
     
    245249
    246250        for (i = 0; i < trace_get_perpkt_threads(trace); i++) {
    247                 assert(libtrace_deque_get_size(&queues[i]) == 0);
     251                /*assert(libtrace_deque_get_size(&queues[i]) == 0);*/
     252                if (libtrace_deque_get_size(&queues[i]) != 0) {
     253                        trace_set_err(trace, TRACE_ERR_COMBINER,
     254                                "Failed to destory queues, A thread still has data in destroy()");
     255                        return;
     256                }
    248257        }
    249258        free(queues);
  • lib/combiner_sorted.c

    ree6e802 rf6f3ae5  
    3434static int init_combiner(libtrace_t *t, libtrace_combine_t *c) {
    3535        int i = 0;
    36         assert(trace_get_perpkt_threads(t) > 0);
     36        /*assert(trace_get_perpkt_threads(t) > 0);*/
     37        if (trace_get_perpkt_threads(t) <= 0) {
     38                trace_set_err(t, TRACE_ERR_INIT_FAILED, "You must have atleast 1 processing thread");
     39                return -1;
     40        }
    3741        libtrace_vector_t *queues;
    3842        c->queues = calloc(sizeof(libtrace_vector_t), trace_get_perpkt_threads(t));
     
    105109
    106110        for (i = 0; i < trace_get_perpkt_threads(trace); i++) {
    107                 assert(libtrace_vector_get_size(&queues[i]) == 0);
     111                /*assert(libtrace_vector_get_size(&queues[i]) == 0);*/
     112                if (libtrace_vector_get_size(&queues[i]) != 0) {
     113                        trace_set_err(trace, TRACE_ERR_COMBINER,
     114                                "Failed to destory queues, A thread still has data in destroy()");
     115                        return;
     116                }
    108117                libtrace_vector_destroy(&queues[i]);
    109118        }
  • lib/combiner_unordered.c

    ree6e802 rf6f3ae5  
    3434static int init_combiner(libtrace_t *t, libtrace_combine_t *c) {
    3535        int i = 0;
    36         assert(trace_get_perpkt_threads(t) > 0);
     36        /*assert(trace_get_perpkt_threads(t) > 0);*/
     37        if (trace_get_perpkt_threads(t) <= 0) {
     38                trace_set_err(t, TRACE_ERR_INIT_FAILED, "You must have atleast 1 processing thread");
     39                return -1;
     40        }
    3741        libtrace_queue_t *queues;
    3842        c->queues = calloc(sizeof(libtrace_queue_t), trace_get_perpkt_threads(t));
     
    8791
    8892        for (i = 0; i < trace_get_perpkt_threads(trace); i++) {
    89                 assert(libtrace_deque_get_size(&queues[i]) == 0);
     93                /*assert(libtrace_deque_get_size(&queues[i]) == 0);*/
     94                if (libtrace_deque_get_size(&queues[i]) != 0) {
     95                        trace_set_err(trace, TRACE_ERR_COMBINER,
     96                                "Failed to destroy queues, A thread still has data in destroy()");
     97                        return;
     98                }
    9099        }
    91100        free(queues);
  • lib/format_dag24.c

    r2725318 rf6f3ae5  
    326326                return NULL;
    327327        size = ntohs(erfptr->rlen);
    328         assert( size >= dag_record_size );
     328        /*assert( size >= dag_record_size );*/
     329        if (size < dag_record_size) {
     330                fprintf(stderr, "Incorrect dag record size in dag_get_record()\n");
     331                return NULL;
     332        }
    329333        FORMAT_DATA->offset += size;
    330334        FORMAT_DATA->diff -= size;
     
    482486
    483487        /* We only want to sleep for a very short time */
    484         assert(data == 0);
     488        /*assert(data == 0);*/
     489        if (!data != 0) {
     490                trace_set_err(trace, TRACE_ERR_BAD_PACKET, "Unexpected data from trace event in trace_event_dag()");
     491                return NULL;
     492        }
    485493        event.type = TRACE_EVENT_SLEEP;
    486494        event.seconds = 0.0001;
  • lib/format_dag25.c

    r2725318 rf6f3ae5  
    245245        FORMAT_DATA->per_stream =
    246246                libtrace_list_init(sizeof(stream_data));
    247         assert(FORMAT_DATA->per_stream != NULL);
     247        /*assert(FORMAT_DATA->per_stream != NULL);*/
     248        if (FORMAT_DATA->per_stream == NULL) {
     249                trace_set_err(libtrace, TRACE_ERR_INIT_FAILED,
     250                        "Unable to create list for stream in dag_init_format_data()");
     251                return -1;
     252        }
    248253
    249254        /* We'll start with just one instance of stream_data, and we'll
     
    284289{
    285290        /* Need to remove from the device list */
    286         assert(dev->ref_count == 0);
     291        /*assert(dev->ref_count == 0);*/
     292        if (dev->ref_count != 0) {
     293                fprintf(stderr, "Cannot close DAG device with non zero reference in dag_close_device()\n");
     294                return;
     295        }
    287296
    288297        if (dev->prev == NULL) {
     
    9961005
    9971006        size = ntohs(erfptr->rlen);
    998         assert( size >= dag_record_size );
     1007        /*assert( size >= dag_record_size );*/
     1008        if (size < dag_record_size) {
     1009                fprintf(stderr, "Incorrect dag record size in dag_get_record()\n");
     1010                return NULL;
     1011        }
    9991012
    10001013        /* Make certain we have the full packet available */
     
    12261239
    12271240                /* Packet length (rlen includes format overhead) */
    1228                 assert(trace_get_capture_length(packet) > 0
    1229                        && trace_get_capture_length(packet) <= 65536);
    1230                 assert(erf_get_framing_length(packet) > 0
    1231                        && trace_get_framing_length(packet) <= 65536);
    1232                 assert(trace_get_capture_length(packet) +
     1241                /*assert(trace_get_capture_length(packet) > 0
     1242                       && trace_get_capture_length(packet) <= 65536);*/
     1243                if (!(trace_get_capture_length(packet) > 0
     1244                       && trace_get_capture_length(packet) <= 65536)) {
     1245                        trace_set_err(libtrace, TRACE_ERR_BAD_PACKET,
     1246                                "Capture length is out of range in dag_write_packet()");
     1247                        return -1;
     1248                }
     1249                /*assert(erf_get_framing_length(packet) > 0
     1250                       && trace_get_framing_length(packet) <= 65536);*/
     1251                if (!(erf_get_framing_length(packet) > 0
     1252                       && trace_get_framing_length(packet) <= 65536)) {
     1253                        trace_set_err(libtrace, TRACE_ERR_BAD_PACKET,
     1254                                "Framing length is out of range in dag_write_packet()");
     1255                        return -1;
     1256                }
     1257                /*assert(trace_get_capture_length(packet) +
    12331258                       erf_get_framing_length(packet) > 0
    12341259                       && trace_get_capture_length(packet) +
    1235                        erf_get_framing_length(packet) <= 65536);
     1260                       erf_get_framing_length(packet) <= 65536);*/
     1261                if (!(trace_get_capture_length(packet) +
     1262                       erf_get_framing_length(packet) > 0
     1263                       && trace_get_capture_length(packet) +
     1264                       erf_get_framing_length(packet) <= 65536)) {
     1265                        trace_set_err(libtrace, TRACE_ERR_BAD_PACKET,
     1266                                "Capture + framing length is out of range in dag_write_packet()");
     1267                        return -1;
     1268                }
    12361269
    12371270                erfhdr.rlen = htons(trace_get_capture_length(packet)
     
    14831516{
    14841517        libtrace_list_node_t *tmp;
    1485         assert(stat && libtrace);
     1518        /*assert(stat && libtrace);*/
     1519        if (!libtrace) {
     1520                fprintf(stderr, "NULL trace passed into dag_get_statistics()\n");
     1521                return;
     1522        }
     1523        if (!stat) {
     1524                trace_set_err, TRACE_ERR_STAT, "NULL stat passed into dag_get_statistics()");
     1525                return;
     1526        }
    14861527        tmp = FORMAT_DATA_HEAD;
    14871528
     
    14991540                                       libtrace_stat_t *stat) {
    15001541        struct dag_per_stream_t *stream_data = t->format_data;
    1501         assert(stat && libtrace);
    1502 
     1542        /*assert(stat && libtrace);*/
     1543        if (!libtrace) {
     1544                fprintf(stderr, "NULL trace passed into dag_get_thread_statistics()\n");
     1545                return;
     1546        }
     1547        if (!stat) {
     1548                trace_set_err, TRACE_ERR_STAT, "NULL stat passed into dag_get_thread_statistics()");
     1549                return;
     1550        }
    15031551        stat->dropped_valid = 1;
    15041552        stat->dropped = stream_data->drops;
  • lib/format_duck.c

    r2725318 rf6f3ae5  
    112112                        return -1;
    113113        }
    114         assert(0);
     114        /*assert(0);*/
     115        trace_set_err_out(libtrace, TRACE_ERR_UNKNOWN_OPTION,
     116                "Unknown option in duck_config_output()");
     117        return -1;
    115118}
    116119
     
    243246
    244247        if (duck_prepare_packet(libtrace, packet, packet->buffer, packet->type,
    245                                 flags)) 
    246                 return -1;
    247        
     248                                flags))
     249                return -1;
     250
    248251        return numbytes;
    249252}
    250253
    251 static int duck_write_packet(libtrace_out_t *libtrace, 
    252                 libtrace_packet_t *packet) 
     254static int duck_write_packet(libtrace_out_t *libtrace,
     255                libtrace_packet_t *packet)
    253256{
    254257
     
    256259        uint32_t duck_version;
    257260
    258         if (packet->type != TRACE_RT_DUCK_2_4 
     261        if (packet->type != TRACE_RT_DUCK_2_4
    259262                        && packet->type != TRACE_RT_DUCK_2_5 &&
    260263                        packet->type != TRACE_RT_DUCK_5_0) {
     
    263266                return -1;
    264267        }
    265        
    266         assert(OUTPUT->file);
     268
     269        /*assert(OUTPUT->file);*/
     270        if (!OUTPUT->file) {
     271                trace_set_err_out(libtrace, TRACE_ERR_BAD_IO,
     272                        "Call init_output before write_packets() in duck_write_packet()");
     273                return -1;
     274        }
    267275
    268276        if (OUTPUT->dag_version == 0) {
     
    271279                if ((numbytes = wandio_wwrite(OUTPUT->file, &duck_version,
    272280                                sizeof(duck_version))) != sizeof(uint32_t)){
    273                         trace_set_err_out(libtrace, errno, 
     281                        trace_set_err_out(libtrace, errno,
    274282                                        "Writing DUCK version failed");
    275283                        return -1;
     
    277285                OUTPUT->dag_version = packet->type;
    278286        }
    279        
    280         if ((numbytes = wandio_wwrite(OUTPUT->file, packet->payload, 
     287
     288        if ((numbytes = wandio_wwrite(OUTPUT->file, packet->payload,
    281289                                        trace_get_capture_length(packet))) !=
    282290                                (int)trace_get_capture_length(packet)) {
  • lib/format_erf.c

    r2725318 rf6f3ae5  
    180180                        exthdr ++;
    181181                        firstbyte = (uint8_t *)exthdr;
    182                         assert(extsize <= ntohs(erfptr->rlen));
     182                        /*assert(extsize <= ntohs(erfptr->rlen));*/
     183                        if (extsize > ntohs(erfptr->rlen)) {
     184                                trace_set_err(packet->trace, TRACE_ERR_BAD_PACKET, "Extension size is greater than dag record record length in erf_get_framing_length()");
     185                                return -1;
     186                        }
    183187                }
    184188        }
     
    384388                        break;
    385389                case INDEX_UNKNOWN:
    386                         assert(0);
     390                        /*assert(0);*/
     391                        trace_set_err(libtrace, TRACE_ERR_SEEK_ERF, "Cannot seek to erf timestamp with unknown index in erf_seek_erf()");
     392                        return -1;
    387393                        break;
    388394        }
     
    481487        }
    482488
    483         assert(erfptr->rlen != 0);
    484        
     489        /*assert(erfptr->rlen != 0);*/
     490        if (erfptr->rlen == 0) {
     491                trace_set_err(libtrace, TRACE_ERR_BAD_PACKET, "Packet is empty in erf_prepare_packet()\n");
     492                return -1;
     493        }
     494
    485495        if (libtrace->format_data == NULL) {
    486496                /* Allocates the format_data structure */
     
    658668        void *payload = packet->payload;
    659669
    660         assert(OUTPUT->file);
     670        /*assert(OUTPUT->file);*/
     671        if (!OUTPUT->file) {
     672                trace_set_err_out(libtrace, TRACE_ERR_BAD_IO, "Call init_output before write_packet() in erf_write_packet()");
     673                return -1;
     674        }
    661675
    662676        if (trace_get_link_type(packet) == TRACE_TYPE_NONDATA)
     
    708722
    709723                /* Packet length (rlen includes format overhead) */
    710                 assert(trace_get_capture_length(packet)>0
    711                                 && trace_get_capture_length(packet)<=65536);
    712                 assert(trace_get_framing_length(packet)<=65536);
    713                
     724                /*assert(trace_get_capture_length(packet)>0
     725                                && trace_get_capture_length(packet)<=65536);*/
     726                if (!(trace_get_capture_length(packet) > 0
     727                        && trace_get_capture_length(packet) <= 65536)) {
     728                        trace_set_err_out(libtrace, TRACE_ERR_BAD_PACKET,
     729                                "Capture length is out of range in erf_write_packet()");
     730                        return -1;
     731                }
     732                /*assert(trace_get_framing_length(packet)<=65536);*/
     733                if (trace_get_framing_length(packet) > 65536) {
     734                        trace_set_err_out(libtrace, TRACE_ERR_BAD_PACKET,
     735                                "Framing length is to large in erf_write_packet()");
     736                        return -1;
     737                }
     738
    714739                if (erfhdr.type == TYPE_ETH)
    715740                        framing = dag_record_size + 2;
    716741                else
    717742                        framing = dag_record_size;
    718                
     743
    719744                rlen = trace_get_capture_length(packet) + framing;
    720                 assert(rlen > 0 && rlen <= 65536);
     745                /*assert(rlen > 0 && rlen <= 65536);*/
     746                if (!(rlen > 0 && rlen <= 65536)) {
     747                        trace_set_err_out(libtrace, TRACE_ERR_BAD_PACKET,
     748                                "Capture + framing length is out of range in erf_write_packet()");
     749                        return -1;
     750                }
    721751                erfhdr.rlen = htons(rlen);
    722752                /* loss counter. Can't do this */
     
    806836        uint16_t wlen;
    807837
    808         assert(packet);
     838        /*assert(packet);*/
     839        if (!packet) {
     840                fprintf(stderr, "NULL packet passed to erf_set_capture_length()\n");
     841                return ~0U;
     842        }
    809843        erfptr = (dag_record_t *)packet->header;
    810844
  • lib/format_etsilive.c

    r2725318 rf6f3ae5  
    595595        libtrace_t *libtrace = packet->trace;
    596596
    597         assert(libtrace);
    598         assert(FORMAT_DATA->shareddec);
     597        /*assert(libtrace);*/
     598        if (!libtrace) {
     599                fprintf(stderr, "Packet is not associated with a trace in etsilive_get_pdu_length()\n");
     600                return TRACE_ERR_NULL_TRACE;
     601        }
     602        /*assert(FORMAT_DATA->shareddec);*/
     603        if (!FORMAT_DATA->shareddec) {
     604                trace_set_err(libtrace, TRACE_ERR_BAD_FORMAT, "Etsilive format data shareddec is NULL in etsilive_get_pdu_length()\n");
     605                return -1;
     606        }
    599607
    600608        /* 0 should be ok here for quickly evaluating the first length
  • lib/format_helper.c

    r25a3255 rf6f3ae5  
    7272        if (!trace) {
    7373                fprintf(stderr, "NULL trace passed into trace_event_device()\n");
    74                 return;
     74                /* Return empty event on error? */
     75                return event;
    7576        }
    7677        /*assert(packet != NULL);*/
    7778        if (!packet) {
    7879                trace_set_err(trace, TRACE_ERR_NULL_PACKET, "NULL packet passed into trace_event_device()");
    79                 return;
     80                /* Return empty event on error? */
     81                return event;
    8082        }
    8183
  • lib/format_linux_int.c

    r25a3255 rf6f3ae5  
    454454        if (!packet) {
    455455                fprintf(stderr, "NULL packet passed into linuxnative_set_capture_length()\n");
    456                 return;
     456                /* Return -1 on error? */
     457                return ~0U;
    457458        }
    458459        if (size > trace_get_capture_length(packet)) {
  • lib/format_linux_ring.c

    r25a3255 rf6f3ae5  
    167167        /*assert(req->tp_block_size % req->tp_frame_size == 0);*/
    168168        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");
     169                fprintf(stderr, "Unexpected value req->tp_block_size %% req->tp_frame_size in calculate_buffers()\n");
    170170        }
    171171}
     
    466466        if (!packet) {
    467467                fprintf(stderr, "NULL packet passed into linuxring_set_capture_length()\n");
    468                 return;
     468                /* Return -1 on error? */
     469                return ~0U;
    469470        }
    470471        if (size > trace_get_capture_length(packet)) {
  • lib/format_pcap.c

    r25a3255 rf6f3ae5  
    779779        /*assert(trace->format_data);*/
    780780        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;
     781                /* cant do this because trace is a const? */
     782                /*trace_set_err(trace, TRACE_ERR_BAD_FORMAT, "Trace format data missing, call init_input() before calling pcap_get_fd()");*/
     783                fprintf(stderr, "Trace format data missing, call init_input() before calling pcap_get_fd()\n");
     784                return TRACE_ERR_BAD_FORMAT;
    783785        }
    784786        return pcap_fileno(DATA(trace)->input.pcap);
  • lib/format_pcapfile.c

    r25a3255 rf6f3ae5  
    576576        if (!packet) {
    577577                fprintf(stderr, "NULL packet passed to pcapfile_get_timeval()\n");
    578                 return;
     578                /* Return default timeval on error? */
     579                return ts;
    579580        }
    580581        /*assert(packet->header);*/
    581582        if (!packet->header) {
    582583                trace_set_err(packet->trace, TRACE_ERR_BAD_HEADER, "Trace with NULL header passed to pcapfile_get_timeval()");
    583                 return;
     584                /* Return default timeval on error? */
     585                return ts;
    584586        }
    585587
     
    602604        if (!packet) {
    603605                fprintf(stderr, "NULL packet passed to pcapfile_get_timespec()");
    604                 return;
     606                /* Return default timespec on error? */
     607                return ts;
    605608        }
    606609        /*assert(packet->header);*/
    607610        if (!packet->header) {
    608611                trace_set_err(packet->trace, TRACE_ERR_BAD_HEADER, "Trace with NULL header passed to pcapfile_get_timespec()");
    609                 return;
     612                /* Return fefault timespec on error? */
     613                return ts;
    610614        }
    611615
     
    691695        if (!packet) {
    692696                fprintf(stderr, "NULL packet passed into pcapfile_set_capture_length\n");
    693                 return;
     697                /* Return -1 on error? */
     698                return ~0U;
    694699        }
    695700        /*assert(packet->header);*/
    696701        if (!packet->header) {
    697702                trace_set_err(packet->trace, TRACE_ERR_BAD_HEADER, "Trace with NULL header passed to pcapfile_set_capture_length()");
    698                 return;
     703                /* Return -1 on error? */
     704                return ~0U;
    699705        }
    700706        if (size > trace_get_capture_length(packet)) {
  • lib/format_pcapng.c

    r25a3255 rf6f3ae5  
    11181118        if (!packet) {
    11191119                fprintf(stderr, "NULL packet passed into pcapng_get_timespec()");
    1120                 return;
     1120                /* Return default timespec on error? */
     1121                return ts;
    11211122        }
    11221123        /*assert(packet->header);*/
    11231124        if (!packet->header) {
    11241125                trace_set_err(packet->trace, TRACE_ERR_BAD_PACKET, "NULL header in packet in pcapng_get_timespec()");
    1125                 return;
     1126                /* Return default timespec on error? */
     1127                return ts;
    11261128        }
    11271129
  • lib/format_rt.c

    r25a3255 rf6f3ae5  
    763763        if (!trace) {
    764764                fprintf(stderr, "NULL trace passed into trace_event_rt()\n");
    765                 return;
     765                /* Return empty event on error? */
     766                return event;
    766767        }
    767768        /*assert(packet);*/
    768769        if (!packet) {
    769770                trace_set_err(trace, TRACE_ERR_NULL_PACKET, "NULL packet passed into trace_event_rt()");
    770                 return;
     771                /* Return empty event on error? */
     772                return event;
    771773        }
    772774
  • lib/libtrace.h.in

    r25a3255 rf6f3ae5  
    322322        /** Buffer is NULL **/
    323323        TRACE_ERR_NULL_BUFFER = -19,
    324         /** Trace err stat **/
     324        /** Trace stats err **/
    325325        TRACE_ERR_STAT = -20,
    326326        /** Unable to create deadtrace **/
     
    332332        /** Trace has bad header **/
    333333        TRACE_ERR_BAD_HEADER = -24,
     334        /** Trace err seeking by erf **/
     335        TRACE_ERR_SEEK_ERF = -25,
     336        /** Trace err combiner **/
     337        TRACE_ERR_COMBINER = -26,
     338        /** Error pausing processing thread **/
     339        TRACE_ERR_PAUSE_PTHREAD = -27,
     340        /** Error with trace thread **/
     341        TRACE_ERR_THREAD = -28,
     342        /** Thread in unexpecting state **/
     343        TRACE_ERR_THREAD_STATE = -29,
     344        /** Trace configuration error **/
     345        TRACE_ERR_CONFIG = -30,
     346        /** NULL passed misc **/
     347        TRACE_ERR_NULL = -31,
    334348};
    335349
     
    17171731 */
    17181732DLLEXPORT
    1719 int trace_get_thread_statistics(libtrace_t *trace, libtrace_thread_t *t,
     1733void trace_get_thread_statistics(libtrace_t *trace, libtrace_thread_t *t,
    17201734                                 libtrace_stat_t *stats);
    17211735
     
    17511765 */
    17521766DLLEXPORT
    1753 int trace_subtract_statistics(const libtrace_stat_t *a,
     1767void trace_subtract_statistics(const libtrace_stat_t *a,
    17541768                               const libtrace_stat_t *b, libtrace_stat_t *c);
    17551769
     
    17631777 */
    17641778DLLEXPORT
    1765 int trace_add_statistics(const libtrace_stat_t *a,
     1779void trace_add_statistics(const libtrace_stat_t *a,
    17661780                          const libtrace_stat_t *b, libtrace_stat_t *c);
    17671781
     
    19511965 */
    19521966DLLEXPORT
    1953 int trace_construct_packet(libtrace_packet_t *packet,
     1967void trace_construct_packet(libtrace_packet_t *packet,
    19541968                libtrace_linktype_t linktype, const void *data, uint16_t len);
    19551969
  • lib/protocols_ospf.c

    r25a3255 rf6f3ae5  
    190190        if (!as_lsa) {
    191191                fprintf(stderr, "NULL as_lsa passed into trace_get_ospf_metric_from_as_external_lsa_v2()\n");
    192                 return;
     192                /* Return metric of 0 on error? */
     193                return metric;
    193194        }
    194195
     
    208209        if (!sum_lsa) {
    209210                fprintf(stderr, "NULL sum_lsa passed into trace_get_ospf_metric_from_summary_lsa_v2()\n");
    210                 return;
     211                /* Return metric of 0 on error? */
     212                return metric;
    211213        }
    212214
  • lib/trace.c

    r25a3255 rf6f3ae5  
    15281528        if (!trace) {
    15291529                fprintf(stderr, "NULL trace passed into trace_event()");
    1530                 return;
     1530                /* Return default event on error? */
     1531                return event;
    15311532        }
    15321533        /*assert(packet && "You called trace_event() with a NULL packet object!");*/
    15331534        if (!packet) {
    15341535                trace_set_err(trace, TRACE_ERR_NULL_PACKET, "NULL packet passed into trace_event()");
    1535                 return;
     1536                /* Return default event on error? */
     1537                return event;
    15361538        }
    15371539
     
    22482250 */
    22492251DLLEXPORT
    2250 int trace_construct_packet(libtrace_packet_t *packet,
     2252void trace_construct_packet(libtrace_packet_t *packet,
    22512253                libtrace_linktype_t linktype,
    22522254                const void *data,
    22532255                uint16_t len) {
    2254 
    2255         if (!packet) {
    2256                 return TRACE_ERR_NULL_PACKET;
    2257         }
    22582256
    22592257        size_t size;
     
    22892287        if (!deadtrace) {
    22902288                fprintf(stderr, "Unable to create dead trace trace_construct_packet()\n");
    2291                 return TRACE_ERR_CREATE_DEADTRACE;
     2289                return;
    22922290        }
    22932291        packet->trace=deadtrace;
     
    23132311
    23142312        trace_clear_cache(packet);
    2315 
    2316         return 0;
    23172313}
    23182314
     
    24912487}
    24922488
    2493 int trace_get_thread_statistics(libtrace_t *trace, libtrace_thread_t *t,
     2489void trace_get_thread_statistics(libtrace_t *trace, libtrace_thread_t *t,
    24942490                                 libtrace_stat_t *stat)
    24952491{
     
    24972493        if (!trace) {
    24982494                fprintf(stderr, "NULL trace passed into trace_get_thread_statistics()\n");
    2499                 return TRACE_ERR_NULL_TRACE;
     2495                return;
    25002496        }
    25012497        if (!stat) {
    25022498                trace_set_err(trace, TRACE_ERR_STAT, "Stat is NULL trace_get_thread_statistics()");
    2503                 return -1;
     2499                return;
    25042500        }
    25052501        /*assert(stat->magic == LIBTRACE_STAT_MAGIC && "Please use"
     
    25082504                trace_set_err(trace, TRACE_ERR_STAT,
    25092505                        "Use trace_create_statistics() to allocate statistics in trace_get_thread_statistics()");
    2510                 return -1;
     2506                return;
    25112507        }
    25122508        stat->reserved1 = 0;
     
    25222518                trace->format->get_thread_statistics(trace, t, stat);
    25232519        }
    2524 
    2525         return 0;
    25262520}
    25272521
     
    25412535}
    25422536
    2543 int trace_subtract_statistics(const libtrace_stat_t *a, const libtrace_stat_t *b,
     2537void trace_subtract_statistics(const libtrace_stat_t *a, const libtrace_stat_t *b,
    25442538                         libtrace_stat_t *c) {
    25452539
     
    25482542                || !(c->magic == LIBTRACE_STAT_MAGIC)) {
    25492543                fprintf(stderr, "Use trace_create_statistics() to allocate statistics in trace_subtract_statistics()\n");
    2550                 return TRACE_ERR_STAT;
     2544                return;
    25512545        }
    25522546
     
    25672561        LIBTRACE_STAT_FIELDS
    25682562#undef X
    2569         return 0;
    2570 }
    2571 
    2572 int trace_add_statistics(const libtrace_stat_t *a, const libtrace_stat_t *b,
     2563}
     2564
     2565void trace_add_statistics(const libtrace_stat_t *a, const libtrace_stat_t *b,
    25732566                         libtrace_stat_t *c) {
    25742567        if (!(a->magic == LIBTRACE_STAT_MAGIC)
     
    25762569                || !(c->magic == LIBTRACE_STAT_MAGIC)) {
    25772570                fprintf(stderr, "Use trace_create_statistics() to allocate statistics in trace_add_statistics()\n");
    2578                 return TRACE_ERR_STAT;
     2571                return;
    25792572        }
    25802573
     
    25952588        LIBTRACE_STAT_FIELDS
    25962589#undef X
    2597         return 0;
    25982590}
    25992591
  • lib/trace_parallel.c

    r2ceec6a rf6f3ae5  
    272272{
    273273        /*assert(libtrace->state != STATE_NEW);*/
    274         if (!(libtrace->stats != STATE_NEW)) {
     274        if (!(libtrace->state != STATE_NEW)) {
    275275                trace_set_err(libtrace, TRACE_ERR_BAD_STATE, "Cannot check reporter for the current state in trace_has_reporter()");
    276276                return false;
Note: See TracChangeset for help on using the changeset viewer.