Changeset 2725318


Ignore:
Timestamp:
11/22/18 11:59:29 (2 years ago)
Author:
Jacob Van Walraven <jcv9@…>
Branches:
develop
Children:
33b735c
Parents:
2dc1d9b
Message:

Cleanup some of the assertions

Location:
lib
Files:
16 edited

Legend:

Unmodified
Added
Removed
  • lib/format_bpf.c

    ra0f031b r2725318  
    123123
    124124/* Initialises a BPF input trace */
    125 static int bpf_init_input(libtrace_t *libtrace)
    126 {
     125static int bpf_init_input(libtrace_t *libtrace) {
    127126        libtrace->format_data = (struct libtrace_format_data_t *)
    128127                malloc(sizeof(struct libtrace_format_data_t));
    129        
     128
     129        if (!libtrace->format_data) {
     130                trace_set_err(libtrace, TRACE_ERR_INIT_FAILED, "Unable to allocate memory bpf_init_input()");
     131                return -1;
     132        }
     133
    130134        /* Throw some default values into the format data */
    131135        FORMATIN(libtrace)->fd = -1;
  • lib/format_dag24.c

    r32ee9b2 r2725318  
    179179                return -1;
    180180        }
    181        
     181
    182182        dag_init_format_data(libtrace);
    183183        if (S_ISCHR(buf.st_mode)) {
  • lib/format_dag25.c

    r32ee9b2 r2725318  
    522522                dag_dev_name = NULL;
    523523                pthread_mutex_unlock(&open_dag_mutex);
     524                trace_set_err(libtrace, TRACE_ERR_INIT_FAILED, "Unable to open DAG device %s", dag_dev_name);
    524525                return -1;
    525526        }
  • lib/format_dpdk.c

    r3b94ef2 r2725318  
    587587        libtrace->format_data = (struct dpdk_format_data_t *)
    588588                                malloc(sizeof(struct dpdk_format_data_t));
     589
     590        if (!libtrace->format_data) {
     591                trace_set_err(libtrace, TRACE_ERR_INIT_FAILED, "Unable to allocate memory dpdk_init_input()");
     592                return 1;
     593        }
     594
    589595        FORMAT(libtrace)->port = 0; /* Always assume 1 port loaded */
    590596        FORMAT(libtrace)->nb_ports = 0;
     
    628634        libtrace->format_data = (struct dpdk_format_data_t *)
    629635                                malloc(sizeof(struct dpdk_format_data_t));
     636
     637        if (!libtrace->format_data) {
     638                trace_set_err_out(libtrace, TRACE_ERR_INIT_FAILED, "Unable to allocate memory dpdk_init_output()");
     639                return -1;
     640        }
    630641        FORMAT(libtrace)->port = 0; /* Always assume 1 port loaded */
    631642        FORMAT(libtrace)->nb_ports = 0;
  • lib/format_dpdkndag.c

    r32ee9b2 r2725318  
    8787                        sizeof(dpdkndag_format_data_t));
    8888
     89        if (!libtrace->format_data) {
     90                trace_set_err(libtrace, TRACE_ERR_INIT_FAILED, "Unable to allocate memory dpdknday_init_input()");
     91                return 1;
     92        }
     93
    8994        FORMAT_DATA->localiface = NULL;
    9095        FORMAT_DATA->threaddatas = NULL;
     
    9398        scan = strchr(libtrace->uridata, ',');
    9499        if (scan == NULL) {
     100                free(libtrace->format_data);
    95101                trace_set_err(libtrace, TRACE_ERR_BAD_FORMAT,
    96102                        "Bad dpdkndag URI. Should be dpdkndag:<interface>,<multicast group>");
     
    109115        if (getaddrinfo(next, NULL, &hints, &result) != 0) {
    110116                perror("getaddrinfo");
     117                free(libtrace->format_data);
    111118                trace_set_err(libtrace, TRACE_ERR_BAD_FORMAT,
    112119                        "Invalid multicast address: %s", next);
  • lib/format_duck.c

    r32ee9b2 r2725318  
    6363        int fileflag;
    6464        iow_t *file;
    65         int dag_version;       
     65        int dag_version;
    6666};
    6767
     
    6969        libtrace->format_data = malloc(sizeof(struct duck_format_data_t));
    7070
     71        if (!libtrace->format_data) {
     72                trace_set_err(libtrace, TRACE_ERR_INIT_FAILED, "Unable to allocate memory duck_init_input()");
     73                return 1;
     74        }
     75
    7176        DATA(libtrace)->dag_version = 0;
    7277        return 0;
     
    7580static int duck_init_output(libtrace_out_t *libtrace) {
    7681        libtrace->format_data = malloc(sizeof(struct duck_format_data_out_t));
    77        
     82
     83        if (!libtrace->format_data) {
     84                trace_set_err_out(libtrace, TRACE_ERR_INIT_FAILED, "Unable to allocate memory duck_init_output()");
     85                return -1;
     86        }
     87
    7888        OUTPUT->level = 0;
    7989        OUTPUT->compress_type = TRACE_OPTION_COMPRESSTYPE_NONE;
  • lib/format_erf.c

    rbccdffc r2725318  
    225225}
    226226
    227 static int erf_init_input(libtrace_t *libtrace)
    228 {
     227static int erf_init_input(libtrace_t *libtrace) {
    229228        libtrace->format_data = malloc(sizeof(struct erf_format_data_t));
    230        
     229
     230        if (!libtrace->format_data) {
     231                trace_set_err(libtrace, TRACE_ERR_INIT_FAILED, "Unable to allocate memory erf_init_input()");
     232                return -1;
     233        }
     234
    231235        IN_OPTIONS.real_time = 0;
    232236        DATA(libtrace)->drops = 0;
    233        
     237
    234238        return 0; /* success */
    235239}
     
    400404static int erf_init_output(libtrace_out_t *libtrace) {
    401405        libtrace->format_data = malloc(sizeof(struct erf_format_data_out_t));
     406
     407        if (!libtrace->format_data) {
     408                trace_set_err_out(libtrace, TRACE_ERR_INIT_FAILED, "Unable to allocate memory erf_init_output()");
     409                return -1;
     410        }
    402411
    403412        OUT_OPTIONS.level = 0;
  • lib/format_etsilive.c

    r2044185 r2725318  
    212212        libtrace->format_data = (etsilive_format_data_t *)malloc(
    213213                        sizeof(etsilive_format_data_t));
     214
     215        if (!libtrace->format) {
     216                trace_set_err(libtrace, TRACE_ERR_INIT_FAILED, "Unable to allocate memory etsilive_init_input()");
     217                return 1;
     218        }
    214219
    215220        FORMAT_DATA->receivers = NULL;
  • lib/format_linux_common.c

    rebed638 r2725318  
    185185        libtrace->format_data = (struct linux_format_data_t *)
    186186                malloc(sizeof(struct linux_format_data_t));
    187         assert(libtrace->format_data != NULL);
     187
     188        /*assert(libtrace->format_data != NULL);*/
     189        if (!libtrace->format_data) {
     190                trace_set_err(libtrace, TRACE_ERR_INIT_FAILED, "Unable to allocate memory linuxcommon_init_input()");
     191                return -1;
     192        }
    188193
    189194        FORMAT_DATA->per_stream =
    190195                libtrace_list_init(sizeof(stream_data));
    191         assert(FORMAT_DATA->per_stream != NULL);
     196
     197        /*assert(FORMAT_DATA->per_stream != NULL);*/
     198        if (!FORMAT_DATA->per_stream) {
     199                trace_set_err(libtrace, TRACE_ERR_INIT_FAILED, "Unable to create list for stream data linuxcommon_init_input()");
     200                return -1;
     201        }
    192202
    193203        libtrace_list_push_back(FORMAT_DATA->per_stream, &stream_data);
     
    211221        libtrace->format_data = (struct linux_format_data_out_t*)
    212222                malloc(sizeof(struct linux_format_data_out_t));
    213         assert(libtrace->format_data != NULL);
     223
     224        /*assert(libtrace->format_data != NULL);*/
     225        if (!libtrace->format_data) {
     226                trace_set_err_out(libtrace, TRACE_ERR_INIT_FAILED, "Unable to allocate memory linuxcommon_init_output()");
     227                return -1;
     228        }
    214229
    215230        FORMAT_DATA_OUT->fd = -1;
  • lib/format_ndag.c

    r857729e r2725318  
    285285        libtrace->format_data = (ndag_format_data_t *)malloc(
    286286                        sizeof(ndag_format_data_t));
     287
     288        if (!libtrace->format_data) {
     289                trace_set_err(libtrace, TRACE_ERR_INIT_FAILED, "Unable to allocate memory ndag_init_input()");
     290                return -1;
     291        }
    287292
    288293        FORMAT_DATA->multicastgroup = NULL;
  • lib/format_pcap.c

    r37ee856 r2725318  
    102102        libtrace->format_data = malloc(sizeof(struct pcap_format_data_t));
    103103
     104        if (!libtrace->format_data) {
     105                trace_set_err(libtrace, TRACE_ERR_INIT_FAILED, "Unable to allocate memory pcap_init_input()");
     106                return -1;
     107        }
     108
    104109        INPUT.pcap = NULL;
    105110        DATA(libtrace)->filter = NULL;
     
    178183static int pcap_init_output(libtrace_out_t *libtrace) {
    179184        libtrace->format_data = malloc(sizeof(struct pcap_format_data_out_t));
     185        if (!libtrace->format_data) {
     186                trace_set_err_out(libtrace, TRACE_ERR_INIT_FAILED, "Unable to allocate memory pcap_init_output()");
     187                return -1;
     188        }
     189
    180190        OUTPUT.trace.pcap = NULL;
    181191        OUTPUT.trace.dump = NULL;
     
    186196#ifdef HAVE_PCAP_INJECT
    187197        libtrace->format_data = malloc(sizeof(struct pcap_format_data_out_t));
     198        if (!libtrace->format_data) {
     199                trace_set_err_out(libtrace, TRACE_ERR_INIT_FAILED, "Unable to allocate memory pcapint_init_output()");
     200                return -1;
     201        }
     202
    188203        OUTPUT.trace.pcap = NULL;
    189204        OUTPUT.trace.dump = NULL;
     
    205220static int pcapint_init_input(libtrace_t *libtrace) {
    206221        libtrace->format_data = malloc(sizeof(struct pcap_format_data_t));
     222        if (!libtrace->format_data) {
     223                trace_set_err(libtrace, TRACE_ERR_INIT_FAILED, "Unable to allocate memory pcapint_init_input()");
     224                return -1;
     225        }
     226
    207227        DATA(libtrace)->filter = NULL;
    208228        DATA(libtrace)->snaplen = LIBTRACE_PACKET_BUFSIZE;
  • lib/format_pcapfile.c

    r37ee856 r2725318  
    125125static int pcapfile_init_input(libtrace_t *libtrace) {
    126126        libtrace->format_data = malloc(sizeof(struct pcapfile_format_data_t));
    127 
    128         if (libtrace->format_data == NULL) {
    129                 trace_set_err(libtrace,ENOMEM,"Out of memory");
     127        if (!libtrace->format_data) {
     128                trace_set_err(libtrace, TRACE_ERR_INIT_FAILED, "Unable to allocate memory pcapfile_init_input()");
    130129                return -1;
    131130        }
     
    139138        libtrace->format_data =
    140139                malloc(sizeof(struct pcapfile_format_data_out_t));
     140        if (!libtrace->format_data) {
     141                trace_set_err_out(libtrace, TRACE_ERR_INIT_FAILED, "Unable to allocate memory pcapfile_init_output()");
     142                return -1;
     143        }
    141144
    142145        DATAOUT(libtrace)->file=NULL;
  • lib/format_pcapng.c

    re9da777 r2725318  
    218218static int pcapng_init_input(libtrace_t *libtrace) {
    219219        libtrace->format_data = malloc(sizeof(struct pcapng_format_data_t));
    220         if (libtrace->format_data == NULL) {
    221                 trace_set_err(libtrace, ENOMEM, "Out of memory!");
     220        if (!libtrace->format_data) {
     221                trace_set_err(libtrace, TRACE_ERR_INIT_FAILED, "Unable to allocate memory pcapng_init_input()");
    222222                return -1;
    223223        }
  • lib/format_rt.c

    r32ee9b2 r2725318  
    233233
    234234        /* If the user specifies "rt:" then assume localhost and the default
    235          * port */     
     235         * port */
    236236        if (strlen(uridata) == 0) {
    237237                RT_INFO->hostname =
  • lib/libtrace.h.in

    r2dc1d9b r2725318  
    317317        TRACE_ERR_PAUSE_FIN = -16,
    318318        /** Packet is NULL **/
    319         TRACE_ERR_NULL_PACKET = -17
     319        TRACE_ERR_NULL_PACKET = -17,
     320        /** Filter is NULL **/
     321        TRACE_ERR_NULL_FILTER = -18,
     322        /** Unable to lock/unlock mutex **/
     323        TRACE_ERR_MUTEX = -19
    320324};
    321325
  • lib/trace.c

    r2dc1d9b r2725318  
    350350        if (libtrace->format->init_input) {
    351351                int err=libtrace->format->init_input(libtrace);
    352                 assert (err==-1 || err==0);
     352                /*assert (err==-1 || err==0);*/
    353353                if (err==-1) {
    354354                        /* init_input should call trace_set_err to set the
     
    409409        libtrace->accepted_packets = 0;
    410410        libtrace->last_packet = NULL;
    411        
     411
    412412        /* Parallel inits */
    413413        ASSERT_RET(pthread_mutex_init(&libtrace->libtrace_lock, NULL), == 0);
     
    590590        /*assert(libtrace->last_packet == NULL);*/
    591591        if(libtrace->last_packet != NULL) {
    592                 trace_set_err(libtrace, TRACE_ERR_PAUSE_FIN, "Unable to remove all data stored against the trace in trace_pause()");
     592                trace_set_err(libtrace, TRACE_ERR_PAUSE_FIN, "Unable to remove all data stored against trace in trace_pause()");
    593593                return -1;
    594594        }
     
    730730 *
    731731 */
    732 DLLEXPORT int trace_destroy(libtrace_t *libtrace) {
     732DLLEXPORT void trace_destroy(libtrace_t *libtrace) {
    733733        int i;
    734734
    735         /*assert(libtrace);*/
    736         if(!libtrace) {
    737                 return TRACE_ERR_NULL_TRACE;
    738         }
     735        assert(libtrace);
     736        //if(!libtrace) {
     737        //      return TRACE_ERR_NULL_TRACE;
     738        //}
    739739
    740740        ASSERT_RET(pthread_mutex_destroy(&libtrace->libtrace_lock), == 0);
     
    758758        }
    759759        assert(libtrace->last_packet == NULL);
     760        //if (libtrace->last_packet != NULL) {
     761        //      trace_set_err(libtrace, TRACE_ERR_PAUSE_FIN, "Unable to remove all data stored against trace in trace_destroy()");
     762        //      return -1;
     763        //}
    760764
    761765        if (libtrace->format) {
     
    771775        if (libtrace->stats)
    772776                free(libtrace->stats);
    773        
     777
    774778        /* Empty any packet memory */
    775779        if (libtrace->state != STATE_NEW) {
     
    821825
    822826        free(libtrace);
    823 
    824         return 0;
    825 }
    826 
    827 
    828 DLLEXPORT int trace_destroy_dead(libtrace_t *libtrace) {
    829         /*assert(libtrace);*/
    830         if(!libtrace) {
    831                 return TRACE_ERR_NULL_TRACE;
    832         }
     827}
     828
     829
     830DLLEXPORT void trace_destroy_dead(libtrace_t *libtrace) {
     831        assert(libtrace);
     832        //if(!libtrace) {
     833        //      return TRACE_ERR_NULL_TRACE;
     834        //}
    833835
    834836        ASSERT_RET(pthread_mutex_destroy(&libtrace->libtrace_lock), == 0);
     
    842844                free(libtrace->format_data);
    843845        free(libtrace);
    844 
    845         return 0;
    846846}
    847847/* Close an output trace file, freeing up any resources it may have been using
     
    849849 * @param libtrace      the output trace file to be destroyed
    850850 */
    851 DLLEXPORT int trace_destroy_output(libtrace_out_t *libtrace) {
    852         /*assert(libtrace);*/
    853         if(!libtrace) {
    854                 return TRACE_ERR_NULL_TRACE;
    855         }
     851DLLEXPORT void trace_destroy_output(libtrace_out_t *libtrace) {
     852        assert(libtrace);
     853        //if(!libtrace) {
     854        //      return TRACE_ERR_NULL_TRACE;
     855        //}
    856856        if (libtrace->format && libtrace->format->fin_output)
    857857                libtrace->format->fin_output(libtrace);
     
    859859                free(libtrace->uridata);
    860860        free(libtrace);
    861 
    862         return 0;
    863861}
    864862
     
    10081006                return -1;
    10091007        }
     1008
     1009        /*assert(packet);*/
     1010        if (!packet) {
     1011                return TRACE_ERR_NULL_PACKET;
     1012        }
     1013
    10101014        if (!(packet->buf_control==TRACE_CTRL_PACKET
    10111015                    || packet->buf_control==TRACE_CTRL_EXTERNAL)) {
    10121016                trace_set_err(libtrace,TRACE_ERR_BAD_STATE,"Packet passed to trace_read_packet() is invalid\n");
    10131017                return -1;
    1014         }
    1015         /*assert(packet);*/
    1016         if (!packet) {
    1017                 return TRACE_ERR_NULL_PACKET;
    10181018        }
    10191019
     
    12101210                wire_len = trace_get_wire_length(packet);
    12111211
    1212                 assert(cap_len >= 0);
     1212                /*assert(cap_len >= 0);*/
     1213                if (!(cap_len >= 0)) {
     1214                        return NULL;
     1215                }
    12131216
    12141217                /* There is the odd corrupt packet, e.g. in IPLS II, that have
     
    14941497        if (!trace) {
    14951498                fprintf(stderr,"You called trace_event() with a NULL trace object!\n");
    1496         }
    1497         assert(trace);
    1498         assert(packet);
     1499                assert(trace);
     1500        }
     1501        if (!packet) {
     1502                fprintf(stderr, "You called trace_event() with a NULL packet object!\n");
     1503                assert(packet);
     1504        }
     1505        /*assert(trace);*/
     1506        /*assert(packet);*/
    14991507
    15001508        /* Free the last packet */
     
    15981606         */
    15991607        static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
    1600         assert(filter);
     1608        /*assert(filter);*/
     1609        if (!filter) {
     1610                trace_set_err(packet->trace,
     1611                                TRACE_ERR_NULL_FILTER, "Filter is NULL trace_bpf_compile()");
     1612                return -1;
     1613        }
     1614
    16011615
    16021616        /* If this isn't a real packet, then fail */
     
    16201634                        return -1;
    16211635                }
    1622                 assert (pthread_mutex_lock(&mutex) == 0);
     1636                /*assert (pthread_mutex_lock(&mutex) == 0);*/
     1637                if (!(pthread_mutex_lock(&mutex) == 0)) {
     1638                        trace_set_err(packet->trace, TRACE_ERR_MUTEX,
     1639                                        "Unable to lock mutex trace_bpf_compile()");
     1640                        return -1;
     1641                }
    16231642                /* Make sure not one bet us to this */
    16241643                if (filter->flag) {
    1625                         assert (pthread_mutex_unlock(&mutex) == 0);
    1626                         return 1;
     1644                        /*assert (pthread_mutex_unlock(&mutex) == 0);*/
     1645                        if (!(pthread_mutex_unlock(&mutex) == 0)) {
     1646                                trace_set_err(packet->trace, TRACE_ERR_MUTEX,
     1647                                                "Unable to unlock mutex trace_bpf_compile()");
     1648                        }
     1649                        return -1;
    16271650                }
    16281651                pcap=(pcap_t *)pcap_open_dead(
     
    16301653                                1500U);
    16311654                /* build filter */
    1632                 assert(pcap);
     1655                /*assert(pcap);*/
     1656                if (!pcap) {
     1657                        trace_set_err(packet->trace, TRACE_ERR_BAD_FILTER,
     1658                                                "Unable to open pcap_t for compiling filters trace_bpf_compile()");
     1659                        return -1;
     1660                }
    16331661                if (pcap_compile( pcap, &filter->filter, filter->filterstring,
    16341662                                        1, 0)) {
     
    16381666                                        pcap_geterr(pcap));
    16391667                        pcap_close(pcap);
    1640                         assert (pthread_mutex_unlock(&mutex) == 0);
     1668                        /*assert (pthread_mutex_unlock(&mutex) == 0);*/
     1669                        if (!(pthread_mutex_unlock(&mutex) == 0)) {
     1670                                trace_set_err(packet->trace, TRACE_ERR_MUTEX,
     1671                                        "Unable to unlock mutex trace_bpf_compile()");
     1672                        }
    16411673                        return -1;
    16421674                }
    16431675                pcap_close(pcap);
    16441676                filter->flag=1;
    1645                 assert (pthread_mutex_unlock(&mutex) == 0);
     1677                /*assert (pthread_mutex_unlock(&mutex) == 0);*/
     1678                if (!(pthread_mutex_unlock(&mutex) == 0)) {
     1679                        trace_set_err(packet->trace, TRACE_ERR_MUTEX,
     1680                                "Unable to unlock mutex trace_bpf_compile()");
     1681                        return -1;
     1682                }
    16461683        }
    16471684        return 0;
    16481685#else
    1649         assert(!"Internal bug: This should never be called when BPF not enabled");
     1686        /*assert(!"Internal bug: This should never be called when BPF not enabled");*/
    16501687        trace_set_err(packet->trace,TRACE_ERR_OPTION_UNAVAIL,
    16511688                                "Feature unavailable");
     
    16671704#endif
    16681705
    1669         assert(filter);
    1670         assert(packet);
     1706        /*assert(packet);*/
     1707        if (!packet) {
     1708                /* Cannot set error in trace without access to it via the
     1709                 * packet so just return -1 */
     1710                return -1;
     1711        }
     1712        /*assert(filter);*/
     1713        if (!filter) {
     1714                trace_set_err(packet->trace, TRACE_ERR_NULL_FILTER,
     1715                        "Filter is NULL trace_apply_filter()");
     1716                return -1;
     1717        }
    16711718
    16721719        /* Match all non-data packets as we probably want them to pass
     
    17381785#endif
    17391786
    1740         assert(filter->flag);
     1787        /*assert(filter->flag);*/
     1788        if (!filter->flag) {
     1789                trace_set_err(packet->trace, TRACE_ERR_BAD_FILTER,
     1790                        "Cannot apply a bad filter trace_apply_filter()");
     1791                return -1;
     1792        }
    17411793        /* Now execute the filter */
    17421794#if HAVE_LLVM
     
    17651817                libtrace_direction_t direction)
    17661818{
    1767         assert(packet);
     1819        /*assert(packet);*/
     1820        if (!packet) {
     1821                /* Cannot return direction of a null packet so just
     1822                 * return unknown */
     1823                return (libtrace_direction_t)~0U;
     1824        }
    17681825        if (packet->trace->format->set_direction) {
    17691826                return packet->trace->format->set_direction(packet,direction);
     
    17821839DLLEXPORT libtrace_direction_t trace_get_direction(const libtrace_packet_t *packet)
    17831840{
    1784         assert(packet);
     1841        /*assert(packet);*/
     1842        if (!packet) {
     1843                /* Cannot return direction of a null packet so just
     1844                 * return unknown */
     1845                return (libtrace_direction_t)~0U;
     1846        }
    17851847        if (packet->which_trace_start != packet->trace->startcount) {
    17861848                return (libtrace_direction_t)~0U;
     
    19191981 */
    19201982DLLEXPORT size_t trace_set_capture_length(libtrace_packet_t *packet, size_t size) {
     1983        /* not sure what to return here is packet is null will come back to it */
    19211984        assert(packet);
    19221985
     
    19592022}
    19602023
    1961 enum base_format_t trace_get_format(libtrace_packet_t *packet)
    1962 {
     2024enum base_format_t trace_get_format(libtrace_packet_t *packet) {
     2025        /* Not sure what to do here, can we add a new trace_format for errors? */
    19632026        assert(packet);
    19642027
Note: See TracChangeset for help on using the changeset viewer.