Changeset 1332

Timestamp:

26/03/08 10:45:36 (10 months ago)

Author:

spa1

Message:

• Added prepare_packet functions to all formats, primarily to support translating RT packets into the appropriate format. These functions are all used internally as well, as most formats still need to "prepare" packets that have been read by setting pointers, updating loss counters etc.
  
• Also added a trace_prepare_packet function, but this is not made available externally at this stage
  
• Added init_format_data functions to some formats to initialise format data structures in cases where the init_trace function does more than just that
  
• Refactored rt packet reading code to use the new trace_prepare_packet functionality - also did a lot of tidying of the code
  
• Added missing RT type for BPF format
  

Files:

• trunk/lib/format_atmhdr.c (modified) (3 diffs)
• trunk/lib/format_bpf.c (modified) (5 diffs)
• trunk/lib/format_dag24.c (modified) (9 diffs)
• trunk/lib/format_dag25.c (modified) (13 diffs)
• trunk/lib/format_duck.c (modified) (7 diffs)
• trunk/lib/format_erf.c (modified) (6 diffs)
• trunk/lib/format_legacy.c (modified) (12 diffs)
• trunk/lib/format_linux.c (modified) (7 diffs)
• trunk/lib/format_pcap.c (modified) (5 diffs)
• trunk/lib/format_pcapfile.c (modified) (5 diffs)
• trunk/lib/format_rt.c (modified) (7 diffs)
• trunk/lib/format_tsh.c (modified) (6 diffs)
• trunk/lib/libtrace.h.in (modified) (1 diff)
• trunk/lib/libtrace_int.h (modified) (2 diffs)
• trunk/lib/trace.c (modified) (3 diffs)

trunk/lib/format_atmhdr.c

@@ -56 +56 @@
-}
-
+static int atmhdr_prepare_packet(libtrace_t *libtrace, 
+                libtrace_packet_t *packet, void *buffer, 
+                libtrace_rt_types_t rt_type, uint32_t flags) {
+
+        if (packet->buffer != buffer &&
+                        packet->buf_control == TRACE_CTRL_PACKET) {
+                free(packet->buffer);
+        }
+
+        if ((flags & TRACE_PREP_OWN_BUFFER) == TRACE_PREP_OWN_BUFFER) {
+                packet->buf_control = TRACE_CTRL_PACKET;
+        } else
+                packet->buf_control = TRACE_CTRL_EXTERNAL;
+
+        packet->buffer = buffer;
+        packet->header = buffer;
+        packet->payload = (void*)((char*)packet->buffer + 
+                        libtrace->format->get_framing_length(packet));
+        packet->type = rt_type;
+
+        if (libtrace->format_data == NULL) {
+                if (atmhdr_init_input(libtrace))
+                        return -1;
+        }
+        return 0;
+}
+
-static int atmhdr_read_packet(libtrace_t *libtrace, libtrace_packet_t *packet) {
-        int numbytes;
-        void *buffer;
-
+
+
-        if (!packet->buffer || packet->buf_control == TRACE_CTRL_EXTERNAL) {
-                packet->buf_control = TRACE_CTRL_PACKET;
-                packet->buffer=malloc((size_t)LIBTRACE_PACKET_BUFSIZE);
-        }
-        buffer = packet->buffer;
-
+
+
-        packet->type = TRACE_RT_DATA_ATMHDR;
-
@@ -76 +104 @@
-        }
-
-
-
-
-
+
+
+
+
+
+
-        return 12;
-}
@@ -117 +147 @@
-        NULL,                           /* fin_output */
-        atmhdr_read_packet,             /* read_packet */
-
+
+
-        NULL,                           /* write_packet */
-        atmhdr_get_link_type,           /* get_link_type */

trunk/lib/format_bpf.c

@@ -206 +206 @@
-static uint64_t bpf_get_received_packets(libtrace_t *trace)
-{
+        if (trace->format_data == NULL)
+                return (uint64_t)-1;
+
+        if (FORMATIN(trace)->fd == -1) {
+                /* Almost certainly a 'dead' trace so there is no socket
+                 * for us to query */
+                return (uint64_t) -1;
+        }
-        /* If we're called with stats_valid == 0, or we're called again
-         * then refresh the stats.  Don't refresh the stats if we're called
@@ -221 +229 @@
-static uint64_t bpf_get_dropped_packets(libtrace_t *trace)
-{
+        if (trace->format_data == NULL)
+                return (uint64_t)-1;
+
+        if (FORMATIN(trace)->fd == -1) {
+                /* Almost certainly a 'dead' trace so there is no socket
+                 * for us to query */
+                return (uint64_t) -1;
+        }
-        /* If we're called with stats_valid == 0, or we're called again
-         * then refresh the stats.  Don't refresh the stats if we're called
@@ -282 +298 @@
-}
-
+static int bpf_prepare_packet(libtrace_t *libtrace, libtrace_packet_t *packet,
+                void *buffer, libtrace_rt_types_t rt_type, uint32_t flags) {
+        if (packet->buffer != buffer &&
+                        packet->buf_control == TRACE_CTRL_PACKET) {
+                free(packet->buffer);
+        }
+
+        if ((flags & TRACE_PREP_OWN_BUFFER) == TRACE_PREP_OWN_BUFFER) {
+                packet->buf_control = TRACE_CTRL_PACKET;
+        } else
+                packet->buf_control = TRACE_CTRL_EXTERNAL;
+
+
+        packet->buffer = buffer;
+        packet->header = buffer;
+        packet->type = rt_type;
+
+        /* Find the payload */
+        /* TODO: Pcap deals with a padded FDDI linktype here */
+        packet->payload=(char *)buffer + BPFHDR(packet)->bh_hdrlen;
+
+        if (libtrace->format_data == NULL) {
+                if (bpf_init_input(libtrace))
+                        return -1;
+        }
+
+        return 0;
+}
+        
-static int bpf_read_packet(libtrace_t *libtrace, libtrace_packet_t *packet) 
-{
+        uint32_t flags = 0;
+        
-        /* Fill the buffer */
-        if (FORMATIN(libtrace)->remaining<=0) {
@@ -311 +358 @@
-        if (packet->buf_control == TRACE_CTRL_PACKET)
-                free(packet->buffer);
-
-
-
-
-
-
-
-
+
+
+
+
+
+
-
-        /* Now deal with any padding */
@@ -389 +434 @@
-        NULL,                   /* fin_output */
-        bpf_read_packet,        /* read_packet */
+        bpf_prepare_packet,     /* prepare_packet */
-        NULL,                   /* fin_packet */
-        NULL,                   /* write_packet */

trunk/lib/format_dag24.c

@@ -83 +83 @@
-};
-
+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;
+        FORMAT_DATA->drops = 0;
+        FORMAT_DATA->top = 0;
+        FORMAT_DATA->bottom = 0;
+        FORMAT_DATA->buf = NULL;
+        FORMAT_DATA->fd = -1;
+        FORMAT_DATA->offset = 0;
+        FORMAT_DATA->diff = 0;
+}
+
-static int dag_available(libtrace_t *libtrace) {
-
@@ -120 +137 @@
-        }
-        
-
-
-
-
+
-        if (S_ISCHR(buf.st_mode)) {
-                /* DEVICE */
@@ -145 +159 @@
-        }
-
-        DUCK.last_duck = 0;
-        DUCK.duck_freq = 0;
-        DUCK.last_pkt = 0;
-        DUCK.dummy_duck = NULL;
-        FORMAT_DATA->drops = 0;
-        free(dag_dev_name);
-
@@ -259 +268 @@
-}
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        packet->buffer = erfptr;
-        packet->header = erfptr;
-
+
+
-        if (erfptr->flags.rxerror == 1) {
-                /* rxerror means the payload is corrupt - drop it
@@ -273 +297 @@
-        }
-
+        if (libtrace->format_data == NULL) {
+                dag_init_format_data(libtrace);
+        }
+
+        DATA(libtrace)->drops += ntohs(erfptr->lctr);
+
+        return 0;
+
-}
-
@@ -278 +310 @@
-        int numbytes;
-        int size = 0;
-
+
+
-        dag_record_t *erfptr = NULL;
-
@@ -307 +340 @@
-                erfptr = dag_get_record(libtrace);
-        } while (erfptr == NULL);
-
-
+
+
+
+
+
+
-        DUCK.last_pkt = tv.tv_sec;
-        DATA(libtrace)->drops += ntohs(erfptr->lctr);
-        return packet->payload ? htons(erfptr->rlen) : erf_get_framing_length(packet);
-}
@@ -348 +384 @@
-static uint64_t dag_get_dropped_packets(libtrace_t *trace)
-{
+        if (!trace->format_data)
+                return (uint64_t)-1;
-        return DATA(trace)->drops;
-}
@@ -377 +415 @@
-        NULL,                           /* fin_output */
-        dag_read_packet,                /* read_packet */
-
+
+
-        NULL,                           /* write_packet */
-        erf_get_link_type,              /* get_link_type */

trunk/lib/format_dag25.c

@@ -99 +99 @@
-struct dag_dev_t *open_dags = NULL;
-
+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;
+        FORMAT_DATA->stream_attached = 0;
+        FORMAT_DATA->drops = 0;
+        FORMAT_DATA->device = NULL;
+        FORMAT_DATA->dagstream = 0;
+        FORMAT_DATA->processed = 0;
+        FORMAT_DATA->bottom = NULL;
+        FORMAT_DATA->top = NULL;
+}
+
-/* 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) {
@@ -187 +203 @@
-        struct dag_dev_t *dag_device = NULL;
-        
+        dag_init_format_data(libtrace);
-        pthread_mutex_lock(&open_dag_mutex);
-        if ((scan = strchr(libtrace->uridata,',')) == NULL) {
@@ -197 +214 @@
-        
-        
-        libtrace->format_data = (struct dag_format_data_t *)
-                malloc(sizeof(struct dag_format_data_t));
-
-        /* For now, we don't offer the ability to select the stream */
@@ -219 +234 @@
-        }
-
-
-
-        DUCK.last_duck = 0;
-        DUCK.duck_freq = 0;
-        DUCK.last_pkt = 0;
-        DUCK.dummy_duck = NULL;
-        FORMAT_DATA->device = dag_device;
-        FORMAT_DATA->stream_attached = 0;
-        FORMAT_DATA->drops = 0;
-        
-        pthread_mutex_unlock(&open_dag_mutex);
@@ -402 +409 @@
-}
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        packet->header = erfptr;
-
-
+
+
+
-                /* rxerror means the payload is corrupt - drop it
-                 * by tweaking rlen */
@@ -415 +438 @@
-                        + erf_get_framing_length(packet);
-        }
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-}
-
@@ -424 +460 @@
-        dag_record_t *erfptr = NULL;
-        int numbytes = 0;
+        uint32_t flags = 0;
-        
-        if (DUCK.last_pkt - DUCK.last_duck > DUCK.duck_freq &&
@@ -437 +474 @@
-
-        if (packet->buf_control == TRACE_CTRL_PACKET) {
-                packet->buf_control = TRACE_CTRL_EXTERNAL;
-                free(packet->buffer);
-                packet->buffer = 0;
@@ -452 +488 @@
-        } while (erfptr == NULL);
-
-
+
+
+
+
-        tv = trace_get_timeval(packet);
-        DUCK.last_pkt = tv.tv_sec;
-        
-        /* No loss counter for DSM coloured records - have to use 
-         * some other API */
-        if (erfptr->type == TYPE_DSM_COLOR_ETH) {
-                
-        } else {
-                DATA(libtrace)->drops += ntohs(erfptr->lctr);
-        }
-        return packet->payload ? htons(erfptr->rlen) : 
-                                erf_get_framing_length(packet);
@@ -472 +504 @@
-        dag_record_t *erfptr = NULL;
-        int numbytes;
+        uint32_t flags = 0;
-        
-        /* Need to call dag_available so that the top pointer will get
@@ -487 +520 @@
-                return event;
-        }
-
+
+
+
+
+
+
+
+
-        event.size = trace_get_capture_length(packet) + trace_get_framing_length(packet);
-        if (trace->filter) {
@@ -509 +549 @@
-
-static uint64_t dag_get_dropped_packets(libtrace_t *trace) {
+        if (trace->format_data == NULL)
+                return (uint64_t)-1;
-        return DATA(trace)->drops;
-}
@@ -538 +580 @@
-        NULL,                           /* fin_output */
-        dag_read_packet,                /* read_packet */
-
+
+
-        NULL,                           /* write_packet */
-        erf_get_link_type,              /* get_link_type */

trunk/lib/format_duck.c

@@ -133 +133 @@
-}
-
+static int duck_prepare_packet(libtrace_t *libtrace, libtrace_packet_t *packet,
+                void *buffer, libtrace_rt_types_t rt_type, uint32_t flags) {
+
+        if (packet->buffer != buffer &&
+                        packet->buf_control == TRACE_CTRL_PACKET) {
+                free(packet->buffer);
+        }
+
+        if ((flags & TRACE_PREP_OWN_BUFFER) == TRACE_PREP_OWN_BUFFER) {
+                packet->buf_control = TRACE_CTRL_PACKET;
+        } else
+                packet->buf_control = TRACE_CTRL_EXTERNAL;
+
+
+        packet->buffer = buffer;
+        packet->header = NULL;
+        packet->payload = buffer;
+        packet->type = rt_type;
+
+        if (libtrace->format_data == NULL) {
+                if (duck_init_input(libtrace))
+                        return -1;
+        }
+
+        return 0;
+}
+
-static int duck_read_packet(libtrace_t *libtrace, libtrace_packet_t *packet) {
-
@@ -138 +165 @@
-        uint32_t version = 0;
-        unsigned int duck_size;
+        uint32_t flags = 0;
-        
-        if (!packet->buffer || packet->buf_control == TRACE_CTRL_EXTERNAL) {
-                packet->buffer = malloc((size_t)LIBTRACE_PACKET_BUFSIZE);
-                packet->buf_control = TRACE_CTRL_PACKET;
-                if (!packet->buffer) {
-                        trace_set_err(libtrace, errno,
@@ -149 +176 @@
-        }
-
+        flags |= TRACE_PREP_OWN_BUFFER;
+        
-        if (INPUT->dag_version == 0) {
-                /* Read in the duck version from the start of the trace */
@@ -164 +193 @@
-        
-
-        packet->header = 0;
-        packet->payload = packet->buffer;
-        
-        if (INPUT->dag_version == TRACE_RT_DUCK_2_4) {
-                duck_size = sizeof(duck2_4_t);
@@ -180 +206 @@
-        }
-
-payload
+buffer
-                                        (size_t)duck_size)) != (int)duck_size) {
-                if (numbytes == -1) {
@@ -194 +220 @@
-        }
-
+        if (duck_prepare_packet(libtrace, packet, packet->buffer, packet->type,
+                                flags)) 
+                return -1;
+        
-        return numbytes;
-}
@@ -284 +314 @@
-        duck_fin_output,                /* fin_output */
-        duck_read_packet,               /* read_packet */
-
+
+
-        duck_write_packet,              /* write_packet */
-        duck_get_link_type,             /* get_link_type */

trunk/lib/format_erf.c

@@ -342 +342 @@
-}
- 
+static int erf_prepare_packet(libtrace_t *libtrace, libtrace_packet_t *packet,
+                void *buffer, libtrace_rt_types_t rt_type, uint32_t flags) {
+        
+        dag_record_t *erfptr;
+        
+        if (packet->buffer != buffer && 
+                packet->buf_control == TRACE_CTRL_PACKET) {
+                free(packet->buffer);
+        }
+
+        if ((flags & TRACE_PREP_OWN_BUFFER) == TRACE_PREP_OWN_BUFFER) {
+                packet->buf_control = TRACE_CTRL_PACKET;
+        } else
+                packet->buf_control = TRACE_CTRL_EXTERNAL;
+        
+        
+        packet->type = rt_type;
+        packet->buffer = buffer;
+        packet->header = buffer;
+        erfptr = (dag_record_t *)packet->buffer;
+        if (erfptr->flags.rxerror == 1) {
+                packet->payload = NULL;
+                /* XXX: Do we want to do this? We never used to do this
+                 
+                erfptr->rlen = htons(erf_get_framing_length(packet));
+                */
+        } else {
+                packet->payload = (char*)packet->buffer + erf_get_framing_length(packet);
+        }
+        
+        if (libtrace->format_data == NULL) {
+                /* Allocates the format_data structure */
+                if (erf_init_input(libtrace)) 
+                        return -1;
+        }
+
+        /* Check for loss */
+        if (erfptr->type == TYPE_DSM_COLOR_ETH) {
+                /* No idea how we get this yet */
+
+        } else {
+                DATA(libtrace)->drops += ntohs(erfptr->lctr);
+        }
+
+        return 0;
+}
-
-static int erf_read_packet(libtrace_t *libtrace, libtrace_packet_t *packet) {
@@ -348 +394 @@
-        void *buffer2 = packet->buffer;
-        unsigned int rlen;
-
+
+
+
-        if (!packet->buffer || packet->buf_control == TRACE_CTRL_EXTERNAL) {
-                packet->buffer = malloc((size_t)LIBTRACE_PACKET_BUFSIZE);
-                packet->buf_control = TRACE_CTRL_PACKET;
-                if (!packet->buffer) {
-                        trace_set_err(libtrace, errno, 
@@ -359 +406 @@
-        }
-
-
-
-
-
-
+
+
-        if ((numbytes=libtrace_io_read(INPUT.file,
-                                        packet->buffer,
@@ -403 +447 @@
-                return -1;
-        }
-
-
-
-
-
+
+
+
+
-        return rlen;
-}
@@ -637 +680 @@
-static uint64_t erf_get_dropped_packets(libtrace_t *trace)
-{
+        if (trace->format_data == NULL)
+                return (uint64_t)-1;
-        return DATA(trace)->drops;
-}
@@ -678 +723 @@
-        erf_fin_output,                 /* fin_output */
-        erf_read_packet,                /* read_packet */
+        erf_prepare_packet,             /* prepare_packet */
-        NULL,                           /* fin_packet */
-        erf_write_packet,               /* write_packet */

trunk/lib/format_legacy.c

@@ -69 +69 @@
-};
-
+static void legacy_init_format_data(libtrace_t *libtrace) {
+        libtrace->format_data = malloc(sizeof(struct legacy_format_data_t));
+        
+        DATA(libtrace)->input.file = NULL;
+        DATA(libtrace)->ts_high = 0;
+        DATA(libtrace)->ts_old = 0;
+        DATA(libtrace)->starttime = 0;
+}
+
-static int legacyeth_get_framing_length(const libtrace_packet_t *packet UNUSED) 
-{
@@ -91 +100 @@
-static int erf_init_input(libtrace_t *libtrace) 
-{
-
-
-
+
-
-        return 0;
@@ -136 +143 @@
-        regmatch_t match;
-
-
-
-
-
+
+
-        if((retval = regcomp(&reg, "[0-9]{8}-[0-9]{6}", REG_EXTENDED)) != 0) {
-                trace_set_err(libtrace, errno, "Failed to compile regex");
@@ -149 +154 @@
-        }
-        DATA(libtrace)->starttime = trtime(&filename[match.rm_so]);
-        DATA(libtrace)->ts_high = 0;
-        DATA(libtrace)->ts_old = 0;
-        return 0;
-}
@@ -173 +176 @@
-}
-
+static int legacy_prepare_packet(libtrace_t *libtrace, 
+                libtrace_packet_t *packet, void *buffer, 
+                libtrace_rt_types_t rt_type, uint32_t flags) {
+
+        if (packet->buffer != buffer &&
+                        packet->buf_control == TRACE_CTRL_PACKET) {
+                free(packet->buffer);
+        }
+
+        if ((flags & TRACE_PREP_OWN_BUFFER) == TRACE_PREP_OWN_BUFFER) {
+                packet->buf_control = TRACE_CTRL_PACKET;
+        } else
+                packet->buf_control = TRACE_CTRL_EXTERNAL;
+
+
+        packet->buffer = buffer;
+        packet->header = buffer;
+        packet->type = rt_type;
+        packet->payload = (void*)((char*)packet->buffer + 
+                libtrace->format->get_framing_length(packet));
+
+
+        if (libtrace->format_data == NULL) {
+                legacy_init_format_data(libtrace);
+        }
+        return 0;
+}
+
-static int legacy_read_packet(libtrace_t *libtrace, libtrace_packet_t *packet) {
-        int numbytes;
-        void *buffer;
-
+
+
-        if (!packet->buffer || packet->buf_control == TRACE_CTRL_EXTERNAL) {
-                packet->buf_control = TRACE_CTRL_PACKET;
-                packet->buffer=malloc((size_t)LIBTRACE_PACKET_BUFSIZE);
-        }
+        flags |= TRACE_PREP_OWN_BUFFER;
-        buffer = packet->buffer;
-
@@ -215 +247 @@
-        }
-        
-
-
-
+
+
+
+
-        
-        return 64;
@@ -231 +264 @@
-        void *buffer;
-        char *data_ptr;
+        uint32_t flags = 0;
-        
-        if (!packet->buffer || packet->buf_control == TRACE_CTRL_EXTERNAL) {
-                packet->buf_control = TRACE_CTRL_PACKET;
-                packet->buffer=malloc((size_t)LIBTRACE_PACKET_BUFSIZE);
-        }
+        flags |= TRACE_PREP_OWN_BUFFER;
+        
-        buffer = packet->buffer;
-
-        packet->type = TRACE_RT_DATA_LEGACY_NZIX;
-        
@@ -263 +297 @@
-        memmove(data_ptr + 2, data_ptr, 26);
-
-
-
-
+
+
+
+
-        return 68;
-}
@@ -432 +467 @@
-        NULL,                           /* fin_output */
-        legacy_read_packet,             /* read_packet */
+        legacy_prepare_packet,          /* prepare_packet */
-        NULL,                           /* fin_packet */
-        NULL,                           /* write_packet */
@@ -471 +507 @@
-        NULL,                           /* fin_output */
-        legacy_read_packet,             /* read_packet */
+        legacy_prepare_packet,          /* prepare_packet */
-        NULL,                           /* fin_packet */
-        NULL,                           /* write_packet */
@@ -510 +547 @@
-        NULL,                           /* fin_output */
-        legacy_read_packet,             /* read_packet */
+        legacy_prepare_packet,          /* prepare_packet */
-        NULL,                           /* fin_packet */
-        NULL,                           /* write_packet */
@@ -549 +587 @@
-        NULL,                           /* fin_output */
-        legacynzix_read_packet,         /* read_packet */
+        legacy_prepare_packet,          /* prepare_packet */
-        NULL,                           /* fin_packet */
-        NULL,                           /* write_packet */

trunk/lib/format_linux.c

@@ -331 +331 @@
-}
-
+static int linuxnative_prepare_packet(libtrace_t *libtrace, 
+                libtrace_packet_t *packet, void *buffer, 
+                libtrace_rt_types_t rt_type, uint32_t flags) {
+
+        if (packet->buffer != buffer &&
+                        packet->buf_control == TRACE_CTRL_PACKET) {
+                free(packet->buffer);
+        }
+
+        if ((flags & TRACE_PREP_OWN_BUFFER) == TRACE_PREP_OWN_BUFFER) {
+                packet->buf_control = TRACE_CTRL_PACKET;
+        } else
+                packet->buf_control = TRACE_CTRL_EXTERNAL;
+
+
+        packet->buffer = buffer;
+        packet->header = buffer;
+        packet->payload = (char *)buffer + 
+                sizeof(struct libtrace_linuxnative_header);
+        packet->type = rt_type;
+
+        if (libtrace->format_data == NULL) {
+                if (linuxnative_init_input(libtrace))
+                        return -1;
+        }
+        return 0;
+        
+}
+
-#define LIBTRACE_MIN(a,b) ((a)<(b) ? (a) : (b))
-
@@ -344 +373 @@
-        socklen_t socklen;
-        int snaplen;
-
+
+
-        if (!packet->buffer || packet->buf_control == TRACE_CTRL_EXTERNAL) {
-                packet->buffer = malloc((size_t)LIBTRACE_PACKET_BUFSIZE);
-       packet->buf_control = TRACE_CTRL_PACKET;
-
-
-packet->header = packet->buffer;
+}
+
+
+
-        packet->type = TRACE_RT_DATA_LINUX_NATIVE;
-        packet->payload = (char*)packet->buffer+sizeof(*hdr);
-
-        hdr=(struct libtrace_linuxnative_header*)packet->buffer;
@@ -398 +427 @@
-                perror("ioctl(SIOCGSTAMP)");
-
+        if (linuxnative_prepare_packet(libtrace, packet, packet->buffer,
+                                packet->type, flags))
+                return -1;
+        
-        return hdr->wirelen+sizeof(*hdr);
-}
@@ -490 +523 @@
-
-static int linuxnative_get_fd(const libtrace_t *trace) {
+        if (trace->format_data == NULL)
+                return -1;
-        return FORMAT(trace->format_data)->fd;
-}
@@ -506 +541 @@
-/* Number of packets that past filtering */
-static uint64_t linuxnative_get_captured_packets(libtrace_t *trace) {
+        if (trace->format_data == NULL)
+                return UINT64_MAX;
+        if (FORMAT(trace->format_data)->fd == -1) {
+                /* This is probably a 'dead' trace so obviously we can't query
+                 * the socket for capture counts, can we? */
+                return UINT64_MAX;
+        }
+        
-        if ((FORMAT(trace->format_data)->stats_valid & 1) 
-                        || FORMAT(trace->format_data)->stats_valid == 0) {
@@ -524 +567 @@
- */
-static uint64_t linuxnative_get_dropped_packets(libtrace_t *trace) {
+        if (trace->format_data == NULL)
+                return UINT64_MAX;
+        if (FORMAT(trace->format_data)->fd == -1) {
+                /* This is probably