Changes in / [04bf7c5:fed9152]

Files:

• Makefile.am (modified) (1 diff)
• lib/format_dag25.c (modified) (85 diffs)
• lib/format_erf.c (modified) (3 diffs)
• lib/format_pcapfile.c (modified) (5 diffs)
• lib/format_tsh.c (modified) (1 diff)
• lib/libtrace.h.in (modified) (1 diff)
• libwandio/ior-zlib.c (modified) (5 diffs)
• tools/tracestats/tracestats.c (modified) (1 diff)

Makefile.am

@@ -22 +22 @@
         $(RM) -rf autom4te.cache/
 
-dist-hook:
-        if which svnversion > /dev/null; then \
-                r=`svnversion -nc . | sed -e 's/^[^:]*://;s/[A-Za-z]//'` ;\
-                sed -i "s/SVN_REVISION.*/SVN_REVISION $$r/" $(distdir)/lib/libtrace.h.in; \
-        fi
-
 if HAS_DOXYGEN
 docs/doxygen/man/man3/*.3: docs

lib/format_dag25.c

@@ -119 +119 @@
 /* Data that is stored for each libtrace_thread_t */
 struct dag_per_thread_t {
-        struct dag_dev_t *device; /* DAG device */
-        uint16_t stream; /* Stream number */
-        uint8_t *top; /* Pointer to the last unread byte in the DAG memory */
-        uint8_t *bottom; /* Pointer to the first unread byte in the DAG memory */
-        uint32_t processed; /* Amount of data processed from the bottom pointer */
-        uint64_t pkt_count; /* Number of packets seen by the thread */
+        /* DAG device */
+        struct dag_dev_t *device;
+        /* Stream number */
+        uint16_t stream;
+        /* Pointer to the last unread byte in the DAG memory */
+        uint8_t *top;
+        /* Pointer to the first unread byte in the DAG memory */
+        uint8_t *bottom;
+        /* Amount of data processed from the bottom pointer */
+        uint32_t processed;
+        /* Number of packets seen by the thread */
+        uint64_t pkt_count;
+        /* Drop count for this particular thread */
         uint64_t drops;
 };
@@ -130 +137 @@
 /* "Global" data that is stored for each DAG input trace */
 struct dag_format_data_t {
-
         /* Data required for regular DUCK reporting */
         struct {
@@ -136 +142 @@
                 uint32_t last_duck;
                 /* The number of seconds between each DUCK report */
-                uint32_t duck_freq;
+                uint32_t duck_freq;
                 /* Timestamp of the last packet read from the DAG card */
-                uint32_t last_pkt;
+                uint32_t last_pkt;
                 /* Dummy trace to ensure DUCK packets are dealt with using the
                  * DUCK format functions */
-                libtrace_t *dummy_duck;
-        } duck;
+                libtrace_t *dummy_duck;
+        } duck;
 
         /* The DAG device that we are reading from */
@@ -158 +164 @@
         /* The number of packets that have been dropped */
         uint64_t drops;
-        /* When running in parallel mode this is malloc'd with an array of thread
-         * structures. Most of the stuff above doesn't get used in parallel mode. */
+        /* When running in parallel mode this is malloc'd with an
+         * array of thread structures. Most of the stuff above doesn't
+         * get used in parallel mode. */
         struct dag_per_thread_t *per_thread;
+
+        uint8_t seeninterface[4];
 };
 
@@ -216 +225 @@
 
 /* Initialises the DAG output data structure */
-static void dag_init_format_out_data(libtrace_out_t *libtrace) {
-        libtrace->format_data = (struct dag_format_data_out_t *) malloc(sizeof(struct dag_format_data_out_t));
+static void dag_init_format_out_data(libtrace_out_t *libtrace)
+{
+        libtrace->format_data = (struct dag_format_data_out_t *)
+                malloc(sizeof(struct dag_format_data_out_t));
         // no DUCK on output
         FORMAT_DATA_OUT->stream_attached = 0;
@@ -227 +238 @@
 
 /* Initialises the DAG input data structure */
-static void dag_init_format_data(libtrace_t *libtrace) {
+static void dag_init_format_data(libtrace_t *libtrace)
+{
         libtrace->format_data = (struct dag_format_data_t *)
                 malloc(sizeof(struct dag_format_data_t));
         DUCK.last_duck = 0;
-        DUCK.duck_freq = 0;
-        DUCK.last_pkt = 0;
-        DUCK.dummy_duck = NULL;
+        DUCK.duck_freq = 0;
+        DUCK.last_pkt = 0;
+        DUCK.dummy_duck = NULL;
         FORMAT_DATA->stream_attached = 0;
         FORMAT_DATA->drops = 0;
@@ -241 +253 @@
         FORMAT_DATA->bottom = NULL;
         FORMAT_DATA->top = NULL;
+        memset(FORMAT_DATA->seeninterface, 0,
+               sizeof(FORMAT_DATA->seeninterface));
 }
 
@@ -247 +261 @@
  *
  * NOTE: This function assumes the open_dag_mutex is held by the caller */
-static struct dag_dev_t *dag_find_open_device(char *dev_name) {
+static struct dag_dev_t *dag_find_open_device(char *dev_name)
+{
         struct dag_dev_t *dag_dev;
 
@@ -258 +273 @@
                         dag_dev->ref_count ++;
                         return dag_dev;
-
                 }
                 dag_dev = dag_dev->next;
         }
         return NULL;
-
-
 }
 
@@ -273 +285 @@
  *
  * NOTE: This function assumes the open_dag_mutex is held by the caller */
-static void dag_close_device(struct dag_dev_t *dev) {
+static void dag_close_device(struct dag_dev_t *dev)
+{
         /* Need to remove from the device list */
-
         assert(dev->ref_count == 0);
 
@@ -290 +302 @@
         dag_close(dev->fd);
         if (dev->dev_name)
-        free(dev->dev_name);
+                free(dev->dev_name);
         free(dev);
 }
@@ -298 +310 @@
  *
  * NOTE: this function should only be called when opening a DAG device for
- * writing - there is little practical difference between this and the 
+ * writing - there is little practical difference between this and the
  * function below that covers the reading case, but we need the output trace
- * object to report errors properly so the two functions take slightly 
+ * object to report errors properly so the two functions take slightly
  * different arguments. This is really lame and there should be a much better
  * way of doing this.
  *
- * NOTE: This function assumes the open_dag_mutex is held by the caller 
+ * NOTE: This function assumes the open_dag_mutex is held by the caller
  */
-static struct dag_dev_t *dag_open_output_device(libtrace_out_t *libtrace, char *dev_name) {
+static struct dag_dev_t *dag_open_output_device(libtrace_out_t *libtrace,
+                                                char *dev_name)
+{
         struct stat buf;
         int fd;
@@ -315 +329 @@
                 trace_set_err_out(libtrace,errno,"stat(%s)",dev_name);
                 return NULL;
-}
+        }
 
         /* Make sure it is the appropriate type of device */
@@ -352 +366 @@
  *
  * NOTE: this function should only be called when opening a DAG device for
- * reading - there is little practical difference between this and the 
+ * reading - there is little practical difference between this and the
  * function above that covers the writing case, but we need the input trace
- * object to report errors properly so the two functions take slightly 
+ * object to report errors properly so the two functions take slightly
  * different arguments. This is really lame and there should be a much better
  * way of doing this.
@@ -365 +379 @@
 
         /* Make sure the device exists */
-        if (stat(dev_name, &buf) == -1) {
-                trace_set_err(libtrace,errno,"stat(%s)",dev_name);
-                return NULL;
-        }
+        if (stat(dev_name, &buf) == -1) {
+                trace_set_err(libtrace,errno,"stat(%s)",dev_name);
+                return NULL;
+        }
 
         /* Make sure it is the appropriate type of device */
@@ -374 +388 @@
                 /* Try opening the DAG device */
                 if((fd = dag_open(dev_name)) < 0) {
-                        trace_set_err(libtrace,errno,"Cannot open DAG %s",
-                                        dev_name);
-                        return NULL;
-                }
+                        trace_set_err(libtrace,errno,"Cannot open DAG %s",
+                                      dev_name);
+                        return NULL;
+                }
         } else {
                 trace_set_err(libtrace,errno,"Not a valid dag device: %s",
-                                dev_name);
-                return NULL;
-        }
+                              dev_name);
+                return NULL;
+        }
 
         /* Add the device to our device list - it is just a doubly linked
@@ -403 +417 @@
 
 /* Creates and initialises a DAG output trace */
-static int dag_init_output(libtrace_out_t *libtrace) {
+static int dag_init_output(libtrace_out_t *libtrace)
+{
         char *dag_dev_name = NULL;
         char *scan = NULL;
         struct dag_dev_t *dag_device = NULL;
         int stream = 1;
-        
+
         /* XXX I don't know if this is important or not, but this function
          * isn't present in all of the driver releases that this code is
@@ -418 +433 @@
 
         dag_init_format_out_data(libtrace);
-        /* Grab the mutex while we're likely to be messing with the device 
+        /* Grab the mutex while we're likely to be messing with the device
          * list */
         pthread_mutex_lock(&open_dag_mutex);
-        
+
         /* Specific streams are signified using a comma in the libtrace URI,
          * e.g. dag:/dev/dag0,1 refers to stream 1 on the dag0 device.
@@ -463 +478 @@
 /* Creates and initialises a DAG input trace */
 static int dag_init_input(libtrace_t *libtrace) {
-        char *dag_dev_name = NULL;
+        char *dag_dev_name = NULL;
         char *scan = NULL;
         int stream = 0, thread_count = 1;
@@ -469 +484 @@
 
         dag_init_format_data(libtrace);
-        /* Grab the mutex while we're likely to be messing with the device 
+        /* Grab the mutex while we're likely to be messing with the device
          * list */
         pthread_mutex_lock(&open_dag_mutex);
@@ -478 +493 @@
          * e.g. dag:/dev/dag0,2 refers to stream 2 on the dag0 device.
          *
-         * If no stream is specified, we will read from stream 0 with one thread
+         * If no stream is specified, we will read from stream 0 with
+         * one thread
          */
         if ((scan = strchr(libtrace->uridata, ',')) == NULL) {
                 dag_dev_name = strdup(libtrace->uridata);
-                
         } else {
                 dag_dev_name = (char *)strndup(libtrace->uridata,
-                                                                           (size_t)(scan - libtrace->uridata));
+                                               (size_t)(scan -
+                                                        libtrace->uridata));
                 stream = atoi(++scan);
         }
@@ -514 +530 @@
         FORMAT_DATA->device = dag_device;
 
-        /* See Config_Status_API_Programming_Guide.pdf from the Endace Dag Documentation */
-        /* Check kBooleanAttributeActive is true -- no point capturing on an interface that's disabled
- 
-        *  The symptom of the port being disabled is that libtrace will appear to hang.
-        */
+        /* See Config_Status_API_Programming_Guide.pdf from the Endace
+           Dag Documentation */
+        /* Check kBooleanAttributeActive is true -- no point capturing
+         * on an interface that's disabled
+         *
+         * The symptom of the port being disabled is that libtrace
+         * will appear to hang. */
         /* Check kBooleanAttributeFault is false */
         /* Check kBooleanAttributeLocalFault is false */
@@ -524 +542 @@
         /* Check kBooleanAttributePeerLink ? */
 
-        /* Set kBooleanAttributePromisc/kBooleanPromiscuousMode based on libtrace promisc attribute?*/
+        /* Set kBooleanAttributePromisc/kBooleanPromiscuousMode based
+           on libtrace promisc attribute?*/
         /* Set kUint32AttributeSnapLength to the snaplength */
 
         pthread_mutex_unlock(&open_dag_mutex);
-        return 0;
+        return 0;
 }
 
 /* Configures a DAG input trace */
 static int dag_config_input(libtrace_t *libtrace, trace_option_t option,
-                                void *data) {
-        char conf_str[4096];
+                            void *data)
+{
+        char conf_str[4096];
         switch(option) {
-                case TRACE_OPTION_META_FREQ:
-                        /* This option is used to specify the frequency of DUCK
-                         * updates */
-                        DUCK.duck_freq = *(int *)data;
-                        return 0;
-                case TRACE_OPTION_SNAPLEN:
-                        /* Tell the card our new snap length */
-                        snprintf(conf_str, 4096, "varlen slen=%i", *(int *)data);
-                        if (dag_configure(FORMAT_DATA->device->fd,
-                                                conf_str) != 0) {
-                                trace_set_err(libtrace, errno, "Failed to configure snaplen on DAG card: %s", libtrace->uridata);
-                                return -1;
-                        }
-                        return 0;
-                case TRACE_OPTION_PROMISC:
-                        /* DAG already operates in a promisc fashion */
-                        return -1;
-                case TRACE_OPTION_FILTER:
-                        /* We don't yet support pushing filters into DAG 
-                         * cards */
-                        return -1;
-                case TRACE_OPTION_EVENT_REALTIME:
-                        /* Live capture is always going to be realtime */
+        case TRACE_OPTION_META_FREQ:
+                /* This option is used to specify the frequency of DUCK
+                 * updates */
+                DUCK.duck_freq = *(int *)data;
+                return 0;
+        case TRACE_OPTION_SNAPLEN:
+                /* Tell the card our new snap length */
+                snprintf(conf_str, 4096, "varlen slen=%i", *(int *)data);
+                if (dag_configure(FORMAT_DATA->device->fd,
+                                  conf_str) != 0) {
+                        trace_set_err(libtrace, errno, "Failed to configure "
+                                      "snaplen on DAG card: %s",
+                                      libtrace->uridata);
                         return -1;
-        }
+                }
+                return 0;
+        case TRACE_OPTION_PROMISC:
+                /* DAG already operates in a promisc fashion */
+                return -1;
+        case TRACE_OPTION_FILTER:
+                /* We don't yet support pushing filters into DAG
+                 * cards */
+                return -1;
+        case TRACE_OPTION_EVENT_REALTIME:
+                /* Live capture is always going to be realtime */
+                return -1;
+        }
         return -1;
 }
 
 /* Starts a DAG output trace */
-static int dag_start_output(libtrace_out_t *libtrace) {
+static int dag_start_output(libtrace_out_t *libtrace)
+{
         struct timeval zero, nopoll;
 
@@ -573 +596 @@
 
         /* Attach and start the DAG stream */
-
         if (dag_attach_stream(FORMAT_DATA_OUT->device->fd,
-                        FORMAT_DATA_OUT->dagstream, 0, 1048576) < 0) {
+                        FORMAT_DATA_OUT->dagstream, 0, 4 * 1024 * 1024) < 0) {
                 trace_set_err_out(libtrace, errno, "Cannot attach DAG stream");
                 return -1;
@@ -588 +610 @@
 
         /* We don't want the dag card to do any sleeping */
-
         dag_set_stream_poll(FORMAT_DATA_OUT->device->fd,
                         FORMAT_DATA_OUT->dagstream, 0, &zero,
@@ -597 +618 @@
 
 /* Starts a DAG input trace */
-static int dag_start_input(libtrace_t *libtrace) {
-        struct timeval zero, nopoll;
-        uint8_t *top, *bottom;
-        uint8_t diff = 0;
+static int dag_start_input(libtrace_t *libtrace)
+{
+        struct timeval zero, nopoll;
+        uint8_t *top, *bottom, *starttop;
+        uint64_t diff = 0;
         top = bottom = NULL;
 
         zero.tv_sec = 0;
-        zero.tv_usec = 10000;
-        nopoll = zero;
+        zero.tv_usec = 10000;
+        nopoll = zero;
 
         /* Attach and start the DAG stream */
         if (dag_attach_stream(FORMAT_DATA->device->fd,
-                                FORMAT_DATA->dagstream, 0, 0) < 0) {
-                trace_set_err(libtrace, errno, "Cannot attach DAG stream");
-                return -1;
-        }
+                              FORMAT_DATA->dagstream, 0, 0) < 0) {
+                trace_set_err(libtrace, errno, "Cannot attach DAG stream");
+                return -1;
+        }
 
         if (dag_start_stream(FORMAT_DATA->device->fd,
-                                FORMAT_DATA->dagstream) < 0) {
-                trace_set_err(libtrace, errno, "Cannot start DAG stream");
-                return -1;
-        }
+                             FORMAT_DATA->dagstream) < 0) {
+                trace_set_err(libtrace, errno, "Cannot start DAG stream");
+                return -1;
+        }
         FORMAT_DATA->stream_attached = 1;
-        
+
         /* We don't want the dag card to do any sleeping */
-        dag_set_stream_poll(FORMAT_DATA->device->fd,
-                                FORMAT_DATA->dagstream, 0, &zero,
-                                &nopoll);
+        dag_set_stream_poll(FORMAT_DATA->device->fd,
+                            FORMAT_DATA->dagstream, 0, &zero,
+                            &nopoll);
+
+        starttop = dag_advance_stream(FORMAT_DATA->device->fd,
+                                      FORMAT_DATA->dagstream,
+                                      &bottom);
 
         /* Should probably flush the memory hole now */
-        do {
+        top = starttop;
+        while (starttop - bottom > 0) {
+                bottom += (starttop - bottom);
                 top = dag_advance_stream(FORMAT_DATA->device->fd,
-                                        FORMAT_DATA->dagstream,
-                                        &bottom);
-                assert(top && bottom);
-                diff = top - bottom;
-                bottom -= diff;
-        } while (diff != 0);
-        FORMAT_DATA->top = NULL;
-        FORMAT_DATA->bottom = NULL;
+                                         FORMAT_DATA->dagstream,
+                                         &bottom);
+        }
+        FORMAT_DATA->top = top;
+        FORMAT_DATA->bottom = bottom;
         FORMAT_DATA->processed = 0;
         FORMAT_DATA->drops = 0;
@@ -644 +669 @@
 
 /* Pauses a DAG output trace */
-static int dag_pause_output(libtrace_out_t *libtrace) {
-
+static int dag_pause_output(libtrace_out_t *libtrace)
+{
         /* Stop and detach the stream */
         if (dag_stop_stream(FORMAT_DATA_OUT->device->fd,
-                        FORMAT_DATA_OUT->dagstream) < 0) {
+                            FORMAT_DATA_OUT->dagstream) < 0) {
                 trace_set_err_out(libtrace, errno, "Could not stop DAG stream");
                 return -1;
         }
         if (dag_detach_stream(FORMAT_DATA_OUT->device->fd,
-                        FORMAT_DATA_OUT->dagstream) < 0) {
-                trace_set_err_out(libtrace, errno, "Could not detach DAG stream");
+                              FORMAT_DATA_OUT->dagstream) < 0) {
+                trace_set_err_out(libtrace, errno,
+                                  "Could not detach DAG stream");
                 return -1;
         }
@@ -662 +688 @@
 
 /* Pauses a DAG input trace */
-static int dag_pause_input(libtrace_t *libtrace) {
-
+static int dag_pause_input(libtrace_t *libtrace)
+{
         /* Stop and detach the stream */
         if (dag_stop_stream(FORMAT_DATA->device->fd,
-                                FORMAT_DATA->dagstream) < 0) {
-                trace_set_err(libtrace, errno, "Could not stop DAG stream");
-                return -1;
-        }
-        if (dag_detach_stream(FORMAT_DATA->device->fd,
-                                FORMAT_DATA->dagstream) < 0) {
-                trace_set_err(libtrace, errno, "Could not detach DAG stream");
-                return -1;
+                            FORMAT_DATA->dagstream) < 0) {
+                trace_set_err(libtrace, errno, "Could not stop DAG stream");
+                return -1;
+        }
+        if (dag_detach_stream(FORMAT_DATA->device->fd,
+                              FORMAT_DATA->dagstream) < 0) {
+                trace_set_err(libtrace, errno, "Could not detach DAG stream");
+                return -1;
         }
         FORMAT_DATA->stream_attached = 0;
@@ -680 +706 @@
 
 /* Closes a DAG input trace */
-static int dag_fin_input(libtrace_t *libtrace) {
+static int dag_fin_input(libtrace_t *libtrace)
+{
         /* Need the lock, since we're going to be handling the device list */
         pthread_mutex_lock(&open_dag_mutex);
-        
+
         /* Detach the stream if we are not paused */
         if (FORMAT_DATA->stream_attached)
@@ -696 +723 @@
         free(libtrace->format_data);
         pthread_mutex_unlock(&open_dag_mutex);
-        return 0; /* success */
+        return 0; /* success */
 }
 
 /* Closes a DAG output trace */
-static int dag_fin_output(libtrace_out_t *libtrace) {
-        
+static int dag_fin_output(libtrace_out_t *libtrace)
+{
+
         /* Commit any outstanding traffic in the txbuffer */
         if (FORMAT_DATA_OUT->waiting) {
-                dag_tx_stream_commit_bytes(FORMAT_DATA_OUT->device->fd, FORMAT_DATA_OUT->dagstream,
-                                FORMAT_DATA_OUT->waiting );
-        }
-
-        /* Wait until the buffer is nearly clear before exiting the program, 
+                dag_tx_stream_commit_bytes(FORMAT_DATA_OUT->device->fd,
+                                           FORMAT_DATA_OUT->dagstream,
+                                           FORMAT_DATA_OUT->waiting );
+        }
+
+        /* Wait until the buffer is nearly clear before exiting the program,
          * as we will lose packets otherwise */
-        dag_tx_get_stream_space(FORMAT_DATA_OUT->device->fd,
-                        FORMAT_DATA_OUT->dagstream,
-                        dag_get_stream_buffer_size(FORMAT_DATA_OUT->device->fd,
-                                        FORMAT_DATA_OUT->dagstream) - 8
-                        );
+        dag_tx_get_stream_space
+                (FORMAT_DATA_OUT->device->fd,
+                 FORMAT_DATA_OUT->dagstream,
+                 dag_get_stream_buffer_size(FORMAT_DATA_OUT->device->fd,
+                                            FORMAT_DATA_OUT->dagstream) - 8);
 
         /* Need the lock, since we're going to be handling the device list */
@@ -733 +762 @@
 
 /* Extracts DUCK information from the DAG card and produces a DUCK packet */
-static int dag_get_duckinfo(libtrace_t *libtrace,
-                                libtrace_packet_t *packet) {
-
+static int dag_get_duckinfo(libtrace_t *libtrace, libtrace_packet_t *packet)
+{
         /* Allocate memory for the DUCK data */
-        if (packet->buf_control == TRACE_CTRL_EXTERNAL ||
-                        !packet->buffer) {
-                packet->buffer = malloc(LIBTRACE_PACKET_BUFSIZE);
-                packet->buf_control = TRACE_CTRL_PACKET;
-                if (!packet->buffer) {
-                        trace_set_err(libtrace, errno,
-                                        "Cannot allocate packet buffer");
-                        return -1;
-                }
-        }
+        if (packet->buf_control == TRACE_CTRL_EXTERNAL ||
+            !packet->buffer) {
+                packet->buffer = malloc(LIBTRACE_PACKET_BUFSIZE);
+                packet->buf_control = TRACE_CTRL_PACKET;
+                if (!packet->buffer) {
+                        trace_set_err(libtrace, errno,
+                                      "Cannot allocate packet buffer");
+                        return -1;
+                }
+        }
 
         /* DUCK doesn't have a format header */
-        packet->header = 0;
-        packet->payload = packet->buffer;
-
-        /* No need to check if we can get DUCK or not - we're modern
-         * enough so just grab the DUCK info */
-        if ((ioctl(FORMAT_DATA->device->fd, DAGIOCDUCK,
-                                        (duckinf_t *)packet->payload) < 0)) {
-                trace_set_err(libtrace, errno, "Error using DAGIOCDUCK");
-                return -1;
-        }
-
-        packet->type = TRACE_RT_DUCK_2_5;
+        packet->header = 0;
+        packet->payload = packet->buffer;
+
+        /* No need to check if we can get DUCK or not - we're modern
+         * enough so just grab the DUCK info */
+        if ((ioctl(FORMAT_DATA->device->fd, DAGIOCDUCK,
+                   (duckinf_t *)packet->payload) < 0)) {
+                trace_set_err(libtrace, errno, "Error using DAGIOCDUCK");
+                return -1;
+        }
+
+        packet->type = TRACE_RT_DUCK_2_5;
 
         /* Set the packet's tracce to point at a DUCK trace, so that the
          * DUCK format functions will be called on the packet rather than the
          * DAG ones */
-        if (!DUCK.dummy_duck)
-                DUCK.dummy_duck = trace_create_dead("rt:localhost:3434");
-        packet->trace = DUCK.dummy_duck;
-        return sizeof(duckinf_t);
+        if (!DUCK.dummy_duck)
+                DUCK.dummy_duck = trace_create_dead("rt:localhost:3434");
+        packet->trace = DUCK.dummy_duck;
+        return sizeof(duckinf_t);
 }
 
 /* Determines the amount of data available to read from the DAG card */
-static int dag_available(libtrace_t *libtrace) {
+static int dag_available(libtrace_t *libtrace)
+{
         uint32_t diff = FORMAT_DATA->top - FORMAT_DATA->bottom;
 
@@ -780 +809 @@
         if (diff >= dag_record_size && FORMAT_DATA->processed < 4 * 1024 * 1024)
                 return diff;
-        
+
         /* Update the top and bottom pointers */
         FORMAT_DATA->top = dag_advance_stream(FORMAT_DATA->device->fd,
-                        FORMAT_DATA->dagstream,
-                        &(FORMAT_DATA->bottom));
-        
+                                              FORMAT_DATA->dagstream,
+                                              &(FORMAT_DATA->bottom));
+
         if (FORMAT_DATA->top == NULL) {
                 trace_set_err(libtrace, errno, "dag_advance_stream failed!");
@@ -796 +825 @@
 
 /* Returns a pointer to the start of the next complete ERF record */
-static dag_record_t *dag_get_record(libtrace_t *libtrace) {
-        dag_record_t *erfptr = NULL;
-        uint16_t size;
+static dag_record_t *dag_get_record(libtrace_t *libtrace)
+{
+        dag_record_t *erfptr = NULL;
+        uint16_t size;
+
         erfptr = (dag_record_t *)FORMAT_DATA->bottom;
         if (!erfptr)
-                return NULL;
-        size = ntohs(erfptr->rlen);
-        assert( size >= dag_record_size );
+                return NULL;
+
+        size = ntohs(erfptr->rlen);
+        assert( size >= dag_record_size );
+
         /* Make certain we have the full packet available */
         if (size > (FORMAT_DATA->top - FORMAT_DATA->bottom))
                 return NULL;
+
         FORMAT_DATA->bottom += size;
         FORMAT_DATA->processed += size;
@@ -815 +849 @@
  * libtrace packet */
 static int dag_prepare_packet(libtrace_t *libtrace, libtrace_packet_t *packet,
-                void *buffer, libtrace_rt_types_t rt_type, uint32_t flags) {
-
+                              void *buffer, libtrace_rt_types_t rt_type,
+                              uint32_t flags)
+{
         dag_record_t *erfptr;
         libtrace_thread_t *t;
-        
+
         /* If the packet previously owned a buffer that is not the buffer
-         * that contains the new packet data, we're going to need to free the
-         * old one to avoid memory leaks */
+         * that contains the new packet data, we're going to need to free the
+         * old one to avoid memory leaks */
         if (packet->buffer != buffer &&
                         packet->buf_control == TRACE_CTRL_PACKET) {
@@ -837 +872 @@
         erfptr = (dag_record_t *)buffer;
         packet->buffer = erfptr;
-        packet->header = erfptr;
-        packet->type = rt_type;
+        packet->header = erfptr;
+        packet->type = rt_type;
 
         if (erfptr->flags.rxerror == 1) {
-                /* rxerror means the payload is corrupt - drop the payload
-                 * by tweaking rlen */
-                packet->payload = NULL;
-                erfptr->rlen = htons(erf_get_framing_length(packet));
-        } else {
-                packet->payload = (char*)packet->buffer
-                        + erf_get_framing_length(packet);
-        }
+                /* rxerror means the payload is corrupt - drop the payload
+                 * by tweaking rlen */
+                packet->payload = NULL;
+                erfptr->rlen = htons(erf_get_framing_length(packet));
+        } else {
+                packet->payload = (char*)packet->buffer
+                        + erf_get_framing_length(packet);
+        }
 
         if (libtrace->format_data == NULL) {
@@ -855 +890 @@
 
         /* Update the dropped packets counter */
-        /* No loss counter for DSM coloured records - have to use
-         * some other API */
-        /* Adding multithread support for this isn't actually that useful for the
-         * DAG7.5G2, as there's no way to use multiple receive streams without DSM */
+        /* No loss counter for DSM coloured records - have to use some
+         * other API */
         if (erfptr->type == TYPE_DSM_COLOR_ETH) {
                 /* TODO */
@@ -867 +900 @@
                         PERPKT_DATA(t)->drops += ntohs(erfptr->lctr);
                 } else {
-                        printf("DROP!\n");
-                        DATA(libtrace)->drops += ntohs(erfptr->lctr);
-                }
-        }
-
+                        if (FORMAT_DATA->seeninterface[erfptr->flags.iface]
+                            == 0) {
+                                FORMAT_DATA->seeninterface[erfptr->flags.iface]
+                                        = 1;
+                        } else {
+                                FORMAT_DATA->drops += ntohs(erfptr->lctr);
+                        }
+                }
+        }
 
         return 0;
@@ -886 +923 @@
 /* Pushes an ERF record onto the transmit stream */
 static int dag_dump_packet(libtrace_out_t *libtrace,
-                dag_record_t *erfptr, unsigned int pad, void *buffer) {
+                           dag_record_t *erfptr, unsigned int pad,
+                           void *buffer)
+{
         int size;
 
         /*
-         * If we've got 0 bytes waiting in the txqueue, assume that we haven't
-         * requested any space yet, and request some, storing the pointer at
-         * FORMAT_DATA_OUT->txbuffer.
+         * If we've got 0 bytes waiting in the txqueue, assume that we
+         * haven't requested any space yet, and request some, storing
+         * the pointer at FORMAT_DATA_OUT->txbuffer.
          *
          * The amount to request is slightly magical at the moment - it's
@@ -899 +938 @@
          */
         if (FORMAT_DATA_OUT->waiting == 0) {
-                FORMAT_DATA_OUT->txbuffer = dag_tx_get_stream_space(FORMAT_DATA_OUT->device->fd,
-                                FORMAT_DATA_OUT->dagstream, 16908288);
+                FORMAT_DATA_OUT->txbuffer =
+                        dag_tx_get_stream_space(FORMAT_DATA_OUT->device->fd,
+                                                FORMAT_DATA_OUT->dagstream,
+                                                16908288);
         }
 
@@ -907 +948 @@
          * are in contiguous memory
          */
-        memcpy(FORMAT_DATA_OUT->txbuffer + FORMAT_DATA_OUT->waiting,erfptr,(dag_record_size + pad));
+        memcpy(FORMAT_DATA_OUT->txbuffer + FORMAT_DATA_OUT->waiting, erfptr,
+               (dag_record_size + pad));
         FORMAT_DATA_OUT->waiting += (dag_record_size + pad);
-
-
 
         /*
@@ -917 +957 @@
          */
         size = ntohs(erfptr->rlen)-(dag_record_size + pad);
-        memcpy(FORMAT_DATA_OUT->txbuffer + FORMAT_DATA_OUT->waiting,buffer,size);
+        memcpy(FORMAT_DATA_OUT->txbuffer + FORMAT_DATA_OUT->waiting, buffer,
+               size);
         FORMAT_DATA_OUT->waiting += size;
 
@@ -926 +967 @@
          * case there is still data in the buffer at program exit.
          */
-
         if (FORMAT_DATA_OUT->waiting >= 16*1024*1024) {
-                FORMAT_DATA_OUT->txbuffer = dag_tx_stream_commit_bytes(FORMAT_DATA_OUT->device->fd, FORMAT_DATA_OUT->dagstream,
-                        FORMAT_DATA_OUT->waiting );
+                FORMAT_DATA_OUT->txbuffer =
+                        dag_tx_stream_commit_bytes(FORMAT_DATA_OUT->device->fd,
+                                                   FORMAT_DATA_OUT->dagstream,
+                                                   FORMAT_DATA_OUT->waiting);
                 FORMAT_DATA_OUT->waiting = 0;
         }
 
         return size + pad + dag_record_size;
-
 }
 
@@ -940 +981 @@
  * if one is found, false otherwise */
 static bool find_compatible_linktype(libtrace_out_t *libtrace,
-                                libtrace_packet_t *packet, char *type)
-{
-         // Keep trying to simplify the packet until we can find
-         //something we can do with it
+                                     libtrace_packet_t *packet, char *type)
+{
+        /* Keep trying to simplify the packet until we can find
+         * something we can do with it */
 
         do {
-                *type=libtrace_to_erf_type(trace_get_link_type(packet));
-
-                // Success
+                *type = libtrace_to_erf_type(trace_get_link_type(packet));
+
+                /* Success */
                 if (*type != (char)-1)
                         return true;
@@ -954 +995 @@
                 if (!demote_packet(packet)) {
                         trace_set_err_out(libtrace,
-                                        TRACE_ERR_NO_CONVERSION,
-                                        "No erf type for packet (%i)",
-                                        trace_get_link_type(packet));
+                                          TRACE_ERR_NO_CONVERSION,
+                                          "No erf type for packet (%i)",
+                                          trace_get_link_type(packet));
                         return false;
                 }
@@ -966 +1007 @@
 
 /* Writes a packet to the provided DAG output trace */
-static int dag_write_packet(libtrace_out_t *libtrace, libtrace_packet_t *packet) {
-        /*
-         * This is heavily borrowed from erf_write_packet(). Yes, CnP coding 
-         * sucks, sorry about that.
+static int dag_write_packet(libtrace_out_t *libtrace, libtrace_packet_t *packet)
+{
+        /* This is heavily borrowed from erf_write_packet(). Yes, CnP
+         * coding sucks, sorry about that.
          */
         unsigned int pad = 0;
@@ -978 +1019 @@
 
         if(!packet->header) {
-                /* No header, probably an RT packet. Lifted from 
+                /* No header, probably an RT packet. Lifted from
                  * erf_write_packet(). */
                 return -1;
@@ -997 +1038 @@
 
         if (packet->type == TRACE_RT_DATA_ERF) {
-                numbytes = dag_dump_packet(libtrace,
-                                header,
-                                pad,
-                                payload
-                                );
-
+                numbytes = dag_dump_packet(libtrace, header, pad, payload);
         } else {
                 /* Build up a new packet header from the existing header */
 
-                /* Simplify the packet first - if we can't do this, break 
+                /* Simplify the packet first - if we can't do this, break
                  * early */
                 if (!find_compatible_linktype(libtrace,packet,&erf_type))
@@ -1025 +1061 @@
 
                 /* Packet length (rlen includes format overhead) */
-                assert(trace_get_capture_length(packet)>0
-                                && trace_get_capture_length(packet)<=65536);
-                assert(erf_get_framing_length(packet)>0
-                                && trace_get_framing_length(packet)<=65536);
-                assert(trace_get_capture_length(packet)+erf_get_framing_length(packet)>0
-                      &&trace_get_capture_length(packet)+erf_get_framing_length(packet)<=65536);
+                assert(trace_get_capture_length(packet) > 0
+                       && trace_get_capture_length(packet) <= 65536);
+                assert(erf_get_framing_length(packet) > 0
+                       && trace_get_framing_length(packet) <= 65536);
+                assert(trace_get_capture_length(packet) +
+                       erf_get_framing_length(packet) > 0
+                       && trace_get_capture_length(packet) +
+                       erf_get_framing_length(packet) <= 65536);
 
                 erfhdr.rlen = htons(trace_get_capture_length(packet)
-                        + erf_get_framing_length(packet));
+                                    + erf_get_framing_length(packet));
 
 
@@ -1042 +1080 @@
 
                 /* Write it out */
-                numbytes = dag_dump_packet(libtrace,
-                                &erfhdr,
-                                pad,
-                                payload);
-
+                numbytes = dag_dump_packet(libtrace, &erfhdr, pad, payload);
         }
 
@@ -1056 +1090 @@
  * If DUCK reporting is enabled, the packet returned may be a DUCK update
  */
-static int dag_read_packet(libtrace_t *libtrace, libtrace_packet_t *packet) {
-        int size = 0;
-        struct timeval tv;
-        dag_record_t *erfptr = NULL;
+static int dag_read_packet(libtrace_t *libtrace, libtrace_packet_t *packet)
+{
+        int size = 0;
+        struct timeval tv;
+        dag_record_t *erfptr = NULL;
         int numbytes = 0;
         uint32_t flags = 0;
@@ -1070 +1105 @@
         maxwait.tv_usec = 250000;
 
-        /* Check if we're due for a DUCK report */
+        /* Check if we're due for a DUCK report */
         if (DUCK.last_pkt - DUCK.last_duck > DUCK.duck_freq &&
-                        DUCK.duck_freq != 0) {
-                size = dag_get_duckinfo(libtrace, packet);
-                DUCK.last_duck = DUCK.last_pkt;
-                if (size != 0) {
-                        return size;
-                }
-                /* No DUCK support, so don't waste our time anymore */
-                DUCK.duck_freq = 0;
-        }
+            DUCK.duck_freq != 0) {
+                size = dag_get_duckinfo(libtrace, packet);
+                DUCK.last_duck = DUCK.last_pkt;
+                if (size != 0) {
+                        return size;
+                }
+                /* No DUCK support, so don't waste our time anymore */
+                DUCK.duck_freq = 0;
+        }
 
         /* Don't let anyone try to free our DAG memory hole! */
@@ -1087 +1122 @@
         /* If the packet buffer is currently owned by libtrace, free it so
          * that we can set the packet to point into the DAG memory hole */
-        if (packet->buf_control == TRACE_CTRL_PACKET) {
-                free(packet->buffer);
-                packet->buffer = 0;
-        }
-        
-        if (dag_set_stream_poll(FORMAT_DATA->device->fd, 
-                        FORMAT_DATA->dagstream, sizeof(dag_record_t), &maxwait, 
-                        &pollwait) == -1)
-        {
+        if (packet->buf_control == TRACE_CTRL_PACKET) {
+                free(packet->buffer);
+                packet->buffer = 0;
+        }
+
+        if (dag_set_stream_poll(FORMAT_DATA->device->fd, FORMAT_DATA->dagstream,
+                                sizeof(dag_record_t), &maxwait,
+                                &pollwait) == -1) {
                 trace_set_err(libtrace, errno, "dag_set_stream_poll");
                 return -1;
@@ -1117 +1151 @@
         /* Prepare the libtrace packet */
         if (dag_prepare_packet(libtrace, packet, erfptr, TRACE_RT_DATA_ERF,
-                                flags))
+                               flags))
                 return -1;
 
         /* Update the DUCK timer */
         tv = trace_get_timeval(packet);
-        DUCK.last_pkt = tv.tv_sec;
+        DUCK.last_pkt = tv.tv_sec;
 
         return packet->payload ? htons(erfptr->rlen) :
-                                erf_get_framing_length(packet);
+                erf_get_framing_length(packet);
 }
 
@@ -1133 +1167 @@
  */
 static libtrace_eventobj_t trace_event_dag(libtrace_t *libtrace,
-                                        libtrace_packet_t *packet) {
-        libtrace_eventobj_t event = {0,0,0.0,0};
+                                           libtrace_packet_t *packet)
+{
+        libtrace_eventobj_t event = {0,0,0.0,0};
         dag_record_t *erfptr = NULL;
         int numbytes;
         uint32_t flags = 0;
         struct timeval minwait;
-        
+
         minwait.tv_sec = 0;
         minwait.tv_usec = 10000;
-        
-        if (dag_set_stream_poll(FORMAT_DATA->device->fd, 
-                        FORMAT_DATA->dagstream, 0, &minwait, 
-                        &minwait) == -1)
-        {
+
+        if (dag_set_stream_poll(FORMAT_DATA->device->fd,
+                                FORMAT_DATA->dagstream, 0, &minwait,
+                                &minwait) == -1) {
                 trace_set_err(libtrace, errno, "dag_set_stream_poll");
                 event.type = TRACE_EVENT_TERMINATE;
@@ -1155 +1189 @@
                 erfptr = NULL;
                 numbytes = 0;
-        
+
                 /* Need to call dag_available so that the top pointer will get
                  * updated, otherwise we'll never see any data! */
                 numbytes = dag_available(libtrace);
 
-                /* May as well not bother calling dag_get_record if 
+                /* May as well not bother calling dag_get_record if
                  * dag_available suggests that there's no data */
                 if (numbytes != 0)
@@ -1168 +1202 @@
                         if (libtrace_halt) {
                                 event.type = TRACE_EVENT_TERMINATE;
-                        } else {                        
+                        } else {
                                 event.type = TRACE_EVENT_SLEEP;
                                 event.seconds = 0.0001;
@@ -1174 +1208 @@
                         break;
                 }
-                if (dag_prepare_packet(libtrace, packet, erfptr, 
-                                        TRACE_RT_DATA_ERF, flags)) {
+                if (dag_prepare_packet(libtrace, packet, erfptr,
+                                       TRACE_RT_DATA_ERF, flags)) {
                         event.type = TRACE_EVENT_TERMINATE;
                         break;
@@ -1181 +1215 @@
 
 
-                event.size = trace_get_capture_length(packet) + 
-                                trace_get_framing_length(packet);
-                
+                event.size = trace_get_capture_length(packet) +
+                        trace_get_framing_length(packet);
+
                 /* XXX trace_read_packet() normally applies the following
                  * config options for us, but this function is called via
@@ -1189 +1223 @@
 
                 if (libtrace->filter) {
-                        int filtret = trace_apply_filter(libtrace->filter, 
-                                        packet);
+                        int filtret = trace_apply_filter(libtrace->filter,
+                                                         packet);
                         if (filtret == -1) {
                                 trace_set_err(libtrace, TRACE_ERR_BAD_FILTER,
-                                                "Bad BPF Filter");
+                                              "Bad BPF Filter");
                                 event.type = TRACE_EVENT_TERMINATE;
                                 break;
@@ -1204 +1238 @@
                                  * a sleep event in this case, like we used to
                                  * do! */
-                                libtrace->filtered_packets ++;
+                                libtrace->filtered_packets ++;
                                 trace_clear_cache(packet);
                                 continue;
                         }
-                                
+
                         event.type = TRACE_EVENT_PACKET;
                 } else {
@@ -1217 +1251 @@
                         trace_set_capture_length(packet, libtrace->snaplen);
                 }
-                libtrace->accepted_packets ++;
+                libtrace->accepted_packets ++;
                 break;
-        } while (1);
+        } while(1);
 
         return event;
@@ -1225 +1259 @@
 
 /* Gets the number of dropped packets */
-static uint64_t dag_get_dropped_packets(libtrace_t *trace) {
+static uint64_t dag_get_dropped_packets(libtrace_t *trace)
+{
         uint64_t sum = 0;
         int i, tot;
 
         if (trace->format_data == NULL)
-                return (uint64_t)-1;
+                return (uint64_t) - 1;
 
         if (DATA(trace)->per_thread) {
@@ -1237 +1272 @@
                 for (i = 0; i < tot; i++) {
                         printf("t%d: drops %" PRIu64 "\n",
-                                   DATA(trace)->per_thread[i].drops);
+                               DATA(trace)->per_thread[i].drops);
                         sum += DATA(trace)->per_thread[i].drops;
                 }
@@ -1249 +1284 @@
 /* Prints some semi-useful help text about the DAG format module */
 static void dag_help(void) {
-        printf("dag format module: $Revision: 1755 $\n");
-        printf("Supported input URIs:\n");
-        printf("\tdag:/dev/dagn\n");
-        printf("\n");
-        printf("\te.g.: dag:/dev/dag0\n");
-        printf("\n");
-        printf("Supported output URIs:\n");
-        printf("\tnone\n");
-        printf("\n");
-}
-
-static int dag_pstart_input(libtrace_t *libtrace) {
+        printf("dag format module: $Revision: 1755 $\n");
+        printf("Supported input URIs:\n");
+        printf("\tdag:/dev/dagn\n");
+        printf("\n");
+        printf("\te.g.: dag:/dev/dag0\n");
+        printf("\n");
+        printf("Supported output URIs:\n");
+        printf("\tnone\n");
+        printf("\n");
+}
+
+static int dag_pstart_input(libtrace_t *libtrace)
+{
         char *scan, *tok;
         uint16_t stream_count = 0, max_streams;
@@ -1268 +1304 @@
         int iserror = 0;
 
-        /* Check we aren't trying to create more threads than the DAG card can 
+        /* Check we aren't trying to create more threads than the DAG card can
          * handle */
         max_streams = dag_rx_get_stream_count(FORMAT_DATA->device->fd);
         if (libtrace->perpkt_thread_count > max_streams) {
-                trace_set_err(libtrace, TRACE_ERR_BAD_FORMAT, "trying to create too "
-                                          "many threads (max is %u)", max_streams);
+                trace_set_err(libtrace, TRACE_ERR_BAD_FORMAT,
+                              "trying to create too many threads (max is %u)",
+                              max_streams);
                 iserror = 1;
                 goto cleanup;
@@ -1280 +1317 @@
         /* Create the thread structures */
         per_thread = calloc(libtrace->perpkt_thread_count,
-                                                                         sizeof(struct dag_per_thread_t));
+                            sizeof(struct dag_per_thread_t));
         FORMAT_DATA->per_thread = per_thread;
 
         /* Get the stream names from the uri */
         if ((scan = strchr(libtrace->uridata, ',')) == NULL) {
-                trace_set_err(libtrace, TRACE_ERR_BAD_FORMAT, "format uri doesn't "
-                                          "specify the DAG streams");
+                trace_set_err(libtrace, TRACE_ERR_BAD_FORMAT,
+                              "format uri doesn't specify the DAG streams");
                 iserror = 1;
                 goto cleanup;
@@ -1292 +1329 @@
 
         scan++;
- 
+
         tok = strtok(scan, ",");
         while (tok != NULL) {
                 /* Ensure we haven't specified too many streams */
                 if (stream_count >= libtrace->perpkt_thread_count) {
-                        trace_set_err(libtrace, TRACE_ERR_BAD_FORMAT, "format uri specifies too "
-                                          "many streams. Max is %u", max_streams);
+                        trace_set_err(libtrace, TRACE_ERR_BAD_FORMAT,
+                                      "format uri specifies too many streams. "
+                                      "Max is %u", max_streams);
                         iserror = 1;
                         goto cleanup;
@@ -1314 +1352 @@
                 /* Free the per_thread memory */
                 free(per_thread);
-                
                 return -1;
         } else {
@@ -1324 +1361 @@
 
 /* TODO: Fold this into dag_available */
-static int dag_pavailable(libtrace_t *libtrace, libtrace_thread_t *t) {
+static int dag_pavailable(libtrace_t *libtrace, libtrace_thread_t *t)
+{
         uint32_t diff = PERPKT_DATA(t)->top - PERPKT_DATA(t)->bottom;
 
@@ -1330 +1368 @@
          * dag_advance_stream, then we should call it again to allow the
          * space occupied by that 4MB to be released */
-        if (diff >= dag_record_size && PERPKT_DATA(t)->processed < 4 * 1024 * 1024)
+        if (diff >= dag_record_size && PERPKT_DATA(t)->processed <
+            4*1024*1024)
                 return diff;
 
         /* Update top and bottom pointers */
         PERPKT_DATA(t)->top = dag_advance_stream(PERPKT_DATA(t)->device->fd,
-                                                                                         PERPKT_DATA(t)->stream,
-                                                                                         &(PERPKT_DATA(t)->bottom));
+                                                 PERPKT_DATA(t)->stream,
+                                                 &(PERPKT_DATA(t)->bottom));
 
         if (PERPKT_DATA(t)->top == NULL) {
@@ -1350 +1389 @@
 /* TODO: Fold this into dag_get_record */
 static dag_record_t *dag_pget_record(libtrace_t *libtrace,
-                                                                         libtrace_thread_t *t) {
+                                     libtrace_thread_t *t)
+{
         dag_record_t *erfptr = NULL;
         uint16_t size;
@@ -1367 +1407 @@
         PERPKT_DATA(t)->bottom += size;
         PERPKT_DATA(t)->processed += size;
-        
+
         return erfptr;
 }
 
 static int dag_pread_packet(libtrace_t *libtrace, libtrace_thread_t *t,
-                                                        libtrace_packet_t *packet) {
+                            libtrace_packet_t *packet)
+{
         dag_record_t *erfptr = NULL;
         int numbytes = 0;
@@ -1396 +1437 @@
 
         /* Configure DAG card stream polling */
-        if (dag_set_stream_poll(PERPKT_DATA(t)->device->fd, PERPKT_DATA(t)->stream,
-                                                        sizeof(dag_record_t), &maxwait, &pollwait) < 0) {
+        if (dag_set_stream_poll(PERPKT_DATA(t)->device->fd,
+                                PERPKT_DATA(t)->stream, sizeof(dag_record_t),
+                                &maxwait, &pollwait) < 0) {
                 trace_set_err(libtrace, errno, "dag_set_stream_poll");
                 return -1;
@@ -1411 +1453 @@
                                 return 0;
 
-                        /* Check message queue to see if we should abort early */
+                        /* Check message queue to see if we should
+                         * abort early */
                         if (libtrace_message_queue_count(&t->messages) > 0)
                                 return -2;
@@ -1424 +1467 @@
         /* Prepare the libtrace packet */
         if (dag_prepare_packet(libtrace, packet, erfptr, TRACE_RT_DATA_ERF,
-                                                   flags))
+                               flags))
                 return -1;
 
@@ -1433 +1476 @@
 }
 
-static int dag_ppause_input(libtrace_t *libtrace) {
+static int dag_ppause_input(libtrace_t *libtrace)
+{
         int i, tot = libtrace->perpkt_thread_count;
         struct dag_per_thread_t *t_data;
@@ -1443 +1487 @@
 
                 if (dag_stop_stream(t_data->device->fd,
-                                                        t_data->stream) < 0) {
-                        trace_set_err(libtrace, errno, "can't stop DAG stream #%u",
-                                                  t_data->stream);
+                                    t_data->stream) < 0) {
+                        trace_set_err(libtrace, errno,
+                                      "can't stop DAG stream #%u",
+                                      t_data->stream);
                         return -1;
                 }
 
                 if (dag_detach_stream(t_data->device->fd,
-                                                          t_data->stream) < 0) {
-                        trace_set_err(libtrace, errno, "can't detach DAG stream #%u",
-                                                  t_data->stream);
+                                      t_data->stream) < 0) {
+                        trace_set_err(libtrace, errno,
+                                      "can't detach DAG stream #%u",
+                                      t_data->stream);
                         return -1;
                 }
@@ -1465 +1511 @@
 
 static int dag_pconfig_input(libtrace_t *libtrace,
-                                                         trace_parallel_option_t option, void *value) {
-
+                             trace_parallel_option_t option, void *value)
+{
         /* We don't support any of these! Normally you configure the DAG card
          * externally. */
@@ -1485 +1531 @@
 
 static int dag_pregister_thread(libtrace_t *libtrace, libtrace_thread_t *t,
-                                                                bool reader) {
+                                bool reader)
+{
         /* XXX: This function gets run sequentially for all
          * threads. Should investigate making it parallel as draining the
@@ -1491 +1538 @@
          */
         uint8_t *top, *bottom;
-        uint8_t diff = 0; /* XXX: Investigate this type, as I would assume the value
-                                           * could be larger than 255 */
+        /* XXX: Investigate this type, as I would assume the value
+         * could be larger than 255 */
+        uint8_t diff = 0;
         struct timeval zero, nopoll;
 
@@ -1505 +1553 @@
                 if (t->type == THREAD_PERPKT) {
                         /* Pass the per thread data to the thread */
-                        t->format_data = &FORMAT_DATA->per_thread[t->perpkt_num];
+                        t->format_data =
+                                &FORMAT_DATA->per_thread[t->perpkt_num];
 
                         /* Attach and start the DAG stream */
-                        printf("t%u: starting and attaching stream #%u\n", t->perpkt_num,
-                                   PERPKT_DATA(t)->stream);
+                        printf("t%u: starting and attaching stream #%u\n",
+                               t->perpkt_num, PERPKT_DATA(t)->stream);
                         if (dag_attach_stream(PERPKT_DATA(t)->device->fd,
-                                                                  PERPKT_DATA(t)->stream, 0, 0) < 0) {
-                                trace_set_err(libtrace, errno, "can't attach DAG stream #%u",
-                                                          PERPKT_DATA(t)->stream);
+                                              PERPKT_DATA(t)->stream, 0,
+                                              0) < 0) {
+                                trace_set_err(libtrace, errno,
+                                              "can't attach DAG stream #%u",
+                                              PERPKT_DATA(t)->stream);
                                 return -1;
                         }
                         if (dag_start_stream(PERPKT_DATA(t)->device->fd,
-                                                                 PERPKT_DATA(t)->stream) < 0) {
-                                trace_set_err(libtrace, errno, "can't start DAG stream #%u",
-                                                          PERPKT_DATA(t)->stream);
+                                             PERPKT_DATA(t)->stream) < 0) {
+                                trace_set_err(libtrace, errno,
+                                              "can't start DAG stream #%u",
+                                              PERPKT_DATA(t)->stream);
                                 return -1;
                         }
@@ -1525 +1577 @@
                         /* Ensure that dag_advance_stream will return without blocking */
                         if(dag_set_stream_poll(PERPKT_DATA(t)->device->fd,
-                                                                   PERPKT_DATA(t)->stream, 0, &zero,
-                                                                   &nopoll) < 0) {
-                                trace_set_err(libtrace, errno, "dag_set_stream_poll failed!");
+                                               PERPKT_DATA(t)->stream, 0, &zero,
+                                               &nopoll) < 0) {
+                                trace_set_err(libtrace, errno,
+                                              "dag_set_stream_poll failed!");
                                 return -1;
                         }
@@ -1533 +1586 @@
                         /* Clear all the data from the memory hole */
                         do {
-                                top = dag_advance_stream(PERPKT_DATA(t)->device->fd,
-                                                                                 PERPKT_DATA(t)->stream,
-                                                                                 &bottom);
+                                top = dag_advance_stream(PERPKT_DATA(t)->
+                                                         device->fd,
+                                                         PERPKT_DATA(t)->stream,
+                                                         &bottom);
 
                                 assert(top && bottom);
@@ -1558 +1612 @@
 
 static struct libtrace_format_t dag = {
-        "dag",
-        "$Id$",
-        TRACE_FORMAT_ERF,
+        "dag",
+        "$Id$",
+        TRACE_FORMAT_ERF,
         dag_probe_filename,             /* probe filename */
         NULL,                           /* probe magic */
-        dag_init_input,                 /* init_input */
-        dag_config_input,               /* config_input */
-        dag_start_input,                /* start_input */
-        dag_pause_input,                /* pause_input */
+        dag_init_input,                 /* init_input */
+        dag_config_input,               /* config_input */
+        dag_start_input,                /* start_input */
+        dag_pause_input,                /* pause_input */
         dag_init_output,                /* init_output */
-        NULL,                           /* config_output */
+        NULL,                           /* config_output */
         dag_start_output,               /* start_output */
-        dag_fin_input,                  /* fin_input */
+        dag_fin_input,                  /* fin_input */
         dag_fin_output,                 /* fin_output */
-        dag_read_packet,                /* read_packet */
-        dag_prepare_packet,             /* prepare_packet */
+        dag_read_packet,                /* read_packet */
+        dag_prepare_packet,             /* prepare_packet */
         NULL,                           /* fin_packet */
         dag_write_packet,               /* write_packet */
-        erf_get_link_type,              /* get_link_type */
-        erf_get_direction,              /* get_direction */
-        erf_set_direction,              /* set_direction */
-        erf_get_erf_timestamp,          /* get_erf_timestamp */
-        NULL,                           /* get_timeval */
-        NULL,                           /* get_seconds */
+        erf_get_link_type,              /* get_link_type */
+        erf_get_direction,              /* get_direction */
+        erf_set_direction,              /* set_direction */
+        erf_get_erf_timestamp,          /* get_erf_timestamp */
+        NULL,                           /* get_timeval */
+        NULL,                           /* get_seconds */
         NULL,                           /* get_timespec */
-        NULL,                           /* seek_erf */
-        NULL,                           /* seek_timeval */
-        NULL,                           /* seek_seconds */
-        erf_get_capture_length,         /* get_capture_length */
-        erf_get_wire_length,            /* get_wire_length */
-        erf_get_framing_length,         /* get_framing_length */
-        erf_set_capture_length,         /* set_capture_length */
+        NULL,                           /* seek_erf */
+        NULL,                           /* seek_timeval */
+        NULL,                           /* seek_seconds */
+        erf_get_capture_length,         /* get_capture_length */
+        erf_get_wire_length,            /* get_wire_length */
+        erf_get_framing_length,         /* get_framing_length */
+        erf_set_capture_length,         /* set_capture_length */
         NULL,                           /* get_received_packets */
         NULL,                           /* get_filtered_packets */
         dag_get_dropped_packets,        /* get_dropped_packets */
         NULL,                           /* get_captured_packets */
-        NULL,                           /* get_fd */
-        trace_event_dag,                /* trace_event */
-        dag_help,                       /* help */
-        NULL,                            /* next pointer */
+        NULL,                           /* get_fd */
+        trace_event_dag,                /* trace_event */
+        dag_help,                       /* help */
+        NULL,                            /* next pointer */
                 {true, 0}, /* live packet capture, thread limit TBD */
                 dag_pstart_input,
@@ -1608 +1662 @@
 };
 
-void dag_constructor(void) {
+void dag_constructor(void)
+{
         register_format(&dag);
 }

lib/format_erf.c

@@ -480 +480 @@
                                         packet->buffer,
                                         (size_t)dag_record_size)) == -1) {
-                trace_set_err(libtrace,errno,"read(%s)",
-                                libtrace->uridata);
+                trace_set_err(libtrace,errno,"reading ERF file");
                 return -1;
         }
@@ -488 +487 @@
                 return 0;
         }
+
+        if (numbytes < (int)dag_record_size) {
+                trace_set_err(libtrace, TRACE_ERR_BAD_PACKET, "Incomplete ERF header");
+                return -1;
+        }
 
         rlen = ntohs(((dag_record_t *)packet->buffer)->rlen);
@@ -522 +526 @@
                 return -1;
         }
+
+        if (numbytes < (int)size) {
+                trace_set_err(libtrace, TRACE_ERR_BAD_PACKET, "Incomplete ERF record");
+                return -1;
+        }
         
         if (erf_prepare_packet(libtrace, packet, packet->buffer, 

lib/format_pcapfile.c

@@ -210 +210 @@
                 
                 if (err<1) {
-                        if (err == 0) {
-                                trace_set_err(libtrace, TRACE_ERR_INIT_FAILED,
-                                                "Reading pcap file header\n");
-                        }
+                        trace_set_err(libtrace, TRACE_ERR_INIT_FAILED,
+                                "Error while reading pcap file header\n");
                         return -1;
                 }
-                
+        
+                if (err != (int)sizeof(DATA(libtrace)->header)) {
+                        trace_set_err(libtrace, TRACE_ERR_INIT_FAILED,
+                                "Incomplete pcap file header");
+                        return -1;
+                }
+                
                 if (!header_is_magic(&(DATA(libtrace)->header))) {
                         trace_set_err(libtrace,TRACE_ERR_INIT_FAILED,
@@ -359 +363 @@
                         packet->buffer,
                         sizeof(libtrace_pcapfile_pkt_hdr_t));
-
         if (err<0) {
                 trace_set_err(libtrace,errno,"reading packet");
@@ -368 +371 @@
                 return 0;
         }
+
+        if (err < (int)sizeof(libtrace_pcapfile_pkt_hdr_t)) {
+                trace_set_err(libtrace, errno, "Incomplete pcap packet header");
+                return -1;
+        }
 
         bytes_to_read = swapl(libtrace,((libtrace_pcapfile_pkt_hdr_t*)packet->buffer)->caplen);
@@ -391 +399 @@
                         );
 
-        
         if (err<0) {
                 trace_set_err(libtrace,errno,"reading packet");
@@ -399 +406 @@
                 return 0;
         }
+
+        if (err < (int)bytes_to_read) {
+                trace_set_err(libtrace, errno, "Incomplete pcap packet body");
+                return -1;
+        }
 
         if (pcapfile_prepare_packet(libtrace, packet, packet->buffer,

lib/format_tsh.c

@@ -147 +147 @@
                 return 0;
         }
+
+        if (numbytes < (int)sizeof(tsh_pkt_header_t)) {
+                trace_set_err(libtrace, errno, "Incomplete TSH header");
+                return -1;
+        }
 
         buffer2 = (char*)buffer2 + numbytes;

lib/libtrace.h.in

@@ -109 +109 @@
             ((@LIBTRACE_MAJOR@<<16)|(@LIBTRACE_MID@<<8)|(@LIBTRACE_MINOR@))
 
-/** Replaced with the current SVN revision number when 'make dist' is invoked
- *  to create a distributable tarball */
-#define LIBTRACE_SVN_REVISION 0
+/** This used to be replaced with the current SVN revision number when 
+ * 'make dist' was invoked to create a distributable tarball. We don't use
+ * SVN anymore and there probably isn't any need to know the exact revision
+ * number either these days. */
+#define LIBTRACE_SVN_REVISION LIBTRACE_API_VERSION
 
 /** DAG driver version installed on the current system */

libwandio/ior-zlib.c

@@ -56 +56 @@
         int outoffset;
         enum err_t err;
+        size_t sincelastend;
 };
 
@@ -83 +84 @@
         DATA(io)->strm.opaque = NULL;
         DATA(io)->err = ERR_OK;
+        DATA(io)->sincelastend = 1;
 
         inflateInit2(&DATA(io)->strm, 15 | 32);
@@ -108 +110 @@
                                 sizeof(DATA(io)->inbuff));
                         if (bytes_read == 0) {
-                                /* EOF */
+                                /* If we get EOF immediately after a 
+                                 * Z_STREAM_END, then we assume we've reached 
+                                 * the end of the file. If there was data 
+                                 * between the Z_STREAM_END and the EOF, the
+                                 * file has more likely been truncated.
+                                 */
+                                if (DATA(io)->sincelastend > 0) {
+                                        fprintf(stderr, "Unexpected EOF while reading compressed file -- file is probably incomplete\n");
+                                        errno = EIO;
+                                        DATA(io)->err = ERR_ERROR;
+                                        return -1;
+                                }
+
+                                /* EOF */
                                 if (DATA(io)->strm.avail_out == (uint32_t)len) {
-                                        DATA(io)->err = ERR_EOF;
+                                        DATA(io)->err = ERR_EOF;
                                         return 0;
                                 }
@@ -128 +143 @@
                         DATA(io)->strm.next_in = DATA(io)->inbuff;
                         DATA(io)->strm.avail_in = bytes_read;
+                        DATA(io)->sincelastend += bytes_read;
                 }
                 /* Decompress some data into the output buffer */
@@ -144 +160 @@
                                 inflateInit2(&DATA(io)->strm, 15 | 32);
                                 DATA(io)->err = ERR_OK;
+                                DATA(io)->sincelastend = 0;
                                 break;
                         default:

tools/tracestats/tracestats.c

@@ -157 +157 @@
 
         if (trace_is_err(trace))
-                trace_perror(trace,"%s",uri);
+                trace_perror(trace,"Processing trace");
 
         trace_destroy(trace);