Changeset 8f4152b

Timestamp:

10/21/05 12:17:08 (16 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:

41660d5

Parents:

b4cb91f

Message:

Moved legacy headers into daglegacy.h
Fixed some prototypes that were missing const's
Added a erf_get_erf_headersize that accoutns for the random +2 for erf
ethernet padding.
Removed a lot of hard coded constants for padding.

Location:

lib

Files:

• dagformat.h (modified) (1 diff)
• daglegacy.h (added)
• format_erf.c (modified) (12 diffs)
• format_pcap.c (modified) (1 diff)
• format_template.c (modified) (1 diff)
• libtrace_int.h (modified) (1 diff)

lib/dagformat.h

@@ -82 +82 @@
 #define dag_record_size         16
 
-
-typedef struct legacy_cell {
-        uint64_t  ts;
-        uint32_t  crc;
-} legacy_cell_t;
-
-typedef struct legacy_ether {
-        uint64_t  ts;
-        uint16_t  wlen;
-} legacy_ether_t;
-
-typedef struct legacy_pos {
-        uint64_t  ts;
-        uint32_t  slen;
-        uint32_t  wlen;
-} legacy_pos_t;
-
-
 #endif // _DAGFORMAT_H_

lib/format_erf.c

@@ -192 +192 @@
 #endif
 
+/* Dag erf ether packets have a 2 byte padding before the packet
+ * so that the ip header is aligned on a 32 bit boundary.
+ */
+static int erf_get_padding(const struct libtrace_packet_t *packet)
+{
+        switch(trace_get_link_type(packet)) {
+                case TRACE_TYPE_ETH:    return 2;
+                default:                return 0;
+        }
+}
+
+static int erf_get_erf_headersize(const struct libtrace_packet_t *packet)
+{
+        return dag_record_size + erf_get_padding(packet);
+}
+
+
 static int erf_init_input(struct libtrace_t *libtrace) {
         struct stat buf;
@@ -498 +515 @@
         }
         rlen = ntohs(((dag_record_t *)buffer)->rlen);
+        buffer2 = buffer + dag_record_size;
         size = rlen - dag_record_size;
         assert(size < LIBTRACE_PACKET_BUFSIZE);
-        buffer2 = buffer + dag_record_size;
         /* If your trace is legacy, or corrupt, then this assert may fire. */
         assert(ntohs(((dag_record_t *)buffer)->rlen) <= 
-                        ntohs(((dag_record_t*)buffer)->wlen)+dag_record_size);
+                        ntohs(((dag_record_t*)buffer)->wlen)+erf_get_erf_headersize(packet));
         /* If it's an unknown type, your trace is legacy */
         assert(((dag_record_t *)buffer)->type != 0);
@@ -512 +529 @@
         if ((numbytes=LIBTRACE_READ(INPUT.file,
                                         buffer2,
-                                        size)) == -1) {
+                                        size)) != size) {
                 perror("libtrace_read");
                 return -1;
@@ -578 +595 @@
                 // read in the ERF header
                 if ((numbytes = tracefifo_out_read(libtrace->fifo, buffer,
-                                                sizeof(dag_record_t))) == 0) {
+                                                dag_record_size)) == 0) {
                         tracefifo_out_reset(libtrace->fifo);
                         read_required = 1;
@@ -603 +620 @@
 }
 
-static int erf_dump_packet(struct libtrace_out_t *libtrace, dag_record_t *erfptr, void *buffer, size_t size) {
+static int erf_dump_packet(struct libtrace_out_t *libtrace, dag_record_t *erfptr, int pad, void *buffer, size_t size) {
         int numbytes = 0;
-        if ((numbytes = LIBTRACE_WRITE(OUTPUT.file, erfptr, dag_record_size + 2)) == 0) {
+        if ((numbytes = LIBTRACE_WRITE(OUTPUT.file, erfptr, dag_record_size + pad)) == 0) {
                 perror("libtrace_write");
                 return -1;
@@ -613 +630 @@
                 return -1;
         }
-        return numbytes + sizeof(dag_record_t);
-
+        return numbytes + pad + dag_record_size;
 }
                 
@@ -620 +636 @@
         int numbytes = 0;
         dag_record_t erfhdr;
+        int pad = 0;
         void *payload = (void *)trace_get_link(packet);
 
+        pad = erf_get_padding(packet);
         if (packet->trace->format == erf_ptr || 
 #if HAVE_DAG
@@ -629 +647 @@
                 numbytes = erf_dump_packet(libtrace,
                                 (dag_record_t *)packet->buffer,
+                                pad,
                                 payload,
                                 packet->size - 
-                                        (dag_record_size + 2)); 
+                                        (dag_record_size + pad)); 
         } else {
                 // convert format - build up a new erf header
                 // Timestamp
                 erfhdr.ts = trace_get_erf_timestamp(packet);
-                // Link type
-                switch(trace_get_link_type(packet)) {
-                case TRACE_TYPE_ETH:
-                        erfhdr.type=TYPE_ETH; break;
-                case TRACE_TYPE_ATM:
-                        erfhdr.type=TYPE_ATM; break;
-                default:
-                        erfhdr.type=0; 
-                }
                 // Flags. Can't do this
                 memset(&erfhdr.flags,1,1);
                 // Packet length (rlen includes format overhead)
-                erfhdr.rlen = trace_get_capture_length(packet) + sizeof(dag_record_t);
+                erfhdr.rlen = trace_get_capture_length(packet) + erf_get_erf_headersize(packet);
                 // loss counter. Can't do this
                 erfhdr.lctr = 0;
@@ -657 +667 @@
                 numbytes = erf_dump_packet(libtrace,
                                 &erfhdr,
+                                pad,
                                 payload,
                                 erfhdr.rlen);
@@ -693 +704 @@
         }
         ethptr = ((uint8_t *)packet->buffer +
-                        dag_record_size + 2);
+                        erf_get_erf_headersize(packet));
         return (void *)ethptr;
 }
@@ -747 +758 @@
         dag_record_t *erfptr = 0;
         erfptr = (dag_record_t *)packet->buffer;
-        return (ntohs(erfptr->rlen) - sizeof(dag_record_t));
+        return (ntohs(erfptr->rlen) - erf_get_erf_headersize(packet));
 }
 
@@ -759 +770 @@
         dag_record_t *erfptr = 0;
         assert(packet);
-        if((size + sizeof(dag_record_t)) > packet->size) {
+        if((size + erf_get_erf_headersize(packet)) > packet->size) {
                 // can't make a packet larger
-                return (packet->size - sizeof(dag_record_t));
+                return (packet->size - erf_get_erf_headersize(packet));
         }
         erfptr = (dag_record_t *)packet->buffer;
-        erfptr->rlen = htons(size + sizeof(dag_record_t));
-        packet->size = size + sizeof(dag_record_t);
+        erfptr->rlen = htons(size + erf_get_erf_headersize(packet));
+        packet->size = size + erf_get_erf_headersize(packet);
         return size;
 }

lib/format_pcap.c

@@ -232 +232 @@
 }
 
-static int pcap_write_packet(struct libtrace_out_t *libtrace, struct libtrace_packet_t *packet) {
+static int pcap_write_packet(struct libtrace_out_t *libtrace, const struct libtrace_packet_t *packet) {
         struct pcap_pkthdr pcap_pkt_hdr;
         void *link = trace_get_link(packet);

lib/format_template.c

@@ -70 +70 @@
 }
 
-static int template_write_packet(struct libtrace_out_t *libtrace, struct libtrace_packet_t *packet) {
+static int template_write_packet(struct libtrace_out_t *libtrace, const struct libtrace_packet_t *packet) {
         return -1;
 }

lib/libtrace_int.h

@@ -69 +69 @@
 #  include "dagformat.h"
 #endif
+#include "daglegacy.h"
 
 typedef enum {SOCKET, TRACE, STDIN, DEVICE, INTERFACE, RT } source_t;