Changes in / [823d8e1:47d64ce]

Files:

• AUTHORS (modified) (1 diff)
• README (modified) (1 diff)
• configure.in (modified) (5 diffs)
• lib/data-struct/simple_circular_buffer.c (modified) (5 diffs)
• lib/data-struct/simple_circular_buffer.h (modified) (1 diff)
• lib/format_bpf.c (modified) (2 diffs)
• lib/format_dpdk.c (modified) (4 diffs)
• lib/format_linux_common.c (modified) (1 diff)
• lib/format_linux_ring.c (modified) (2 diffs)
• lib/format_pcapng.c (modified) (36 diffs)
• lib/libtrace.h.in (modified) (1 diff)
• lib/protocols_pktmeta.c (modified) (1 diff)
• lib/trace.c (modified) (3 diffs)
• lib/trace_parallel.c (modified) (1 diff)
• libpacketdump/Makefile.am (modified) (2 diffs)
• libpacketdump/eth_2054.c (modified) (4 diffs)
• tools/tracereport/misc_report.c (modified) (1 diff)
• tools/tracesplit/tracesplit.c (modified) (1 diff)

AUTHORS

@@ -36 +36 @@
  * Anthony Coddington for adding ERF provenance support and fixing a number
    of other ERF/DAG issues
+ * Tim Dawson for fixing issues with building against musl libc
  * Hendrik Leppelsack for reporting and fixing some errors in the tool manpages
  * Jamie Curtis for fixing a couple of bugs many many years ago

README

@@ -1 @@
-libtrace 4.0.3
+libtrace 4.0.4
 
 ---------------------------------------------------------------------------

configure.in

@@ -4 +4 @@
 # and in the README
 
-AC_INIT([libtrace],[4.0.3],[contact@wand.net.nz],[libtrace])
+AC_INIT([libtrace],[4.0.4],[contact@wand.net.nz],[libtrace])
 
 LIBTRACE_MAJOR=4
 LIBTRACE_MID=0
-LIBTRACE_MINOR=3
+LIBTRACE_MINOR=4
 
 # OpenSolaris hides libraries like libncurses in /usr/gnu/lib, which is not
@@ -198 +198 @@
 
 # Check for libwandio (no longer bundled with libtrace)
-AC_CHECK_LIB(wandio,wandio_create,wandiofound=1,wandiofound=0)
+AC_CHECK_LIB(wandio,wandio_wflush,wandiofound=1,wandiofound=0)
 if test "$wandiofound" = 0; then
-        AC_MSG_ERROR(libwandio is required to compile libtrace. If you have installed it in a non-standard location please use LDFLAGS to specify the location of the library. WANDIO can be obtained from http://research.wand.net.nz/software/libwandio.php)
+        AC_MSG_ERROR(libwandio 1.0.5 or better is required to compile this version of libtrace. If you have installed libwandio in a non-standard location please use LDFLAGS to specify the location of the library. WANDIO can be obtained from http://research.wand.net.nz/software/libwandio.php)
 else
         LIBTRACE_LIBS="$LIBTRACE_LIBS -lwandio"
@@ -485 +485 @@
         with_numa=yes
 else
-        AC_DEFINE(HAVE_LIBNUMA, 0, [Set to 1 if libnuma is supported])
         with_numa=no
 fi
@@ -494 +493 @@
         wandder_avail=yes
 else
-        AC_DEFINE(HAVE_WANDDER, 0, [Set to 1 if libwandder is available])
         wandder_avail=no
 fi
@@ -545 +543 @@
         with_clock_gettime=yes
 else
-        AC_DEFINE(HAVE_CLOCK_GETTIME, 0, [Set to 1 if clock_gettime is supported])
         with_clock_gettime=no
 fi

lib/data-struct/simple_circular_buffer.c

@@ -10 +10 @@
 #include <fcntl.h>
 #include <sys/socket.h>
+#include <errno.h>
 
 #include "simple_circular_buffer.h"
 
-DLLEXPORT void libtrace_scb_init(libtrace_scb_t *buf, uint32_t size,
+DLLEXPORT int libtrace_scb_init(libtrace_scb_t *buf, uint32_t size,
                 uint16_t id) {
 
@@ -28 +29 @@
         buf->fd = shm_open(anonname, O_RDWR | O_CREAT, 0600);
 #endif
-        ftruncate(buf->fd, size);
-
-        buf->address = mmap(NULL, 2 * size, PROT_NONE,
-                        MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
-        mmap(buf->address, size, PROT_READ | PROT_WRITE,
-                        MAP_SHARED | MAP_FIXED, buf->fd, 0);
-        mmap(buf->address + size, size, PROT_READ | PROT_WRITE,
-                        MAP_SHARED | MAP_FIXED, buf->fd, 0);
+        if (ftruncate(buf->fd, size) < 0) {
+                perror("ftruncate in libtrace_scb_init");
+                close(buf->fd);
+                buf->fd = -1;
+                buf->address = NULL;
+        } else {
+                buf->address = mmap(NULL, 2 * size, PROT_NONE,
+                                MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+                mmap(buf->address, size, PROT_READ | PROT_WRITE,
+                                MAP_SHARED | MAP_FIXED, buf->fd, 0);
+                mmap(buf->address + size, size, PROT_READ | PROT_WRITE,
+                                MAP_SHARED | MAP_FIXED, buf->fd, 0);
+        }
         buf->read_offset = 0;
         buf->write_offset = 0;
         buf->count_bytes = size;
+
+        if (buf->address) {
+                return 0;
+        }
+        return -1;
 }
 
@@ -44 +55 @@
         /* TODO shm_unlink the file name if we used shm_open? */
 
-        munmap(buf->address, buf->count_bytes * 2);
-        close(buf->fd);
+        if (buf->address) {
+                munmap(buf->address, buf->count_bytes * 2);
+        }
+        if (buf->fd != -1) {
+                close(buf->fd);
+        }
 }
 
@@ -52 +67 @@
         int space = buf->count_bytes - (buf->write_offset - buf->read_offset);
         int ret;
+
+        if (buf->address == NULL) {
+                return -1;
+        }
 
         if (space == 0) {
@@ -68 +87 @@
                 uint32_t *available) {
 
+        if (buf->address == NULL) {
+                return NULL;
+        }
         *available = buf->write_offset - buf->read_offset;
         return buf->address + buf->read_offset;

lib/data-struct/simple_circular_buffer.h

@@ -13 +13 @@
 
 
-DLLEXPORT void libtrace_scb_init(libtrace_scb_t *buf, uint32_t size,
+DLLEXPORT int libtrace_scb_init(libtrace_scb_t *buf, uint32_t size,
                 uint16_t id);
 DLLEXPORT void libtrace_scb_destroy(libtrace_scb_t *buf);

lib/format_bpf.c

@@ -371 +371 @@
                         /* TODO investigate hashing in BSD? */
                         break;
-
+                case TRACE_OPTION_REPLAY_SPEEDUP:
+                        break;
                 /* Avoid default: so that future options will cause a warning
                  * here to remind us to implement it, or flag it as
@@ -616 +617 @@
         NULL,                   /* fin_packet */
         NULL,                   /* write_packet */
+        NULL,                   /* flush_output */
         bpf_get_link_type,      /* get_link_type */
         bpf_get_direction,      /* get_direction */

lib/format_dpdk.c

@@ -57 +57 @@
 #include <math.h>
 
-#if HAVE_LIBNUMA
+#ifdef HAVE_LIBNUMA
 #include <numa.h>
 #endif
@@ -460 +460 @@
         }
 
-#if HAVE_LIBNUMA
+#ifdef HAVE_LIBNUMA
         format_data->nic_numa_node = pci_to_numa(&use_addr);
         if (my_cpu < 0) {
@@ -702 +702 @@
         case TRACE_OPTION_META_FREQ:
         case TRACE_OPTION_EVENT_REALTIME:
+        case TRACE_OPTION_REPLAY_SPEEDUP:
                 break;
         /* Avoid default: so that future options will cause a warning
@@ -891 +892 @@
          * these to any particular physical core */
         if (real) {
-#if HAVE_LIBNUMA
+#ifdef HAVE_LIBNUMA
                 for (i = 0; i < RTE_MAX_LCORE; ++i) {
                         if (!rte_lcore_is_enabled(i) && numa_node_of_cpu(i) == socket) {

lib/format_linux_common.c

@@ -87 +87 @@
                 sock = socket(PF_INET, SOCK_STREAM, 0);
                 memset(&ifr, 0, sizeof(struct ifreq));
-                strncpy(ifr.ifr_name, libtrace->uridata, IF_NAMESIZE);
+                strncpy(ifr.ifr_name, libtrace->uridata, IF_NAMESIZE - 1);
                 if (ioctl(sock, SIOCGIFHWADDR, &ifr) != 0) {
                         perror("Can't get HWADDR for interface");

lib/format_linux_ring.c

@@ -61 +61 @@
         ((mac) > (hdrend) && (mac) < (net) ? (mac) : (net))
 
+static pthread_mutex_t pagesize_mutex;
 #ifdef HAVE_NETPACKET_PACKET_H
 /* Get current frame in the ring buffer*/
@@ -71 +72 @@
 static int pagesize = 0;
 
-static pthread_mutex_t pagesize_mutex;
 
 /*

lib/format_pcapng.c

@@ -173 +173 @@
 };
 
+typedef struct pcapng_peeker pcapng_hdr_t;
+
 
 #define DATA(x) ((struct pcapng_format_data_t *)((x)->format_data))
@@ -287 +289 @@
 
 static char *pcapng_parse_next_option(libtrace_t *libtrace, char **pktbuf,
-                uint16_t *code, uint16_t *length) {
+                uint16_t *code, uint16_t *length, pcapng_hdr_t *blockhdr) {
 
         struct pcapng_optheader *opthdr = (struct pcapng_optheader *)*pktbuf;
         int to_skip;
         int padding = 0;
+        char *eob; //end of block
         char *optval;
+        if (DATA(libtrace)->byteswapped) {
+                eob = ((char *) blockhdr) + byteswap32(blockhdr->blocklen);
+        } else {
+                eob = ((char *) blockhdr) + blockhdr->blocklen;
+        }
+
+        assert((char *)blockhdr < *pktbuf);
+        // Check if we have reached the end of the block, +4 for trailing block-size
+        // We cannot assume a endofopt, so we add one
+        if (eob == (*pktbuf) + 4) {
+                *code = 0;
+                *length = 0;
+                return *pktbuf;
+        }
+        // If there is not enough space for another header we've encountered an error
+        if (eob < (*pktbuf) + 4 + sizeof(struct pcapng_optheader)) {
+                return NULL;
+        }
 
         if (DATA(libtrace)->byteswapped) {
@@ -311 +332 @@
 
         to_skip = (*length) + padding;
+        // Check the value we return is within the block length
+        if (eob < optval + to_skip + 4) {
+                return NULL;
+        }
         *pktbuf = optval + to_skip;
 
         return optval;
-}
-
-static inline int skip_block(libtrace_t *libtrace, uint32_t toread) {
-        int err;
-
-        while (toread > 0) {
-                char buf[4096];
-                int nextread;
-
-                if (toread < 4096) {
-                        nextread = toread;
-                } else {
-                        nextread = 4096;
-                }
-
-                err = wandio_read(libtrace->io, buf, nextread);
-                if (err < 0) {
-                        trace_set_err(libtrace, TRACE_ERR_WANDIO_FAILED,
-                                "Reading section header options");
-                        return -1;
-                }
-                if (err == 0) {
-                        return 0;
-                }
-                toread -= err;
-        }
-
-        return 1;
-
 }
 
@@ -353 +349 @@
         if (err < 0) {
                 trace_set_err(libtrace, TRACE_ERR_WANDIO_FAILED,
-                        "Failed to read pcapng interface options");
+                        "Failed reading pcapng block");
                 return err;
         }
@@ -363 +359 @@
         if (err < (int)to_read) {
                 trace_set_err(libtrace, TRACE_ERR_BAD_PACKET,
-                        "Incomplete pcapng interface header block");
+                        "Incomplete pcapng block");
                 return -1;
         }
@@ -454 +450 @@
         }
 
-        if (err < (int)(sizeof(sechdr))) {
+        if (err < (int)(sizeof(pcapng_sec_t))) {
                 trace_set_err(libtrace, TRACE_ERR_BAD_PACKET,
                         "Incomplete pcapng section header block");
@@ -491 +487 @@
         /* Read all of the options etc. -- we don't need them for now, but
          * we have to skip forward to the next useful header. */
-        bodyptr = packet->buffer + sizeof(pcapng_sec_t);
+        bodyptr = (char *) packet->buffer + sizeof(pcapng_sec_t);
         err = pcapng_read_body(libtrace, bodyptr, to_read);
         if (err <= 0) {
@@ -507 +503 @@
 
 static int pcapng_read_interface(libtrace_t *libtrace,
-                libtrace_packet_t *packet, uint32_t flags) {
+                libtrace_packet_t *packet, uint32_t blocklen, uint32_t flags) {
 
         pcapng_int_t *inthdr;
-        int err;
-        uint32_t to_read;
         pcapng_interface_t *newint;
         uint16_t optcode, optlen;
@@ -517 +511 @@
         char *bodyptr = NULL;
 
-        err = wandio_read(libtrace->io, packet->buffer, sizeof(pcapng_int_t));
-
-        if (err < 0) {
-                trace_set_err(libtrace, TRACE_ERR_WANDIO_FAILED,
-                        "Reading pcapng interface header block");
-                return -1;
-        }
-
-        if (err == 0) {
-                return 0;
-        }
-
-        if (err < (int)sizeof(inthdr)) {
+        if (blocklen < sizeof(pcapng_int_t) + 4) {
                 trace_set_err(libtrace, TRACE_ERR_BAD_PACKET,
                         "Incomplete pcapng interface header block");
@@ -552 +534 @@
                 newint->snaplen = byteswap32(inthdr->snaplen);
                 newint->linktype = byteswap16(inthdr->linktype);
-                to_read = byteswap32(inthdr->blocklen) - sizeof(pcapng_int_t);
         } else {
                 assert(inthdr->blocktype == PCAPNG_INTERFACE_TYPE);
                 newint->snaplen = inthdr->snaplen;
                 newint->linktype = inthdr->linktype;
-                to_read = inthdr->blocklen - sizeof(pcapng_int_t);
         }
 
@@ -566 +546 @@
                         DATA(libtrace)->allocatedinterfaces * sizeof(
                                 pcapng_interface_t *));
-
-                /* Could memset the new memory to zero, if required */
+                memset(&DATA(libtrace)->interfaces[DATA(libtrace)->nextintid], 0, sizeof(void *) * 10);
         }
 
@@ -573 +552 @@
         DATA(libtrace)->nextintid += 1;
 
-        bodyptr = packet->buffer + sizeof(pcapng_int_t);
-        err = pcapng_read_body(libtrace, bodyptr, to_read);
-        if (err <= 0) {
-                return err;
-        }
+        bodyptr = (char *) packet->buffer + sizeof(pcapng_int_t);
 
         packet->type = TRACE_RT_PCAPNG_META;
@@ -588 +563 @@
         do {
                 optval = pcapng_parse_next_option(libtrace, &bodyptr,
-                                &optcode, &optlen);
+                                &optcode, &optlen, (pcapng_hdr_t *) packet->buffer);
                 if (optval == NULL) {
                         trace_set_err(libtrace, TRACE_ERR_BAD_PACKET,
@@ -608 +583 @@
         } while (optcode != 0);
 
-        return 1;
+        return (int) blocklen;
 
 }
 
 static int pcapng_read_nrb(libtrace_t *libtrace, libtrace_packet_t *packet,
-                uint32_t flags) {
+                uint32_t blocklen, uint32_t flags) {
 
         /* Just read the NR records and pass them off to the caller. If
@@ -620 +595 @@
          */
         pcapng_nrb_t *hdr = NULL;
-        int err;
-        uint32_t to_read;
-        char *bodyptr;
-
-        err = wandio_read(libtrace->io, packet->buffer, sizeof(pcapng_nrb_t));
-
-        if (err < 0) {
-                trace_set_err(libtrace, TRACE_ERR_WANDIO_FAILED, "reading pcapng name resolution block");
-                return -1;
-        }
-
-        if (err == 0) {
-                return 0;
-        }
-
-        if (err < (int)sizeof(pcapng_nrb_t)) {
+
+        if (blocklen < sizeof(pcapng_nrb_t) + 4) {
                 trace_set_err(libtrace, TRACE_ERR_BAD_PACKET,
                                 "Incomplete pcapng name resolution block");
@@ -646 +607 @@
         if (DATA(libtrace)->byteswapped) {
                 assert(byteswap32(hdr->blocktype) == PCAPNG_NAME_RESOLUTION_TYPE);
-                to_read = byteswap32(hdr->blocklen) - sizeof(pcapng_nrb_t);
         } else {
                 assert(hdr->blocktype == PCAPNG_NAME_RESOLUTION_TYPE);
-                to_read = hdr->blocklen - sizeof(pcapng_nrb_t);
-        }
-
-        bodyptr = packet->buffer + sizeof(pcapng_nrb_t);
-        err = pcapng_read_body(libtrace, bodyptr, to_read);
-        if (err <= 0) {
-                return err;
         }
 
@@ -664 +617 @@
         }
 
-        return sizeof(pcapng_nrb_t) + to_read;
+        return (int) blocklen;
 
 }
 
 static int pcapng_read_custom(libtrace_t *libtrace, libtrace_packet_t *packet,
-                uint32_t flags) {
+                uint32_t blocklen, uint32_t flags) {
 
         /* Just read the custom records and pass them off to the caller. If
@@ -676 +629 @@
          */
         pcapng_custom_t *hdr = NULL;
-        int err;
-        uint32_t to_read;
-        char *bodyptr;
-
-        err = wandio_read(libtrace->io, packet->buffer, sizeof(pcapng_custom_t));
-
-        if (err < 0) {
-                trace_set_err(libtrace, TRACE_ERR_WANDIO_FAILED, "reading pcapng custom block");
-                return -1;
-        }
-
-        if (err == 0) {
-                return 0;
-        }
-
-        if (err < (int)sizeof(pcapng_custom_t)) {
+
+        if (blocklen < sizeof(pcapng_custom_t) + 4) {
                 trace_set_err(libtrace, TRACE_ERR_BAD_PACKET,
                                 "Incomplete pcapng custom block");
@@ -703 +642 @@
                 assert(byteswap32(hdr->blocktype) == PCAPNG_CUSTOM_TYPE ||
                         byteswap32(hdr->blocktype) == PCAPNG_CUSTOM_NONCOPY_TYPE);
-                to_read = byteswap32(hdr->blocklen) - sizeof(pcapng_custom_t);
-        } else {
-                assert(hdr->blocktype == PCAPNG_NAME_RESOLUTION_TYPE ||
+        } else {
+                assert(hdr->blocktype == PCAPNG_CUSTOM_TYPE ||
                         hdr->blocktype == PCAPNG_CUSTOM_NONCOPY_TYPE);
-                to_read = hdr->blocklen - sizeof(pcapng_custom_t);
-        }
-
-        bodyptr = packet->buffer + sizeof(pcapng_custom_t);
-        err = pcapng_read_body(libtrace, bodyptr, to_read);
-        if (err <= 0) {
-                return err;
         }
 
@@ -722 +653 @@
         }
 
-        return sizeof(pcapng_custom_t) + to_read;
+        return (int) blocklen;
 
 }
 
 static int pcapng_read_stats(libtrace_t *libtrace, libtrace_packet_t *packet,
-                uint32_t flags) {
+                uint32_t blocklen, uint32_t flags) {
         pcapng_stats_t *hdr = NULL;
-        int err;
-        uint32_t to_read;
         uint32_t ifaceid;
         uint64_t timestamp;
@@ -738 +667 @@
         char *bodyptr;
 
-        err = wandio_read(libtrace->io, packet->buffer, sizeof(pcapng_stats_t));
-
-        if (err < 0) {
-                trace_set_err(libtrace, TRACE_ERR_WANDIO_FAILED, "reading pcapng interface stats");
-                return -1;
-        }
-
-        if (err == 0) {
-                return 0;
-        }
-
-        if (err < (int)sizeof(pcapng_stats_t)) {
+        if (blocklen < sizeof(pcapng_stats_t) + 4) {
                 trace_set_err(libtrace, TRACE_ERR_BAD_PACKET,
                                 "Incomplete pcapng interface stats header");
@@ -760 +678 @@
         if (DATA(libtrace)->byteswapped) {
                 assert(byteswap32(hdr->blocktype) == PCAPNG_INTERFACE_STATS_TYPE);
-                to_read = byteswap32(hdr->blocklen) - sizeof(pcapng_stats_t);
                 ifaceid = byteswap32(hdr->interfaceid);
                 timestamp = ((uint64_t)(byteswap32(hdr->timestamp_high)) << 32) + byteswap32(hdr->timestamp_low);
         } else {
                 assert(hdr->blocktype == PCAPNG_INTERFACE_STATS_TYPE);
-                to_read = hdr->blocklen - sizeof(pcapng_stats_t);
                 ifaceid = hdr->interfaceid;
                 timestamp = ((uint64_t)(hdr->timestamp_high) << 32) +
                                 hdr->timestamp_low;
-        }
-
-        bodyptr = packet->buffer + sizeof(pcapng_stats_t);
-        err = pcapng_read_body(libtrace, bodyptr, to_read);
-        if (err <= 0) {
-                return err;
         }
 
@@ -791 +701 @@
 
         if (timestamp < interface->laststats) {
-                return sizeof(pcapng_stats_t) + to_read;
+                return (int) blocklen;
         }
 
@@ -799 +709 @@
         do {
                 optval = pcapng_parse_next_option(packet->trace, &bodyptr,
-                                &optcode, &optlen);
+                                &optcode, &optlen, (pcapng_hdr_t *) packet->buffer);
                 if (optval == NULL) {
                         trace_set_err(libtrace, TRACE_ERR_BAD_PACKET,
-                                "Failed to read options for pcapng enhanced packet");
+                                "Failed to read options for pcapng interface stats");
                         return -1;
                 }
@@ -845 +755 @@
         interface->laststats = timestamp;
 
-        return sizeof(pcapng_stats_t) + to_read;
+        return (int) blocklen;
 
 }
 
 static int pcapng_read_simple(libtrace_t *libtrace, libtrace_packet_t *packet,
-                uint32_t flags) {
-
-        int err;
-        uint32_t to_read;
+                uint32_t blocklen, uint32_t flags) {
+
         uint32_t caplen;
         pcapng_spkt_t *hdr = NULL;
         pcapng_interface_t *interface;
-        char *bodyptr;
-
-        err = wandio_read(libtrace->io, packet->buffer, sizeof(pcapng_spkt_t));
-
-        if (err < 0) {
-                trace_set_err(libtrace, TRACE_ERR_WANDIO_FAILED, "reading pcapng simple packet");
-                return -1;
-        }
-
-        if (err == 0) {
-                return 0;
-        }
-
-        if (err < (int)sizeof(pcapng_spkt_t)) {
+
+        if (blocklen < sizeof(pcapng_spkt_t) + 4) {
                 trace_set_err(libtrace, TRACE_ERR_BAD_PACKET,
                                 "Incomplete pcapng simple packet header");
@@ -881 +777 @@
         if (DATA(libtrace)->byteswapped) {
                 assert(byteswap32(hdr->blocktype) == PCAPNG_SIMPLE_PACKET_TYPE);
-                to_read = byteswap32(hdr->blocklen) - sizeof(pcapng_spkt_t);
-                caplen = to_read - 4;   /* account for trailing length field */
+                caplen = byteswap32(hdr->blocklen) - sizeof(pcapng_spkt_t) - 4;
+                         /* account for trailing length field */
         } else {
                 assert(hdr->blocktype == PCAPNG_SIMPLE_PACKET_TYPE);
-                to_read = hdr->blocklen - sizeof(pcapng_spkt_t);
-                caplen = to_read - 4; /* account for trailing length field */
-        }
-
-        bodyptr = packet->buffer + sizeof(pcapng_spkt_t);
-        err = pcapng_read_body(libtrace, bodyptr, to_read);
-        if (err <= 0) {
-                return err;
+                caplen = hdr->blocklen - sizeof(pcapng_spkt_t) - 4;
+                         /* account for trailing length field */
         }
 
@@ -912 +802 @@
                 return -1;
         }
-        return sizeof(pcapng_spkt_t) + to_read;
+        return (int) blocklen;
 
 }
 
 static int pcapng_read_enhanced(libtrace_t *libtrace, libtrace_packet_t *packet,
-                uint32_t flags) {
+                uint32_t blocklen, uint32_t flags) {
         pcapng_epkt_t *hdr = NULL;
-        int err;
-        uint32_t to_read;
         uint32_t caplen;
         uint32_t ifaceid;
@@ -928 +816 @@
         char *bodyptr;
 
-        err = wandio_read(libtrace->io, packet->buffer, sizeof(pcapng_epkt_t));
-
-        if (err < 0) {
-                trace_set_err(libtrace, TRACE_ERR_WANDIO_FAILED, "reading pcapng enhanced packet");
-                return -1;
-        }
-
-        if (err == 0) {
-                return 0;
-        }
-
-        if (err < (int)sizeof(pcapng_epkt_t)) {
+        if (blocklen < (int)sizeof(pcapng_epkt_t) + 4) {
                 trace_set_err(libtrace, TRACE_ERR_BAD_PACKET,
                                 "Incomplete pcapng enhanced packet header");
@@ -951 +828 @@
                 assert(byteswap32(hdr->blocktype) == PCAPNG_ENHANCED_PACKET_TYPE);
                 caplen = byteswap32(hdr->caplen);
-                to_read = byteswap32(hdr->blocklen) - sizeof(pcapng_epkt_t);
                 ifaceid = byteswap32(hdr->interfaceid);
         } else {
                 assert(hdr->blocktype == PCAPNG_ENHANCED_PACKET_TYPE);
                 caplen = hdr->caplen;
-                to_read = hdr->blocklen - sizeof(pcapng_epkt_t);
                 ifaceid = hdr->interfaceid;
         }
 
-        bodyptr = packet->buffer + sizeof(pcapng_epkt_t);
-        err = pcapng_read_body(libtrace, bodyptr, to_read);
-        if (err <= 0) {
-                return err;
-        }
+        bodyptr = (char *) packet->buffer + sizeof(pcapng_epkt_t);
 
         /* Set packet type based on interface linktype */
@@ -985 +856 @@
         /* Make sure to parse any useful options */
         if ((caplen % 4) == 0) {
-                bodyptr = packet->payload + caplen;
-        } else {
-                bodyptr = packet->payload + caplen + (4 - (caplen % 4));
+                bodyptr = (char *) packet->payload + caplen;
+        } else {
+                bodyptr = (char *) packet->payload + caplen + (4 - (caplen % 4));
+        }
+        // Check the packet caplen actually fits within the block we read
+        if ((char *) packet->buffer + blocklen < bodyptr + 4) {
+                trace_set_err(libtrace, TRACE_ERR_BAD_PACKET,
+                                "Incomplete pcapng enhanced packet header");
+                return -1;
         }
 
         do {
                 optval = pcapng_parse_next_option(packet->trace, &bodyptr,
-                                &optcode, &optlen);
+                                &optcode, &optlen, (pcapng_hdr_t *) packet->buffer);
                 if (optval == NULL) {
                         trace_set_err(libtrace, TRACE_ERR_BAD_PACKET,
@@ -1009 +886 @@
 
         } while (optcode != 0);
-        return sizeof(pcapng_epkt_t) + to_read;
+        return (int) blocklen;
 
 }
@@ -1053 +930 @@
                 }
 
+                // Warning: the byteorder might not be set yet, the section header sets this
                 if (DATA(libtrace)->byteswapped) {
                         btype = byteswap32(peeker.blocktype);
+                        to_read = byteswap32(peeker.blocklen);
                 } else {
                         btype = peeker.blocktype;
+                        to_read = peeker.blocklen;
+                }
+
+                // Check we won't read off the end of the packet buffer. Assuming corruption.
+                // Exclude the SECTION header, as this is used to identify the byteorder
+                if (to_read > LIBTRACE_PACKET_BUFSIZE && btype != PCAPNG_SECTION_TYPE) {
+                        trace_set_err(libtrace, TRACE_ERR_BAD_PACKET,
+                                      "Oversized pcapng block found, is the trace corrupted?");
+                        return -1;
+                }
+                if (btype != PCAPNG_SECTION_TYPE) {
+                        // Read the entire block, unless it is a section as our byte ordering has
+                        // not been set yet.
+                        err = pcapng_read_body(libtrace, packet->buffer, to_read);
+                        if (err <= 0) {
+                                return err;
+                        }
+                        if (*((uint32_t *)((char *)packet->buffer+to_read-4)) != peeker.blocklen) {
+                                trace_set_err(libtrace, TRACE_ERR_BAD_PACKET,
+                                              "Mismatched pcapng block sizes found, trace is invalid.");
+                                return -1;
+                        }
                 }
 
@@ -1068 +969 @@
                         /* Interface Header */
                         case PCAPNG_INTERFACE_TYPE:
-                                err = pcapng_read_interface(libtrace, packet, flags);
+                                err = pcapng_read_interface(libtrace, packet, to_read, flags);
                                 gotpacket = 1;
                                 break;
@@ -1075 +976 @@
                         case PCAPNG_ENHANCED_PACKET_TYPE:
                                 err = pcapng_read_enhanced(libtrace, packet,
-                                                flags);
+                                                to_read, flags);
                                 gotpacket = 1;
                                 break;
 
                         case PCAPNG_SIMPLE_PACKET_TYPE:
-                                err = pcapng_read_simple(libtrace, packet, flags);
+                                err = pcapng_read_simple(libtrace, packet, to_read, flags);
                                 gotpacket = 1;
                                 break;
 
                         case PCAPNG_INTERFACE_STATS_TYPE:
-                                err = pcapng_read_stats(libtrace, packet, flags);
+                                err = pcapng_read_stats(libtrace, packet, to_read, flags);
                                 gotpacket = 1;
                                 break;
 
                         case PCAPNG_NAME_RESOLUTION_TYPE:
-                                err = pcapng_read_nrb(libtrace, packet, flags);
+                                err = pcapng_read_nrb(libtrace, packet, to_read, flags);
                                 gotpacket = 1;
                                 break;
@@ -1096 +997 @@
                         case PCAPNG_CUSTOM_TYPE:
                         case PCAPNG_CUSTOM_NONCOPY_TYPE:
-                                err = pcapng_read_custom(libtrace, packet, flags);
+                                err = pcapng_read_custom(libtrace, packet, to_read, flags);
                                 gotpacket = 1;
                                 break;
@@ -1106 +1007 @@
                         /* Everything else -- don't care, skip it */
                         default:
-                                if (DATA(libtrace)->byteswapped) {
-                                        to_read = byteswap32(peeker.blocklen);
-                                } else {
-                                        to_read = peeker.blocklen;
-                                }
-                                err = skip_block(libtrace, to_read);
                                 break;
                 }

lib/libtrace.h.in

@@ -277 +277 @@
 typedef struct trace_err_t{
         int err_num;            /**< error code */
-        char problem[255];      /**< the format, uri etc that caused the error for reporting purposes */
+        char problem[1024];     /**< the format, uri etc that caused the error for reporting purposes */
 } libtrace_err_t;
 

lib/protocols_pktmeta.c

@@ -142 +142 @@
 
 #else
-        *remaining = NULL;
+        (void)link;
+        (void)type;
+        *remaining = 0;
         return NULL;
 #endif

lib/trace.c

@@ -107 +107 @@
  * will use our own one that does
  */
-static void xstrncpy(char *dest, const char *src, size_t n)
-{
-        strncpy(dest,src,n);
-        dest[n]='\0';
+static inline void xstrncpy(char *dest, const char *src, size_t n,
+                size_t destlen)
+{
+        size_t slen = destlen - 1;
+        if (n < slen) {
+                slen = n;
+        }
+        strncpy(dest,src,slen);
+        dest[slen]='\0';
 }
 
@@ -120 +125 @@
                 exit(EXIT_FAILURE);
         }
-        xstrncpy(ret,src,n);
+        xstrncpy(ret,src,n,n+1);
         return ret;
 }
@@ -371 +376 @@
 
         if((uridata = strchr(uri,':')) == NULL) {
-                xstrncpy(scan, uri, strlen(uri));
+                xstrncpy(scan, uri, strlen(uri), URI_PROTO_LINE);
         } else {
-                xstrncpy(scan,uri, (size_t)(uridata - uri));
+                xstrncpy(scan,uri, (size_t)(uridata - uri), URI_PROTO_LINE);
         }
 

lib/trace_parallel.c

@@ -690 +690 @@
                         if (!trace->pread) {
                                 assert(packets[0]);
-                                ASSERT_RET(pthread_mutex_lock(&trace->libtrace_lock), == 0);
                                 nb_packets = trace_read_packet(trace, packets[0]);
-                                ASSERT_RET(pthread_mutex_unlock(&trace->libtrace_lock), == 0);
                                 packets[0]->error = nb_packets;
                                 if (nb_packets > 0)

libpacketdump/Makefile.am

@@ -62 +62 @@
 
 # 22: ETSI LI
+if HAVE_WANDDER
 BIN_PROTOCOLS+=link_22.la
+endif
 
 # Decoders for various ethertypes (in decimal)
@@ -138 +140 @@
 link_11_la_LDFLAGS=$(modflags)
 link_15_la_LDFLAGS=$(modflags) 
+if HAVE_WANDDER
 link_22_la_LDFLAGS=$(modflags) 
+endif
 eth_0_la_LDFLAGS=$(modflags)
 eth_2048_la_LDFLAGS=$(modflags)

libpacketdump/eth_2054.c

@@ -47 +47 @@
 static char *format_hrd(const struct arphdr *arp, const char *hrd) {
         static char buffer[1024] = {0,};
-        int i;
+        int i, ret;
+        size_t bufused;
 
         if (!hrd) {
@@ -59 +60 @@
                         break;
                 default:
+                        bufused = 0;
                         for (i=0;i<arp->ar_hln;i++) {
-                                snprintf(buffer,sizeof(buffer),"%s %02x",
-                                                buffer,(unsigned char)hrd[i]);
+                                if (bufused >= sizeof(buffer)) {
+                                        break;
+                                }
+                                ret = snprintf(buffer + bufused,
+                                                sizeof(buffer) - bufused,
+                                                "%02x ",
+                                                (unsigned char)hrd[i]);
+                                if (ret > 0) {
+                                        bufused += ret;
+                                }
                         }
                         break;
@@ -77 +87 @@
 static char *format_pro(const struct arphdr *arp, const char *pro) {
         static char buffer[1024] = {0,};
-        int i;
+        int i, ret;
+        size_t bufused;
         
         if (!pro) {
@@ -91 +102 @@
                 default:
                         snprintf(buffer, sizeof(buffer), "%s", " (");
+                        bufused = 2;
                         for (i=0;i<arp->ar_pln;i++) {
-                                snprintf(buffer,sizeof(buffer),"%s %02x",
-                                                buffer,(unsigned char)pro[i]);
+                                if (bufused >= sizeof(buffer)) {
+                                        break;
+                                }
+                                ret = snprintf(buffer + bufused,
+                                                sizeof(buffer) - bufused,
+                                                "%02x ",
+                                                (unsigned char)pro[i]);
+                                if (ret > 0) {
+                                        bufused += ret;
+                                }
                         }
-                        strncat(buffer,")",sizeof(buffer) - strlen(buffer) - 1);
+                        if (bufused < sizeof(buffer)) {
+                                snprintf(buffer + bufused,
+                                                sizeof(buffer) - bufused,
+                                                ")");
+                        }
                         break;
         }

tools/tracereport/misc_report.c

@@ -67 +67 @@
 {
         static char ret[1024];
-        char tmp[1024];
+        char tmp[128];
         ret[0]='\0';
         if (ts == 0) 

tools/tracesplit/tracesplit.c

@@ -61 +61 @@
 static char *strdupcat(char *str,char *app)
 {
-        str=realloc(str,strlen(str)+strlen(app)+1);
-        strncat(str,app,strlen(str) + strlen(app));
+        int newsize = strlen(str)+strlen(app)+1;
+        str=realloc(str,newsize);
+        strncat(str,app,newsize - strlen(str) - 1);
         return str;
 }