Changeset fe76c55

Timestamp:

02/21/06 16:06:17 (16 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:

c1db742

Parents:

9ff68ff

Message:

More fixups for writing

Location:

lib

Files:

• format_erf.c (modified) (6 diffs)
• format_helper.c (modified) (2 diffs)
• format_pcap.c (modified) (3 diffs)
• format_wag.c (modified) (9 diffs)
• trace.c (modified) (1 diff)

lib/format_erf.c

@@ -275 +275 @@
         OUTPUT.file = 0;
 
-        return 1;
+        return 0;
 }
 
@@ -547 +547 @@
 }
 
-static int erf_dump_packet(struct libtrace_out_t *libtrace,
+static int erf_dump_packet(libtrace_out_t *libtrace,
                 dag_record_t *erfptr, int pad, void *buffer, size_t size) {
         int numbytes = 0;
+        assert(size>=0 && size<=65536);
+        /* FIXME: Shouldn't this return != dag_record_size+pad on error? */
         if ((numbytes = LIBTRACE_WRITE(OUTPUT.file, erfptr, dag_record_size + pad)) == 0) {
                 trace_set_err(errno,"write(%s)",libtrace->uridata);
@@ -569 +571 @@
                         OPTIONS.erf.fileflag);
         if (!OUTPUT.file) {
-                printf("%s\n",trace_err.problem);
                 return -1;
         }
@@ -579 +580 @@
 {
         int numbytes = 0;
-        dag_record_t erfhdr;
         int pad = 0;
         dag_record_t *dag_hdr = (dag_record_t *)packet->header;
@@ -606 +606 @@
                                 );
         } else {
+                dag_record_t erfhdr;
                 /* convert format - build up a new erf header */
                 /* Timestamp */
@@ -611 +612 @@
                 erfhdr.type = libtrace_to_erf_type(trace_get_link_type(packet));
                 /* Flags. Can't do this */
-                memset(&erfhdr.flags,1,1);
+                memset(&erfhdr.flags,1,sizeof(erfhdr.flags));
                 /* Packet length (rlen includes format overhead) */
-                erfhdr.rlen = trace_get_capture_length(packet) + erf_get_framing_length(packet);
+                erfhdr.rlen = trace_get_capture_length(packet) 
+                        + erf_get_framing_length(packet);
                 /* loss counter. Can't do this */
                 erfhdr.lctr = 0;
                 /* Wire length */
                 erfhdr.wlen = trace_get_wire_length(packet);
-                
+
                 /* Write it out */
                 numbytes = erf_dump_packet(libtrace,

lib/format_helper.c

@@ -144 +144 @@
 #endif 
 
+/* open a file or stdin using gzip compression if necessary (and supported)
+ * @internal
+ */
 LIBTRACE_FILE trace_open_file(libtrace_t *trace)
 {
@@ -167 +170 @@
 }
 
+/* Create a file or write to stdout using compression if requested
+ * @internal
+ */
 LIBTRACE_FILE trace_open_file_out(libtrace_out_t *trace,int level, int fileflag)
 {

lib/format_pcap.c

@@ -167 +167 @@
         OUTPUT.trace.pcap = NULL;
         OUTPUT.trace.dump = NULL;
-        return 1;
+        return 0;
 }
 
@@ -254 +254 @@
         numbytes = pcaphdr->len;
 
-        packet->header = (void *)pcaphdr;
+        packet->buf_control = PACKET;
+        if (!packet->buffer) {
+                /* We only need struct pcap_pkthdr, but we have no way
+                 * to say how much we malloc'd so that formats can determine
+                 * if they need to malloc more, so at the moment we just
+                 * malloc 64k
+                 */
+                packet->buffer=malloc(65536);
+        }
+        memcpy(packet->buffer,pcaphdr,sizeof(struct pcap_pkthdr));
+        packet->header = packet->buffer;
         packet->payload = (void *)pcappkt;
 
-
         packet->size = numbytes + sizeof(struct pcap_pkthdr);
+
+        assert(pcaphdr->caplen>=0 && pcaphdr->caplen<=65536);
 }
 
@@ -388 +399 @@
         struct pcap_pkthdr *pcapptr = 0;
         pcapptr = (struct pcap_pkthdr *)packet->header;
+        assert(pcapptr->caplen>=0 && pcapptr->caplen<=65536);
         return pcapptr->caplen;
 }

lib/format_wag.c

@@ -146 +146 @@
                 malloc(sizeof(struct libtrace_format_data_t));
 
+        return 1;
+}
+
+static int wtf_start_input(libtrace_t *libtrace)
+{
         libtrace->format_data->input.file = trace_open_file(libtrace);
 
@@ -155 +160 @@
 
 static int wtf_init_output(struct libtrace_out_t *libtrace) {
-        char *filemode = 0;
         libtrace->format_data = (struct libtrace_format_data_out_t *)
                 calloc(1,sizeof(struct libtrace_format_data_out_t));
 
-        OPTIONS.zlib.level = 0;
-        asprintf(&filemode,"wb%d",OPTIONS.zlib.level);
-        if (!strncmp(libtrace->uridata,"-",1)) {
-                /* STDOUT */
-                OUTPUT.file = LIBTRACE_FDOPEN(dup(1), filemode);
-        } else {
-                int fd;
-                /* TRACE */
-                fd=open(libtrace->uridata,OPTIONS.zlib.filemode,
-                                        S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
-                if (fd==-1) {
-                        trace_set_err(errno,"open(%s)",libtrace->uridata);
-                        return 0;
-                }
-                OUTPUT.file = LIBTRACE_FDOPEN(fd, filemode);
-        }
-
-        return 1;
+        return 0;
+}
+
+static int wtf_start_output(libtrace_out_t *libtrace) {
+        OUTPUT.file = trace_open_file_out(libtrace,
+                        OPTIONS.zlib.level,
+                        OPTIONS.zlib.filemode);
+        if (!OUTPUT.file) {
+                return -1;
+        }
+        return 0;
 }
 
@@ -248 +245 @@
         }
 
+
         framesize = ntohs(((struct frame_t *)buffer)->size);
         magic = ntohs(((struct frame_t *)buffer)->magic);
@@ -282 +280 @@
         int numbytes;
         
-        if (packet->buf_control == EXTERNAL) {
+        if (packet->buf_control == EXTERNAL || !packet->buffer) {
                 packet->buf_control = PACKET;
                 packet->buffer = malloc(LIBTRACE_PACKET_BUFSIZE);
-        }
+        }
         
         
@@ -304 +302 @@
 static int wtf_read_packet(struct libtrace_t *libtrace, struct libtrace_packet_t *packet) {
         int numbytes;
-        void *buffer = packet->buffer;
-        void *buffer2 = packet->buffer;
+        void *buffer;
+        void *buffer2;
         int framesize;
         int size;
 
-        if (packet->buf_control == EXTERNAL) {
+        if (packet->buf_control == EXTERNAL || !packet->buffer) {
                 packet->buf_control = PACKET;
                 packet->buffer = malloc(LIBTRACE_PACKET_BUFSIZE);
         }
 
+        buffer2 = buffer = packet->buffer;
         
         if ((numbytes = LIBTRACE_READ(INPUT.file, buffer, sizeof(struct frame_t))) == -1) {
-                trace_set_err(errno,"read(%s)",packet->trace->uridata);
+                trace_set_err(errno,"read(%s,frame_t)",packet->trace->uridata);
                 return -1;
         }
@@ -322 +321 @@
         if (numbytes == 0) {
                 return 0;
+        }
+
+        if (htons(((struct frame_t *)buffer)->magic) != 0xdaa1) {
+                trace_set_err(TRACE_ERR_BAD_PACKET,"Insufficient magic");
+                return -1;
         }
 
@@ -331 +335 @@
         
         if ((numbytes=LIBTRACE_READ(INPUT.file, buffer2, size)) != size) {
-                trace_set_err(errno,"read(%s)",packet->trace->uridata);
+                trace_set_err(errno,"read(%s,buffer)",packet->trace->uridata);
                 return -1;
         }
@@ -351 +355 @@
         }
 
-        /* We could just read from packet->buffer, but I feel it is more technically correct
-         * to read from the header and payload pointers
+        /* We could just read from packet->buffer, but I feel it is more
+         * technically correct to read from the header and payload pointers
          */
-        if ((numbytes = LIBTRACE_WRITE(OUTPUT.file, packet->header, trace_get_framing_length(packet))) == -1) {
+        if ((numbytes = LIBTRACE_WRITE(OUTPUT.file, packet->header, 
+                                trace_get_framing_length(packet))) == -1) {
                 trace_set_err(errno,"write(%s)",packet->trace->uridata);
                 return -1;
         }
         if ((numbytes = LIBTRACE_WRITE(OUTPUT.file, packet->payload, 
-                        packet->size - trace_get_framing_length(packet))) == 0) {
+                        packet->size - trace_get_framing_length(packet))) == -1) {
                 trace_set_err(errno,"write(%s)",packet->trace->uridata);
                 return -1;
@@ -472 +477 @@
         wtf_init_input,                 /* init_input */
         NULL,                           /* config input */
-        NULL,                           /* start input */
+        wtf_start_input,                /* start input */
         NULL,                           /* pause_input */
         wtf_init_output,                /* init_output */
         wtf_config_output,              /* config_output */
-        NULL,                           /* start output */
+        wtf_start_output,               /* start output */
         wtf_fin_input,                  /* fin_input */
         wtf_fin_output,                 /* fin_output */

lib/trace.c

@@ -370 +370 @@
 
         if (libtrace->format->init_output) {
-                if(!libtrace->format->init_output( libtrace)) {
-                        return 0;
+                /* 0 on success, -1 on failure */
+                switch(libtrace->format->init_output(libtrace)) {
+                        case -1: /* failure */
+                                free(libtrace);
+                                return 0;
+                        case 0: /* success */
+                                break;
+                        default:
+                                assert(!"init_output() should return -1 for failure, or 0 for success");
                 }
         } else {
                 trace_set_err(TRACE_ERR_NO_INIT_OUT,
                                 "Format does not support writing (%s)",scan);
+                free(libtrace);
                 return 0;
         }