Changeset 0a6638f

Timestamp:

02/20/06 18:36:13 (15 years ago)

Author:

Perry Lorier <perry@…>

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:

5b91b48

Parents:

8ee7caa

Message:

Fixed up erf output
Force trace_create_packet to be called, don't let people cheat.

Location:

lib

Files:

• format_erf.c (modified) (7 diffs)
• format_helper.c (modified) (2 diffs)
• format_helper.h (modified) (1 diff)
• libtrace.h (modified) (1 diff)
• libtrace_int.h (modified) (1 diff)
• trace.c (modified) (6 diffs)

lib/format_erf.c

@@ -281 +281 @@
 }
 
-static int erf_open_output(struct libtrace_out_t *libtrace) {
-        char *filemode;
-        int fd;
-
-#if HAVE_ZLIB
-        asprintf(&filemode,"wb%d",OPTIONS.erf.level);
-#else
-        asprintf(&filemode,"w");
-#endif
-
-        if (!strncmp(libtrace->uridata,"-",1)) {
-                /* STDOUT */
-                OUTPUT.file = LIBTRACE_FDOPEN(fileno(stdout),filemode);
-        }
-        else {
-                /* TRACE */
-                fd = open(libtrace->uridata, 
-                                OPTIONS.erf.fileflag,
-                                S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
-                if (fd <= 0) {
-                        trace_set_err(errno,"OPEN(%s,\"w\")",
-                                        libtrace->uridata);
-                        return 0;
-                }
-                OUTPUT.file = LIBTRACE_FDOPEN(fd,filemode);
-
-        }
-        free(filemode);
-        return 1;
-}
-
 static int erf_config_output(struct libtrace_out_t *libtrace, trace_option_t option, void *value) {
 
@@ -428 +397 @@
         void *buffer2 = packet->buffer;
         int rlen;
-        if (packet->buf_control == EXTERNAL) {
-                packet->buf_control = PACKET;
-                packet->buffer = malloc(LIBTRACE_PACKET_BUFSIZE);
-        }
-        packet->header = packet->buffer;
-
-        if (packet->buffer) {
+
+        if (!packet->buffer) {
                 packet->buffer = malloc(LIBTRACE_PACKET_BUFSIZE);
                 packet->buf_control = PACKET;
         }
 
+        packet->header = packet->buffer;
 
         if ((numbytes=LIBTRACE_READ(INPUT.file,
@@ -455 +420 @@
         size = rlen - dag_record_size;
         assert(size < LIBTRACE_PACKET_BUFSIZE);
+
         
         /* Unknown/corrupt */
@@ -589 +555 @@
         }
 
-        if (buffer) {
-                if ((numbytes=LIBTRACE_WRITE(OUTPUT.file, buffer, size)) == 0) {
-                        trace_set_err(errno,"write(%s)",libtrace->uridata);
-                        return -1;
-                }
-        
-                return numbytes + pad + dag_record_size;
-        }
-        return numbytes;
+        if ((numbytes=LIBTRACE_WRITE(OUTPUT.file, buffer, size)) == 0) {
+                trace_set_err(errno,"write(%s)",libtrace->uridata);
+                return -1;
+        }
+
+        return numbytes + pad + dag_record_size;
+}
+
+static int erf_start_output(libtrace_out_t *libtrace)
+{
+        OUTPUT.file = trace_open_file_out(libtrace,
+                        OPTIONS.erf.level,
+                        OPTIONS.erf.fileflag);
+        if (!OUTPUT.file) {
+                printf("%s\n",trace_err.problem);
+                return -1;
+        }
+        return 0;
 }
                 
-static int erf_write_packet(struct libtrace_out_t *libtrace, const struct libtrace_packet_t *packet) {
+static int erf_write_packet(libtrace_out_t *libtrace, 
+                const libtrace_packet_t *packet) 
+{
         int numbytes = 0;
         dag_record_t erfhdr;
@@ -607 +584 @@
         void *payload = packet->payload;
 
-        /* Because of configuration, we don't actually open the output file
-           until we get the first packet. Not ideal, but it'll do for now */
-        if (!OUTPUT.file) {
-                if (erf_open_output(libtrace) <= 0) { 
-                        trace_set_err(errno,"open(%s)",libtrace->uridata);
-                        return -1;
-                }
-        }
+        assert(OUTPUT.file);
 
         pad = erf_get_padding(packet);
@@ -633 +603 @@
                                 pad,
                                 payload,
-                                packet->size - 
-                                        (dag_record_size + pad)); 
+                                trace_get_capture_length(packet)
+                                );
         } else {
                 /* convert format - build up a new erf header */
@@ -810 +780 @@
         erf_init_output,                /* init_output */
         erf_config_output,              /* config_output */
-        NULL,                           /* start_output */
+        erf_start_output,               /* start_output */
         erf_fin_input,                  /* fin_input */
         erf_fin_output,                 /* fin_output */

lib/format_helper.c

@@ -46 +46 @@
 
 #include <sys/ioctl.h>
+#include <assert.h>
 
 struct libtrace_eventobj_t trace_event_device(struct libtrace_t *trace, struct libtrace_packet_t *packet) {
@@ -165 +166 @@
         return ret;
 }
+
+LIBTRACE_FILE trace_open_file_out(libtrace_out_t *trace,int level, int fileflag)
+{
+        int fd;
+        LIBTRACE_FILE ret;
+        char filemode[4]; /* wb9\0 */
+        assert(level<10);
+        assert(level>=0);
+#if HAVE_ZLIB
+        sprintf(filemode,"wb%d",level);
+#else
+        sprintf(filemode,"w");
+#endif
+
+        if (strcmp(trace->uridata,"-")==0) {
+                ret=LIBTRACE_FDOPEN(fileno(stdout),filemode);
+                return ret;
+        }
+
+        /* We open the file with open(2), so we can provide O_LARGEFILE
+         * as zlib doesn't always do it itself
+         */
+        fd=open(trace->uridata,fileflag,0666);
+        if (fd==-1) {
+                trace_set_err(errno,"Unable to open %s",trace->uridata);
+                return 0;
+        }
+        ret=LIBTRACE_FDOPEN(fd,filemode);
+        if (ret==NULL) {
+                printf("%s\n",filemode);
+                trace_set_err(TRACE_ERR_INIT_FAILED,"gz out of memory");
+        }
+        return ret;
+}
+
+
+

lib/format_helper.h

@@ -39 +39 @@
 
 LIBTRACE_FILE trace_open_file(libtrace_t *libtrace);
+LIBTRACE_FILE trace_open_file_out(libtrace_out_t *libtrace,
+                int level,
+                int filemode);
 #endif /* FORMAT_HELPER_H */

lib/libtrace.h

@@ -86 +86 @@
 typedef struct libtrace_filter_t libtrace_filter_t;
 
-typedef enum {PACKET, EXTERNAL } buf_control_t;
+/* the letters p and e are magic numbers used to detect if the packet
+ * wasn't created properly
+ */
+typedef enum {PACKET='p', EXTERNAL='e' } buf_control_t;
 /** Structure holding information about a packet */
 #define LIBTRACE_PACKET_BUFSIZE 65536

lib/libtrace_int.h

@@ -116 +116 @@
         char *uridata;
         struct tracefifo_t *fifo;
+        bool started;
 };
 

lib/trace.c

@@ -331 +331 @@
  */
         
-struct libtrace_out_t *trace_create_output(const char *uri) {
+libtrace_out_t *trace_create_output(const char *uri) {
         struct libtrace_out_t *libtrace = malloc(sizeof(struct libtrace_out_t));
         
@@ -382 +382 @@
         assert( libtrace->fifo);
         free(scan);
+        libtrace->started=false;
         return libtrace;
 }
@@ -403 +404 @@
 
         libtrace->started=true;
+        return 0;
+}
+
+int trace_start_output(libtrace_out_t *libtrace) 
+{
+        assert(libtrace);
+        if (libtrace->format->start_output) {
+                int ret=libtrace->format->start_output(libtrace);
+                if (ret < 0) {
+                        return ret;
+                }
+        }
+
+        libtrace->started=false;
         return 0;
 }
@@ -495 +510 @@
 libtrace_packet_t *trace_create_packet() {
         libtrace_packet_t *packet = calloc(1,sizeof(libtrace_packet_t));
-        /* This used to malloc a packet!  Why do we need to malloc a packet
-         * if we're doing zero copy?
-         */
+        packet->buf_control=PACKET;
         return packet;
 }
@@ -525 +538 @@
         assert(libtrace->started && "BUG: You must call libtrace_start() before trace_read_packet()\n");
         assert(packet);
+        assert((packet->buf_control==PACKET || packet->buf_control==EXTERNAL)&&
+                "BUG: You must allocate a packet using packet_create()");
       
         /* Store the trace we are reading from into the packet opaque 
@@ -1555 +1570 @@
  * @param errcode either an Econstant from libc, or a LIBTRACE_ERROR
  * @param msg a plaintext error message
+ * @internal
  */
 void trace_set_err(int errcode,const char *msg,...)