Changeset 1344aa8

Timestamp:

07/03/07 13:34:06 (14 years ago)

Author:

Shane Alcock <salcock@…>

Branches:

4.0.1-hotfixes, cachetimestamps, develop, dpdk-ndag, etsilive, getfragoff, help, libtrace4, master, ndag_format, pfring, rc-4.0.1, rc-4.0.2, rc-4.0.3, rc-4.0.4, ringdecrementfix, ringperformance, ringtimestampfixes

Children:

721c0e4

Parents:

e1fdc05

Message:

• Added a new format for reading NZIX-I traces, called legacynzix

Location:

lib

Files:

• daglegacy.h (modified) (1 diff)
• format_legacy.c (modified) (12 diffs)
• libtrace.h.in (modified) (2 diffs)
• protocols.c (modified) (1 diff)

lib/daglegacy.h

@@ -22 +22 @@
         uint32_t ts_sec;
 } PACKED atmhdr_t;
+
+typedef struct legacy_nzix {
+        uint32_t ts;
+        uint32_t crc;
+        uint32_t len;
+        /* The padding has actually been placed in the middle of the IP
+         * header - when we read in the packet, we will move various bits
+         * of the packet around until the padding ends up here and the 
+         * IP header is undivided */
+        uint8_t pad[2];         
+} PACKED legacy_nzix_t;
 #endif

lib/format_legacy.c

@@ -43 +43 @@
 #include <string.h>
 #include <stdlib.h>
+#include <regex.h>
 
 #ifdef WIN32
@@ -56 +57 @@
 
 #define DATA(x) ((struct legacy_format_data_t *)x->format_data)
-
 #define INPUT DATA(libtrace)->input
 
@@ -64 +64 @@
                 libtrace_io_t *file;
         } input;
+        time_t starttime;       /* Used for legacy_nzix */
+        uint64_t ts_high;       /* Used for legacy_nzix */
+        uint32_t ts_old;        /* Used for legacy_nzix */
 };
 
@@ -81 +84 @@
 }
 
+static int legacynzix_get_framing_length(const libtrace_packet_t *packet UNUSED)
+{
+        return sizeof(legacy_nzix_t);
+}
+
 static int erf_init_input(libtrace_t *libtrace) 
 {
@@ -87 +95 @@
         DATA(libtrace)->input.file = NULL;
 
+        return 0;
+}
+
+static time_t trtime(char *s) {
+        /* XXX: this function may not be particularly portable to
+         * other platforms, e.g. *BSDs, Windows */
+        struct tm tm;
+        char *tz;
+        time_t ret;
+        static char envbuf[256];
+
+        if(sscanf(s, "%4u%2u%2u-%2u%2u%2u", &tm.tm_year, &tm.tm_mon,
+                                &tm.tm_mday, &tm.tm_hour, &tm.tm_min,
+                                &tm.tm_sec) != 6) {
+                return (time_t)0;
+        }
+        tm.tm_year = tm.tm_year - 1900;
+        tm.tm_mon --;
+        tm.tm_wday = 0; /* ignored */
+        tm.tm_yday = 0; /* ignored */
+        tm.tm_isdst = -1; /* forces check for summer time */
+        
+        tz = getenv("TZ");
+        if (putenv("TZ=Pacific/Auckland")) {
+                perror("putenv");
+                return (time_t)0;
+        }
+        tzset();
+        ret = mktime(&tm);
+
+        return ret;
+}
+        
+
+static int legacynzix_init_input(libtrace_t *libtrace) {
+
+        int retval;
+        char *filename = libtrace->uridata;
+        regex_t reg;
+        regmatch_t match;
+
+        libtrace->format_data = malloc(sizeof(struct legacy_format_data_t));
+
+        DATA(libtrace)->input.file = NULL;
+        
+        if((retval = regcomp(&reg, "[0-9]{8}-[0-9]{6}", REG_EXTENDED)) != 0) {
+                trace_set_err(libtrace, errno, "Failed to compile regex");
+                return -1;
+        }
+        if ((retval = regexec(&reg, filename, 1, &match, 0)) !=0) {
+                trace_set_err(libtrace, errno, "Failed to exec regex");
+                return -1;
+        }
+        DATA(libtrace)->starttime = trtime(&filename[match.rm_so]);
+        DATA(libtrace)->ts_high = 0;
+        DATA(libtrace)->ts_old = 0;
         return 0;
 }
@@ -159 +223 @@
 }
 
+static int legacynzix_read_packet(libtrace_t *libtrace, libtrace_packet_t *packet) {
+        /* Firstly, I apologize for all the constants being thrown around in
+         * this function, but it does befit the hackish origins of the
+         * NZIX format that I use them. Anyone who wants to clean them up is
+         * welcome to do so */
+        int numbytes;
+        void *buffer;
+        char *data_ptr;
+        
+        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_LEGACY_NZIX;
+        
+        while (1) {
+                if ((numbytes = libtrace_io_read(INPUT.file, buffer,
+                                                (size_t)68)) != 68) {
+                        if (numbytes < 0) {
+                                trace_set_err(libtrace,errno,"read(%s)",libtrace->uridata);
+                        } else if (numbytes > 0)
+                                continue;
+                        return numbytes;
+                } 
+                /* Packets with a zero length are GPS timestamp packets
+                 * but they aren't inserted at the right time to be
+                 * useful - instead we'll ignore them unless we can think
+                 * of a compelling reason to do otherwise */
+                if (((legacy_nzix_t *)buffer)->len == 0)
+                        continue;
+                
+                break;
+        }
+
+        /* lets move the padding so that it's in the framing header */
+        data_ptr = ((char *)buffer) + 12;
+        memmove(data_ptr + 2, data_ptr, 26);
+
+        packet->header = packet->buffer;
+        packet->payload = (void*)((char*)packet->buffer +
+                        libtrace->format->get_framing_length(packet));
+        return 68;
+}
+                
+
 static libtrace_linktype_t legacypos_get_link_type(const libtrace_packet_t *packet UNUSED) {
         return TRACE_TYPE_PPP;
@@ -171 +282 @@
 }
 
+static libtrace_linktype_t legacynzix_get_link_type(const libtrace_packet_t *packet UNUSED) {
+        return TRACE_TYPE_ETH;
+}
+
 static int legacy_get_capture_length(const libtrace_packet_t *packet UNUSED) {
         return 64;
+}
+
+static int legacynzix_get_capture_length(const libtrace_packet_t *packet UNUSED)
+{
+        return 54;
 }
 
@@ -190 +310 @@
 }
 
+static int legacynzix_get_wire_length(const libtrace_packet_t *packet) {
+        legacy_nzix_t *lnzix = (legacy_nzix_t *)packet->header;
+        return lnzix->len;
+}
+
 static uint64_t legacy_get_erf_timestamp(const libtrace_packet_t *packet)
 {
@@ -195 +320 @@
         return legacy->ts;
 }  
+
+static uint32_t ts_cmp(uint32_t ts_a, uint32_t ts_b) {
+        
+        /* each ts is actually a 30 bit value */
+        ts_a <<= 2;
+        ts_b <<= 2;
+
+
+        if (ts_a > ts_b) 
+                return (ts_a - ts_b);
+        else
+                return (ts_b - ts_a);
+        
+}
+
+static struct timeval legacynzix_get_timeval(const libtrace_packet_t *packet) {
+        uint64_t new_ts = DATA(packet->trace)->ts_high;
+        uint32_t old_ts = DATA(packet->trace)->ts_old;
+        struct timeval tv;
+        uint32_t hdr_ts;
+
+        double dts;
+        
+        legacy_nzix_t *legacy = (legacy_nzix_t *)packet->header;
+                
+        hdr_ts = legacy->ts;
+
+        /* seems we only need 30 bits to represent our timestamp */
+        hdr_ts >>=2;
+        /* try a sequence number wrap-around comparison */
+        if (ts_cmp(hdr_ts, old_ts) > (UINT32_MAX / 2) )
+                new_ts += (1LL << 30); /* wraparound */
+        new_ts &= ~((1LL << 30) -1);    /* mask lower 30 bits */
+        new_ts += hdr_ts;               /* packet ts is the new 30 bits */
+        DATA(packet->trace)->ts_old = hdr_ts;
+
+        tv.tv_sec = DATA(packet->trace)->starttime + (new_ts / (1000 * 1000));
+        tv.tv_usec = new_ts % (1000 * 1000);
+        DATA(packet->trace)->ts_high = new_ts;
+
+
+        dts = tv.tv_sec + (double)tv.tv_usec / 1000 / 1000;
+        return tv;
+        
+}       
 
 static void legacypos_help(void) {
@@ -226 +396 @@
         printf("\n");
         printf("\te.g.: legacyeth:/tmp/trace.gz\n");
+        printf("\n");
+}
+
+static void legacynzix_help(void) {
+        printf("legacynzix format module: $Revision$\n");
+        printf("Supported input URIs:\n");
+        printf("\tlegacynzix:/path/to/file\t(uncompressed)\n");
+        printf("\tlegacynzix:/path/to/file.gz\t(gzip-compressed)\n");
+        printf("\tlegacynzix:-\t(stdin, either compressed or not)\n");
+        printf("\n");
+        printf("\te.g.: legacynzix:/tmp/trace.gz\n");
         printf("\n");
 }
@@ -334 +515 @@
 };
 
+static struct libtrace_format_t legacynzix = {
+        "legacynzix",
+        "$Id$",
+        TRACE_FORMAT_LEGACY_NZIX,
+        legacynzix_init_input,          /* init_input */        
+        NULL,                           /* config_input */
+        erf_start_input,                /* start_input */
+        NULL,                           /* pause_input */
+        NULL,                           /* init_output */
+        NULL,                           /* config_output */
+        NULL,                           /* start_output */
+        erf_fin_input,                  /* fin_input */
+        NULL,                           /* fin_output */
+        legacynzix_read_packet,         /* read_packet */
+        NULL,                           /* fin_packet */
+        NULL,                           /* write_packet */
+        legacynzix_get_link_type,       /* get_link_type */
+        NULL,                           /* get_direction */
+        NULL,                           /* set_direction */
+        NULL,                           /* get_erf_timestamp */
+        legacynzix_get_timeval,         /* get_timeval */
+        NULL,                           /* get_seconds */
+        NULL,                           /* seek_erf */
+        NULL,                           /* seek_timeval */
+        NULL,                           /* seek_seconds */
+        legacynzix_get_capture_length,  /* get_capture_length */
+        legacynzix_get_wire_length,     /* get_wire_length */
+        legacynzix_get_framing_length,  /* get_framing_length */
+        NULL,                           /* set_capture_length */
+        NULL,                           /* get_fd */
+        trace_event_trace,              /* trace_event */
+        legacynzix_help,                /* help */
+        NULL,                           /* next pointer */
+};
         
 void legacy_constructor(void) {
@@ -339 +554 @@
         register_format(&legacyeth);
         register_format(&legacyatm);
-}
+        register_format(&legacynzix);
+}

lib/libtrace.h.in

@@ -263 +263 @@
         TRACE_FORMAT_BPF          =11,
         TRACE_FORMAT_TSH          =12,
-        TRACE_FORMAT_ATMHDR       =13
+        TRACE_FORMAT_ATMHDR       =13,
+        TRACE_FORMAT_LEGACY_NZIX  =14
 };
 
@@ -301 +302 @@
 
         TRACE_RT_DATA_ATMHDR = TRACE_RT_DATA_SIMPLE + TRACE_FORMAT_ATMHDR,
+        TRACE_RT_DATA_LEGACY_NZIX=TRACE_RT_DATA_SIMPLE + TRACE_FORMAT_LEGACY_NZIX,
         TRACE_RT_DATA_DLT               = 2000, /**< Pcap doesn't store the
                                                   * linktype per packet, and

lib/protocols.c

@@ -336 +336 @@
                         break;
         }
-        fprintf(stderr,"Don't understand link layer type %i in trace_get_payload_from_link()\n",
+        fprintf(stderr, "Don't understand link layer type %i in trace_get_payload_from_link()\n",
                 linktype);
         return NULL;