Changeset d7d3267 for lib/trace.c

Timestamp:

11/29/18 13:37:20 (2 years ago)

Author:

Shane Alcock <salcock@…>

Branches:

develop

Children:

50e9c6b

Parents:

54642da (diff), fdf23b8 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of ​git://github.com/jacobvw/libtrace into jacobvw-master

Conflicts:

lib/format_linux_ring.c

File:

• lib/trace.c (modified) (53 diffs)

lib/trace.c

@@ -122 +122 @@
         char *ret=(char*)malloc(n+1);
         if (ret==NULL) {
-                fprintf(stderr,"Out of memory");
+                fprintf(stderr,"Out of memory\n");
                 exit(EXIT_FAILURE);
         }
@@ -201 +201 @@
 
         libtrace->io = wandio_create(filename);
-        if (!libtrace->io)
+        if (!libtrace->io) {
+                trace_set_err(libtrace,TRACE_ERR_URI_NOT_FOUND,"Unable to find URI (%s)", filename);
                 return;
+        }
 
         /* Try and guess based on file magic */
@@ -216 +218 @@
          * used to probe the file magic */
         wandio_destroy(libtrace->io);
+        trace_set_err(libtrace,TRACE_ERR_BAD_FORMAT,"Unable to guess format (%s)", filename);
         return;
 }
@@ -247 +250 @@
         trace_init();
 
-        assert(uri && "Passing NULL to trace_create makes me a very sad program");
-
         if (!libtrace) {
-                /* Out of memory */
-                return NULL;
+                fprintf(stderr, "Unable to allocate memory in trace_create()\n");
+                return NULL;
+        }
+
+        if(!uri) {
+                trace_set_err(libtrace, TRACE_ERR_URI_NULL, "NULL uri passed to trace_create()");
+                return libtrace;
         }
 
@@ -272 +278 @@
         libtrace->accepted_packets = 0;
         libtrace->last_packet = NULL;
-        
+
         /* Parallel inits */
         ASSERT_RET(pthread_mutex_init(&libtrace->libtrace_lock, NULL), == 0);
@@ -306 +312 @@
                 /* Could not parse the URI nicely */
                 guess_format(libtrace,uri);
-                if (!libtrace->format) {
-                        trace_set_err(libtrace,TRACE_ERR_BAD_FORMAT,"Unable to guess format (%s)",uri);
+                if (trace_is_err(libtrace)) {
                         return libtrace;
                 }
@@ -339 +344 @@
         if (libtrace->format->init_input) {
                 int err=libtrace->format->init_input(libtrace);
-                assert (err==-1 || err==0);
                 if (err==-1) {
                         /* init_input should call trace_set_err to set the
@@ -398 +402 @@
         libtrace->accepted_packets = 0;
         libtrace->last_packet = NULL;
-        
+
         /* Parallel inits */
         ASSERT_RET(pthread_mutex_init(&libtrace->libtrace_lock, NULL), == 0);
@@ -498 +502 @@
 
         if (libtrace->format->init_output) {
-                /* 0 on success, -1 on failure */
-                switch(libtrace->format->init_output(libtrace)) {
-                        case -1: /* failure */
-                                return libtrace;
-                        case 0: /* success */
-                                break;
-                        default:
-                                assert(!"Internal error: init_output() should return -1 for failure, or 0 for success");
+                int err = libtrace->format->init_output(libtrace);
+                if (err == -1) {
+                        /* init_output should call trace_set_err to set the
+                         * error message
+                         */
+                        return libtrace;
                 }
         } else {
@@ -527 +529 @@
 DLLEXPORT int trace_start(libtrace_t *libtrace)
 {
-        assert(libtrace);
+        if(!libtrace) {
+                fprintf(stderr, "NULL trace passed to trace_start()\n");
+                return TRACE_ERR_NULL_TRACE;
+        }
+
         if (trace_is_err(libtrace))
                 return -1;
@@ -544 +550 @@
 DLLEXPORT int trace_start_output(libtrace_out_t *libtrace)
 {
-        assert(libtrace);
+        if(!libtrace) {
+                fprintf(stderr, "NULL trace passed to trace_start_output()\n");
+                return TRACE_ERR_NULL_TRACE;
+        }
         if (libtrace->format->start_output) {
                 int ret=libtrace->format->start_output(libtrace);
@@ -558 +567 @@
 DLLEXPORT int trace_pause(libtrace_t *libtrace)
 {
-        assert(libtrace);
+        if(!libtrace) {
+                fprintf(stderr, "NULL trace passed to trace_pause()\n");
+                return TRACE_ERR_NULL_TRACE;
+        }
         if (!libtrace->started) {
                 trace_set_err(libtrace,TRACE_ERR_BAD_STATE, "You must call trace_start() before calling trace_pause()");
@@ -567 +579 @@
         if (!libtrace_parallel && libtrace->last_packet)
                 trace_fin_packet(libtrace->last_packet);
-        assert(libtrace->last_packet == NULL);
+        if(libtrace->last_packet != NULL) {
+                trace_set_err(libtrace, TRACE_ERR_PAUSE_FIN, "Unable to remove all data stored against trace in trace_pause()");
+                return -1;
+        }
 
         if (libtrace->format->pause_input)
@@ -707 +722 @@
 DLLEXPORT void trace_destroy(libtrace_t *libtrace) {
         int i;
-        assert(libtrace);
+
+        if(!libtrace) {
+                fprintf(stderr, "NULL trace passed to trace_destroy()\n");
+                return;
+        }
 
         ASSERT_RET(pthread_mutex_destroy(&libtrace->libtrace_lock), == 0);
@@ -728 +747 @@
                 trace_fin_packet(libtrace->last_packet);
         }
-        assert(libtrace->last_packet == NULL);
+        if (libtrace->last_packet != NULL) {
+                trace_set_err(libtrace, TRACE_ERR_PAUSE_FIN, "Unable to remove all data stored against trace in trace_destroy()");
+                return;
+        }
 
         if (libtrace->format) {
@@ -742 +764 @@
         if (libtrace->stats)
                 free(libtrace->stats);
-        
+
         /* Empty any packet memory */
         if (libtrace->state != STATE_NEW) {
@@ -796 +818 @@
 
 DLLEXPORT void trace_destroy_dead(libtrace_t *libtrace) {
-        assert(libtrace);
+        if(!libtrace) {
+                fprintf(stderr, "NULL trace passed to trace_destroy_dead()\n");
+                return;
+        }
 
         ASSERT_RET(pthread_mutex_destroy(&libtrace->libtrace_lock), == 0);
@@ -813 +838 @@
  * @param libtrace      the output trace file to be destroyed
  */
-DLLEXPORT void trace_destroy_output(libtrace_out_t *libtrace)
-{
-        assert(libtrace);
+DLLEXPORT void trace_destroy_output(libtrace_out_t *libtrace) {
+        if(!libtrace) {
+                fprintf(stderr, "NULL trace passed to trace_destroy_output()\n");
+                return;
+        }
         if (libtrace->format && libtrace->format->fin_output)
                 libtrace->format->fin_output(libtrace);
@@ -825 +852 @@
 DLLEXPORT int trace_flush_output(libtrace_out_t *libtrace) {
         if (!libtrace) {
-                return -1;
+                fprintf(stderr, "NULL trace passed to trace_flush_output()\n");
+                return TRACE_ERR_NULL_TRACE;
         }
         if (libtrace->format && libtrace->format->flush_output) {
                 return libtrace->format->flush_output(libtrace);
         }
-        return 0;
+
+        return 0;
 }
 
@@ -897 +926 @@
                 packet->trace->last_packet = NULL;
         }
-        
+
         if (packet->buf_control == TRACE_CTRL_PACKET && packet->buffer) {
                 free(packet->buffer);
@@ -958 +987 @@
 DLLEXPORT int trace_read_packet(libtrace_t *libtrace, libtrace_packet_t *packet) {
 
-        assert(libtrace && "You called trace_read_packet() with a NULL libtrace parameter!\n");
+        if (!libtrace) {
+                fprintf(stderr, "NULL trace passed to trace_read_packet()\n");
+                return TRACE_ERR_NULL_TRACE;
+        }
+
         if (trace_is_err(libtrace))
                 return -1;
+
         if (!libtrace->started) {
-                trace_set_err(libtrace,TRACE_ERR_BAD_STATE,"You must call libtrace_start() before trace_read_packet()\n");
+                trace_set_err(libtrace,TRACE_ERR_BAD_STATE,"You must call libtrace_start() before trace_read_packet()");
                 return -1;
         }
+
+        if (!packet) {
+                trace_set_err(libtrace, TRACE_ERR_NULL_PACKET, "NULL packet passed into trace_read_packet()");
+                return -1;
+        }
+
         if (!(packet->buf_control==TRACE_CTRL_PACKET
                     || packet->buf_control==TRACE_CTRL_EXTERNAL)) {
-                trace_set_err(libtrace,TRACE_ERR_BAD_STATE,"Packet passed to trace_read_packet() is invalid\n");
+                trace_set_err(libtrace,TRACE_ERR_BAD_STATE,"Packet passed to trace_read_packet() is invalid");
                 return -1;
         }
-        assert(packet);
 
         if (libtrace->format->read_packet) {
@@ -1052 +1091 @@
                 void *buffer, libtrace_rt_types_t rt_type, uint32_t flags) {
 
-        assert(packet);
-        assert(trace);
-
-        /* XXX Proper error handling?? */
-        if (buffer == NULL)
+        if (!trace) {
+                fprintf(stderr, "NULL trace passed into trace_prepare_packet()\n");
+                return TRACE_ERR_NULL_TRACE;
+        }
+
+        if (!packet) {
+                trace_set_err(trace, TRACE_ERR_NULL_TRACE, "NULL packet passed into trace_prepare_packet()");
                 return -1;
+        }
+
+        if (!buffer) {
+                trace_set_err(trace, TRACE_ERR_NULL_BUFFER, "NULL buffer passed into trace_prepare_packet()");
+                return -1;
+        }
 
         if (!(packet->buf_control==TRACE_CTRL_PACKET || packet->buf_control==TRACE_CTRL_EXTERNAL)) {
-                trace_set_err(trace,TRACE_ERR_BAD_STATE,"Packet passed to trace_read_packet() is invalid\n");
+                trace_set_err(trace,TRACE_ERR_BAD_STATE,"Packet passed to trace_read_packet() is invalid");
                 return -1;
         }
@@ -1075 +1122 @@
         }
         trace_set_err(trace, TRACE_ERR_UNSUPPORTED,
-                        "This format does not support preparing packets\n");
+                        "This format does not support preparing packets");
         return -1;
 
@@ -1087 +1134 @@
  */
 DLLEXPORT int trace_write_packet(libtrace_out_t *libtrace, libtrace_packet_t *packet) {
-        assert(libtrace);
-        assert(packet);
+
+        if (!libtrace) {
+                fprintf(stderr, "NULL trace passed into trace_write_packet()\n");
+                return TRACE_ERR_NULL_TRACE;
+        }
+        if (!packet) {
+                trace_set_err_out(libtrace, TRACE_ERR_NULL_PACKET, "NULL trace passed into trace_write_packet()");
+                return -1;
+        }
         /* Verify the packet is valid */
         if (!libtrace->started) {
                 trace_set_err_out(libtrace,TRACE_ERR_BAD_STATE,
-                        "Trace is not started before trace_write_packet");
+                        "You must call trace_start_output() before calling trace_write_packet()");
                 return -1;
         }
@@ -1117 +1171 @@
         libtrace_linktype_t ltype;
 
-        assert(packet != NULL);
+        if (!packet) {
+                fprintf(stderr, "NULL packet passed into trace_get_packet_buffer()\n");
+                return NULL;
+        }
         ltype = trace_get_link_type(packet);
 
@@ -1149 +1206 @@
                 wire_len = trace_get_wire_length(packet);
 
-                assert(cap_len >= 0);
+                if (!(cap_len >= 0)) {
+                        fprintf(stderr, "Was expecting capture length of atleast 0 in trace_get_packet_buffer()\n");
+                        return NULL;
+                }
 
                 /* There is the odd corrupt packet, e.g. in IPLS II, that have
@@ -1341 +1401 @@
         }
 
-        assert(packet->capture_length < LIBTRACE_PACKET_BUFSIZE);
+        if (!(packet->capture_length < LIBTRACE_PACKET_BUFSIZE)) {
+                fprintf(stderr, "Capture length is greater than the buffer size in trace_get_capture_length()\n");
+                return 0;
+                /* should we be returning ~OU here? */
+        }
 
         return packet->capture_length;
@@ -1366 +1430 @@
         }
 
-        assert(packet->wire_length < LIBTRACE_PACKET_BUFSIZE);
+        if (!(packet->wire_length < LIBTRACE_PACKET_BUFSIZE)) {
+                fprintf(stderr, "Wire length is greater than the buffer size in trace_get_wire_length()\n");
+                return 0;
+                /* should we be returning ~OU here? */
+        }
         return packet->wire_length;
 
@@ -1432 +1500 @@
 
         if (!trace) {
-                fprintf(stderr,"You called trace_event() with a NULL trace object!\n");
-        }
-        assert(trace);
-        assert(packet);
+                fprintf(stderr, "NULL trace passed into trace_event()");
+                /* Return default event on error? */
+                return event;
+        }
+        if (!packet) {
+                trace_set_err(trace, TRACE_ERR_NULL_PACKET, "NULL packet passed into trace_event()");
+                /* Return default event on error? */
+                return event;
+        }
 
         /* Free the last packet */
@@ -1537 +1610 @@
          */
         static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
-        assert(filter);
+
+        if (!packet) {
+                fprintf(stderr, "NULL packet passed into trace_bpf_compile()");
+                return TRACE_ERR_NULL_PACKET;
+        }
+
+        if (!filter) {
+                trace_set_err(packet->trace,
+                                TRACE_ERR_NULL_FILTER, "Filter is NULL trace_bpf_compile()");
+                return -1;
+        }
 
         /* If this isn't a real packet, then fail */
@@ -1559 +1642 @@
                         return -1;
                 }
-                assert (pthread_mutex_lock(&mutex) == 0);
+                pthread_mutex_lock(&mutex);
                 /* Make sure not one bet us to this */
                 if (filter->flag) {
-                        assert (pthread_mutex_unlock(&mutex) == 0);
-                        return 1;
+                        pthread_mutex_unlock(&mutex);
+                        return -1;
                 }
                 pcap=(pcap_t *)pcap_open_dead(
@@ -1569 +1652 @@
                                 1500U);
                 /* build filter */
-                assert(pcap);
+                if (!pcap) {
+                        trace_set_err(packet->trace, TRACE_ERR_BAD_FILTER,
+                                                "Unable to open pcap_t for compiling filters trace_bpf_compile()");
+                        return -1;
+                }
                 if (pcap_compile( pcap, &filter->filter, filter->filterstring,
                                         1, 0)) {
@@ -1577 +1664 @@
                                         pcap_geterr(pcap));
                         pcap_close(pcap);
-                        assert (pthread_mutex_unlock(&mutex) == 0);
+                        pthread_mutex_unlock(&mutex);
                         return -1;
                 }
                 pcap_close(pcap);
                 filter->flag=1;
-                assert (pthread_mutex_unlock(&mutex) == 0);
+                pthread_mutex_unlock(&mutex);
         }
         return 0;
 #else
-        assert(!"Internal bug: This should never be called when BPF not enabled");
         trace_set_err(packet->trace,TRACE_ERR_OPTION_UNAVAIL,
                                 "Feature unavailable");
@@ -1606 +1692 @@
 #endif
 
-        assert(filter);
-        assert(packet);
+        if (!packet) {
+                fprintf(stderr, "NULL packet passed into trace_apply_filter()\n");
+                return TRACE_ERR_NULL_PACKET;
+        }
+        if (!filter) {
+                trace_set_err(packet->trace, TRACE_ERR_NULL_FILTER,
+                        "NULL filter passed into trace_apply_filter()");
+                return -1;
+        }
 
         /* Match all non-data packets as we probably want them to pass
@@ -1677 +1770 @@
 #endif
 
-        assert(filter->flag);
+        if (!filter->flag) {
+                trace_set_err(packet->trace, TRACE_ERR_BAD_FILTER,
+                        "Bad filter passed into trace_apply_filter()");
+                return -1;
+        }
         /* Now execute the filter */
 #if HAVE_LLVM
@@ -1704 +1801 @@
                 libtrace_direction_t direction)
 {
-        assert(packet);
+        if (!packet) {
+                fprintf(stderr, "NULL packet passed into trace_set_direction()\n");
+                return (libtrace_direction_t)~0U;
+        }
         if (packet->trace->format->set_direction) {
                 return packet->trace->format->set_direction(packet,direction);
@@ -1721 +1821 @@
 DLLEXPORT libtrace_direction_t trace_get_direction(const libtrace_packet_t *packet)
 {
-        assert(packet);
+        if (!packet) {
+                fprintf(stderr, "NULL packet passed into trace_set_direction()\n");
+                return (libtrace_direction_t)~0U;
+        }
         if (packet->which_trace_start != packet->trace->startcount) {
                 return (libtrace_direction_t)~0U;
@@ -1858 +1961 @@
  */
 DLLEXPORT size_t trace_set_capture_length(libtrace_packet_t *packet, size_t size) {
-        assert(packet);
+        if (!packet) {
+                fprintf(stderr, "NULL packet passed into trace_set_capture_length()\n");
+                return ~0U;
+        }
 
         if (packet->trace->format->set_capture_length) {
@@ -1898 +2004 @@
 }
 
-enum base_format_t trace_get_format(libtrace_packet_t *packet)
-{
-        assert(packet);
+enum base_format_t trace_get_format(libtrace_packet_t *packet) {
+        if (!packet) {
+                fprintf(stderr, "NULL packet passed into trace_get_format()\n");
+                return TRACE_FORMAT_UNKNOWN;
+        }
 
         return packet->trace->format->type;
@@ -2102 +2210 @@
                 libtrace_linktype_t linktype,
                 const void *data,
-                uint16_t len)
-{
+                uint16_t len) {
+
+        if (!packet) {
+                fprintf(stderr, "NULL packet passed into trace_contruct_packet()\n");
+                return;
+        }
+        /* Check a valid linktype was supplied */
+        if (linktype == TRACE_TYPE_UNKNOWN || linktype == TRACE_TYPE_CONTENT_INVALID) {
+                fprintf(stderr, "Unknown or invalid linktype passed into trace_construct_packet()\n");
+                return;
+        }
+
         size_t size;
         static libtrace_t *deadtrace=NULL;
@@ -2133 +2251 @@
 
         /* Now fill in the libtrace packet itself */
-        assert(deadtrace);
+        if (!deadtrace) {
+                fprintf(stderr, "Unable to create dummy trace for use within trace_construct_packet()\n");
+                return;
+        }
         packet->trace=deadtrace;
         size=len+sizeof(hdr);
@@ -2165 +2286 @@
 uint64_t trace_get_received_packets(libtrace_t *trace)
 {
-        assert(trace);
         uint64_t ret;
+
+        if (!trace) {
+                fprintf(stderr, "NULL trace passed to trace_get_received_packets()\n");
+                /* When the number of received packets is not known we return UINT64_MAX */
+                return UINT64_MAX;
+        }
 
         if (trace->format->get_received_packets) {
@@ -2188 +2314 @@
 uint64_t trace_get_filtered_packets(libtrace_t *trace)
 {
-        assert(trace);
+        if (!trace) {
+                fprintf(stderr, "NULL trace passed to trace_get_filtered_packets()\n");
+                return UINT64_MAX;
+        }
         int i = 0;
         uint64_t lib_filtered = trace->filtered_packets;
@@ -2219 +2348 @@
 uint64_t trace_get_dropped_packets(libtrace_t *trace)
 {
-        assert(trace);
+        if (!trace) {
+                fprintf(stderr, "NULL trace passed into trace_get_dropped_packets()\n");
+                return UINT64_MAX;
+        }
         uint64_t ret;
 
@@ -2242 +2374 @@
 uint64_t trace_get_accepted_packets(libtrace_t *trace)
 {
-        assert(trace);
+        if (!trace) {
+                fprintf(stderr, "NULL trace passed into trace_get_accepted_packets()\n");
+                return UINT64_MAX;
+        }
         int i = 0;
         uint64_t ret = 0;
@@ -2260 +2395 @@
         uint64_t ret = 0;
         int i;
-        assert(trace);
+        if (!trace) {
+                fprintf(stderr, "NULL trace passed into trace_get_statistics()\n");
+                return NULL;
+        }
         if (stat == NULL) {
                 if (trace->stats == NULL)
@@ -2266 +2404 @@
                 stat = trace->stats;
         }
-        assert(stat->magic == LIBTRACE_STAT_MAGIC && "Please use"
-               "trace_create_statistics() to allocate statistics");
+        if (stat->magic != LIBTRACE_STAT_MAGIC) {
+                trace_set_err(trace, TRACE_ERR_STAT, "Use trace_create_statistics() to allocate "
+                        "statistics prior to calling trace_get_statistics()");
+                return NULL;
+        }
 
         /* If the trace has paused or finished get the cached results */
@@ -2313 +2454 @@
                                  libtrace_stat_t *stat)
 {
-        assert(trace && stat);
-        assert(stat->magic == LIBTRACE_STAT_MAGIC && "Please use"
-               "trace_create_statistics() to allocate statistics");
+        if (!trace) {
+                fprintf(stderr, "NULL trace passed into trace_get_thread_statistics()\n");
+                return;
+        }
+        if (!stat) {
+                trace_set_err(trace, TRACE_ERR_STAT, "NULL statistics structure passed into "
+                        "trace_get_thread_statistics()");
+                return;
+        }
+        if (stat->magic != LIBTRACE_STAT_MAGIC) {
+                trace_set_err(trace, TRACE_ERR_STAT, "Use trace_create_statistics() to "
+                        "allocate statistics prior to calling trace_get_thread_statistics()");
+                return;
+        }
         stat->reserved1 = 0;
         stat->reserved2 = 0;
@@ -2328 +2480 @@
                 trace->format->get_thread_statistics(trace, t, stat);
         }
-        return;
 }
 
@@ -2348 +2499 @@
 void trace_subtract_statistics(const libtrace_stat_t *a, const libtrace_stat_t *b,
                          libtrace_stat_t *c) {
-        assert(a->magic == LIBTRACE_STAT_MAGIC && "Please use"
-               "trace_create_statistics() to allocate statistics");
-        assert(b->magic == LIBTRACE_STAT_MAGIC && "Please use"
-               "trace_create_statistics() to allocate statistics");
-        assert(c->magic == LIBTRACE_STAT_MAGIC && "Please use"
-               "trace_create_statistics() to allocate statistics");
+
+        if (a->magic != LIBTRACE_STAT_MAGIC
+                || b->magic != LIBTRACE_STAT_MAGIC
+                || c->magic != LIBTRACE_STAT_MAGIC) {
+                fprintf(stderr, "Use trace_create_statistics() to allocate statistics prior to "
+                        "calling trace_subtract_statistics()\n");
+                return;
+        }
 
 #define X(x) \
@@ -2368 +2521 @@
 void trace_add_statistics(const libtrace_stat_t *a, const libtrace_stat_t *b,
                          libtrace_stat_t *c) {
-        assert(a->magic == LIBTRACE_STAT_MAGIC && "Please use"
-               "trace_create_statistics() to allocate statistics");
-        assert(b->magic == LIBTRACE_STAT_MAGIC && "Please use"
-               "trace_create_statistics() to allocate statistics");
-        assert(c->magic == LIBTRACE_STAT_MAGIC && "Please use"
-               "trace_create_statistics() to allocate statistics");
+        if (a->magic != LIBTRACE_STAT_MAGIC
+                || b->magic != LIBTRACE_STAT_MAGIC
+                || c->magic != LIBTRACE_STAT_MAGIC) {
+                fprintf(stderr, "Use trace_create_statistics() to allocate statistics prior to "
+                        "calling trace_add_statistics()\n");
+                return;
+        }
 
 #define X(x) \
@@ -2387 +2541 @@
 
 int trace_print_statistics(const libtrace_stat_t *s, FILE *f, const char *format) {
-        assert(s->magic == LIBTRACE_STAT_MAGIC && "Please use"
-               "trace_create_statistics() to allocate statistics");
+        if (s->magic != LIBTRACE_STAT_MAGIC) {
+                fprintf(stderr, "Use trace_create_statistics() to allocate statistics prior to "
+                        "calling trace_print_statistics\n");
+                return TRACE_ERR_STAT;
+        }
         if (format == NULL)
                 format = "%s: %"PRIu64"\n";
@@ -2427 +2584 @@
 
 void register_format(struct libtrace_format_t *f) {
-        assert(f->next==NULL); /* Can't register a format twice */
+        if (f->next != NULL) {
+                fprintf(stderr, "You cannot register a format twice in register_format()");
+                return;
+        }
         f->next=formats_list;
         formats_list=f;