Changes in / [4cc6e74:97d170d]

Files:

• Makefile.am (modified) (1 diff)
• lib/format_dag25.c (modified) (7 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

@@ -161 +161 @@
          * structures. Most of the stuff above doesn't get used in parallel mode. */
         struct dag_per_thread_t *per_thread;
+
+        uint8_t seeninterface[4];
 };
 
@@ -241 +243 @@
         FORMAT_DATA->bottom = NULL;
         FORMAT_DATA->top = NULL;
+        memset(FORMAT_DATA->seeninterface, 0, sizeof(FORMAT_DATA->seeninterface));
 }
 
@@ -290 +293 @@
         dag_close(dev->fd);
         if (dev->dev_name)
-        free(dev->dev_name);
+                free(dev->dev_name);
         free(dev);
 }
@@ -575 +578 @@
 
         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;
@@ -599 +602 @@
 static int dag_start_input(libtrace_t *libtrace) {
         struct timeval zero, nopoll;
-        uint8_t *top, *bottom;
-        uint8_t diff = 0;
+        uint8_t *top, *bottom, *starttop;
+        uint64_t diff = 0;
         top = bottom = NULL;
 
@@ -626 +629 @@
                                 &nopoll);
 
+        starttop = dag_advance_stream(FORMAT_DATA->device->fd,
+                                        FORMAT_DATA->dagstream,
+                                        &bottom);
+
         /* Should probably flush the memory hole now */
-        do {
+        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->top = top;
+        FORMAT_DATA->bottom = bottom;
         FORMAT_DATA->processed = 0;
         FORMAT_DATA->drops = 0;
@@ -867 +872 @@
                         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);
+                        }
                 }
         }

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);