Changeset 2193905


Ignore:
Timestamp:
11/29/18 10:12:59 (2 years ago)
Author:
Jacob Van Walraven <jcv9@…>
Branches:
develop
Children:
fdf23b8
Parents:
d74ca03
Message:

Apply changes required for pull request #81

Files:
2 deleted
39 edited

Legend:

Unmodified
Added
Removed
  • lib/combiner_ordered.c

    rf6f3ae5 r2193905  
    3636static int init_combiner(libtrace_t *t, libtrace_combine_t *c) {
    3737        int i = 0;
    38         /*assert(trace_get_perpkt_threads(t) > 0);*/
    3938        if (trace_get_perpkt_threads(t) <= 0) {
    4039                trace_set_err(t, TRACE_ERR_INIT_FAILED, "You must have atleast 1 processing thread");
     
    249248
    250249        for (i = 0; i < trace_get_perpkt_threads(trace); i++) {
    251                 /*assert(libtrace_deque_get_size(&queues[i]) == 0);*/
    252250                if (libtrace_deque_get_size(&queues[i]) != 0) {
    253251                        trace_set_err(trace, TRACE_ERR_COMBINER,
    254                                 "Failed to destory queues, A thread still has data in destroy()");
     252                                "Failed to destroy queues, A thread still has data in destroy()");
    255253                        return;
    256254                }
  • lib/combiner_sorted.c

    rf6f3ae5 r2193905  
    3434static int init_combiner(libtrace_t *t, libtrace_combine_t *c) {
    3535        int i = 0;
    36         /*assert(trace_get_perpkt_threads(t) > 0);*/
    3736        if (trace_get_perpkt_threads(t) <= 0) {
    3837                trace_set_err(t, TRACE_ERR_INIT_FAILED, "You must have atleast 1 processing thread");
     
    109108
    110109        for (i = 0; i < trace_get_perpkt_threads(trace); i++) {
    111                 /*assert(libtrace_vector_get_size(&queues[i]) == 0);*/
    112110                if (libtrace_vector_get_size(&queues[i]) != 0) {
    113111                        trace_set_err(trace, TRACE_ERR_COMBINER,
    114                                 "Failed to destory queues, A thread still has data in destroy()");
     112                                "Failed to destroy queues, A thread still has data in destroy()");
    115113                        return;
    116114                }
  • lib/combiner_unordered.c

    rf6f3ae5 r2193905  
    3434static int init_combiner(libtrace_t *t, libtrace_combine_t *c) {
    3535        int i = 0;
    36         /*assert(trace_get_perpkt_threads(t) > 0);*/
    3736        if (trace_get_perpkt_threads(t) <= 0) {
    3837                trace_set_err(t, TRACE_ERR_INIT_FAILED, "You must have atleast 1 processing thread");
     
    9190
    9291        for (i = 0; i < trace_get_perpkt_threads(trace); i++) {
    93                 /*assert(libtrace_deque_get_size(&queues[i]) == 0);*/
    9492                if (libtrace_deque_get_size(&queues[i]) != 0) {
    9593                        trace_set_err(trace, TRACE_ERR_COMBINER,
  • lib/data-struct/buckets.c

    r88b9798 r2193905  
    2626
    2727#include <stdlib.h>
    28 #include <assert.h>
    2928#include <string.h>
    3029#include "buckets.h"
     
    183182        libtrace_bucket_node_t tmp;
    184183
    185         /*assert(id != 0);*/
    186184        if (id == 0) {
    187185                fprintf(stderr, "bucket ID cannot be 0 in libtrace_release_bucket_id()\n");
     
    191189        pthread_mutex_lock(&b->lock);
    192190        bnode = b->packets[id];
    193         /*assert(bnode != NULL);*/
    194         if (bnode == NULL) {
     191        if (!bnode) {
    195192                fprintf(stderr, "bucket ID %lu is NULL in libtrace_release_bucket_id()\n", id);
    196193                return;
     
    204201                s = id - bnode->startindex;
    205202        }
    206         /*assert(s < bnode->slots);*/
    207203        if (s >= bnode->slots) {
    208204                fprintf(stderr, "Error in libtrace_release_bucket_id()\n");
    209205                return;
    210206        }
    211         /*assert(bnode->released[s] != 0);*/
    212207        if (bnode->released[s] == 0) {
    213208                fprintf(stderr, "Error in libtrace_release_bucket_id()\n");
     
    244239                        break;
    245240
    246                 /*assert(lnode->next != NULL);*/
    247                 if (lnode->next == NULL) {
     241                if (!lnode->next) {
    248242                        fprintf(stderr, "Error in libtrace_release_bucket_id()\n");
    249243                        return;
  • lib/data-struct/deque.c

    r88b9798 r2193905  
    6363        ASSERT_RET(pthread_mutex_lock(&q->lock), == 0);
    6464        if (q->head == NULL) {
    65                 /*assert(q->tail == NULL && q->size == 0);*/
    66                 if (q->tail != NULL && q->size != 0) {
     65                if (q->tail != NULL || q->size != 0) {
    6766                        fprintf(stderr, "Error deque head cannot be NULL with a non NULL tail and size of more than 0 in libtrace_deque_push_back()\n");
    6867                        return;
     
    7170                q->head = q->tail = new_node;
    7271        } else {
    73                 /*assert (q->tail != NULL);*/
    7472                if (q->tail == NULL) {
    7573                        fprintf(stderr, "Error deque tail cannot be NULL if it contains a head in libtrace_deque_push_back()\n");
     
    9492        ASSERT_RET(pthread_mutex_lock(&q->lock), == 0);
    9593        if (q->head == NULL) {
    96                 /*assert(q->tail == NULL && q->size == 0);*/
    97                 if (q->tail != NULL && q->size != 0) {
     94                if (q->tail != NULL || q->size != 0) {
    9895                        fprintf(stderr, "Error deque head cannot be NULL with a non NULL tail and size of more than 0 in libtrace_deque_push_front()\n");
    9996                        return;
     
    10299                q->head = q->tail = new_node;
    103100        } else {
    104                 /*assert (q->head != NULL);*/
    105                 if (q->head == NULL) {
    106                         fprintf(stderr, "Error deque tail cannot be NULL if it contains a head in libtrace_deque_push_front()\n");
    107                         return;
    108                 }
    109101                q->head->prev = new_node;
    110102                new_node->next = q->head; // Done the double link
  • lib/data-struct/linked_list.c

    r88b9798 r2193905  
    2626#include "linked_list.h"
    2727
    28 #include <assert.h>
    2928#include <stddef.h>
    3029#include <stdlib.h>
     
    7271        /* Create the new node */
    7372        new = (libtrace_list_node_t *)malloc(sizeof(libtrace_list_node_t));
    74         /*assert(new != NULL);*/
    7573        if (!new) {
    7674                fprintf(stderr, "Unable to allocate memory for node in libtrace_list_push_front()\n");
     
    7876        }
    7977        new->data = malloc(l->element_size);
    80         /*assert(new->data != NULL);*/
    8178        if (!new->data) {
    8279                fprintf(stderr, "Unable to allocate memory for node data in libtrace_list_push_front()\n");
     
    8784
    8885        if (l->head == NULL) {
    89                 /*assert(l->tail == NULL && l->size == 0);*/
    90                 if (l->tail != NULL && l->size != 0) {
     86                if (l->tail != NULL || l->size != 0) {
    9187                        fprintf(stderr, "Error cannot have a NULL head with a non NULL tail and a size of non 0 in libtrace_list_push_front()\n");
    9288                        return;
     
    111107        /* Create the new node */
    112108        new = (libtrace_list_node_t *)malloc(sizeof(libtrace_list_node_t));
    113         /*assert(new != NULL);*/
    114109        if (!new) {
    115110                fprintf(stderr, "Unable to allocate memory for node in libtrace_list_push_back()\n");
     
    117112        }
    118113        new->data = malloc(l->element_size);
    119         /*assert(new->data != NULL);*/
    120114        if (!new->data) {
    121115                fprintf(stderr, "Unable to allocate memory for node data in libtrace_list_push_back()\n");
     
    126120
    127121        if (l->tail == NULL) {
    128                 /*assert(l->head == NULL && l->size == 0);*/
    129                 if (l->head != NULL && l->size != 0) {
     122                if (l->head != NULL || l->size != 0) {
    130123                        fprintf(stderr, "Error cannot have a NULL tail with a non NULL head and a size of non 0 in libtrace_list_push_back()\n");
    131124                        return;
     
    219212        while (index--) {
    220213                ret = ret->next;
    221                 /*assert(ret != NULL);*/
    222214                if (!ret) {
    223215                        fprintf(stderr, "Error encountered NULL index in libtrace_list_get_index()\n");
  • lib/data-struct/message_queue.c

    r0a474e3 r2193905  
    4343void libtrace_message_queue_init(libtrace_message_queue_t *mq, size_t message_len)
    4444{
    45         /*assert(message_len);*/
    4645        if (!message_len) {
    4746                fprintf(stderr, "Message length cannot be 0 in libtrace_message_queue_init()\n");
     
    7372{
    7473        int ret;
    75         /*assert(mq->message_len);*/
    76         //if (!mq->message_len) {
    77         //      fprintf(stderr, "Message queue must be initialised with libtrace_message_queue_init()"
    78         //              "before inserting messages in libtrace_message_queue_put()\n");
    79         //      /* Can we return -1 here as this could imply threads are waiting */
    80         //      return -1;
    81         //}
     74        if (!mq->message_len) {
     75                fprintf(stderr, "Message queue must be initialised with libtrace_message_queue_init()"
     76                        "before inserting messages in libtrace_message_queue_put()\n");
     77                return 0;
     78        }
    8279        ASSERT_RET(write(mq->pipefd[1], message, mq->message_len), == (int) mq->message_len);
    8380        // Update after we've written
  • lib/data-struct/object_cache.c

    rb6ff245 r2193905  
    143143 */
    144144static void resize_memory_caches(struct local_caches *lcs) {
    145         /*assert (lcs->t_mem_caches_total > 0);*/
    146145        if (lcs->t_mem_caches_total <= 0) {
    147146                fprintf(stderr, "Expected lcs->t_mem_caches_total to be greater or equal to 0 in resize_memory_caches()\n");
     
    170169                /* This thread has not been used with a memory pool before */
    171170                /* Allocate our TLS */
    172                 /*assert(lcs == NULL);*/
    173171                if (lcs) {
    174172                        fprintf(stderr, "Expected lcs to be NULL in get_local_caches()\n");
     
    176174                }
    177175                lcs = calloc(1, sizeof (struct local_caches));
    178                 /*assert(lcs);*/
    179176                if (!lcs) {
    180177                        fprintf(stderr, "Unable to allocate memory for lcs in get_local_caches()\n");
     
    186183                lcs->t_mem_caches_total = 0x10;
    187184                lcs->t_mem_caches = calloc(0x10, sizeof(struct local_cache));
    188                 /*assert(lcs);*/
    189                 /*assert(lcs->t_mem_caches);*/
    190185                if (!lcs->t_mem_caches) {
    191                         fprintf(stderr, "Unable to allocate memory for lcs->t_mem_caches in get_local_cahces()\n");
     186                        fprintf(stderr, "Unable to allocate memory for lcs->t_mem_caches in get_local_caches()\n");
    192187                        return NULL;
    193188                }
     
    226221        }
    227222
    228         /*assert(!lc->invalid);*/
    229223        if (lc->invalid) {
    230224                fprintf(stderr, "lc cache is invalid in find_cache()\n");
     
    266260                                    size_t buffer_size, bool limit_size) {
    267261
    268         /*assert(buffer_size);*/
    269         if (!buffer_size) {
     262        if (buffer_size <= 0) {
    270263                fprintf(stderr, "NULL buffer_size passed into libtrace_ocache_init()\n");
    271264                return -1;
    272265        }
    273         /*assert(alloc);*/
    274266        if (!alloc) {
    275267                fprintf(stderr, "NULL alloc passed into libtrace_ocache_init()\n");
    276268                return -1;
    277269        }
    278         /*assert(free);*/
    279270        if (!free) {
    280271                fprintf(stderr, "NULL free method passed into libtrace_ocache_init()\n");
     
    398389        mem_hits.read.miss += nb_buffers - i;
    399390#endif
    400         /*assert(i >= min_nb_buffers);*/
    401391        if (i < min_nb_buffers) {
    402392                fprintf(stderr, "Unable to fill remaining cache in libtrace_ocache_alloc_cache()\n");
     
    412402        bool try_alloc = !(oc->max_allocations && oc->max_allocations <= oc->current_allocations);
    413403
    414         assert(oc->max_allocations ? nb_buffers < oc->max_allocations : 1);
     404        if (oc->max_allocations) {
     405                if(nb_buffers >= oc->max_allocations) {
     406                        fprintf(stderr, "Expected nb_buffers to be less than or equal to the object cache "
     407                                "max allocation in libtrace_ocache_alloc()\n");
     408                        return ~0U;
     409                }
     410        }
    415411        min = try_alloc ? 0: min_nb_buffers;
    416412        if (lc)
     
    435431                for (;i < nb; ++i) {
    436432                        values[i] = (*oc->alloc)();
    437                         /*assert(values[i]);*/
    438433                        if (!values[i]) {
    439434                                fprintf(stderr, "Unable to alloc memory for values[%zu] in libtrace_ocache_alloc()\n", i);
     
    441436                        }
    442437                }
    443                 /*assert (i == nb);*/
     438
    444439                if (i != nb) {
    445440                        fprintf(stderr, "Expected i == nb in libtrace_ocache_alloc()\n");
     
    454449                }
    455450        }
    456         /*assert(i >= min_nb_buffers);*/
    457451        if (i < min_nb_buffers) {
    458                 fprintf(stderr, "Expected min_nb_buffers to be equal or less than i in libtrace_ocache_alloc()\n");
     452                fprintf(stderr, "Failed to allocate minimum number of buffers for libtrace "
     453                        "object cache in libtrace_ocache_alloc()\n");
    459454                return ~0U;
    460455        }
     
    535530        size_t min;
    536531
    537         assert(oc->max_allocations ? nb_buffers < oc->max_allocations : 1);
     532        if (oc->max_allocations) {
     533                if(nb_buffers >= oc->max_allocations) {
     534                        fprintf(stderr, "Expected nb_buffers to be less than or equal to the object cache "
     535                                "max allocation in libtrace_ocache_alloc()\n");
     536                        return ~0U;
     537                }
     538        }
    538539        min = oc->max_allocations ? min_nb_buffers : 0;
    539540        if (lc)
  • lib/data-struct/ring_buffer.c

    r0a474e3 r2193905  
    268268        size_t nb_ready;
    269269        size_t i = 0;
    270        
    271         /*assert(min_nb_buffers <= nb_buffers);*/
     270
    272271        if (min_nb_buffers > nb_buffers) {
    273272                fprintf(stderr, "min_nb_buffers must be greater than or equal to nb_buffers in libtrace_ringbuffer_write_bulk()\n");
     
    351350        size_t i = 0;
    352351
    353         /*assert(min_nb_buffers <= nb_buffers);*/
    354352        if (min_nb_buffers > nb_buffers) {
    355353                fprintf(stderr, "min_nb_buffers must be greater than or equal to nb_buffers in libtrace_ringbuffer_write_bulk()\n");
  • lib/data-struct/sliding_window.c

    r0a474e3 r2193905  
    2727
    2828#include <stdlib.h>
    29 #include <assert.h>
    3029#include <string.h>
    3130
     
    4443        sw->start = 0;
    4544        sw->elements = calloc(sw->size, sizeof(void*));
    46         /*assert(sw->elements);*/
    4745        if (!sw->elements) {
    4846                fprintf(stderr, "Unable to allocate memory for sw->elements in libtrace_slidingwindow_init()\n");
  • lib/data-struct/vector.c

    r0a474e3 r2193905  
    5454                v->max_size *= 2;
    5555                v->elements = realloc(v->elements, v->max_size * v->element_size);
    56                 /*assert(v->elements);*/
    5756                if (!v->elements) {
    5857                        fprintf(stderr, "Unable to allocate memory for v->elements in libtrace_vector_push_back()\n");
     
    108107DLLEXPORT void libtrace_vector_append(libtrace_vector_t *dest, libtrace_vector_t *src)
    109108{
    110         /*assert(dest->element_size == src->element_size);*/
    111109        if (dest->element_size != src->element_size) {
    112110                fprintf(stderr, "Elements must be the same size in libtrace_vector_append()\n");
  • lib/format_atmhdr.c

    r32ee9b2 r2193905  
    3434
    3535#include <sys/stat.h>
    36 #include <assert.h>
    3736#include <errno.h>
    3837#include <fcntl.h>
  • lib/format_bpf.c

    r2725318 r2193905  
    128128
    129129        if (!libtrace->format_data) {
    130                 trace_set_err(libtrace, TRACE_ERR_INIT_FAILED, "Unable to allocate memory bpf_init_input()");
     130                trace_set_err(libtrace, TRACE_ERR_INIT_FAILED, "Unable to allocate memory "
     131                        "for format data inside bpf_init_input()");
    131132                return -1;
    132133        }
  • lib/format_dag24.c

    rf6f3ae5 r2193905  
    3333#include "format_erf.h"
    3434
    35 #include <assert.h>
    3635#include <errno.h>
    3736#include <fcntl.h>
     
    326325                return NULL;
    327326        size = ntohs(erfptr->rlen);
    328         /*assert( size >= dag_record_size );*/
    329327        if (size < dag_record_size) {
    330                 fprintf(stderr, "Incorrect dag record size in dag_get_record()\n");
     328                fprintf(stderr, "DAG2.4 rlen is invalid (rlen = %u, must be at least %u)\n",
     329                        size, dag_record_size);
    331330                return NULL;
    332331        }
     
    484483        } while (1);
    485484
    486 
    487         /* We only want to sleep for a very short time */
    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         }
    493485        event.type = TRACE_EVENT_SLEEP;
    494486        event.seconds = 0.0001;
  • lib/format_dag25.c

    rb6ff245 r2193905  
    3333#include "format_erf.h"
    3434
    35 #include <assert.h>
    3635#include <errno.h>
    3736#include <fcntl.h>
     
    245244        FORMAT_DATA->per_stream =
    246245                libtrace_list_init(sizeof(stream_data));
    247         /*assert(FORMAT_DATA->per_stream != NULL);*/
    248246        if (FORMAT_DATA->per_stream == NULL) {
    249247                trace_set_err(libtrace, TRACE_ERR_INIT_FAILED,
     
    289287{
    290288        /* Need to remove from the device list */
    291         /*assert(dev->ref_count == 0);*/
    292289        if (dev->ref_count != 0) {
    293290                fprintf(stderr, "Cannot close DAG device with non zero reference in dag_close_device()\n");
     
    10051002
    10061003        size = ntohs(erfptr->rlen);
    1007         /*assert( size >= dag_record_size );*/
    10081004        if (size < dag_record_size) {
    1009                 fprintf(stderr, "Incorrect dag record size in dag_get_record()\n");
     1005                fprintf(stderr, "DAG2.5 rlen is invalid (rlen %u, must be at least %u\n",
     1006                        size, dag_record_size);
    10101007                return NULL;
    10111008        }
     
    12391236
    12401237                /* Packet length (rlen includes format overhead) */
    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)) {
     1238                if (trace_get_capture_length(packet) <= 0
     1239                       || trace_get_capture_length(packet) > 65536) {
    12451240                        trace_set_err(libtrace, TRACE_ERR_BAD_PACKET,
    12461241                                "Capture length is out of range in dag_write_packet()");
    12471242                        return -1;
    12481243                }
    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)) {
     1244                if (erf_get_framing_length(packet) <= 0
     1245                       || trace_get_framing_length(packet) > 65536) {
    12531246                        trace_set_err(libtrace, TRACE_ERR_BAD_PACKET,
    12541247                                "Framing length is out of range in dag_write_packet()");
    12551248                        return -1;
    12561249                }
    1257                 /*assert(trace_get_capture_length(packet) +
    1258                        erf_get_framing_length(packet) > 0
    1259                        && trace_get_capture_length(packet) +
    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)) {
     1250                if (trace_get_capture_length(packet) +
     1251                       erf_get_framing_length(packet) <= 0
     1252                       || trace_get_capture_length(packet) +
     1253                       erf_get_framing_length(packet) > 65536) {
    12651254                        trace_set_err(libtrace, TRACE_ERR_BAD_PACKET,
    12661255                                "Capture + framing length is out of range in dag_write_packet()");
     
    15161505{
    15171506        libtrace_list_node_t *tmp;
    1518         /*assert(stat && libtrace);*/
    15191507        if (!libtrace) {
    15201508                fprintf(stderr, "NULL trace passed into dag_get_statistics()\n");
     
    15401528                                       libtrace_stat_t *stat) {
    15411529        struct dag_per_stream_t *stream_data = t->format_data;
    1542         /*assert(stat && libtrace);*/
    15431530        if (!libtrace) {
    15441531                fprintf(stderr, "NULL trace passed into dag_get_thread_statistics()\n");
  • lib/format_dpdk.c

    r2725318 r2193905  
    5151
    5252#include <stdlib.h>
    53 #include <assert.h>
    5453#include <unistd.h>
    5554#include <endian.h>
     
    213212static int parse_pciaddr(char * str, struct rte_pci_addr * addr, long * core) {
    214213        int matches;
    215         assert(str);
     214
     215        if (!str) {
     216                fprintf(stderr, "NULL str passed into parse_pciaddr()\n");
     217                return -1;
     218        }
    216219#if RTE_VERSION >= RTE_VERSION_NUM(17, 8, 0, 1)
    217220        matches = sscanf(str, "%8"SCNx32":%2"SCNx8":%2"SCNx8".%2"SCNx8"-%ld",
     
    325328        int i;
    326329
    327         assert (core < RTE_MAX_LCORE);
    328         assert (rte_get_master_lcore() == rte_lcore_id());
     330        if (core >= RTE_MAX_LCORE) {
     331                fprintf(stderr, "Core must be a value less than the number of cores "
     332                        "in dpdk_move_master_lcore()\n");
     333                return -1;
     334        }
     335        if (rte_get_master_lcore() != rte_lcore_id()) {
     336                fprintf(stderr, "Master core not equal to core id in dpdk_move_master_lcore()\n");
     337                return -1;
     338        }
    329339
    330340        if (core == rte_lcore_id())
     
    332342
    333343        /* Make sure we are not overwriting someone else */
    334         assert(!rte_lcore_is_enabled(core));
     344        if (rte_lcore_is_enabled(core)) {
     345                fprintf(stderr, "Cannot override another core in dpdk_move_master_lcore()\n");
     346                return -1;
     347        }
    335348
    336349        /* Move the core */
     
    470483                        int max_node_cpu = -1;
    471484                        struct bitmask *mask = numa_allocate_cpumask();
    472                         assert(mask);
     485                        if (!mask) {
     486                                fprintf(stderr, "Unable to allocate cpu mask in dpdk_init_environment()\n");
     487                                return -1;
     488                        }
    473489                        numa_node_to_cpus(format_data->nic_numa_node, mask);
    474490                        for (i = 0 ; i < nb_cpu; ++i) {
     
    530546        }
    531547        // Only the master should be running
    532         assert(cfg->lcore_count == 1);
     548        if (cfg->lcore_count != 1) {
     549                fprintf(stderr, "Expected only the master core to be running in dpdk_init_environment()\n");
     550                return -1;
     551        }
    533552
    534553        // TODO XXX TODO
     
    589608
    590609        if (!libtrace->format_data) {
    591                 trace_set_err(libtrace, TRACE_ERR_INIT_FAILED, "Unable to allocate memory dpdk_init_input()");
     610                trace_set_err(libtrace, TRACE_ERR_INIT_FAILED, "Unable to allocate memory for "
     611                        "format data inside dpdk_init_input()");
    592612                return 1;
    593613        }
     
    636656
    637657        if (!libtrace->format_data) {
    638                 trace_set_err_out(libtrace, TRACE_ERR_INIT_FAILED, "Unable to allocate memory dpdk_init_output()");
     658                trace_set_err_out(libtrace, TRACE_ERR_INIT_FAILED, "Unable to allocate memory for "
     659                        "format data inside dpdk_init_output()");
    639660                return -1;
    640661        }
     
    843864        struct dpdk_format_data_t * format_data = cb_arg;
    844865        struct rte_eth_link link_info;
    845         assert(event == RTE_ETH_EVENT_INTR_LSC);
    846         assert(port == format_data->port);
     866        if (event != RTE_ETH_EVENT_INTR_LSC) {
     867                fprintf(stderr, "Received unexpected event in dpdk_lsc_callback()\n");
     868                #if RTE_VERSION >= RTE_VERSION_NUM(17, 8, 0, 1)
     869                return -1;
     870                #else
     871                return;
     872                #endif
     873        }
     874        if (port != format_data->port) {
     875                fprintf(stderr, "Port does not match port in format data in dpdk_lsc_callback()\n");
     876                return -1;
     877        }
    847878
    848879        rte_eth_link_get_nowait(port, &link_info);
     
    14561487        struct rte_config *cfg = rte_eal_get_configuration();
    14571488
    1458         assert(rte_lcore_id() < RTE_MAX_LCORE);
     1489        if (rte_lcore_id() >= RTE_MAX_LCORE) {
     1490                fprintf(stderr, "Expected core id less than or equal to RTE_MAX_LCORE in "
     1491                        "dpdk_punregister_thread()\n");
     1492                return;
     1493        }
    14591494        pthread_mutex_lock(&dpdk_lock);
    14601495        /* Skip if master */
     
    14691504        cfg->lcore_count--;
    14701505        RTE_PER_LCORE(_lcore_id) = -1; // Might make the world burn if used again
    1471         assert(cfg->lcore_count >= 1); // We cannot unregister the master LCORE!!
     1506        if (cfg->lcore_count < 1) {
     1507                fprintf(stderr, "You cannot unregister the master lcore in dpdk_punregister_thread()\n");
     1508                return;
     1509        }
    14721510        pthread_mutex_unlock(&dpdk_lock);
    14731511        return;
     
    15951633 */
    15961634static inline struct dpdk_addt_hdr * get_addt_hdr (const libtrace_packet_t *packet) {
    1597         assert(packet);
    1598         assert(packet->buffer);
     1635        if (!packet) {
     1636                fprintf(stderr, "NULL packet passed into dpdk_addt_hdr()\n");
     1637                return NULL;
     1638        }
     1639        if (!packet->buffer) {
     1640                fprintf(stderr, "NULL packet buffer passed into dpdk_addt_hdr()\n");
     1641                return NULL;
     1642        }
    15991643        /* Our header sits straight after the mbuf header */
    16001644        return (struct dpdk_addt_hdr *) ((struct rte_mbuf*) packet->buffer + 1);
     
    16481692                               libtrace_packet_t *packet, void *buffer,
    16491693                               libtrace_rt_types_t rt_type, uint32_t flags) {
    1650         assert(packet);
     1694        if (!packet) {
     1695                fprintf(stderr, "NULL packet passed into dpdk_prepare_packet()\n");
     1696                return TRACE_ERR_NULL_PACKET;
     1697        }
    16511698        if (packet->buffer != buffer &&
    16521699            packet->buf_control == TRACE_CTRL_PACKET) {
     
    19501997                        if (packets[i]->buffer != NULL) {
    19511998                                /* The packet should always be finished */
    1952                                 assert(packets[i]->buf_control == TRACE_CTRL_PACKET);
     1999                                if (packets[i]->buf_control != TRACE_CTRL_PACKET) {
     2000                                        trace_set_err(libtrace, TRACE_ERR_BAD_PACKET, "Expected packet buffer "
     2001                                                "to be empty in dpdk_pread_packets()\n");
     2002                                        return -1;
     2003                                }
    19532004                                free(packets[i]->buffer);
    19542005                        }
     
    19752026        if (packet->buffer != NULL) {
    19762027                /* The packet should always be finished */
    1977                 assert(packet->buf_control == TRACE_CTRL_PACKET);
     2028                if (packet->buf_control != TRACE_CTRL_PACKET) {
     2029                        trace_set_err(libtrace, TRACE_ERR_BAD_PACKET, "Expected packet buffer to be "
     2030                                "empty in dpdk_read_packet()\n");
     2031                        return -1;
     2032                }
    19782033                free(packet->buffer);
    19792034                packet->buffer = NULL;
     
    20972152                        if (packet->buffer != NULL) {
    20982153                                /* The packet should always be finished */
    2099                                 assert(packet->buf_control == TRACE_CTRL_PACKET);
     2154                                if (packet->buf_control != TRACE_CTRL_PACKET) {
     2155                                        trace_set_err(libtrace, TRACE_ERR_BAD_PACKET, "Expected packet "
     2156                                                "buffer to be empty in dpdk_trace_event()\n");
     2157                                        return -1;
     2158                                }
    21002159                                free(packet->buffer);
    21012160                                packet->buffer = NULL;
  • lib/format_dpdkndag.c

    r0a474e3 r2193905  
    77#include "format_erf.h"
    88
    9 #include <assert.h>
    109#include <errno.h>
    1110#include <fcntl.h>
     
    8887
    8988        if (!libtrace->format_data) {
    90                 trace_set_err(libtrace, TRACE_ERR_INIT_FAILED, "Unable to allocate memory dpdknday_init_input()");
     89                trace_set_err(libtrace, TRACE_ERR_INIT_FAILED, "Unable to allocate memory for "
     90                        "format data inside dpdknday_init_input()");
    9191                return -1;
    9292        }
  • lib/format_duck.c

    rf6f3ae5 r2193905  
    3333
    3434#include <errno.h>
    35 #include <assert.h>
    3635#include <stdio.h>
    3736#include <fcntl.h>
     
    7069
    7170        if (!libtrace->format_data) {
    72                 trace_set_err(libtrace, TRACE_ERR_INIT_FAILED, "Unable to allocate memory duck_init_input()");
     71                trace_set_err(libtrace, TRACE_ERR_INIT_FAILED, "Unable to allocate memory for "
     72                        "format data inside duck_init_input()");
    7373                return 1;
    7474        }
     
    8282
    8383        if (!libtrace->format_data) {
    84                 trace_set_err_out(libtrace, TRACE_ERR_INIT_FAILED, "Unable to allocate memory duck_init_output()");
     84                trace_set_err_out(libtrace, TRACE_ERR_INIT_FAILED, "Unable to allocate memory for "
     85                        "format data inside duck_init_output()");
    8586                return -1;
    8687        }
     
    112113                        return -1;
    113114        }
    114         /*assert(0);*/
    115115        trace_set_err_out(libtrace, TRACE_ERR_UNKNOWN_OPTION,
    116116                "Unknown option in duck_config_output()");
     
    267267        }
    268268
    269         /*assert(OUTPUT->file);*/
    270269        if (!OUTPUT->file) {
    271270                trace_set_err_out(libtrace, TRACE_ERR_BAD_IO,
    272                         "Call init_output before write_packets() in duck_write_packet()");
     271                        "Attempted to write DUCK packets to a closed file, must call "
     272                                "trace_create_output() before calling trace_write_output()");
    273273                return -1;
    274274        }
  • lib/format_erf.c

    rf6f3ae5 r2193905  
    3535#include "wandio.h"
    3636
    37 #include <assert.h>
    3837#include <errno.h>
    3938#include <fcntl.h>
     
    180179                        exthdr ++;
    181180                        firstbyte = (uint8_t *)exthdr;
    182                         /*assert(extsize <= ntohs(erfptr->rlen));*/
    183181                        if (extsize > ntohs(erfptr->rlen)) {
    184182                                trace_set_err(packet->trace, TRACE_ERR_BAD_PACKET, "Extension size is greater than dag record record length in erf_get_framing_length()");
     
    233231
    234232        if (!libtrace->format_data) {
    235                 trace_set_err(libtrace, TRACE_ERR_INIT_FAILED, "Unable to allocate memory erf_init_input()");
     233                trace_set_err(libtrace, TRACE_ERR_INIT_FAILED, "Unable to allocate memory for "
     234                        "format data inside erf_init_input()");
    236235                return -1;
    237236        }
     
    388387                        break;
    389388                case INDEX_UNKNOWN:
    390                         /*assert(0);*/
    391389                        trace_set_err(libtrace, TRACE_ERR_SEEK_ERF, "Cannot seek to erf timestamp with unknown index in erf_seek_erf()");
    392390                        return -1;
     
    412410
    413411        if (!libtrace->format_data) {
    414                 trace_set_err_out(libtrace, TRACE_ERR_INIT_FAILED, "Unable to allocate memory erf_init_output()");
     412                trace_set_err_out(libtrace, TRACE_ERR_INIT_FAILED, "Unable to allocate memory for "
     413                        "format data inside erf_init_output()");
    415414                return -1;
    416415        }
     
    475474        } else
    476475                packet->buf_control = TRACE_CTRL_EXTERNAL;
    477        
    478        
     476
    479477        packet->type = rt_type;
    480478        packet->buffer = buffer;
     
    487485        }
    488486
    489         /*assert(erfptr->rlen != 0);*/
    490487        if (erfptr->rlen == 0) {
    491                 trace_set_err(libtrace, TRACE_ERR_BAD_PACKET, "Packet is empty in erf_prepare_packet()\n");
     488                trace_set_err(libtrace, TRACE_ERR_BAD_PACKET, "ERF packet has an invalid record "
     489                        "length: zero, in erf_prepare_packet()\n");
    492490                return -1;
    493491        }
     
    668666        void *payload = packet->payload;
    669667
    670         /*assert(OUTPUT->file);*/
    671668        if (!OUTPUT->file) {
    672                 trace_set_err_out(libtrace, TRACE_ERR_BAD_IO, "Call init_output before write_packet() in erf_write_packet()");
     669                trace_set_err_out(libtrace, TRACE_ERR_BAD_IO, "Attempted to write ERF packets to a "
     670                        "closed file, must call trace_create_output() before calling trace_write_output()");
    673671                return -1;
    674672        }
     
    722720
    723721                /* Packet length (rlen includes format overhead) */
    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)) {
     722                if (trace_get_capture_length(packet) <= 0
     723                        || trace_get_capture_length(packet) > 65536) {
    728724                        trace_set_err_out(libtrace, TRACE_ERR_BAD_PACKET,
    729725                                "Capture length is out of range in erf_write_packet()");
    730726                        return -1;
    731727                }
    732                 /*assert(trace_get_framing_length(packet)<=65536);*/
    733728                if (trace_get_framing_length(packet) > 65536) {
    734729                        trace_set_err_out(libtrace, TRACE_ERR_BAD_PACKET,
     
    743738
    744739                rlen = trace_get_capture_length(packet) + framing;
    745                 /*assert(rlen > 0 && rlen <= 65536);*/
    746                 if (!(rlen > 0 && rlen <= 65536)) {
     740                if (rlen <= 0 || rlen > 65536) {
    747741                        trace_set_err_out(libtrace, TRACE_ERR_BAD_PACKET,
    748742                                "Capture + framing length is out of range in erf_write_packet()");
     
    836830        uint16_t wlen;
    837831
    838         /*assert(packet);*/
    839832        if (!packet) {
    840833                fprintf(stderr, "NULL packet passed to erf_set_capture_length()\n");
  • lib/format_etsilive.c

    rf6f3ae5 r2193905  
    3737#include <libwandder_etsili.h>
    3838
    39 #include <assert.h>
    4039#include <errno.h>
    4140#include <fcntl.h>
     
    214213
    215214        if (!libtrace->format) {
    216                 trace_set_err(libtrace, TRACE_ERR_INIT_FAILED, "Unable to allocate memory etsilive_init_input()");
     215                trace_set_err(libtrace, TRACE_ERR_INIT_FAILED, "Unable to allocate memory for "
     216                        "format data inside etsilive_init_input()");
    217217                return 1;
    218218        }
     
    595595        libtrace_t *libtrace = packet->trace;
    596596
    597         /*assert(libtrace);*/
    598597        if (!libtrace) {
    599598                fprintf(stderr, "Packet is not associated with a trace in etsilive_get_pdu_length()\n");
    600599                return TRACE_ERR_NULL_TRACE;
    601600        }
    602         /*assert(FORMAT_DATA->shareddec);*/
    603601        if (!FORMAT_DATA->shareddec) {
    604602                trace_set_err(libtrace, TRACE_ERR_BAD_FORMAT, "Etsilive format data shareddec is NULL in etsilive_get_pdu_length()\n");
  • lib/format_helper.c

    rf6f3ae5 r2193905  
    3939#include "format_helper.h"
    4040
    41 #include <assert.h>
    4241#include <stdarg.h>
    4342
     
    6968        struct timeval tv;
    7069
    71         /*assert(trace != NULL);*/
    7270        if (!trace) {
    7371                fprintf(stderr, "NULL trace passed into trace_event_device()\n");
    74                 /* Return empty event on error? */
     72                event.type = TRACE_EVENT_TERMINATE;
    7573                return event;
    7674        }
    77         /*assert(packet != NULL);*/
    7875        if (!packet) {
    7976                trace_set_err(trace, TRACE_ERR_NULL_PACKET, "NULL packet passed into trace_event_device()");
    80                 /* Return empty event on error? */
     77                event.type = TRACE_EVENT_TERMINATE;
    8178                return event;
    8279        }
     
    300297        va_list va;
    301298        va_start(va,msg);
    302         /*assert(errcode != 0 && "An error occurred, but it is unknown what it is");*/
     299
    303300        if (errcode == 0) {
    304301                fprintf(stderr, "An error occurred, but it is unknown what it is");
    305302                return;
    306303        }
     304
    307305        trace->err.err_num=errcode;
    308306        if (errcode>0) {
     
    327325        va_list va;
    328326        va_start(va,msg);
    329         /*assert(errcode != 0 && "An error occurred, but it is unknown what it is");*/
    330327        if (errcode == 0) {
    331328                fprintf(stderr, "An error occurred, but is is unknown what is is");
  • lib/format_legacy.c

    r25a3255 r2193905  
    3434
    3535#include <sys/stat.h>
    36 #include <assert.h>
    3736#include <errno.h>
    3837#include <fcntl.h>
     
    258257                        break;
    259258                default:
    260                         /*assert(0);*/
    261259                        trace_set_err(libtrace, TRACE_ERR_BAD_FORMAT, "Invalid trace format type in legacy_read_packet()");
    262260                        return -1;
     
    394392static int legacypos_get_wire_length(const libtrace_packet_t *packet) {
    395393        legacy_pos_t *lpos = (legacy_pos_t *)packet->header;
    396         /*assert(ntohl(lpos->wlen)>0);*/
     394
    397395        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()");
     396                trace_set_err(packet->trace, TRACE_ERR_BAD_PACKET, "Packet wire length is invalid (%d) "
     397                        "in legacypos_get_wire_length()", ntohl(lpos->wlen));
    399398                return -1;
    400399        }
  • lib/format_linux_common.c

    r2725318 r2193905  
    4040#include <unistd.h>
    4141#include <string.h>
    42 #include <assert.h>
    4342
    4443#ifdef HAVE_INTTYPES_H
     
    186185                malloc(sizeof(struct linux_format_data_t));
    187186
    188         /*assert(libtrace->format_data != NULL);*/
    189187        if (!libtrace->format_data) {
    190                 trace_set_err(libtrace, TRACE_ERR_INIT_FAILED, "Unable to allocate memory linuxcommon_init_input()");
     188                trace_set_err(libtrace, TRACE_ERR_INIT_FAILED, "Unable to allocate memory for "
     189                        "format data inside linuxcommon_init_input()");
    191190                return -1;
    192191        }
     
    195194                libtrace_list_init(sizeof(stream_data));
    196195
    197         /*assert(FORMAT_DATA->per_stream != NULL);*/
    198196        if (!FORMAT_DATA->per_stream) {
    199197                trace_set_err(libtrace, TRACE_ERR_INIT_FAILED, "Unable to create list for stream data linuxcommon_init_input()");
     
    222220                malloc(sizeof(struct linux_format_data_out_t));
    223221
    224         /*assert(libtrace->format_data != NULL);*/
    225222        if (!libtrace->format_data) {
    226                 trace_set_err_out(libtrace, TRACE_ERR_INIT_FAILED, "Unable to allocate memory linuxcommon_init_output()");
     223                trace_set_err_out(libtrace, TRACE_ERR_INIT_FAILED, "Unable to allocate memory for "
     224                        "format data inside linuxcommon_init_output()");
    227225                return -1;
    228226        }
  • lib/format_linux_int.c

    rf6f3ae5 r2193905  
    4444#include <unistd.h>
    4545#include <string.h>
    46 #include <assert.h>
    4746
    4847#ifdef HAVE_INTTYPES_H
     
    451450
    452451        struct libtrace_linuxnative_header *linux_hdr = NULL;
    453         /*assert(packet);*/
    454452        if (!packet) {
    455453                fprintf(stderr, "NULL packet passed into linuxnative_set_capture_length()\n");
  • lib/format_linux_ring.c

    rf6f3ae5 r2193905  
    4545#include <unistd.h>
    4646#include <string.h>
    47 #include <assert.h>
    4847
    4948#ifdef HAVE_INTTYPES_H
     
    149148
    150149        /* In case we have some silly values*/
    151         /*assert(req->tp_block_size);*/
    152150        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);*/
     151                fprintf(stderr, "Unexpected value of zero for req->tp_block_size in calculate_buffers()\n");
     152        }
    156153        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);*/
     154                fprintf(stderr, "Unexpected value of zero for req->tp_block_nr in calculate_buffers()\n");
     155        }
    160156        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);*/
     157                fprintf(stderr, "Unexpected value of zero for req->tp_frame_size in calculate_buffers()\n");
     158        }
    164159        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);*/
     160                fprintf(stderr, "Unexpected value of zero for req->tp_frame_nr in calculate_buffers()\n");
     161        }
    168162        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");
     163                fprintf(stderr, "Unexpected value of zero for req->tp_block_size %% req->tp_frame_size in calculate_buffers()\n");
    170164        }
    171165}
     
    463457                                           size_t size)
    464458{
    465         /*assert(packet);*/
    466459        if (!packet) {
    467460                fprintf(stderr, "NULL packet passed into linuxring_set_capture_length()\n");
     
    529522        /* Fetch the current frame */
    530523        header = GET_CURRENT_BUFFER(stream);
    531         /*assert((((unsigned long) header) & (pagesize - 1)) == 0);*/
    532524        if ((((unsigned long) header) & (pagesize - 1)) != 0) {
    533                 trace_set_err(libtrace, TRACE_ERR_BAD_IO, "Header of pagesize-1 is not zero in linux_read_string()");
     525                trace_set_err(libtrace, TRACE_ERR_BAD_IO, "Linux ring packet is not correctly "
     526                        "aligned to page size in linux_read_string()");
    534527                return -1;
    535528        }
     
    679672        if (packet->buffer == NULL)
    680673                return;
    681         /*assert(packet->trace);*/
    682674        if (!packet->trace) {
    683                 fprintf(stderr, "Packet contains a NULL trace in linuxring_fin_packet()\n");
     675                fprintf(stderr, "Linux ring packet is not attached to a valid "
     676                        "trace, Unable to release it, in linuxring_fin_packet()\n");
    684677                return;
    685678        }
  • lib/format_ndag.c

    r25a3255 r2193905  
    3535#include "format_erf.h"
    3636
    37 #include <assert.h>
    3837#include <errno.h>
    3938#include <fcntl.h>
     
    287286
    288287        if (!libtrace->format_data) {
    289                 trace_set_err(libtrace, TRACE_ERR_INIT_FAILED, "Unable to allocate memory ndag_init_input()");
     288                trace_set_err(libtrace, TRACE_ERR_INIT_FAILED, "Unable to allocate memory for "
     289                        "format data inside ndag_init_input()");
    290290                return -1;
    291291        }
     
    658658        ssock->nextts = 0;
    659659
    660         /*assert(ssock->nextread - ssock->saved[nr] <= ssock->savedsize[nr]);*/
    661660        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()");
     661                trace_set_err(libtrace, TRACE_ERR_INIT_FAILED, "Walked past the end of the "
     662                        "nDAG receive buffer, probably due to a invalid rlen, in ndag_prepare_packet_stream()");
    663663                return -1;
    664664        }
     
    689689                uint32_t flags UNUSED) {
    690690
    691         /*assert(0 && "Sending nDAG records over RT doesn't make sense! Please stop.");*/
    692691        fprintf(stderr, "Sending nDAG records over RT doesn't make sense! Please stop\n");
    693692        return 0;
     
    873872        }
    874873#else
    875         /*assert(required > 0);*/
    876874        if (required <= 0) {
    877                 fprintf(stderr, "You are required to have atleast 1 receiver in init_reveivers\n");
     875                fprintf(stderr, "You are required to have atleast 1 receiver in init_receivers\n");
    878876                return TRACE_ERR_INIT_FAILED;
    879877        }
     
    912910        ssock->bufavail --;
    913911
    914         /*assert(ssock->bufavail >= 0);*/
    915912        if (ssock->bufavail < 0) {
    916913                fprintf(stderr, "No space in buffer in check_ndag_received()\n");
     
    12991296                src->bufavail += src->bufwaiting;
    13001297                src->bufwaiting = 0;
    1301                 /*assert(src->bufavail >= 0 && src->bufavail <= ENCAP_BUFFERS);*/
    1302                 if (src->bufavail < 0 && src->bufavail > ENCAP_BUFFERS) {
     1298                if (src->bufavail < 0 || src->bufavail > ENCAP_BUFFERS) {
    13031299                        trace_set_err(libtrace, TRACE_ERR_BAD_IO, "Not enough buffer space in ndag_pread_packets()");
    13041300                        return -1;
     
    13921388                src->bufavail += src->bufwaiting;
    13931389                src->bufwaiting = 0;
    1394                 /*assert(src->bufavail >= 0 && src->bufavail <= ENCAP_BUFFERS);*/
    1395                 if (src->bufavail < 0 && src->bufavail > ENCAP_BUFFERS) {
     1390                if (src->bufavail < 0 || src->bufavail > ENCAP_BUFFERS) {
    13961391                        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? */
     1392                        break;
    13981393                }
    13991394        }
  • lib/format_pcap.c

    rf6f3ae5 r2193905  
    3131
    3232#include <sys/stat.h>
    33 #include <assert.h>
    3433#include <stdio.h>
    3534#include <stdlib.h>
     
    103102
    104103        if (!libtrace->format_data) {
    105                 trace_set_err(libtrace, TRACE_ERR_INIT_FAILED, "Unable to allocate memory pcap_init_input()");
     104                trace_set_err(libtrace, TRACE_ERR_INIT_FAILED, "Unable to allocate memory for "
     105                        "format data inside pcap_init_input()");
    106106                return -1;
    107107        }
     
    178178                        return -1;
    179179        }
    180         /*assert(0);*/
    181180        return -1;
    182181}
     
    185184        libtrace->format_data = malloc(sizeof(struct pcap_format_data_out_t));
    186185        if (!libtrace->format_data) {
    187                 trace_set_err_out(libtrace, TRACE_ERR_INIT_FAILED, "Unable to allocate memory pcap_init_output()");
     186                trace_set_err_out(libtrace, TRACE_ERR_INIT_FAILED, "Unable to allocate memory for "
     187                        "format data inside pcap_init_output()");
    188188                return -1;
    189189        }
     
    198198        libtrace->format_data = malloc(sizeof(struct pcap_format_data_out_t));
    199199        if (!libtrace->format_data) {
    200                 trace_set_err_out(libtrace, TRACE_ERR_INIT_FAILED, "Unable to allocate memory pcapint_init_output()");
     200                trace_set_err_out(libtrace, TRACE_ERR_INIT_FAILED, "Unable to allocate memory for "
     201                        "format data inside pcapint_init_output()");
    201202                return -1;
    202203        }
     
    222223        libtrace->format_data = malloc(sizeof(struct pcap_format_data_t));
    223224        if (!libtrace->format_data) {
    224                 trace_set_err(libtrace, TRACE_ERR_INIT_FAILED, "Unable to allocate memory pcapint_init_input()");
     225                trace_set_err(libtrace, TRACE_ERR_INIT_FAILED, "Unable to allocate memory for "
     226                        "format data inside pcapint_init_input()");
    225227                return -1;
    226228        }
     
    261263                        return -1;
    262264        }
    263         /*assert(0);*/
    264265        return -1;
    265266}
     
    446447        uint32_t flags = 0;
    447448
    448         /*assert(libtrace->format_data);*/
    449449        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()");
     450                trace_set_err(libtrace, TRACE_ERR_BAD_FORMAT, "Trace format data missing, "
     451                        "call trace_create() before calling pcap_read_packet()");
    451452                return -1;
    452453        }
     
    611612                        pcap_pkt_hdr.len = trace_get_wire_length(packet);
    612613
    613                 /*assert(pcap_pkt_hdr.caplen<65536);*/
    614614                if (pcap_pkt_hdr.caplen >= 65536) {
    615615                        trace_set_err_out(libtrace, TRACE_ERR_BAD_HEADER, "Header capture length is larger than it should be in pcap_write_packet()");
    616616                        return -1;
    617617                }
    618                 /*assert(pcap_pkt_hdr.len<65536);*/
    619618                if (pcap_pkt_hdr.len >= 65536) {
    620619                        trace_set_err_out(libtrace, TRACE_ERR_BAD_HEADER, "Header wire length is larger than it should be pcap_write_packet()");
     
    720719        struct pcap_pkthdr *pcapptr = 0;
    721720        pcapptr = (struct pcap_pkthdr *)packet->header;
    722         /*assert(pcapptr->caplen<=65536);*/
    723721        if (pcapptr->caplen > 65536) {
    724722                trace_set_err(packet->trace, TRACE_ERR_BAD_PACKET, "Capture length is to large, Packet may be corrupt in pcap_get_capture_length()");
     
    756754static size_t pcap_set_capture_length(libtrace_packet_t *packet,size_t size) {
    757755        struct pcap_pkthdr *pcapptr = 0;
    758         /*assert(packet);*/
    759756        if (!packet) {
    760757                fprintf(stderr, "NULL packet passed to pcap_set_capture_length()\n");
     
    777774                return TRACE_ERR_NULL_TRACE;
    778775        }
    779         /*assert(trace->format_data);*/
    780776        if (!trace->format_data) {
    781777                /* cant do this because trace is a const? */
  • lib/format_pcapfile.c

    rf6f3ae5 r2193905  
    3131
    3232#include <sys/stat.h>
    33 #include <assert.h>
    3433#include <stdio.h>
    3534#include <stdlib.h>
     
    126125        libtrace->format_data = malloc(sizeof(struct pcapfile_format_data_t));
    127126        if (!libtrace->format_data) {
    128                 trace_set_err(libtrace, TRACE_ERR_INIT_FAILED, "Unable to allocate memory pcapfile_init_input()");
     127                trace_set_err(libtrace, TRACE_ERR_INIT_FAILED, "Unable to allocate memory for "
     128                        "format data inside pcapfile_init_input()");
    129129                return -1;
    130130        }
     
    139139                malloc(sizeof(struct pcapfile_format_data_out_t));
    140140        if (!libtrace->format_data) {
    141                 trace_set_err_out(libtrace, TRACE_ERR_INIT_FAILED, "Unable to allocate memory pcapfile_init_output()");
     141                trace_set_err_out(libtrace, TRACE_ERR_INIT_FAILED, "Unable to allocate memory for "
     142                        "format data inside pcapfile_init_output()");
    142143                return -1;
    143144        }
     
    204205
    205206                DATA(libtrace)->started = true;
    206                 /*assert(sizeof(DATA(libtrace)->header) > 0);*/
    207207                if (!(sizeof(DATA(libtrace)->header) > 0)) {
    208208                        trace_set_err(libtrace, TRACE_ERR_INIT_FAILED, "Trace is missing header in pcapfile_start_input()");
     
    352352        size_t bytes_to_read = 0;
    353353
    354         /*assert(libtrace->format_data);*/
    355354        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()");
     355                trace_set_err(libtrace, TRACE_ERR_BAD_FORMAT, "Trace format data missing, "
     356                        "call trace_create() before calling trace_read_packet()");
    358357                return -1;
    359358        }
     
    456455                                TRACE_ERR_NO_CONVERSION,
    457456                                "pcap does not support this format");
    458                         /*assert(0);*/
    459457                        return -1;
    460458                }
     
    497495        hdr.ts_usec = (uint32_t)tv.tv_usec;
    498496        hdr.caplen = trace_get_capture_length(packet);
    499         /*assert(hdr.caplen < LIBTRACE_PACKET_BUFSIZE);*/
    500497        if (hdr.caplen >= LIBTRACE_PACKET_BUFSIZE) {
    501498                trace_set_err_out(out, TRACE_ERR_BAD_PACKET, "Capture length is greater than buffer size in pcap_write_packet()");
     
    579576                return ts;
    580577        }
    581         /*assert(packet->header);*/
     578
    582579        if (!packet->header) {
    583                 trace_set_err(packet->trace, TRACE_ERR_BAD_HEADER, "Trace with NULL header passed to pcapfile_get_timeval()");
     580                trace_set_err(packet->trace, TRACE_ERR_BAD_HEADER, "pcap packet with NULL header passed to "
     581                        "pcapfile_get_timeval()");
    584582                /* Return default timeval on error? */
    585583                return ts;
     
    607605                return ts;
    608606        }
    609         /*assert(packet->header);*/
     607
    610608        if (!packet->header) {
    611                 trace_set_err(packet->trace, TRACE_ERR_BAD_HEADER, "Trace with NULL header passed to pcapfile_get_timespec()");
     609                trace_set_err(packet->trace, TRACE_ERR_BAD_HEADER, "pcap packet with NULL header passed to "
     610                        "pcapfile_get_timespec()");
    612611                /* Return fefault timespec on error? */
    613612                return ts;
     
    632631                return TRACE_ERR_NULL_PACKET;
    633632        }
    634         /*assert(packet->header);*/
     633
    635634        if (!packet->header) {
    636                 trace_set_err(packet->trace, TRACE_ERR_BAD_HEADER, "Trace with NULL header passed to pcapfile_get_capture_length()");
     635                trace_set_err(packet->trace, TRACE_ERR_BAD_HEADER, "pcap packet with NULL header passed to "
     636                        "pcapfile_get_capture_length()");
    637637                return -1;
    638638        }
     
    649649                return TRACE_ERR_NULL_PACKET;
    650650        }
    651         /*assert(packet->header); */
     651
    652652        if (!packet->header) {
    653                 trace_set_err(packet->trace, TRACE_ERR_BAD_HEADER, "Trace with NULL header passed to pcapfile_get_wire_length()");
     653                trace_set_err(packet->trace, TRACE_ERR_BAD_HEADER, "pcap packet with NULL header passed to "
     654                        "pcapfile_get_wire_length()");
    654655                return -1;
    655656        }
     
    692693static size_t pcapfile_set_capture_length(libtrace_packet_t *packet,size_t size) {
    693694        libtrace_pcapfile_pkt_hdr_t *pcapptr = 0;
    694         /*assert(packet);*/
     695
    695696        if (!packet) {
    696697                fprintf(stderr, "NULL packet passed into pcapfile_set_capture_length\n");
     
    698699                return ~0U;
    699700        }
    700         /*assert(packet->header);*/
     701
    701702        if (!packet->header) {
    702                 trace_set_err(packet->trace, TRACE_ERR_BAD_HEADER, "Trace with NULL header passed to pcapfile_set_capture_length()");
     703                trace_set_err(packet->trace, TRACE_ERR_BAD_HEADER, "pcap packet with NULL header passed to "
     704                        "pcapfile_set_capture_length()");
    703705                /* Return -1 on error? */
    704706                return ~0U;
  • lib/format_pcapng.c

    rf6f3ae5 r2193905  
    3131
    3232#include <sys/stat.h>
    33 #include <assert.h>
    3433#include <stdio.h>
    3534#include <stdlib.h>
     
    219218        libtrace->format_data = malloc(sizeof(struct pcapng_format_data_t));
    220219        if (!libtrace->format_data) {
    221                 trace_set_err(libtrace, TRACE_ERR_INIT_FAILED, "Unable to allocate memory pcapng_init_input()");
     220                trace_set_err(libtrace, TRACE_ERR_INIT_FAILED, "Unable to allocate memory for "
     221                        "format data inside pcapng_init_input()");
    222222                return -1;
    223223        }
     
    302302        }
    303303
    304         /*assert((char *)blockhdr < *pktbuf);*/
    305         if (!((char *)blockhdr < *pktbuf)) {
     304        if ((char *)blockhdr >= *pktbuf) {
    306305                return NULL;
    307306        }
     
    459458        }
    460459
    461         /*assert(sechdr->blocktype == PCAPNG_SECTION_TYPE);*/
    462460        if (sechdr->blocktype != PCAPNG_SECTION_TYPE) {
    463                 trace_set_err(libtrace, TRACE_ERR_BAD_PACKET, "Section is not a pcapng section type");
     461                trace_set_err(libtrace, TRACE_ERR_BAD_PACKET, "Invalid block type in pcapng section block");
    464462                return -1;
    465463        }
     
    538536
    539537        if (DATA(libtrace)->byteswapped) {
    540                 /*assert(byteswap32(inthdr->blocktype) == PCAPNG_INTERFACE_TYPE);*/
    541538                if (byteswap32(inthdr->blocktype) != PCAPNG_INTERFACE_TYPE) {
    542                         trace_set_err(libtrace, TRACE_ERR_BAD_PACKET, "Interface is not a pcapng type");
     539                        trace_set_err(libtrace, TRACE_ERR_BAD_PACKET, "Invalid block type in pcapng interface");
    543540                        return -1;
    544541                }
     
    546543                newint->linktype = byteswap16(inthdr->linktype);
    547544        } else {
    548                 /*assert(inthdr->blocktype == PCAPNG_INTERFACE_TYPE);*/
    549545                if (inthdr->blocktype != PCAPNG_INTERFACE_TYPE) {
    550                         trace_set_err(libtrace, TRACE_ERR_BAD_PACKET, "Interface is not a pcapng type");
     546                        trace_set_err(libtrace, TRACE_ERR_BAD_PACKET, "Invalid block type in pcapng interface");
    551547                        return -1;
    552548                }
     
    621617        /* Read the rest of the packet into the buffer */
    622618        if (DATA(libtrace)->byteswapped) {
    623                 /*assert(byteswap32(hdr->blocktype) == PCAPNG_NAME_RESOLUTION_TYPE);*/
    624619                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");
     620                        trace_set_err(libtrace, TRACE_ERR_BAD_PACKET, "Invalid block type in pcapng name "
     621                                "resolution block");
    626622                        return -1;
    627623                }
    628624        } else {
    629                 /*assert(hdr->blocktype == PCAPNG_NAME_RESOLUTION_TYPE);*/
    630625                if (hdr->blocktype != PCAPNG_NAME_RESOLUTION_TYPE) {
    631                         trace_set_err(libtrace, TRACE_ERR_BAD_PACKET, "Blocktype is not a pcapng name resolution type");
     626                        trace_set_err(libtrace, TRACE_ERR_BAD_PACKET, "Invalid block type in pcapng name "
     627                                "resolution block");
    632628                        return -1;
    633629                }
     
    663659        /* Read the rest of the packet into the buffer */
    664660        if (DATA(libtrace)->byteswapped) {
    665                 /*assert(byteswap32(hdr->blocktype) == PCAPNG_CUSTOM_TYPE ||
    666                         byteswap32(hdr->blocktype) == PCAPNG_CUSTOM_NONCOPY_TYPE);*/
    667661                if (byteswap32(hdr->blocktype) != PCAPNG_CUSTOM_TYPE ||
    668662                        byteswap32(hdr->blocktype) != PCAPNG_CUSTOM_NONCOPY_TYPE) {
    669                         trace_set_err(libtrace, TRACE_ERR_BAD_PACKET, "Blocktype is not pcapng custom type");
     663                        trace_set_err(libtrace, TRACE_ERR_BAD_PACKET, "Invalid blocktype "
     664                                "in pcapng custom block");
    670665                        return -1;
    671666                }
    672667        } else {
    673                 /*assert(hdr->blocktype == PCAPNG_CUSTOM_TYPE ||
    674                         hdr->blocktype == PCAPNG_CUSTOM_NONCOPY_TYPE);*/
    675668                if (hdr->blocktype != PCAPNG_CUSTOM_TYPE ||
    676669                        hdr->blocktype != PCAPNG_CUSTOM_NONCOPY_TYPE) {
    677                         trace_set_err(libtrace, TRACE_ERR_BAD_PACKET, "Blocktype is not pcapng custom type");
     670                        trace_set_err(libtrace, TRACE_ERR_BAD_PACKET, "Invalid blocktype "
     671                                "in pcapng custom block");
    678672                        return -1;
    679673                }
     
    710704        /* Read the rest of the packet into the buffer */
    711705        if (DATA(libtrace)->byteswapped) {
    712                 /*assert(byteswap32(hdr->blocktype) == PCAPNG_INTERFACE_STATS_TYPE);*/
    713706                if (byteswap32(hdr->blocktype) != PCAPNG_INTERFACE_STATS_TYPE) {
    714                         trace_set_err(libtrace, TRACE_ERR_BAD_PACKET, "Blocktype is not a pcapng stats type");
     707                        trace_set_err(libtrace, TRACE_ERR_BAD_PACKET, "Invalid block type "
     708                                "in pcapng statistics block");
    715709                        return -1;
    716710                }
     
    718712                timestamp = ((uint64_t)(byteswap32(hdr->timestamp_high)) << 32) + byteswap32(hdr->timestamp_low);
    719713        } else {
    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");
     714                if (hdr->blocktype != PCAPNG_INTERFACE_STATS_TYPE) {
     715                        trace_set_err(libtrace, TRACE_ERR_BAD_PACKET, "Invalid block type "
     716                                "in pcapng statistics block");
    723717                        return -1;
    724718                }
     
    817811        /* Read the rest of the packet into the buffer */
    818812        if (DATA(libtrace)->byteswapped) {
    819                 /*assert(byteswap32(hdr->blocktype) == PCAPNG_SIMPLE_PACKET_TYPE);*/
    820813                if (byteswap32(hdr->blocktype) != PCAPNG_SIMPLE_PACKET_TYPE) {
    821                         trace_set_err(libtrace, TRACE_ERR_BAD_PACKET, "Blocktype is not a pcapng simple type");
     814                        trace_set_err(libtrace, TRACE_ERR_BAD_PACKET, "Invalid block type in "
     815                                "pcapng simple packet block");
    822816                        return -1;
    823817                }
     
    825819                         /* account for trailing length field */
    826820        } else {
    827                 /*assert(hdr->blocktype == PCAPNG_SIMPLE_PACKET_TYPE);*/
    828821                if (hdr->blocktype != PCAPNG_SIMPLE_PACKET_TYPE) {
    829                         trace_set_err(libtrace, TRACE_ERR_BAD_PACKET, "Blocktype is not a pcapng simple type");
     822                        trace_set_err(libtrace, TRACE_ERR_BAD_PACKET, "Invalid block type in "
     823                                "pcapng simple packet block");
     824                        return -1;
    830825                }
    831826                caplen = hdr->blocklen - sizeof(pcapng_spkt_t) - 4;
     
    874869        /* Read the rest of the packet into the buffer */
    875870        if (DATA(libtrace)->byteswapped) {
    876                 /*assert(byteswap32(hdr->blocktype) == PCAPNG_ENHANCED_PACKET_TYPE);*/
    877871                if (byteswap32(hdr->blocktype) != PCAPNG_ENHANCED_PACKET_TYPE) {
    878                         trace_set_err(libtrace, TRACE_ERR_BAD_PACKET, "Blocktype is not a pcapng enhanced type");
     872                        trace_set_err(libtrace, TRACE_ERR_BAD_PACKET, "Invalid block type in "
     873                                "pcapng enhanced packet block");
    879874                        return -1;
    880875                }
     
    882877                ifaceid = byteswap32(hdr->interfaceid);
    883878        } else {
    884                 /*assert(hdr->blocktype == PCAPNG_ENHANCED_PACKET_TYPE);*/
    885879                if (hdr->blocktype != PCAPNG_ENHANCED_PACKET_TYPE) {
    886                         trace_set_err(libtrace, TRACE_ERR_BAD_PACKET, "Blocktype is not a pcapng enhanced type");
     880                        trace_set_err(libtrace, TRACE_ERR_BAD_PACKET, "Invalid block type in "
     881                                "pcapng enhanced packet block");
    887882                        return -1;
    888883                }
     
    961956        }
    962957        if (!packet) {
    963                 trace_set_err(libtrace, TRACE_ERR_NULL_PACKET, "NULL packet passed into pcapng_read_packet()\n");
     958                trace_set_err(libtrace, TRACE_ERR_NULL_PACKET, "NULL packet passed into "
     959                        "pcapng_read_packet()\n");
    964960                return -1;
    965961        }
    966962
    967963        /* Peek to get next block type */
    968         /*assert(libtrace->format_data);*/
    969964        if (!libtrace->format_data) {
    970                 trace_set_err(libtrace, TRACE_ERR_BAD_FORMAT, "Trace has no format data in pcapng_read_packet()");
     965                trace_set_err(libtrace, TRACE_ERR_BAD_FORMAT, "Trace has no format data in "
     966                        "pcapng_read_packet()");
    971967                return -1;
    972968        }
    973         /*assert(libtrace->io);*/
    974969        if (!libtrace->io) {
    975                 trace_set_err(libtrace, TRACE_ERR_BAD_IO, "Trace has no IO associated with it in pcapng_read_packet()");
     970                trace_set_err(libtrace, TRACE_ERR_BAD_IO, "Trace has no valid file handle "
     971                        "attached to it in pcapng_read_packet()");
    976972                return -1;
    977973        }
     
    11211117                return ts;
    11221118        }
    1123         /*assert(packet->header);*/
    11241119        if (!packet->header) {
    11251120                trace_set_err(packet->trace, TRACE_ERR_BAD_PACKET, "NULL header in packet in pcapng_get_timespec()");
  • lib/format_rt.c

    rf6f3ae5 r2193905  
    3737
    3838#include <sys/stat.h>
    39 #include <assert.h>
    4039#include <errno.h>
    4140#include <fcntl.h>
     
    611610        packet->payload = RT_INFO->buf_read + sizeof(rt_header_t);
    612611        packet->internalid = libtrace_push_into_bucket(RT_INFO->bucket);
    613         /*assert(packet->internalid != 0);*/
    614612        if (!packet->internalid) {
    615613                trace_set_err(libtrace, TRACE_ERR_RT_FAILURE, "packet->internalid is 0 in rt_get_next_packet()");
     
    760758        libtrace_err_t read_err;
    761759
    762         /*assert(trace);*/
    763760        if (!trace) {
    764761                fprintf(stderr, "NULL trace passed into trace_event_rt()\n");
     
    766763                return event;
    767764        }
    768         /*assert(packet);*/
    769765        if (!packet) {
    770766                trace_set_err(trace, TRACE_ERR_NULL_PACKET, "NULL packet passed into trace_event_rt()");
  • lib/format_tsh.c

    r32ee9b2 r2193905  
    3131#include "format_helper.h"
    3232
    33 #include <assert.h>
    3433#include <errno.h>
    3534#include <fcntl.h>
  • lib/linktypes.c

    r25a3255 r2193905  
    2828
    2929#include "rt_protocol.h"
    30 #include <assert.h>
    3130#include "libtrace_int.h"
    3231#include <stdlib.h>
     
    162161
    163162        fprintf(stderr, "Error: RT type %u cannot be converted to a pcap DLT\n", rt_type);
    164         /*assert(false);*/
    165163        return 0;       /* satisfy warnings */
    166164}
  • lib/protocols_l2.c

    r25a3255 r2193905  
    2727#include "libtrace.h"
    2828#include "protocols.h"
    29 #include <assert.h>
    3029#include <stdlib.h>
    3130#include <string.h>
     
    196195                uint32_t *remaining) {
    197196        /* Ensure supplied type is not NULL */
    198         /*assert(type);*/
    199197        if (!type) {
    200198                fprintf(stderr, "NULL type passed into trace_get_payload_from_mpls()\n");
     
    332330                uint32_t *remaining) {
    333331        /* Ensure type supplied is not NULL */
    334         /*assert(type);*/
    335332        if (!type) {
    336333                fprintf(stderr, "NULL type passed into trace_get_payload_from_pppoe()\n");
     
    447444        void *meta = NULL;
    448445
    449         /*assert(packet != NULL);*/
    450446        if (!packet) {
    451447                fprintf(stderr, "NULL packet passed into trace_get_layer2()\n");
    452448                return NULL;
    453449        }
    454         /*assert(linktype != NULL);*/
    455450        if (!linktype) {
    456451                fprintf(stderr, "NULL linktype passed into trace_get_layer2()\n");
     
    727722                case TRACE_TYPE_80211_RADIO:
    728723                case TRACE_TYPE_ETSILI:
    729                         /*assert(!"Metadata headers should already be skipped");*/
    730724                        fprintf(stderr, "Metadata headers should already be skipped in trace_get_source_mac()\n");
    731725                        return NULL;
    732726        }
    733727        fprintf(stderr,"%s not implemented for linktype %i\n", __func__, linktype);
    734         /*assert(0);*/
    735728        return NULL;
    736729}
     
    785778                case TRACE_TYPE_80211_RADIO:
    786779                case TRACE_TYPE_ETSILI:
    787                         /*assert(!"Metadata headers should already be skipped");*/
    788780                        fprintf(stderr, "Metadata headers should already be skipped in trace_get_destination_mac()\n");
    789781                        return NULL;
    790782        }
    791783        fprintf(stderr,"Not implemented\n");
    792         /*assert(0);*/
    793784        return NULL;
    794785}
  • lib/protocols_l3.c

    r25a3255 r2193905  
    2929#include "protocols.h"
    3030#include "checksum.h"
    31 #include <assert.h>
    3231#include <stdlib.h>
    3332#include <arpa/inet.h>
     
    103102        void *trans_ptr = 0;
    104103
    105         /*assert(ipptr != NULL);*/
    106104        if (!ipptr) {
    107105                fprintf(stderr, "NULL libtrace_ip_t pointer passed into trace_get_payload_from_ip()\n");
     
    146144        uint16_t len;
    147145
    148         /*assert (ipptr != NULL);*/
    149146        if (!ipptr) {
    150147                fprintf(stderr, "NULL libtrace_ip6_t passed into trace_get_payload_from_ip6()\n");
     
    350347                        return 1;
    351348        }
    352         /*assert(0);*/
    353349}
    354350
     
    356352                int spacelen) {
    357353
    358         /*assert(addrptr && space);*/
    359354        if (!addrptr) {
    360355                fprintf(stderr, "NULL sockaddr passed into sockaddr_to_string()\n");
     
    362357        }
    363358        if (!space) {
    364                 fprintf(stderr, "NULL space passed into sockaddr_to_string()\n");
    365                 return NULL;
    366         }
    367         /*assert(spacelen > 0);*/
     359                fprintf(stderr, "NULL buffer space passed into sockaddr_to_string()\n");
     360                return NULL;
     361        }
    368362        if (spacelen <= 0) {
    369                 fprintf(stderr, "Spacelen must be greater than 0 when passed into sockaddr_to_string()\n");
     363                fprintf(stderr, "Buffer size must be greater than 0 when passed into sockaddr_to_string()\n");
    370364                return NULL;
    371365        }
  • lib/protocols_ospf.c

    rf6f3ae5 r2193905  
    2727#include "libtrace.h"
    2828#include "protocols.h"
    29 #include <assert.h>
    3029#include <stdlib.h>
    3130#include <stdio.h> // fprintf
     
    4544                return NULL;
    4645        }
    47         /*assert(version != NULL && "version may not be NULL when calling trace_get_ospf_header!");*/
    4846        if (!version) {
    4947                fprintf(stderr, "NULL version passed into trace_get_ospf_version()\n");
     
    7068        char *ptr;
    7169
    72         /*assert(remaining != NULL && "remaining may not be NULL when calling trace_get_ospf_contents!");*/
    7370        if (!remaining) {
    7471                fprintf(stderr, "Remaining may not be NULL when calling trace_get_ospf_contents()\n");
     
    8683                *ospf_type = 0;
    8784                *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");
    8985                return NULL;
    9086        }
     
    104100
    105101        unsigned char *link_ptr = NULL;
    106         /*assert(remaining != NULL && "remaining may not be NULL when calling trace_get_first_link_from_router_lsa_v2!");*/
    107102        if (!remaining) {
    108103                fprintf(stderr, "Remaining may not be NULL when calling trace_get_first_link_from_router_lsa_v2()\n");
     
    116111        if (*remaining < sizeof(libtrace_ospf_router_lsa_v2_t)) {
    117112                *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");
    119113                return NULL;
    120114        }
     
    132126        unsigned char *lsa_ptr = NULL;
    133127
    134         /*assert(remaining != NULL && "remaining may not be NULL when calling trace_get_first_ospf_v2_lsa!");*/
    135128        if (!remaining) {
    136129                fprintf(stderr, "Remaining may not be NULL when calling trace_get_first_ospf_v2_lsa()\n");
     
    144137        if (*remaining < sizeof(libtrace_ospf_db_desc_v2_t)) {
    145138                *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");
    147139                return NULL;
    148140        }
     
    160152        unsigned char *lsa_ptr = NULL;
    161153
    162         /*assert(remaining != NULL && "remaining may not be NULL when calling trace_get_first_ospf_v2_lsa!");*/
    163154        if (!remaining) {
    164                 fprintf(stderr, "Remaining may not be NULL when calling trace_get_first_ospf_v2_lsa()\n");
     155                fprintf(stderr, "Remaining may not be NULL when calling "
     156                        "trace_get_first_ospf_lsa_from_update_v2()\n");
    165157                return NULL;
    166158        }
    167159        if (!ls_update) {
    168                 fprintf(stderr, "ls_update may not be NULL when calling trace_get_first_ospf_v2_lsa()\n");
     160                fprintf(stderr, "ls_update may not be NULL when calling "
     161                        "trace_get_first_ospf_lsa_from_update_v2()\n");
    169162                return NULL;
    170163        }
     
    172165        if (*remaining < sizeof(libtrace_ospf_ls_update_t)) {
    173166                *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");
    175167                return NULL;
    176168        }
     
    187179        uint32_t metric = 0;
    188180
    189         /*assert(as_lsa);*/
    190181        if (!as_lsa) {
    191182                fprintf(stderr, "NULL as_lsa passed into trace_get_ospf_metric_from_as_external_lsa_v2()\n");
     
    206197        uint32_t metric = 0;
    207198
    208         /*assert(sum_lsa);*/
    209199        if (!sum_lsa) {
    210200                fprintf(stderr, "NULL sum_lsa passed into trace_get_ospf_metric_from_summary_lsa_v2()\n");
  • lib/protocols_pktmeta.c

    r25a3255 r2193905  
    2727#include "libtrace.h"
    2828#include "protocols.h"
    29 #include <assert.h>
    3029
    3130#ifdef HAVE_WANDDER
     
    156155        uint32_t dummyrem;
    157156        void *pktbuf = NULL;
    158         /*assert(packet != NULL);*/
    159157        if (!packet) {
    160158                fprintf(stderr, "NULL packet passed into trace_get_packet_meta()");
    161159                return NULL;
    162160        }
    163         /*assert(linktype != NULL);*/
    164161        if (!linktype) {
    165162                fprintf(stderr, "NULL linkype passed into trace_get_packet_meta()");
     
    210207        uint16_t next = 0;
    211208
    212         /*assert(meta != NULL);*/
    213209        if (!meta) {
    214210                fprintf(stderr, "NULL meta passed into trace_get_payload_from_meta()");
    215211                return NULL;
    216212        }
    217         /*assert(linktype != NULL);*/
    218213        if (!linktype) {
    219214                fprintf(stderr, "NULL linktype passed into trace_get_payload_from_meta()");
    220215                return NULL;
    221216        }
    222         /*assert(remaining != NULL);*/
    223217        if (!remaining) {
    224218                fprintf(stderr, "NULL remaining passed into trace_get_payload_from_meta()");
  • lib/protocols_transport.c

    r54a76f2 r2193905  
    2929#include "protocols.h"
    3030#include "checksum.h"
    31 #include <assert.h>
    3231#include <stdlib.h>
    3332#include <stdio.h> // fprintf
     
    568567        sum += add_checksum(header, (uint16_t)plen);
    569568        *csum = ntohs(finish_checksum(sum));
    570         //assert(0);
    571        
     569
    572570        return (uint16_t *)csum_ptr;
    573571}
  • lib/trace.c

    r1ed3f1e r2193905  
    201201
    202202        libtrace->io = wandio_create(filename);
    203         if (!libtrace->io)
     203        if (!libtrace->io) {
     204                trace_set_err(libtrace,TRACE_ERR_URI_NOT_FOUND,"Unable to find URI (%s)", filename);
    204205                return;
     206        }
    205207
    206208        /* Try and guess based on file magic */
     
    216218         * used to probe the file magic */
    217219        wandio_destroy(libtrace->io);
     220        trace_set_err(libtrace,TRACE_ERR_BAD_FORMAT,"Unable to guess format (%s)", filename);
    218221        return;
    219222}
     
    252255        }
    253256
    254         /*assert(uri && "Passing NULL to trace_create makes me a very sad program");*/
    255257        if(!uri) {
    256258                trace_set_err(libtrace, TRACE_ERR_URI_NULL, "NULL uri passed to trace_create()");
     
    310312                /* Could not parse the URI nicely */
    311313                guess_format(libtrace,uri);
    312                 if (!libtrace->format) {
    313                         /* Check if the file exists */
    314                         FILE *file;
    315                         if(!(file=fopen(uri, "r"))) {
    316                                 trace_set_err(libtrace,TRACE_ERR_URI_NOT_FOUND,"Unable to find URI (%s)",uri);
    317                         } else {
    318                                 fclose(file);
    319                                 trace_set_err(libtrace,TRACE_ERR_BAD_FORMAT,"Unable to guess format (%s)",uri);
    320                         }
     314                if (trace_is_err(libtrace)) {
    321315                        return libtrace;
    322316                }
     
    350344        if (libtrace->format->init_input) {
    351345                int err=libtrace->format->init_input(libtrace);
    352                 /*assert (err==-1 || err==0);*/
    353346                if (err==-1) {
    354347                        /* init_input should call trace_set_err to set the
     
    536529DLLEXPORT int trace_start(libtrace_t *libtrace)
    537530{
    538         /*assert(libtrace);*/
    539531        if(!libtrace) {
    540532                fprintf(stderr, "NULL trace passed to trace_start()\n");
     
    558550DLLEXPORT int trace_start_output(libtrace_out_t *libtrace)
    559551{
    560         /*assert(libtrace);*/
    561552        if(!libtrace) {
    562553                fprintf(stderr, "NULL trace passed to trace_start_output()\n");
     
    576567DLLEXPORT int trace_pause(libtrace_t *libtrace)
    577568{
    578         /*assert(libtrace);*/
    579569        if(!libtrace) {
    580570                fprintf(stderr, "NULL trace passed to trace_pause()\n");
     
    589579        if (!libtrace_parallel && libtrace->last_packet)
    590580                trace_fin_packet(libtrace->last_packet);
    591         /*assert(libtrace->last_packet == NULL);*/
    592581        if(libtrace->last_packet != NULL) {
    593582                trace_set_err(libtrace, TRACE_ERR_PAUSE_FIN, "Unable to remove all data stored against trace in trace_pause()");
     
    734723        int i;
    735724
    736         /*assert(libtrace);*/
    737725        if(!libtrace) {
    738                 fprintf(stderr, "NULL trace passed to trace_destory()\n");
     726                fprintf(stderr, "NULL trace passed to trace_destroy()\n");
    739727                return;
    740728        }
     
    759747                trace_fin_packet(libtrace->last_packet);
    760748        }
    761         /*assert(libtrace->last_packet == NULL);*/
    762749        if (libtrace->last_packet != NULL) {
    763750                trace_set_err(libtrace, TRACE_ERR_PAUSE_FIN, "Unable to remove all data stored against trace in trace_destroy()");
     
    831818
    832819DLLEXPORT void trace_destroy_dead(libtrace_t *libtrace) {
    833         /*assert(libtrace);*/
    834820        if(!libtrace) {
    835                 fprintf(stderr, "NULL trace passed to trace_destory_dead()\n");
     821                fprintf(stderr, "NULL trace passed to trace_destroy_dead()\n");
    836822                return;
    837823        }
     
    853839 */
    854840DLLEXPORT void trace_destroy_output(libtrace_out_t *libtrace) {
    855         /*assert(libtrace);*/
    856841        if(!libtrace) {
    857842                fprintf(stderr, "NULL trace passed to trace_destroy_output()\n");
     
    1002987DLLEXPORT int trace_read_packet(libtrace_t *libtrace, libtrace_packet_t *packet) {
    1003988
    1004         /*assert(libtrace && "You called trace_read_packet() with a NULL libtrace parameter!\n");*/
    1005989        if (!libtrace) {
    1006990                fprintf(stderr, "NULL trace passed to trace_read_packet()\n");
     
    10161000        }
    10171001
    1018         /*assert(packet);*/
    10191002        if (!packet) {
    10201003                trace_set_err(libtrace, TRACE_ERR_NULL_PACKET, "NULL packet passed into trace_read_packet()");
     
    11081091                void *buffer, libtrace_rt_types_t rt_type, uint32_t flags) {
    11091092
    1110         /*assert(trace);*/
    11111093        if (!trace) {
    11121094                fprintf(stderr, "NULL trace passed into trace_prepare_packet()\n");
     
    11141096        }
    11151097
    1116         /*assert(packet);*/
    11171098        if (!packet) {
    11181099                trace_set_err(trace, TRACE_ERR_NULL_TRACE, "NULL packet passed into trace_prepare_packet()");
     
    11531134 */
    11541135DLLEXPORT int trace_write_packet(libtrace_out_t *libtrace, libtrace_packet_t *packet) {
    1155         /*assert(libtrace);*/
     1136
    11561137        if (!libtrace) {
    11571138                fprintf(stderr, "NULL trace passed into trace_write_packet()\n");
    11581139                return TRACE_ERR_NULL_TRACE;
    11591140        }
    1160         /*assert(packet);*/
    11611141        if (!packet) {
    11621142                trace_set_err_out(libtrace, TRACE_ERR_NULL_PACKET, "NULL trace passed into trace_write_packet()");
     
    11661146        if (!libtrace->started) {
    11671147                trace_set_err_out(libtrace,TRACE_ERR_BAD_STATE,
    1168                         "You must call trace_start() before calling trace_write_packet()");
     1148                        "You must call trace_start_output() before calling trace_write_packet()");
    11691149                return -1;
    11701150        }
     
    11911171        libtrace_linktype_t ltype;
    11921172
    1193         /*assert(packet != NULL);*/
    11941173        if (!packet) {
    11951174                fprintf(stderr, "NULL packet passed into trace_get_packet_buffer()\n");
     
    12271206                wire_len = trace_get_wire_length(packet);
    12281207
    1229                 /*assert(cap_len >= 0);*/
    12301208                if (!(cap_len >= 0)) {
    12311209                        fprintf(stderr, "Was expecting capture length of atleast 0 in trace_get_packet_buffer()\n");
     
    14231401        }
    14241402
    1425         /*assert(packet->capture_length < LIBTRACE_PACKET_BUFSIZE);*/
    14261403        if (!(packet->capture_length < LIBTRACE_PACKET_BUFSIZE)) {
    14271404                fprintf(stderr, "Capture length is greater than the buffer size in trace_get_capture_length()\n");
     
    14531430        }
    14541431
    1455         /*assert(packet->wire_length < LIBTRACE_PACKET_BUFSIZE);*/
    14561432        if (!(packet->wire_length < LIBTRACE_PACKET_BUFSIZE)) {
    14571433                fprintf(stderr, "Wire length is greater than the buffer size in trace_get_wire_length()\n");
     
    15231499        libtrace_eventobj_t event = {TRACE_EVENT_IOWAIT,0,0.0,0};
    15241500
    1525 
    1526         /*assert(trace && "You called trace_event() with a NULL trace object!");*/
    15271501        if (!trace) {
    15281502                fprintf(stderr, "NULL trace passed into trace_event()");
     
    15301504                return event;
    15311505        }
    1532         /*assert(packet && "You called trace_event() with a NULL packet object!");*/
    15331506        if (!packet) {
    15341507                trace_set_err(trace, TRACE_ERR_NULL_PACKET, "NULL packet passed into trace_event()");
     
    16431616        }
    16441617
    1645         /*assert(filter && "You called trace_bpf_compile() with a NULL filter");*/
    16461618        if (!filter) {
    16471619                trace_set_err(packet->trace,
     
    16701642                        return -1;
    16711643                }
    1672                 /*assert (pthread_mutex_lock(&mutex) == 0);*/
    16731644                pthread_mutex_lock(&mutex);
    16741645                /* Make sure not one bet us to this */
    16751646                if (filter->flag) {
    1676                         /*assert (pthread_mutex_unlock(&mutex) == 0);*/
    16771647                        pthread_mutex_unlock(&mutex);
    16781648                        return -1;
     
    16821652                                1500U);
    16831653                /* build filter */
    1684                 /*assert(pcap && "Unable to open pcap_t for compiling filters trace_bpf_compile()");*/
    16851654                if (!pcap) {
    16861655                        trace_set_err(packet->trace, TRACE_ERR_BAD_FILTER,
     
    16951664                                        pcap_geterr(pcap));
    16961665                        pcap_close(pcap);
    1697                         /*assert (pthread_mutex_unlock(&mutex) == 0);*/
    16981666                        pthread_mutex_unlock(&mutex);
    16991667                        return -1;
     
    17011669                pcap_close(pcap);
    17021670                filter->flag=1;
    1703                 /*assert (pthread_mutex_unlock(&mutex) == 0);*/
    17041671                pthread_mutex_unlock(&mutex);
    17051672        }
    17061673        return 0;
    17071674#else
    1708         /*assert(!"Internal bug: This should never be called when BPF not enabled");*/
    17091675        trace_set_err(packet->trace,TRACE_ERR_OPTION_UNAVAIL,
    17101676                                "Feature unavailable");
     
    17261692#endif
    17271693
    1728         /*assert(packet && "You called trace_apply_filter() with a NULL packet");*/
    17291694        if (!packet) {
    17301695                fprintf(stderr, "NULL packet passed into trace_apply_filter()\n");
    17311696                return TRACE_ERR_NULL_PACKET;
    17321697        }
    1733         /*assert(filter && "You called trace_apply_filter() with a NULL filter");*/
    17341698        if (!filter) {
    17351699                trace_set_err(packet->trace, TRACE_ERR_NULL_FILTER,
     
    18061770#endif
    18071771
    1808         /*assert(filter->flag);*/
    18091772        if (!filter->flag) {
    18101773                trace_set_err(packet->trace, TRACE_ERR_BAD_FILTER,
     
    18381801                libtrace_direction_t direction)
    18391802{
    1840         /*assert(packet);*/
    18411803        if (!packet) {
    18421804                fprintf(stderr, "NULL packet passed into trace_set_direction()\n");
     
    18591821DLLEXPORT libtrace_direction_t trace_get_direction(const libtrace_packet_t *packet)
    18601822{
    1861         /*assert(packet);*/
    18621823        if (!packet) {
    18631824                fprintf(stderr, "NULL packet passed into trace_set_direction()\n");
     
    20001961 */
    20011962DLLEXPORT size_t trace_set_capture_length(libtrace_packet_t *packet, size_t size) {
    2002         /*assert(packet);*/
    20031963        if (!packet) {
    20041964                fprintf(stderr, "NULL packet passed into trace_set_capture_length()\n");
     
    20452005
    20462006enum base_format_t trace_get_format(libtrace_packet_t *packet) {
    2047         /* Not sure what to do here, can we add a new trace_format for errors? */
    2048         /*assert(packet);*/
    20492007        if (!packet) {
    20502008                fprintf(stderr, "NULL packet passed into trace_get_format()\n");
     
    22932251
    22942252        /* Now fill in the libtrace packet itself */
    2295         /*assert(deadtrace);*/
    22962253        if (!deadtrace) {
    2297                 fprintf(stderr, "Unable to create dead trace trace_construct_packet()\n");
     2254                fprintf(stderr, "Unable to create dummy trace for use within trace_construct_packet()\n");
    22982255                return;
    22992256        }
     
    23272284        uint64_t ret;
    23282285
    2329         /*assert(trace);*/
    23302286        if (!trace) {
    23312287                fprintf(stderr, "NULL trace passed to trace_get_received_packets()\n");
     
    23542310uint64_t trace_get_filtered_packets(libtrace_t *trace)
    23552311{
    2356         /*assert(trace);*/
    23572312        if (!trace) {
    23582313                fprintf(stderr, "NULL trace passed to trace_get_filtered_packets()\n");
     
    23892344uint64_t trace_get_dropped_packets(libtrace_t *trace)
    23902345{
    2391         /*assert(trace);*/
    23922346        if (!trace) {
    23932347                fprintf(stderr, "NULL trace passed into trace_get_dropped_packets()\n");
     
    24162370uint64_t trace_get_accepted_packets(libtrace_t *trace)
    24172371{
    2418         /*assert(trace);*/
    24192372        if (!trace) {
    24202373                fprintf(stderr, "NULL trace passed into trace_get_accepted_packets()\n");
     
    24382391        uint64_t ret = 0;
    24392392        int i;
    2440         /*assert(trace);*/
    24412393        if (!trace) {
    24422394                fprintf(stderr, "NULL trace passed into trace_get_statistics()\n");
     
    24482400                stat = trace->stats;
    24492401        }
    2450         /*assert(stat->magic == LIBTRACE_STAT_MAGIC && "Please use"
    2451                "trace_create_statistics() to allocate statistics");*/
    2452         if (!(stat->magic == LIBTRACE_STAT_MAGIC)) {
    2453                 trace_set_err(trace, TRACE_ERR_STAT, "Use trace_create_statistics() to allocate statistics in trace_get_statistics()");
     2402        if (stat->magic != LIBTRACE_STAT_MAGIC) {
     2403                trace_set_err(trace, TRACE_ERR_STAT, "Use trace_create_statistics() to allocate "
     2404                        "statistics prior to calling trace_get_statistics()");
    24542405                return NULL;
    24552406        }
     
    24992450                                 libtrace_stat_t *stat)
    25002451{
    2501         /*assert(trace && stat);*/
    25022452        if (!trace) {
    25032453                fprintf(stderr, "NULL trace passed into trace_get_thread_statistics()\n");
     
    25052455        }
    25062456        if (!stat) {
    2507                 trace_set_err(trace, TRACE_ERR_STAT, "Stat is NULL trace_get_thread_statistics()");
     2457                trace_set_err(trace, TRACE_ERR_STAT, "NULL statistics structure passed into "
     2458                        "trace_get_thread_statistics()");
    25082459                return;
    25092460        }
    2510         /*assert(stat->magic == LIBTRACE_STAT_MAGIC && "Please use"
    2511                "trace_create_statistics() to allocate statistics");*/
    2512         if (!(stat->magic == LIBTRACE_STAT_MAGIC)) {
    2513                 trace_set_err(trace, TRACE_ERR_STAT,
    2514                         "Use trace_create_statistics() to allocate statistics in trace_get_thread_statistics()");
     2461        if (stat->magic != LIBTRACE_STAT_MAGIC) {
     2462                trace_set_err(trace, TRACE_ERR_STAT, "Use trace_create_statistics() to "
     2463                        "allocate statistics prior to calling trace_get_thread_statistics()");
    25152464                return;
    25162465        }
     
    25472496                         libtrace_stat_t *c) {
    25482497
    2549         if (!(a->magic == LIBTRACE_STAT_MAGIC)
    2550                 || !(b->magic == LIBTRACE_STAT_MAGIC)
    2551                 || !(c->magic == LIBTRACE_STAT_MAGIC)) {
    2552                 fprintf(stderr, "Use trace_create_statistics() to allocate statistics in trace_subtract_statistics()\n");
     2498        if (a->magic != LIBTRACE_STAT_MAGIC
     2499                || b->magic != LIBTRACE_STAT_MAGIC
     2500                || c->magic != LIBTRACE_STAT_MAGIC) {
     2501                fprintf(stderr, "Use trace_create_statistics() to allocate statistics prior to "
     2502                        "calling trace_subtract_statistics()\n");
    25532503                return;
    25542504        }
    2555 
    2556         /*assert(a->magic == LIBTRACE_STAT_MAGIC && "Please use"
    2557                "trace_create_statistics() to allocate statistics");
    2558         assert(b->magic == LIBTRACE_STAT_MAGIC && "Please use"
    2559                "trace_create_statistics() to allocate statistics");
    2560         assert(c->magic == LIBTRACE_STAT_MAGIC && "Please use"
    2561                "trace_create_statistics() to allocate statistics");*/
    25622505
    25632506#define X(x) \
     
    25742517void trace_add_statistics(const libtrace_stat_t *a, const libtrace_stat_t *b,
    25752518                         libtrace_stat_t *c) {
    2576         if (!(a->magic == LIBTRACE_STAT_MAGIC)
    2577                 || !(b->magic == LIBTRACE_STAT_MAGIC)
    2578                 || !(c->magic == LIBTRACE_STAT_MAGIC)) {
    2579                 fprintf(stderr, "Use trace_create_statistics() to allocate statistics in trace_add_statistics()\n");
     2519        if (a->magic != LIBTRACE_STAT_MAGIC
     2520                || b->magic != LIBTRACE_STAT_MAGIC
     2521                || c->magic != LIBTRACE_STAT_MAGIC) {
     2522                fprintf(stderr, "Use trace_create_statistics() to allocate statistics prior to "
     2523                        "calling trace_add_statistics()\n");
    25802524                return;
    25812525        }
    2582 
    2583         /*assert(a->magic == LIBTRACE_STAT_MAGIC && "Please use"
    2584                "trace_create_statistics() to allocate statistics");
    2585         assert(b->magic == LIBTRACE_STAT_MAGIC && "Please use"
    2586                "trace_create_statistics() to allocate statistics");
    2587         assert(c->magic == LIBTRACE_STAT_MAGIC && "Please use"
    2588                "trace_create_statistics() to allocate statistics");*/
    25892526
    25902527#define X(x) \
     
    26002537
    26012538int trace_print_statistics(const libtrace_stat_t *s, FILE *f, const char *format) {
    2602         /*assert(s->magic == LIBTRACE_STAT_MAGIC && "Please use"
    2603                "trace_create_statistics() to allocate statistics");*/
    2604         if (!(s->magic == LIBTRACE_STAT_MAGIC)) {
    2605                 fprintf(stderr, "Use trace_create_statistics() to allocate statistics in trace_print_statistics\n");
     2539        if (s->magic != LIBTRACE_STAT_MAGIC) {
     2540                fprintf(stderr, "Use trace_create_statistics() to allocate statistics prior to "
     2541                        "calling trace_print_statistics\n");
    26062542                return TRACE_ERR_STAT;
    26072543        }
     
    26442580
    26452581void register_format(struct libtrace_format_t *f) {
    2646         /*assert(f->next==NULL);*/ /* Can't register a format twice */
    2647         if (!(f->next==NULL)) {
     2582        if (f->next != NULL) {
    26482583                fprintf(stderr, "You cannot register a format twice in register_format()");
    26492584                return;
  • lib/trace_parallel.c

    rb6ff245 r2193905  
    271271DLLEXPORT bool trace_has_reporter(libtrace_t * libtrace)
    272272{
    273         /*assert(libtrace->state != STATE_NEW);*/
    274273        if (!(libtrace->state != STATE_NEW)) {
    275274                trace_set_err(libtrace, TRACE_ERR_BAD_STATE, "Cannot check reporter for the current state in trace_has_reporter()");
     
    372371static inline bool trace_supports_parallel(libtrace_t *trace)
    373372{
    374         /*assert(trace);*/
    375373        if (!trace) {
    376374                fprintf(stderr, "NULL trace passed into trace_supports_parallel()\n");
    377375                return false;
    378376        }
    379         /*assert(trace->format);*/
    380377        if (!trace->format) {
    381378                trace_set_err(trace, TRACE_ERR_BAD_FORMAT,
     
    413410                        return &libtrace->perpkt_threads[i];
    414411        }
    415         return NULL;
     412        pthread_exit(NULL);
    416413}
    417414
     
    503500                trace_fin_packet(*packet);
    504501        } else {
    505                 /*assert((*packet)->error == READ_TICK);*/
    506                 if (!((*packet)->error == READ_TICK)) {
     502                if ((*packet)->error != READ_TICK) {
    507503                        trace_set_err(trace, TRACE_ERR_BAD_STATE,
    508                                 "Packet is not in READ_TICK state in dispath_packet()");
     504                                "dispatch_packet() called with invalid 'packet'");
    509505                        return -1;
    510506                }
     
    551547                } else {
    552548                        /* Break early */
    553                         /*assert(ret == READ_MESSAGE);*/
    554                         if (!(ret == READ_MESSAGE)) {
     549                        if (ret != READ_MESSAGE) {
    555550                                trace_set_err(trace, TRACE_ERR_UNKNOWN_OPTION,
    556                                         "Expected READ_MESSAGE in dispatch_packets()");
     551                                        "dispatch_packets() called with at least one invalid packet");
    557552                                return -1;
    558553                        }
     
    606601                        } else if (ret != READ_MESSAGE) {
    607602                                /* Ignore messages we pick these up next loop */
    608                                 /*assert (ret == READ_EOF || ret == READ_ERROR);*/
    609603                                if (!(ret == READ_EOF || ret == READ_ERROR)) {
    610604                                        trace_set_err(trace, TRACE_ERR_PAUSE_PTHREAD,
     
    617611                                        ASSERT_RET(trace->pread(trace, t, &packet, 1), <= 0);
    618612                                        // No packets after this should have any data in them
    619                                         /*assert(packet->error <= 0);*/
    620                                         if (!(packet->error <= 0)) {
    621                                                 trace_set_err(trace, TRACE_ERR_BAD_PACKET,
    622                                                         "Expected no data from packets however found some in trace_perpkt_thread_pause()");
     613                                        if (packet->error > 0) {
     614                                                trace_set_err(trace, TRACE_ERR_BAD_PACKET, "Bogus data in "
     615                                                        "libtrace ring buffer after pausing perpkt thread");
    623616                                                return -1;
    624617                                        }
     
    658651        ASSERT_RET(pthread_mutex_lock(&trace->libtrace_lock), == 0);
    659652        t = get_thread_table(trace);
    660         /*assert(t);*/
    661653        if (!t) {
    662654                trace_set_err(trace, TRACE_ERR_THREAD, "Unable to get thread table in perpkt_threads_entry()");
    663                 return NULL;
     655                pthread_exit(NULL);
    664656        }
    665657        if (trace->state == STATE_ERROR) {
     
    703695                                                goto error;
    704696                                        }
    705                                         /*assert(ret == 1);*/
    706                                         if (!(ret == 1)) {
     697                                        if (ret != 1) {
    707698                                                fprintf(stderr, "Unknown error pausing thread in perpkt_threads_entry()\n");
    708                                                 return NULL;
     699                                                pthread_exit(NULL);
    709700                                        }
    710701                                        continue;
     
    730721                        }
    731722                        if (!trace->pread) {
    732                                 /*assert(packets[0]);*/
    733723                                if (!packets[0]) {
    734                                         fprintf(stderr, "Packet missing in perpkt_threads_entry()\n");
    735                                         return NULL;
     724                                        fprintf(stderr, "Unable to read into NULL packet structure\n");
     725                                        pthread_exit(NULL);
    736726                                }
    737727                                nb_packets = trace_read_packet(trace, packets[0]);
     
    826816        int pkt_skipped = 0;
    827817
    828         /*assert(trace_has_dedicated_hasher(trace));*/
    829818        if (!trace_has_dedicated_hasher(trace)) {
    830819                fprintf(stderr, "Trace does not have hasher associated with it in hasher_entry()\n");
    831                 return NULL;
     820                pthread_exit(NULL);
    832821        }
    833822        /* Wait until all threads are started and objects are initialised (ring buffers) */
    834823        ASSERT_RET(pthread_mutex_lock(&trace->libtrace_lock), == 0);
    835824        t = &trace->hasher_thread;
    836         /*assert(t->type == THREAD_HASHER && pthread_equal(pthread_self(), t->tid));*/
    837825        if (!(t->type == THREAD_HASHER && pthread_equal(pthread_self(), t->tid))) {
    838826                fprintf(stderr, "Incorrect thread type or non matching thread IDs in hasher_entry()\n");
    839                 return NULL;
     827                pthread_exit(NULL);
    840828        }
    841829
     
    857845                if (!pkt_skipped)
    858846                        libtrace_ocache_alloc(&trace->packet_freelist, (void **) &packet, 1, 1);
    859                 /*assert(packet);*/
    860847                if (!packet) {
    861                         fprintf(stderr, "Cannot hash and queue a NULL packet in hasher_entry()\n");
    862                         return NULL;
     848                        fprintf(stderr, "Hasher thread was unable to get a fresh packet from the "
     849                                "object cache\n");
     850                        pthread_exit(NULL);
    863851                }
    864852
     
    879867                                case MESSAGE_DO_STOP:
    880868                                        /* Either FINISHED or FINISHING */
    881                                         /*assert(trace->started == false);*/
    882869                                        if (!(trace->started == false)) {
    883                                                 fprintf(stderr, "Expected trace to have not started in hasher_entry()\n");
    884                                                 return NULL;
     870                                                fprintf(stderr, "STOP message received by hasher, but "
     871                                                        "trace is still active\n");
     872                                                pthread_exit(NULL);
    885873                                        }
    886874                                        /* Mark the current packet as EOF */
     
    922910                        }
    923911                        pkt_skipped = 0;
    924                 } else {
    925                         /*assert(!"Dropping a packet!!");*/
    926                         fprintf(stderr, "Expected THREAD_FINISHED state in hasher_entry()\n");
    927                         return NULL;
    928                         pkt_skipped = 1; // Reuse that packet no one read it
    929912                }
    930913        }
     
    10541037                           sent once*/
    10551038                        if (packets[i]->error != READ_MESSAGE) {
    1056                                 /*assert(t->format_data == NULL);*/
    1057                                 if (!(t->format_data == NULL)) {
    1058                                         trace_set_err(libtrace, TRACE_ERR_BAD_FORMAT,
    1059                                                 "Expected format data to be NULL in trace_pread_packet_hasher_thread()");
    1060                                         return -1;
    1061                                 }
    10621039                                t->format_data = packets[i];
    10631040                        }
     
    12191196                                break;
    12201197                        case MESSAGE_DO_PAUSE:
    1221                                 /*assert(trace->combiner.pause);*/
    1222                                 if(!(trace->combiner.pause)) {
    1223                                         trace_set_err(trace, TRACE_ERR_COMBINER,
    1224                                                 "Expected combiner to be paused in reporter_entry()");
    1225                                         return NULL;
     1198                                if(trace->combiner.pause) {
     1199                                        trace->combiner.pause(trace, &trace->combiner);
    12261200                                }
    1227                                 trace->combiner.pause(trace, &trace->combiner);
    12281201                                send_message(trace, t, MESSAGE_PAUSING,
    12291202                                                (libtrace_generic_t) {0}, t);
     
    12471220        thread_change_state(trace, &trace->reporter_thread, THREAD_FINISHED, true);
    12481221        print_memory_stats();
    1249         return NULL;
     1222        pthread_exit(NULL);
    12501223}
    12511224
     
    12831256                                libtrace_message_t msg;
    12841257                                libtrace_message_queue_get(&t->messages, &msg);
    1285                                 /*assert(msg.code == MESSAGE_DO_STOP);*/
    1286                                 if (!(msg.code == MESSAGE_DO_STOP)) {
     1258                                if (msg.code != MESSAGE_DO_STOP) {
    12871259                                        fprintf(stderr, "Unexpected message code in keepalive_entry()\n");
    1288                                         return NULL;
     1260                                        pthread_exit(NULL);
    12891261                                }
    12901262                                goto done;
     
    13011273
    13021274        thread_change_state(trace, t, THREAD_FINISHED, true);
    1303         return NULL;
     1275        pthread_exit(NULL);
    13041276}
    13051277
     
    13511323                        return READ_MESSAGE;
    13521324                } else {
    1353                         /*assert(!"trace_delay_packet: Unexpected return from select");*/
    13541325                        trace_set_err(libtrace, TRACE_ERR_BAD_PACKET, "Unexpected return from select in delay_tracetime()");
    13551326                        return -1;
     
    14051376                                      size_t nb_packets) {
    14061377        int i;
    1407         /*assert(libtrace && "libtrace is NULL in trace_read_packet()");*/
    14081378        if (!libtrace) {
    14091379                fprintf(stderr, "NULL trace passed into trace_read_packet()\n");
    14101380                return TRACE_ERR_NULL_TRACE;
    14111381        }
    1412         /*assert(nb_packets);*/
    1413         if (!nb_packets) {
     1382        if (nb_packets <= 0) {
    14141383                trace_set_err(libtrace, TRACE_ERR_NULL,
    1415                         "NULL nb_packets passed into trace_pread_packet_wrapper()");
     1384                        "nb_packets must be greater than zero in trace_pread_packet_wrapper()");
    14161385                return -1;
    14171386        }
     
    14271396                int ret;
    14281397                for (i = 0; i < (int) nb_packets; ++i) {
    1429                         /*assert(i[packets]); <--- is this ment to be packets[i]?? */
    14301398                        if (!i[packets]) {
    1431                                 trace_set_err(libtrace, TRACE_ERR_BAD_STATE, "NULL packets in trace_read_packet()");
     1399                                trace_set_err(libtrace, TRACE_ERR_BAD_STATE, "NULL packets in "
     1400                                        "trace_pread_packet_wrapper()");
    14321401                                return -1;
    14331402                        }
     
    14901459        }
    14911460
    1492         /*assert(libtrace_parallel);*/
    14931461        if (!libtrace_parallel) {
    1494                 trace_set_err(libtrace, TRACE_ERR_THREAD, "Expected parallel trace in trace_prestart()");
     1462                trace_set_err(libtrace, TRACE_ERR_THREAD, "Trace_prestart() has been called on a "
     1463                        "non-parallel libtrace input?");
    14951464                return -1;
    14961465        }
    1497         /*assert(!libtrace->perpkt_thread_states[THREAD_RUNNING]);*/
    1498         if (!(!libtrace->perpkt_thread_states[THREAD_RUNNING])) {
    1499                 trace_set_err(libtrace, TRACE_ERR_THREAD, "Expected no running threads in trace_prestart()");
     1466        if (libtrace->perpkt_thread_states[THREAD_RUNNING]) {
     1467                trace_set_err(libtrace, TRACE_ERR_THREAD, "Cannot restart a parallel libtrace input "
     1468                        "while it is still running");
    15001469                return -1;
    15011470        }
     
    15041473        pthread_spin_lock(&libtrace->first_packets.lock);
    15051474        for (i = 0; i < libtrace->perpkt_thread_count; ++i) {
    1506                 /*assert(!!libtrace->perpkt_threads[i].recorded_first == !!libtrace->first_packets.packets[i].packet);*/
    1507                 if (!(!!libtrace->perpkt_threads[i].recorded_first == !!libtrace->first_packets.packets[i].packet)) {
    1508                         trace_set_err(libtrace, TRACE_ERR_THREAD, "Expected different first packet in trace_pstart()");
    1509                         return -1;
    1510                 }
    15111475                if (libtrace->first_packets.packets[i].packet) {
    15121476                        trace_destroy_packet(libtrace->first_packets.packets[i].packet);
     
    15181482                }
    15191483        }
    1520         /*assert(libtrace->first_packets.count == 0);*/
    1521         if (!(libtrace->first_packets.count == 0)) {
     1484        if (libtrace->first_packets.count != 0) {
    15221485                trace_set_err(libtrace, TRACE_ERR_THREAD, "Expected a first packets count of 0 in trace_pstart()");
    15231486                return -1;
     
    16611624#endif
    16621625        int ret;
    1663         /*assert(t->type == THREAD_EMPTY);*/
    1664         if (!(t->type == THREAD_EMPTY)) {
     1626        if (t->type != THREAD_EMPTY) {
    16651627                trace_set_err(trace, TRACE_ERR_THREAD,
    16661628                        "Expected thread type of THREAD_EMPTY in trace_start_thread()");
     
    16731635        t->state = THREAD_RUNNING;
    16741636
    1675         /*assert(name);*/
    16761637        if (!name) {
    16771638                trace_set_err(trace, TRACE_ERR_THREAD, "NULL thread name in trace_start_thread()");
     
    18001761        char name[24];
    18011762        sigset_t sig_before, sig_block_all;
    1802         /*assert(libtrace);*/
    18031763        if (!libtrace) {
    18041764                fprintf(stderr, "NULL trace passed to trace_pstart()\n");
     
    20261986        ASSERT_RET(pthread_mutex_lock(&libtrace->libtrace_lock), == 0);
    20271987        libtrace_change_state(libtrace, STATE_NEW, false);
    2028         /*assert(libtrace->perpkt_thread_states[THREAD_RUNNING] == 0);*/
    2029         if (!(libtrace->perpkt_thread_states[THREAD_RUNNING] == 0)) {
     1988        if (libtrace->perpkt_thread_states[THREAD_RUNNING] != 0) {
    20301989                trace_set_err(libtrace, TRACE_ERR_THREAD, "Expected 0 running threads in trace_pstart()");
    20311990                return -1;
     
    21222081        libtrace_thread_t *t;
    21232082        int i;
    2124         /*assert(libtrace);*/
    21252083        if (!libtrace) {
    21262084                fprintf(stderr, "NULL trace passed into trace_ppause()\n");
     
    22592217        int i, err;
    22602218        libtrace_message_t message = {0, {.uint64=0}, NULL};
    2261         /*assert(libtrace);*/
    22622219        if (!libtrace) {
    22632220                fprintf(stderr, "NULL trace passed into trace_pstop()\n");
     
    23612318                // the producer (or any other threads) don't block.
    23622319                libtrace_packet_t * packet;
    2363                 /*assert(libtrace->perpkt_threads[i].state == THREAD_FINISHED);*/
    2364                 if (!(libtrace->perpkt_threads[i].state == THREAD_FINISHED)) {
     2320                if (libtrace->perpkt_threads[i].state != THREAD_FINISHED) {
    23652321                        trace_set_err(libtrace, TRACE_ERR_THREAD_STATE,
    2366                                 "Expected processing threads state THREAD_FINISHED in trace_join()");
     2322                                "Expected processing thread state to be THREAD_FINISHED in trace_join()");
    23672323                        return;
    23682324                }
     
    23752331        if (trace_has_dedicated_hasher(libtrace)) {
    23762332                pthread_join(libtrace->hasher_thread.tid, NULL);
    2377                 /*assert(libtrace->hasher_thread.state == THREAD_FINISHED);*/
    2378                 if (!(libtrace->hasher_thread.state == THREAD_FINISHED)) {
     2333                if (libtrace->hasher_thread.state != THREAD_FINISHED) {
    23792334                        trace_set_err(libtrace, TRACE_ERR_THREAD_STATE,
    2380                                 "Expected hasher thread state THREAD_FINISHED in trace_join()");
     2335                                "Expected hasher thread state to be THREAD_FINISHED in trace_join()");
    23812336                        return;
    23822337                }
     
    23922347                        trace_destroy_packet(packet);
    23932348                if (trace_has_dedicated_hasher(libtrace)) {
    2394                         /*assert(libtrace_ringbuffer_is_empty(&libtrace->perpkt_threads[i].rbuffer));*/
    2395                         if (!(libtrace_ringbuffer_is_empty(&libtrace->perpkt_threads[i].rbuffer))) {
     2349                        if (!libtrace_ringbuffer_is_empty(&libtrace->perpkt_threads[i].rbuffer)) {
    23962350                                trace_set_err(libtrace, TRACE_ERR_THREAD,
    23972351                                        "Expected processing threads ring buffers to be empty in trace_join()");
     
    24052359        if (trace_has_reporter(libtrace)) {
    24062360                pthread_join(libtrace->reporter_thread.tid, NULL);
    2407                 /*assert(libtrace->reporter_thread.state == THREAD_FINISHED);*/
    2408                 if (!(libtrace->reporter_thread.state == THREAD_FINISHED)) {
     2361                if (libtrace->reporter_thread.state != THREAD_FINISHED) {
    24092362                        trace_set_err(libtrace, TRACE_ERR_THREAD_STATE,
    24102363                                "Expected reporting thread state to be THREAD_FINISHED in trace_join()");
     
    25172470        res.key = key;
    25182471        res.value = value;
    2519         /*assert(libtrace->combiner.publish);*/
    25202472        if (!libtrace->combiner.publish) {
    2521                 fprintf(stderr, "Unable to publish result in trace_publish_result()\n");
     2473                fprintf(stderr, "Combiner has no publish method -- can not publish results!\n");
    25222474                return;
    25232475        }
     
    26732625/* Note update documentation on trace_set_configuration */
    26742626static void config_string(struct user_configuration *uc, char *key, size_t nkey, char *value, size_t nvalue) {
    2675         /*assert(key);*/
    26762627        if (!key) {
    26772628                fprintf(stderr, "NULL key passed to config_string()\n");
    26782629                return;
    26792630        }
    2680         /*assert(value);*/
    26812631        if (!value) {
    26822632                fprintf(stderr, "NULL value passed to config_string()\n");
    26832633                return;
    26842634        }
    2685         /*assert(uc);*/
    26862635        if (!uc) {
    26872636                fprintf(stderr, "NULL uc (user_configuration) passed to config_string()\n");
     
    27342683        char value[100];
    27352684        char *dup;
    2736         /*assert(trace);*/
    27372685        if (!trace) {
    27382686                fprintf(stderr, "NULL trace passed into trace_set_configuration()\n");
    27392687                return TRACE_ERR_NULL_TRACE;
    27402688        }
    2741         /*assert(str);*/
    27422689        if (!str) {
    27432690                trace_set_err(trace, TRACE_ERR_CONFIG, "NULL configuration string passed to trace_set_configuration()");
     
    27542701                        config_string(&trace->config, key, sizeof(key), value, sizeof(value));
    27552702                } else {
    2756                         fprintf(stderr, "Error parsing option %s\n", pch);
     2703                        fprintf(stderr, "Error: parsing option %s\n", pch);
    27572704                }
    27582705                pch = strtok (NULL," ,.-");
     
    27792726
    27802727DLLEXPORT void trace_free_packet(libtrace_t *libtrace, libtrace_packet_t *packet) {
    2781         /*assert(packet);*/
    27822728        if (!packet) {
    27832729                trace_set_err(libtrace, TRACE_ERR_NULL_PACKET,
     
    28152761                return &libtrace->format->info;
    28162762        else
    2817                 return NULL;
    2818 }
     2763                pthread_exit(NULL);
     2764}
Note: See TracChangeset for help on using the changeset viewer.