Changeset 7068467 for lib

Timestamp:

02/10/06 18:02:32 (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:

6eb91ff

Parents:

7f32bb5

Message:

Major cleanup of libtrace3
Lots of documentation fixes
Lots of zerocopy fixes
Lots of config option fixes

Location:

lib

Files:

• Makefile.am (modified) (1 diff)
• common.h (modified) (1 diff)
• dagformat.h (modified) (2 diffs)
• fifo.c (modified) (3 diffs)
• fifo.h (modified) (2 diffs)
• format_erf.c (modified) (28 diffs)
• format_helper.h (modified) (1 diff)
• format_legacy.c (modified) (1 diff)
• format_pcap.c (modified) (7 diffs)
• format_wag.c (modified) (18 diffs)
• libtrace.h (modified) (37 diffs)
• libtrace_int.h (modified) (4 diffs)
• parse_cmd.h (modified) (1 diff)
• trace.c (modified) (30 diffs)
• wag.h (modified) (4 diffs)

lib/Makefile.am

@@ -6 +6 @@
                 format_erf.c format_pcap.c format_wag.c format_legacy.c \
                 format_helper.c format_helper.h \
-                parse_cmd.c parse_cmd.h libtrace_int.h lt_inttypes.h
+                parse_cmd.c parse_cmd.h libtrace_int.h lt_inttypes.h \
+                linktypes.c 
 if DAG2_4
 nodist_libtrace_la_SOURCES = dagopts.c dagapi.c

lib/common.h

@@ -25 +25 @@
 #endif
 
-#endif // COMMON_H
+#endif /* COMMON_H */

lib/dagformat.h

@@ -38 +38 @@
 
 typedef struct flags {
-        uint8_t   iface:2;
-        uint8_t   vlen:1;
-        uint8_t   trunc:1;
-        uint8_t   rxerror:1;
-        uint8_t   dserror:1;
-        uint8_t   pad:2;
+        unsigned int   iface:2;
+        unsigned int   vlen:1;
+        unsigned int   trunc:1;
+        unsigned int   rxerror:1;
+        unsigned int   dserror:1;
+        unsigned int   pad:2;
 } __attribute__((packed)) flags_t;
 
@@ -87 +87 @@
 #define dag_record_size         16
 
-#endif // _DAGFORMAT_H_
+#endif /* _DAGFORMAT_H_ */

lib/fifo.c

@@ -98 +98 @@
 {
         assert(fifo);
-        //free(tracefifo_stat_buffer);
         free(fifo->base);
         free(fifo);
@@ -116 +115 @@
 
 void tracefifo_flush(struct tracefifo_t *fifo __attribute__((unused))) {
-        // do nothing
+        /* do nothing */
         return;
 }
@@ -220 +219 @@
                                 size);
                 increment_pointer(fifo,which,size);
-                buffer += size;
+                buffer = (char*)buffer+size;
                 lenleft -= size;
         }

lib/fifo.h

@@ -32 +32 @@
 #ifndef _FIFO_H_
 #define _FIFO_H_
+#include <inttypes.h>
 
 struct tracefifo_t;
 
 typedef struct tracefifo_state {
-        long long int in;
-        long long int out;
-        long long int ack;
-        long long int length;
-        long long int used;
+        uint64_t in;
+        uint64_t out;
+        uint64_t ack;
+        uint64_t length;
+        uint64_t used;
 } tracefifo_state_t;
 
@@ -70 +71 @@
 
 
-#endif // _FIFO_H_
+#endif /* _FIFO_H_ */

lib/format_erf.c

@@ -30 +30 @@
 #define _GNU_SOURCE
 
+#define RT_MSG 2
+#define RT_DATA 1
+
 #include "config.h"
 #include "common.h"
@@ -98 +101 @@
                 gzFile *file;
 #else   
-                //FILE  *file;
                 int file;
 #endif
@@ -129 +131 @@
                 struct {
                         int level;
-                        int append;
+                        int fileflag;
                 } erf;
                 
@@ -140 +142 @@
                 gzFile *file;
 #else
-                //FILE *file;
                 int file;
 #endif
         } output;
 };
+
+/** Structure holding status information for a packet */
+typedef struct libtrace_packet_status {
+        uint8_t type;
+        uint8_t reserved;
+        uint16_t message;
+} libtrace_packet_status_t;
+
 
 #ifdef HAVE_DAG
@@ -158 +167 @@
         } 
         if (S_ISCHR(buf.st_mode)) {
-                // DEVICE
+                /* DEVICE */
                 libtrace->sourcetype = DEVICE;
                 if((INPUT.fd = dag_open(CONNINFO.path)) < 0) {
@@ -209 +218 @@
         CONNINFO.path = libtrace->uridata;
         if (!strncmp(CONNINFO.path,"-",1)) {
-                // STDIN
+                /* STDIN */
                 libtrace->sourcetype = STDIN;
                 INPUT.file = LIBTRACE_FDOPEN(fileno(stdin), "r");
@@ -242 +251 @@
                         libtrace->sourcetype = TRACE;
 
-                        // we use an FDOPEN call to reopen an FD
-                        // returned from open(), so that we can set
-                        // O_LARGEFILE. This gets around gzopen not
-                        // letting you do this...
+                        /* we use an FDOPEN call to reopen an FD
+                         * returned from open(), so that we can set
+                         * O_LARGEFILE. This gets around gzopen not
+                         * letting you do this...
+                         */
                         INPUT.file = LIBTRACE_FDOPEN(open(
                                                 CONNINFO.path,
@@ -307 +317 @@
 
 static int erf_init_output(struct libtrace_out_t *libtrace) {
-        int fd;
         libtrace->format_data = (struct libtrace_format_data_out_t *)
                 calloc(1,sizeof(struct libtrace_format_data_out_t));
 
         OPTIONS.erf.level = 0;
-        OPTIONS.erf.append = 0;
+        OPTIONS.erf.fileflag = O_CREAT | O_LARGEFILE | O_WRONLY;
         OUTPUT.file = 0;
 
@@ -320 +329 @@
 static int erf_open_output(struct libtrace_out_t *libtrace) {
         char *filemode;
-        int trunc_flag = O_TRUNC;
         int fd;
 
@@ -329 +337 @@
 #endif
 
-        if (OPTIONS.erf.append) {
-                trunc_flag = O_APPEND;
-        }               
-
         if (!strncmp(libtrace->uridata,"-",1)) {
-                // STDOUT
+                /* STDOUT */
                 OUTPUT.file = LIBTRACE_FDOPEN(fileno(stdout),filemode);
         }
         else {
-                // TRACE
-                fd = open(libtrace->uridata, O_CREAT | O_LARGEFILE | O_WRONLY | trunc_flag, 
+                /* TRACE */
+                fd = open(libtrace->uridata, 
+                                OPTIONS.erf.fileflag,
                                 S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
                 if (fd <= 0) {
@@ -351 +356 @@
 }
 
-static int erf_config_output(struct libtrace_out_t *libtrace, int argc, char *argv[]) {
-        int opt;
-        int level = OPTIONS.erf.level;
-        optind = 1;
-
-
-        while ((opt = getopt(argc, argv, "z:a")) != EOF) {
-                switch (opt) {
-                        case 'z':
-                                level = atoi(optarg);
-                                break;
-                        case 'a':
-                                OPTIONS.erf.append = 1;
-                                break;
-                        default:
-                                printf("Bad argument to erf: %s\n", optarg);
-                                // maybe spit out some help here
-                                return -1;
-                }
-        }
-        
-        return 0;
-
+static int erf_config_output(struct libtrace_out_t *libtrace, trace_option_t option, void *value) {
+
+        switch (option) {
+                case TRACE_OPTION_OUTPUT_COMPRESS:
+                        OPTIONS.erf.level = *(int*)value;
+                        return 0;
+                case TRACE_OPTION_OUTPUT_FILEFLAGS:
+                        OPTIONS.erf.fileflag = *(int*)value;
+                        return 0;
+                default:
+                        /* Unknown option */
+                        return -1;
+        }
 }
 
@@ -443 +438 @@
                 return numbytes;
 
-        //DAG always gives us whole packets
+        /*DAG always gives us whole packets */
         erfptr = (dag_record_t *) ((void *)DAG.buf + 
                         (DAG.bottom + DAG.offset));
@@ -460 +455 @@
         }
 
-        
-        packet->status.type = RT_DATA;
-        packet->status.message = 0;
         packet->size = size;
         DAG.offset += size;
@@ -476 +468 @@
         int numbytes;
         int size;
-        void *buffer = packet->buffer;
-        void *buffer2 = buffer;
+        void *buffer2 = packet->buffer;
         int rlen;
         if (packet->buf_control == EXTERNAL) {
@@ -483 +474 @@
                 packet->buffer = malloc(LIBTRACE_PACKET_BUFSIZE);
         }
-        buffer = packet->buffer;
         packet->header = packet->buffer;
 
+        if (packet->buffer) {
+                packet->buffer = malloc(LIBTRACE_PACKET_BUFSIZE);
+                packet->buf_control = PACKET;
+        }
+
 
         if ((numbytes=LIBTRACE_READ(INPUT.file,
-                                        buffer,
+                                        packet->buffer,
                                         dag_record_size)) == -1) {
                 perror("libtrace_read");
@@ -497 +492 @@
         }
 
-        rlen = ntohs(((dag_record_t *)buffer)->rlen);
-        buffer2 = buffer + dag_record_size;
+        rlen = ntohs(((dag_record_t *)packet->buffer)->rlen);
+        buffer2 = (char*)packet->buffer + dag_record_size;
         size = rlen - dag_record_size;
         assert(size < LIBTRACE_PACKET_BUFSIZE);
@@ -509 +504 @@
         */
         /* Unknown/corrupt */
-        assert(((dag_record_t *)buffer)->type < 10);
-        
-        // read in the rest of the packet
+        assert(((dag_record_t *)packet->buffer)->type < 10);
+        
+        /* read in the rest of the packet */
         if ((numbytes=LIBTRACE_READ(INPUT.file,
                                         buffer2,
@@ -518 +513 @@
                 return -1;
         }
-        packet->status.type = RT_DATA;
-        packet->status.message = 0;
         packet->size = rlen;
-        if (((dag_record_t *)buffer)->flags.rxerror == 1) {
+        if (((dag_record_t *)packet->buffer)->flags.rxerror == 1) {
                 packet->payload = NULL;
         } else {
-                packet->payload = packet->buffer + erf_get_framing_length(packet);
+                packet->payload = (char*)packet->buffer + erf_get_framing_length(packet);
         }
         return rlen;
@@ -543 +536 @@
                                                 MSG_NOSIGNAL)) == -1) {
                         if (errno == EINTR) {
-                                //ignore EINTR in case
-                                // a caller is using signals
+                                /*ignore EINTR in case
+                                 *a caller is using signals
+                                 */
                                 continue;
                         }
@@ -575 +569 @@
         
         do {
+                struct libtrace_packet_status status;
                 if (tracefifo_out_available(libtrace->fifo) == 0 || read_required) {
                         if ((numbytes = rtclient_read(
@@ -583 +578 @@
                         read_required = 0;
                 }
-                // Read status byte
+                /* Read status byte */
                 if (tracefifo_out_read(libtrace->fifo,
-                                &packet->status, sizeof(uint32_t)) == 0) {
+                                &status, sizeof(uint32_t)) == 0) {
                         read_required = 1;
                         continue;
                 }
                 tracefifo_out_update(libtrace->fifo,sizeof(uint32_t));
-                // Read in packet size
+                /* Read in packet size */
                 if (tracefifo_out_read(libtrace->fifo,
                                 &packet->size, sizeof(uint32_t)) == 0) {
@@ -608 +603 @@
                 }
                 */
-                if (packet->status.type == RT_MSG) {
-                        // Need to skip this packet as it is a message packet
+                if (status.type == RT_MSG) {
+                        /* Need to skip this packet as it is a message packet */
                         tracefifo_out_update(libtrace->fifo, packet->size);
                         tracefifo_ack_update(libtrace->fifo, packet->size + 
@@ -617 +612 @@
                 }
                 
-                //size = ntohs(((dag_record_t *)buffer)->rlen);
-                
-                // read in the full packet
+                /* read in the full packet */
                 if ((numbytes = tracefifo_out_read(libtrace->fifo, 
                                                 buffer, packet->size)) == 0) {
@@ -627 +620 @@
                 }
 
-                // got in our whole packet, so...
+                /* got in our whole packet, so... */
                 tracefifo_out_update(libtrace->fifo,packet->size);
 
@@ -634 +627 @@
                                 sizeof(libtrace_packet_status_t));
 
-                //packet->size = numbytes;
                 if (((dag_record_t *)buffer)->flags.rxerror == 1) {
                         packet->payload = NULL;
                 } else {
-                        packet->payload = packet->buffer + erf_get_framing_length(packet);
+                        packet->payload = (char*)packet->buffer + erf_get_framing_length(packet);
                 }
                 return numbytes;
@@ -698 +690 @@
                                         (dag_record_size + pad)); 
         } else {
-                // convert format - build up a new erf header
-                // Timestamp
+                /* convert format - build up a new erf header */
+                /* Timestamp */
                 erfhdr.ts = trace_get_erf_timestamp(packet);
-                // Flags. Can't do this
+                erfhdr.type = libtrace_to_erf_type(trace_get_link_type(packet));
+                /* Flags. Can't do this */
                 memset(&erfhdr.flags,1,1);
-                // Packet length (rlen includes format overhead)
+                /* Packet length (rlen includes format overhead) */
                 erfhdr.rlen = trace_get_capture_length(packet) + erf_get_framing_length(packet);
-                // loss counter. Can't do this
+                /* loss counter. Can't do this */
                 erfhdr.lctr = 0;
-                // Wire length
+                /* Wire length */
                 erfhdr.wlen = trace_get_wire_length(packet);
                 
-                // Write it out
+                /* Write it out */
                 numbytes = erf_dump_packet(libtrace,
                                 &erfhdr,
@@ -720 +713 @@
 }
 
-static void *erf_get_link(const struct libtrace_packet_t *packet) {
-        return (void *)packet->payload;
-}
-
 static libtrace_linktype_t erf_get_link_type(const struct libtrace_packet_t *packet) {
         dag_record_t *erfptr = 0;
         erfptr = (dag_record_t *)packet->header;
-        switch (erfptr->type) {
-                case TYPE_LEGACY:       return TRACE_TYPE_LEGACY;
-                case TYPE_ETH:          return TRACE_TYPE_ETH;
-                case TYPE_ATM:          return TRACE_TYPE_ATM;
-                default: 
-                               fprintf(stderr,"Unknown erf type %02x\n",erfptr->type);
-                               assert(0);
-        }
-        return erfptr->type;
+        return erf_type_to_libtrace(erfptr->type);
 }
 
@@ -773 +754 @@
         assert(packet);
         if((size + erf_get_framing_length(packet)) > packet->size) {
-                // can't make a packet larger
+                /* can't make a packet larger */
                 return (packet->size - erf_get_framing_length(packet));
         }

lib/format_helper.h

@@ -36 +36 @@
 struct libtrace_eventobj_t trace_event_device(struct libtrace_t *trace, struct libtrace_packet_t *packet);
 struct libtrace_eventobj_t trace_event_trace(struct libtrace_t *trace, struct libtrace_packet_t *packet);
-#endif // FORMAT_HELPER_H
+#endif /* FORMAT_HELPER_H */

lib/format_legacy.c

@@ -193 +193 @@
                 return -1;
         }
-        packet->status.type = RT_DATA;
-        packet->status.message = 0;
         packet->size = 64;
         

lib/format_pcap.c

@@ -152 +152 @@
                 }       
         }
-        //fprintf(stderr,       "Unsupported scheme (%s) for format pcap\n",
-        //              CONNINFO.path);
         return 1;
         
@@ -209 +207 @@
         int numbytes = 0;
 
+        /*
         // pcap provides us with the right bits, in it's own buffers.
         // We hijack them.
+        */
         numbytes = pcaphdr->len;
 
@@ -231 +231 @@
                 return pcapbytes;
         }
-        packet->status.type = RT_DATA;
-        packet->status.message = 0;
         return (packet->size - sizeof(struct pcap_pkthdr));
 }
@@ -251 +249 @@
                 pcap_dump((u_char*)OUTPUT.trace.dump,(struct pcap_pkthdr *)packet->header,packet->payload);
         } else {
-                // Leave the manual copy as it is, as it gets around 
-                // some OS's having different structures in pcap_pkt_hdr
+                /* Leave the manual copy as it is, as it gets around 
+                 * some OS's having different structures in pcap_pkt_hdr
+                 */
                 struct timeval ts = trace_get_timeval(packet);
                 pcap_pkt_hdr.ts.tv_sec = ts.tv_sec;
@@ -265 +264 @@
 
 static int pcapint_write_packet(struct libtrace_out_t *libtrace __attribute__((unused)), const struct libtrace_packet_t *packet __attribute__((unused))) {
-//      void *link = trace_get_link(packet);
 
         return 0;
-}
-
-static void *pcap_get_link(const struct libtrace_packet_t *packet) {
-        return (void *) packet->payload;
 }
 
@@ -382 +376 @@
         assert(packet);
         if ((size + sizeof(struct pcap_pkthdr)) > packet->size) {
-                // can't make a packet larger
+                /* can't make a packet larger */
                 return (packet->size - sizeof(struct pcap_pkthdr));
         }
@@ -478 +472 @@
 };
 
-//pcap_ptr = &pcap;
-//pcapint_ptr = &pcapint;
-
 void __attribute__((constructor)) pcap_constructor() {
         register_format(&pcap);

lib/format_wag.c

@@ -99 +99 @@
                 gzFile *file;
 #else   
-                //FILE *file;
                 int file;
 #endif
@@ -119 +118 @@
                 gzFile *file;
 #else
-                //FILE *file;
                 int file;
 #endif
@@ -127 +125 @@
 static int wag_init_input(struct libtrace_t *libtrace) {
         struct stat buf;
-        //struct sockaddr_un unix_sock;
         libtrace->format_data = (struct libtrace_format_data_t *) 
                 calloc(1,sizeof(struct libtrace_format_data_t));
@@ -151 +148 @@
 
 static int wtf_init_input(struct libtrace_t *libtrace) {
-        struct stat buf;
-        struct sockaddr_un unix_sock;
 
         libtrace->format_data = (struct libtrace_format_data_t *)
@@ -159 +154 @@
 
         if (!strncmp(CONNINFO.path,"-",1)) {
-                // STDIN
+                /* STDIN */
                 libtrace->sourcetype = STDIN;
                 INPUT.file = LIBTRACE_FDOPEN(fileno(stdin),"r");
 
         } else {
-
-
-                // Do we need this socket stuff at all??
-                // If we do, put it into wag_init_input as it uses
-                // INPUT.fd
+                /* Do we need this socket stuff at all??
+                 * If we do, put it into wag_init_input as it uses
+                 * INPUT.fd
+                 */
 
                 /*
@@ -197 +191 @@
                 } else { 
                 */
-                        // TRACE
+                        /* TRACE */
                         libtrace->sourcetype = TRACE;
                         
-                        // we use an FDOPEN call to reopen an FD
-                        // returned from open(), so that we can set
-                        // O_LARGEFILE. This gets around gzopen not
-                        // letting you do this...
+                        /* we use an FDOPEN call to reopen an FD
+                         * returned from open(), so that we can set
+                         * O_LARGEFILE. This gets around gzopen not
+                         * letting you do this...
+                         */
                         INPUT.file = LIBTRACE_FDOPEN(open(
                                         CONNINFO.path,
                                         O_LARGEFILE), "r");
 
-                //}
         }
         return 1;
@@ -222 +216 @@
         asprintf(&filemode,"wb%d",OPTIONS.zlib.level);
         if (!strncmp(libtrace->uridata,"-",1)) {
-                // STDOUT                               
+                /* STDOUT */
                 OUTPUT.file = LIBTRACE_FDOPEN(dup(1), filemode);
         } else {
-                // TRACE
+                /* TRACE */
                 OUTPUT.file = LIBTRACE_FDOPEN(open(
                                         libtrace->uridata,
@@ -235 +229 @@
 }
 
-static int wtf_config_output(struct libtrace_out_t *libtrace, int argc, char *argv[]) {
+static int wtf_config_output(struct libtrace_out_t *libtrace, 
+                trace_option_output_t option,
+                void *value) {
+        switch(option) {
 #if HAVE_ZLIB
-        int opt;
-        int level = OPTIONS.zlib.level;
-        optind = 1;
-        while ((opt = getopt(argc, argv, "z:")) != EOF) {
-                switch (opt) {
-                        case 'z':
-                                level = atoi(optarg);
-                                break;
-                        default:
-                                printf("Bad argument to wag: %s\n", optarg);
-                                return -1;
-                }
-        }
-        if (level != OPTIONS.zlib.level) {
-                if (level > 9 || level < 0) {
-                        // retarded level choice
-                        printf("Compression level must be between 0 and 9 inclusive - you selected %i \n", level);
-                } else {
-                        OPTIONS.zlib.level = level;
-                        return gzsetparams(OUTPUT.file, level, Z_DEFAULT_STRATEGY);
-                }
-        }
-#endif
-        return 0;
+                case TRACE_OPTION_OUTPUT_COMPRESS:
+                        OPTIONS.zlib.level = *(int*)value;
+                        assert(OPTIONS.zlib.level>=0 
+                                        && OPTIONS.zlib.level<=9);
+                        break;
+#else
+                case TRACE_OPTION_OUTPUT_COMPRESS:
+                        /* E feature unavailable */
+                        return -1;
+#endif
+                default:
+                        /* E unknown feature */
+                        return -1;
+        }
 }
 
@@ -280 +267 @@
 static int wag_read(struct libtrace_t *libtrace, void *buffer, size_t len) {
         int numbytes;
-        int framesize;
+        size_t framesize;
         assert(libtrace);
 
@@ -286 +273 @@
                 buffer = malloc(len);
 
-        // read in wag_frame_hdr
+        /* read in wag_frame_hdr */
         if ((numbytes = read(INPUT.fd, 
                         buffer,
@@ -299 +286 @@
         }
 
-        // read in remainder of packet
+        /* read in remainder of packet */
         if((numbytes = read(INPUT.fd,
-                        buffer + sizeof(struct wag_frame_hdr),
+                        (char*)buffer + sizeof(struct wag_frame_hdr),
                         framesize - sizeof(struct wag_frame_hdr))) != 
                         (framesize - sizeof(struct wag_frame_hdr))) {
@@ -316 +303 @@
         int numbytes;
         
-        char buf[RP_BUFSIZE];
         if (packet->buf_control == EXTERNAL) {
                 packet->buf_control = PACKET;
@@ -331 +317 @@
 
         
-//      memcpy(packet->buffer, buf, numbytes);
-        
-        packet->status.type = RT_DATA;
-        packet->status.message = 0;
         packet->size = numbytes;
         packet->header = packet->buffer;
-        packet->payload = packet->buffer + trace_get_framing_length(packet);
+        packet->payload=(char*)packet->buffer+trace_get_framing_length(packet);
         return numbytes;
 }
@@ -364 +346 @@
 
         framesize = ntohs(((struct wag_frame_hdr *)buffer)->size);
-        buffer2 = buffer + sizeof(struct wag_frame_hdr);
+        buffer2 = (char*)buffer + sizeof(struct wag_frame_hdr);
         size = framesize - sizeof(struct wag_frame_hdr);
         assert(size < LIBTRACE_PACKET_BUFSIZE);
@@ -374 +356 @@
         }
 
-        packet->status.type = RT_DATA;
-        packet->status.message = 0;
         packet->size = framesize;
         packet->header = packet->buffer;
-        packet->payload = packet->buffer + trace_get_framing_length(packet);
+        packet->payload=(char*)packet->buffer+trace_get_framing_length(packet);
         return framesize;
         
@@ -406 +386 @@
 }
 
-static void *wag_get_link(const struct libtrace_packet_t *packet) {
-        /*
-        struct wag_data_frame *wagptr = (struct wag_data_frame *)packet->buffer;
-        void *payload = wagptr->data;
-        return (void*)payload;
-        */
-        return (void *)packet->payload;
-}
-
 static libtrace_linktype_t wag_get_link_type(const struct libtrace_packet_t *packet __attribute__((unused))) {
         return TRACE_TYPE_80211;
@@ -436 +407 @@
 static int wag_get_capture_length(const struct libtrace_packet_t *packet) {
         struct wag_data_frame *wagptr = (struct wag_data_frame *)packet->buffer;
-        //return (wagptr->hdr.size);
         return ntohs(wagptr->hdr.size);
 }
@@ -442 +412 @@
 static int wag_get_wire_length(const struct libtrace_packet_t *packet) {
         struct wag_data_frame *wagptr = (struct wag_data_frame *)packet->buffer;
-        //return (wagptr->hdr.size);
         return ntohs(wagptr->hdr.size);
 }

lib/libtrace.h

@@ -71 +71 @@
 #  define SIMPLE_FUNCTION __attribute__((pure))
 #  define UNUSED __attribute__((unused))
+#  define PACKED __attribute__((packed))
 #else
 #  define SIMPLE_FUNCTION
 #  define UNUSED
 #endif
-        
-#define RT_DATA 1
-#define RT_MSG 2
-
         
 /** Opaque structure holding information about an output trace */
@@ -89 +86 @@
 typedef struct libtrace_filter_t libtrace_filter_t;
 
-/** Structure holding status information for a packet */
-typedef struct libtrace_packet_status {
-        uint8_t type;
-        uint8_t reserved;
-        uint16_t message;
-
-} libtrace_packet_status_t;
-
 typedef enum {PACKET, EXTERNAL } buf_control_t;
 /** Structure holding information about a packet */
@@ -106 +95 @@
         void *buffer;
         size_t size;
-        libtrace_packet_status_t status;
         buf_control_t buf_control; 
-} __attribute__ ((packed)) libtrace_packet_t;
+} libtrace_packet_t;
                      
 
@@ -114 +102 @@
 enum {E_NOERROR, E_BAD_FORMAT, E_NO_INIT, E_NO_INIT_OUT, E_URI_LONG, E_URI_NOCOLON, E_INIT_FAILED };
 
+/** @name Packet structures
+ * These convenience structures are here as they are portable ways of dealing
+ * with various protocols.
+ * @{
+ */
+
 /** Structure for dealing with IP packets */
-typedef struct libtrace_ip
+typedef PACKED struct libtrace_ip
 {
 #if BYTE_ORDER == LITTLE_ENDIAN
@@ -129 +123 @@
     u_short ip_len;                     /**< total length */
     u_short ip_id;                      /**< identification */
-    u_short ip_off;                     /**< fragment offset field */
-#define IP_RF 0x8000                    /**< reserved fragment flag */
-#define IP_DF 0x4000                    /**< dont fragment flag */
-#define IP_MF 0x2000                    /**< more fragments flag */
-#define IP_OFFMASK 0x1fff               /**< mask for fragmenting bits */
+#if BYTE_ORDER == LITTLE_ENDIAN
+    unsigned int ip_off:12;             /**< fragment offset */
+    unsigned int ip_mf:1;               /**< more fragments flag */
+    unsigned int ip_df:1;               /**< dont fragment flag */
+    unsigned int ip_rf:1;               /**< reserved fragment flag */
+#elif BYTE_ORDER == BIG_ENDIAN
+    unsigned int ip_rf:1;
+    unsigned int ip_df:1;
+    unsigned int ip_mf:1;
+    unsigned int ip_off:12;
+#else
+#   error "Adjust your <bits/endian.h> defines"
+#endif
     u_int8_t ip_ttl;                    /**< time to live */
     u_int8_t ip_p;                      /**< protocol */
@@ -139 +141 @@
     struct in_addr ip_src;              /**< source address */
     struct in_addr ip_dst;              /**< dest address */
-} __attribute__ ((packed)) libtrace_ip_t
+} libtrace_ip_t
 ;
 
@@ -150 +152 @@
     u_int32_t ack_seq;          /**< Acknowledgement Number */
 #  if BYTE_ORDER == LITTLE_ENDIAN
-    u_int16_t res1:4;           /**< Reserved bits */
-    u_int16_t doff:4;           
-    u_int16_t fin:1;            /**< FIN */
-    u_int16_t syn:1;            /**< SYN flag */
-    u_int16_t rst:1;            /**< RST flag */
-    u_int16_t psh:1;            /**< PuSH flag */
-    u_int16_t ack:1;            /**< ACK flag */
-    u_int16_t urg:1;            /**< URG flag */
-    u_int16_t res2:2;           /**< Reserved */
+    unsigned int res1:4;        /**< Reserved bits */
+    unsigned int doff:4;        /**< data offset */     
+    unsigned int fin:1;         /**< FIN */
+    unsigned int syn:1;         /**< SYN flag */
+    unsigned int rst:1;         /**< RST flag */
+    unsigned int psh:1;         /**< PuSH flag */
+    unsigned int ack:1;         /**< ACK flag */
+    unsigned int urg:1;         /**< URG flag */
+    unsigned int res2:2;        /**< Reserved */
 #  elif BYTE_ORDER == BIG_ENDIAN
-    u_int16_t doff:4;           
-    u_int16_t res1:4;           /**< Reserved bits */
-    u_int16_t res2:2;           /**< Reserved */
-    u_int16_t urg:1;            /**< URG flag */
-    u_int16_t ack:1;            /**< ACK flag */
-    u_int16_t psh:1;            /**< PuSH flag */
-    u_int16_t rst:1;            /**< RST flag */
-    u_int16_t syn:1;            /**< SYN flag */
-    u_int16_t fin:1;            /**< FIN flag */
+    unsigned int doff:4;        /**< Data offset */
+    unsigned int res1:4;        /**< Reserved bits */
+    unsigned int res2:2;        /**< Reserved */
+    unsigned int urg:1;         /**< URG flag */
+    unsigned int ack:1;         /**< ACK flag */
+    unsigned int psh:1;         /**< PuSH flag */
+    unsigned int rst:1;         /**< RST flag */
+    unsigned int syn:1;         /**< SYN flag */
+    unsigned int fin:1;         /**< FIN flag */
 #  else
 #   error "Adjust your <bits/endian.h> defines"
@@ -231 +233 @@
   u_int8_t  ether_shost[6];      /* source ether addr    */
   u_int16_t ether_type;          /* packet type ID field , 0x8100 for VLAN */
-  u_int16_t vlan_pri:3;          /* vlan user priority */
-  u_int16_t vlan_cfi:1;          /* vlan format indicator, 0 for ethernet, 1 for token ring */
-  u_int16_t vlan_id:12;          /* vlan id */
+  unsigned int vlan_pri:3;       /* vlan user priority */
+  unsigned int vlan_cfi:1;       /* vlan format indicator, 0 for ethernet, 1 for token ring */
+  unsigned int vlan_id:12;       /* vlan id */
   u_int16_t vlan_ether_type;     /* vlan sub-packet type ID field (next-header)*/
 } __attribute__ ((packed)) libtrace_8021q_t;
@@ -240 +242 @@
 typedef struct libtrace_atm_cell
 {
-  u_int8_t gfc:4;
+  unsigned int gfc:4;
   u_int8_t vpi;
   u_int16_t vci;
-  u_int8_t pt:3;
-  u_int8_t clp:1;
-  u_int8_t hec;
+  unsigned int pt:3;
+  unsigned int clp:1;
+  unsigned int hec;
 } __attribute__ ((packed)) libtrace_atm_cell;
 
@@ -254 +256 @@
  u_int16_t ether_type;
 } __attribute__ ((packed)) libtrace_pos;
+/*@}*/
 
 /** Prints help information for libtrace 
@@ -265 +268 @@
  *
  * @param libtrace      the output trace to get the name of the format fo
- * @returns callee-owned null-terminated char* containing the output format
- *
- */
-SIMPLE_FUNCTION
-char *trace_get_output_format(const struct libtrace_out_t *libtrace);
+ * @return callee-owned null-terminated char* containing the output format
+ *
+ */
+SIMPLE_FUNCTION
+char *trace_get_output_format(const libtrace_out_t *libtrace);
 
 /** Prints error information
@@ -279 +282 @@
 /** @name Creation and destruction of traces
  * These members deal with creating, configuring and cleaning up a trace object
- */
-//@{
+ *@{
+ */
 
 /** Create a trace file from a URI
  * 
  * @param uri containing a valid libtrace URI
- * @returns opaque pointer to a libtrace_t
+ * @return opaque pointer to a libtrace_t
  *
  * Valid URI's are:
@@ -310 +313 @@
 /** Creates a "dummy" trace file that has only the format type set.
  *
- * @returns opaque pointer to a (sparsely initialised) libtrace_t
+ * @return opaque pointer to a (sparsely initialised) libtrace_t
  *
  * IMPORTANT: Do not attempt to call trace_read_packet or other such functions with
@@ -321 +324 @@
  *
  * @param uri   the uri string describing the output format and destination
- * @returns opaque pointer to a libtrace_output_t
+ * @return opaque pointer to a libtrace_output_t
  * @author Shane Alcock
  *
@@ -333 +336 @@
  *  and trace_errno is set. Use trace_perror() to get more information
  */
-struct libtrace_out_t *trace_create_output(const char *uri);
-
-/** Parses an output options string and calls the appropriate function to deal with output options.
- *
- * @param libtrace      the output trace object to apply the options to
- * @param options       the options string
- * @returns -1 if option configuration failed, 0 otherwise
- *
- * @author Shane Alcock
- */
-int trace_config_output(struct libtrace_out_t *libtrace, char *options);
+libtrace_out_t *trace_create_output(const char *uri);
+
+/** Start the capture
+ * @param libtrace      The trace to start
+ * @return 0 on success
+ *
+ * This does the actual work with starting the trace capture, and applying
+ * all the config options.  This may fail.
+ */
+int trace_start(libtrace_t *libtrace);
+
+/** Start an output trace
+ * @param libtrace      The trace to start
+ * @return 0 on success
+ *
+ * This does the actual work with starting a trace for write.  This generally
+ * creates the file.
+ */
+int trace_start_output(libtrace_out_t *libtrace);
+
+/** Valid trace capture options */
+typedef enum {
+        TRACE_OPTION_SNAPLEN, /**< Number of bytes captured */
+        TRACE_OPTION_PROMISC, /**< Capture packets to other hosts */
+        TRACE_OPTION_FILTER   /**< Apply this filter to all packets recieved */
+} trace_option_t;
+
+/** Sets an input config option
+ * @param libtrace      the trace object to apply the option to
+ * @param option        the option to set
+ * @param value         the value to set the option to
+ * @return -1 if option configuration failed, 0 otherwise
+ * This should be called after trace_create, and before trace_start
+ */
+int trace_config(libtrace_t *libtrace,
+                trace_option_t option,
+                void *value);
+
+typedef enum {
+        TRACE_OPTION_OUTPUT_FILEFLAGS, /**< File flags to open the trace file
+                                        * with.  eg O_APPEND
+                                        */
+        TRACE_OPTION_OUTPUT_COMPRESS   /**< Compression level, eg 6. */
+} trace_option_output_t;
+
+/** Sets an output config option
+ *
+ * @param libtrace      the output trace object to apply the option to
+ * @param option        the option to set
+ * @param value         the value to set the option to
+ * @return -1 if option configuration failed, 0 otherwise
+ * This should be called after trace_create_output, and before 
+ * trace_start_output
+ */
+int trace_config_output(libtrace_out_t *libtrace, 
+                trace_option_output_t option,
+                void *value
+                );
 
 /** Close a trace file, freeing up any resources it may have been using
  *
  */
-void trace_destroy(struct libtrace_t *trace);
+void trace_destroy(libtrace_t *trace);
 
 /** Close a trace file, freeing up any resources it may have been using
  * @param trace         trace file to be destroyed
  */
-void trace_destroy_dead(struct libtrace_t *trace);
+void trace_destroy_dead(libtrace_t *trace);
 
 /** Close a trace output file, freeing up any resources it may have been using
@@ -361 +411 @@
  * @author Shane Alcock
  */
-void trace_destroy_output(struct libtrace_out_t *trace);
-//@}
+void trace_destroy_output(libtrace_out_t *trace);
+/*@}*/
 
 /** @name Reading/Writing packets
  * These members deal with creating, reading and writing packets
- */
-//@{
+ *
+ * @{
+ */
 
 /** Create a new packet object
@@ -373 +424 @@
  * @return a pointer to an initialised libtrace_packet_t object
  */
-struct libtrace_packet_t *trace_create_packet();
+libtrace_packet_t *trace_create_packet();
 
 /** Destroy a packet object
@@ -379 +430 @@
  * sideeffect: sets packet to NULL
  */
-void trace_destroy_packet(struct libtrace_packet_t **packet);
+void trace_destroy_packet(libtrace_packet_t **packet);
 
 
@@ -386 +437 @@
  * @param trace         the libtrace opaque pointer
  * @param packet        the packet opaque pointer
- * @returns 0 on EOF, negative value on error
- *
- */
-int trace_read_packet(struct libtrace_t *trace, struct libtrace_packet_t *packet);
+ * @return 0 on EOF, negative value on error
+ *
+ * @note the trace must have been started with trace_start before calling
+ * this function
+ */
+int trace_read_packet(libtrace_t *trace, libtrace_packet_t *packet);
+
+/** Event types 
+ * see \ref libtrace_eventobj_t and \ref trace_event
+ */
+typedef enum {
+        TRACE_EVENT_IOWAIT,     /**< Need to block on fd */
+        TRACE_EVENT_SLEEP,      /**< Sleep for some time */
+        TRACE_EVENT_PACKET,     /**< packet has arrived */
+        TRACE_EVENT_TERMINATE   /**< End of trace */
+} libtrace_event_t;
+
+/** structure returned by libtrace_event explaining what the current event is */
+typedef struct libtrace_eventobj_t {
+        libtrace_event_t type; /**< event type (iowait,sleep,packet) */
+        int fd;                /**< if IOWAIT, the fd to sleep on */
+        double seconds;        /**< if SLEEP, the amount of time to sleep for */
+        int size;              /**< if PACKET, the value returned from trace_read_packet */
+} libtrace_eventobj_t;
+
+/** process a libtrace event
+ * @param trace the libtrace opaque pointer
+ * @param packet the libtrace_packet opaque pointer
+ * @return libtrace_event struct containing the type, and potential
+ *      fd or seconds to sleep on
+ *
+ * Type can be:
+ *  TRACE_EVENT_IOWAIT  Waiting on I/O on fd
+ *  TRACE_EVENT_SLEEP   Next event in seconds
+ *  TRACE_EVENT_PACKET  Packet arrived in buffer with size size
+ *  TRACE_EVENT_TERMINATE Trace terminated (perhaps with an error condition)
+ */
+libtrace_eventobj_t trace_event(libtrace_t *trace,
+                libtrace_packet_t *packet);
+
 
 /** Write one packet out to the output trace
@@ -395 +482 @@
  * @param trace         the libtrace_out opaque pointer
  * @param packet        the packet opaque pointer
- * @returns the number of bytes written out, if zero or negative then an error has occured.
- */
-int trace_write_packet(struct libtrace_out_t *trace, const struct libtrace_packet_t *packet);
-//@}
+ * @return the number of bytes written out, if zero or negative then an error has occured.
+ */
+int trace_write_packet(libtrace_out_t *trace, const libtrace_packet_t *packet);
+/*@}*/
 
 /** @name Headers
  * These functions locate and return a pointer to various headers inside a packet
- */
-//@{
+ * @{
+ */
 
 /** get a pointer to the link layer
  * @param packet        the packet opaque pointer
  *
- * @returns a pointer to the link layer, or NULL if there is no link layer
+ * @return a pointer to the link layer, or NULL if there is no link layer
  *
  * @note you should call getLinkType() to find out what type of link layer 
@@ -414 +501 @@
  */
 SIMPLE_FUNCTION
-void *trace_get_link(const struct libtrace_packet_t *packet);
+void *trace_get_link(const libtrace_packet_t *packet);
 
 /** get a pointer to the IP header (if any)
  * @param packet        the packet opaque pointer
  *
- * @returns a pointer to the IP header, or NULL if there is not an IP packet
- */
-SIMPLE_FUNCTION
-struct libtrace_ip *trace_get_ip(const struct libtrace_packet_t *packet);
+ * @return a pointer to the IP header, or NULL if there is not an IP packet
+ */
+SIMPLE_FUNCTION
+libtrace_ip_t *trace_get_ip(const libtrace_packet_t *packet);
 
 /** Gets a pointer to the transport layer header (if any)
  * @param packet        a pointer to a libtrace_packet structure
  *
- * @returns a pointer to the transport layer header, or NULL if there is no header
- */
-void *trace_get_transport(const struct libtrace_packet_t *packet);
+ * @return a pointer to the transport layer header, or NULL if there is no header
+ */
+void *trace_get_transport(const libtrace_packet_t *packet);
 
 /** Gets a pointer to the transport layer header (if any) given a pointer to the
@@ -436 +523 @@
  * @param[out] skipped  An output variable of the number of bytes skipped
  *
- * @returns a pointer to the transport layer header, or NULL if there is no header
+ * @return a pointer to the transport layer header, or NULL if there is no header
  *
  * Skipped can be NULL, in which case it will be ignored
  */
-void *trace_get_transport_from_ip(const struct libtrace_ip *ip, int *skipped);
+void *trace_get_transport_from_ip(const libtrace_ip_t *ip, int *skipped);
 
 /** get a pointer to the TCP header (if any)
  * @param packet        the packet opaque pointer
  *
- * @returns a pointer to the TCP header, or NULL if there is not a TCP packet
- */
-SIMPLE_FUNCTION
-struct libtrace_tcp *trace_get_tcp(const struct libtrace_packet_t *packet);
+ * @return a pointer to the TCP header, or NULL if there is not a TCP packet
+ */
+SIMPLE_FUNCTION
+libtrace_tcp_t *trace_get_tcp(const libtrace_packet_t *packet);
 
 /** get a pointer to the TCP header (if any) given a pointer to the IP header
@@ -454 +541 @@
  * @param[out] skipped  An output variable of the number of bytes skipped
  *
- * @returns a pointer to the TCP header, or NULL if this is not a TCP packet
+ * @return a pointer to the TCP header, or NULL if this is not a TCP packet
  *
  * Skipped can be NULL, in which case it will be ignored by the program.
@@ -461 +548 @@
  */
 SIMPLE_FUNCTION
-struct libtrace_tcp *trace_get_tcp_from_ip(const struct libtrace_ip *ip,int *skipped);
+libtrace_tcp_t *trace_get_tcp_from_ip(const libtrace_ip_t *ip,int *skipped);
 
 /** get a pointer to the UDP header (if any)
  * @param packet        the packet opaque pointer
  *
- * @returns a pointer to the UDP header, or NULL if this is not a UDP packet
- */
-SIMPLE_FUNCTION
-struct libtrace_udp *trace_get_udp(const struct libtrace_packet_t *packet);
+ * @return a pointer to the UDP header, or NULL if this is not a UDP packet
+ */
+SIMPLE_FUNCTION
+libtrace_udp_t *trace_get_udp(const libtrace_packet_t *packet);
 
 /** get a pointer to the UDP header (if any) given a pointer to the IP header
@@ -475 +562 @@
  * @param[out]  skipped An output variable of the number of bytes skipped
  *
- * @returns a pointer to the UDP header, or NULL if this is not an UDP packet
+ * @return a pointer to the UDP header, or NULL if this is not an UDP packet
  *
  * Skipped may be NULL, in which case it will be ignored by this function.
  */
 SIMPLE_FUNCTION
-struct libtrace_udp *trace_get_udp_from_ip(const struct libtrace_ip *ip,int *skipped);
+libtrace_udp_t *trace_get_udp_from_ip(const libtrace_ip_t *ip,int *skipped);
 
 /** get a pointer to the ICMP header (if any)
  * @param packet        the packet opaque pointer
  *
- * @returns a pointer to the ICMP header, or NULL if this is not a ICMP packet
- */
-SIMPLE_FUNCTION
-struct libtrace_icmp *trace_get_icmp(const struct libtrace_packet_t *packet);
+ * @return a pointer to the ICMP header, or NULL if this is not a ICMP packet
+ */
+SIMPLE_FUNCTION
+libtrace_icmp_t *trace_get_icmp(const libtrace_packet_t *packet);
 
 /** get a pointer to the ICMP header (if any) given a pointer to the IP header
@@ -494 +581 @@
  * @param[out] skipped  An output variable of the number of bytes skipped
  *
- * @returns a pointer to the ICMP header, or NULL if this is not an ICMP packet
+ * @return a pointer to the ICMP header, or NULL if this is not an ICMP packet
  *
  * Skipped may be NULL, in which case it will be ignored by this function
  */
 SIMPLE_FUNCTION
-struct libtrace_icmp *trace_get_icmp_from_ip(const struct libtrace_ip *ip,int *skipped);
-//@}
+libtrace_icmp_t *trace_get_icmp_from_ip(const libtrace_ip_t *ip,int *skipped);
+/*@}*/
 
 /** parse an ip or tcp option
@@ -509 +596 @@
  * @param[out] data     the data of the option
  *
- * @returns bool true if there is another option (and the fields are filled in)
+ * @return bool true if there is another option (and the fields are filled in)
  *               or false if this was the last option.
  *
@@ -528 +615 @@
  * These functions deal with time that a packet arrived and return it
  * in various formats
- */
-//@{
+ * @{
+ */
 /** Get the current time in DAG time format 
  * @param packet        the packet opaque pointer
  *
- * @returns a 64 bit timestamp in DAG ERF format (upper 32 bits are the seconds
+ * @return a 64 bit timestamp in DAG ERF format (upper 32 bits are the seconds
  * past 1970-01-01, the lower 32bits are partial seconds)
  * @author Daniel Lawson
  */
 SIMPLE_FUNCTION
-uint64_t trace_get_erf_timestamp(const struct libtrace_packet_t *packet);
+uint64_t trace_get_erf_timestamp(const libtrace_packet_t *packet);
 
 /** Get the current time in struct timeval
  * @param packet        the packet opaque pointer
  *
- * @returns time that this packet was seen in a struct timeval
+ * @return time that this packet was seen in a struct timeval
  * @author Daniel Lawson
  * @author Perry Lorier
  */ 
 SIMPLE_FUNCTION
-struct timeval trace_get_timeval(const struct libtrace_packet_t *packet);
+struct timeval trace_get_timeval(const libtrace_packet_t *packet);
 
 /** Get the current time in floating point seconds
  * @param packet        the packet opaque pointer
  *
- * @returns time that this packet was seen in 64bit floating point seconds
- * @author Daniel Lawson
- * @author Perry Lorier
- */
-SIMPLE_FUNCTION
-double trace_get_seconds(const struct libtrace_packet_t *packet);
-//@}
+ * @return time that this packet was seen in 64bit floating point seconds
+ * @author Daniel Lawson
+ * @author Perry Lorier
+ */
+SIMPLE_FUNCTION
+double trace_get_seconds(const libtrace_packet_t *packet);
+/*@}*/
 
 /** @name Sizes
  * This section deals with finding or setting the various different lengths
  * a packet can have
- */
-//@{
+ * @{
+ */
 /** Get the size of the packet in the trace
  * @param packet        the packet opaque pointer
- * @returns the size of the packet in the trace
+ * @return the size of the packet in the trace
  * @author Perry Lorier
  * @note Due to this being a header capture, or anonymisation, this may not
@@ -578 +665 @@
  */
 SIMPLE_FUNCTION
-int trace_get_capture_length(const struct libtrace_packet_t *packet);
+int trace_get_capture_length(const libtrace_packet_t *packet);
 
 /** Get the size of the packet as it was seen on the wire.
  * @param packet        the packet opaque pointer
- * @returns the size of the packet as it was on the wire.
+ * @return the size of the packet as it was on the wire.
  * @author Perry Lorier
  * @author Daniel Lawson
@@ -589 +676 @@
  */ 
 SIMPLE_FUNCTION
-int trace_get_wire_length(const struct libtrace_packet_t *packet);
+int trace_get_wire_length(const libtrace_packet_t *packet);
 
 /** Get the length of the capture framing headers.
  * @param packet        the packet opaque pointer
- * @returns the size of the packet as it was on the wire.
+ * @return the size of the packet as it was on the wire.
  * @author Perry Lorier
  * @author Daniel Lawson
@@ -600 +687 @@
  */ 
 SIMPLE_FUNCTION
-int trace_get_framing_length(const struct libtrace_packet_t *packet);
+int trace_get_framing_length(const libtrace_packet_t *packet);
 
 /** Truncate the packet at the suggested length
  * @param packet        the packet opaque pointer
  * @param size          the new length of the packet
- * @returns the new length of the packet, or the original length of the 
+ * @return the new length of the packet, or the original length of the 
  * packet if unchanged
  * @author Daniel Lawson
  */
-size_t trace_set_capture_length(struct libtrace_packet_t *packet, size_t size);
-
-//@}
+size_t trace_set_capture_length(libtrace_packet_t *packet, size_t size);
+
+/*@}*/
 
 
@@ -635 +722 @@
 /** Get the type of the link layer
  * @param packet        the packet opaque pointer
- * @returns libtrace_linktype_t
- * @author Perry Lorier
- * @author Daniel Lawson
- */
-SIMPLE_FUNCTION
-inline libtrace_linktype_t trace_get_link_type(const struct libtrace_packet_t *packet);
+ * @return libtrace_linktype_t
+ * @author Perry Lorier
+ * @author Daniel Lawson
+ */
+SIMPLE_FUNCTION
+inline libtrace_linktype_t trace_get_link_type(const libtrace_packet_t *packet);
 
 /** Get the destination MAC addres
  * @param packet        the packet opaque pointer
- * @returns a pointer to the destination mac, (or NULL if there is no 
+ * @return a pointer to the destination mac, (or NULL if there is no 
  * destination MAC)
  * @author Perry Lorier
  */
 SIMPLE_FUNCTION
-uint8_t *trace_get_destination_mac(const struct libtrace_packet_t *packet);
+uint8_t *trace_get_destination_mac(const libtrace_packet_t *packet);
 
 /** Get the source MAC addres
  * @param packet        the packet opaque pointer
- * @returns a pointer to the source mac, (or NULL if there is no source MAC)
- * @author Perry Lorier
- */
-SIMPLE_FUNCTION
-uint8_t *trace_get_source_mac(const struct libtrace_packet_t *packet);
+ * @return a pointer to the source mac, (or NULL if there is no source MAC)
+ * @author Perry Lorier
+ */
+SIMPLE_FUNCTION
+uint8_t *trace_get_source_mac(const libtrace_packet_t *packet);
 
 /** Set the direction flag, if it has one
  * @param packet        the packet opaque pointer
  * @param direction     the new direction (0,1,2,3)
- * @returns a signed value containing the direction flag, or -1 if this is not supported
- * @author Daniel Lawson
- */
-int8_t trace_set_direction(struct libtrace_packet_t *packet, int8_t direction);
+ * @return a signed value containing the direction flag, or -1 if this is not supported
+ * @author Daniel Lawson
+ */
+int8_t trace_set_direction(libtrace_packet_t *packet, int8_t direction);
 
 /** Get the direction flag, if it has one
  * @param packet        the packet opaque pointer
- * @returns a signed value containing the direction flag, or -1 if this is not supported
+ * @return a signed value containing the direction flag, or -1 if this is not supported
  * The direction is defined as 0 for packets originating locally (ie, outbound)
  * and 1 for packets originating remotely (ie, inbound).
@@ -677 +764 @@
  */
 SIMPLE_FUNCTION
-int8_t trace_get_direction(const struct libtrace_packet_t *packet);
-
-/** Event types 
- * see \ref libtrace_eventobj_t and \ref trace_event
- */
-typedef enum {
-        TRACE_EVENT_IOWAIT,     /**< Need to block on fd */
-        TRACE_EVENT_SLEEP,      /**< Sleep for some time */
-        TRACE_EVENT_PACKET,     /**< packet has arrived */
-        TRACE_EVENT_TERMINATE   /**< End of trace */
-} libtrace_event_t;
-
-/** structure returned by libtrace_event explaining what the current event is */
-struct libtrace_eventobj_t {
-        libtrace_event_t type; /**< event type (iowait,sleep,packet) */
-        int fd;                /**< if IOWAIT, the fd to sleep on */
-        double seconds;        /**< if SLEEP, the amount of time to sleep for */
-        int size;              /**< if PACKET, the value returned from trace_read_packet */
-};
-
-/** process a libtrace event
- * @param trace the libtrace opaque pointer
- * @param packet the libtrace_packet opaque pointer
- * @returns libtrace_event struct containing the type, and potential
- *      fd or seconds to sleep on
- *
- * Type can be:
- *  TRACE_EVENT_IOWAIT  Waiting on I/O on fd
- *  TRACE_EVENT_SLEEP   Next event in seconds
- *  TRACE_EVENT_PACKET  Packet arrived in buffer with size size
- *  TRACE_EVENT_TERMINATE Trace terminated (perhaps with an error condition)
- */
-struct libtrace_eventobj_t trace_event(struct libtrace_t *trace,
-                struct libtrace_packet_t *packet);
+int8_t trace_get_direction(const libtrace_packet_t *packet);
 
 /** @name BPF
  * This section deals with using Berkley Packet Filters
- */
-//@{
+ * @{
+ */
 /** setup a BPF filter
  * @param filterstring a char * containing the bpf filter string
- * @returns opaque pointer pointer to a libtrace_filter_t object
+ * @return opaque pointer pointer to a libtrace_filter_t object
  * @author Daniel Lawson
  * @note The filter is not actually compiled at this point, so no correctness
@@ -726 +780 @@
  */
 SIMPLE_FUNCTION
-struct libtrace_filter_t *trace_bpf_setfilter(const char *filterstring);
+libtrace_filter_t *trace_bpf_setfilter(const char *filterstring);
 
 /** apply a BPF filter
  * @param filter        the filter opaque pointer
  * @param packet        the packet opaque pointer
- * @returns 0 if the filter fails, 1 if it succeeds
+ * @return 0 if the filter fails, 1 if it succeeds
  * @author Daniel Lawson
  * @note Due to the way BPF filters are built, the filter is not actually compiled
  * until the first time trace_bpf_filter is called. If your filter is incorrect, it will generate an error message and assert, exiting the program. This behaviour may change to more graceful handling of this error in the future.
  */
-int trace_bpf_filter(struct libtrace_filter_t *filter,
-                const struct libtrace_packet_t *packet);
-//@}
+int trace_bpf_filter(libtrace_filter_t *filter,
+                const libtrace_packet_t *packet);
+/*@}*/
 
 /** Which port is the server port */
@@ -748 +802 @@
 /** Get the source port
  * @param packet        the packet to read from
- * @returns a port in \em HOST byte order, or equivilent to ports for this
+ * @return a port in \em HOST byte order, or equivilent to ports for this
  * protocol, or 0 if this protocol has no ports.
  * @author Perry Lorier
  */
 SIMPLE_FUNCTION
-uint16_t trace_get_source_port(const struct libtrace_packet_t *packet);
+uint16_t trace_get_source_port(const libtrace_packet_t *packet);
 
 /** Get the destination port
  * @param packet        the packet to read from
- * @returns a port in \em HOST byte order, or equivilent to ports for this
+ * @return a port in \em HOST byte order, or equivilent to ports for this
  * protocol, or 0 if this protocol has no ports.
  * @author Perry Lorier
  */
 SIMPLE_FUNCTION
-uint16_t trace_get_destination_port(const struct libtrace_packet_t *packet);
+uint16_t trace_get_destination_port(const libtrace_packet_t *packet);
 
 /** hint at the server port in specified protocol
@@ -768 +822 @@
  * @param source        the source port from the packet
  * @param dest          the destination port from the packet
- * @returns one of USE_SOURCE or USE_DEST depending on which one you should use
+ * @return one of USE_SOURCE or USE_DEST depending on which one you should use
  * @note ports must be in \em HOST byte order!
  * @author Daniel Lawson
@@ -779 +833 @@
  * @param uri           the uri to be parsed
  * @param format        destination location for the format component of the uri 
- * @returns 0 if an error occured, otherwise returns the uridata component
+ * @return 0 if an error occured, otherwise return the uridata component
  * @author Shane Alcock
  */
 const char *trace_parse_uri(const char *uri, char **format);
 #ifdef __cplusplus
-} // extern "C"
-#endif // #ifdef __cplusplus
-#endif // LIBTRACE_H_
+} /* extern "C" */
+#endif /* #ifdef __cplusplus */
+#endif /* LIBTRACE_H_ */

lib/libtrace_int.h

@@ -77 +77 @@
 
 extern struct trace_err_t{
-        int err_num;    // error code
-        char problem[255];      // the format, uri etc that caused the error for reporting purposes
+        int err_num;            /* error code */
+        char problem[255];      /* the format, uri etc that caused the error for reporting purposes */
 } trace_err;
 
@@ -153 +153 @@
         char *type;
         int (*init_input)(struct libtrace_t *libtrace);
-        int (*config_input)(struct libtrace_t *libtrace,char *option,void *value);
+        int (*config_input)(struct libtrace_t *libtrace,trace_option_t option,void *value);
         int (*start_input)(struct libtrace_t *libtrace);
         int (*init_output)(struct libtrace_out_t *libtrace);
-        int (*config_output)(struct libtrace_out_t *libtrace, int argc, char *argv[]);
+        int (*config_output)(struct libtrace_out_t *libtrace, trace_option_output_t, void *);
         int (*start_output)(struct libtrace_out_t *libtrace);
         int (*fin_input)(struct libtrace_t *libtrace);
@@ -180 +180 @@
 
 void register_format(struct libtrace_format_t *format);
+
+libtrace_linktype_t pcap_dlt_to_libtrace(int dlt);
+char libtrace_to_pcap_dlt(libtrace_linktype_t type);
+libtrace_linktype_t erf_type_to_libtrace(char erf);
+char libtrace_to_erf_type(libtrace_linktype_t linktype);
+
         
 #ifdef __cplusplus
@@ -185 +191 @@
 #endif
 
-#endif // LIBTRACE_INT_H
+#endif /* LIBTRACE_INT_H */

lib/parse_cmd.h

@@ -5 +5 @@
 
 
-#endif // PARSE_CMD_H
+#endif /* PARSE_CMD_H */

lib/trace.c

@@ -264 +264 @@
         trace_err.err_num = E_NOERROR;
         
-        // parse the URI to determine what sort of event we are dealing with
+        /* parse the URI to determine what sort of event we are dealing with */
         if ((uridata = trace_parse_uri(uri, &scan)) == 0) {
                 return 0;
@@ -284 +284 @@
                 trace_err.err_num = E_BAD_FORMAT;
                 strcpy(trace_err.problem, scan);
-                //trace_err.problem = scan;
                 return 0;
         }
 
         libtrace->uridata = strdup(uridata);
-        // libtrace->format now contains the type of uri
-        // libtrace->uridata contains the appropriate data for this
+        /* libtrace->format now contains the type of uri
+         * libtrace->uridata contains the appropriate data for this
+         */
         
         if (libtrace->format->init_input) {
@@ -296 +296 @@
                         trace_err.err_num = E_INIT_FAILED;
                         strcpy(trace_err.problem, scan);
-                        //trace_err.problem = scan;
                         return 0;
                 }
@@ -302 +301 @@
                 trace_err.err_num = E_NO_INIT;
                 strcpy(trace_err.problem, scan);
-                //trace_err.problem = scan;
                 return 0;
         }
@@ -350 +348 @@
                 trace_err.err_num = E_BAD_FORMAT;
                 strcpy(trace_err.problem, scan);
-                //trace_err.problem = scan;
                 return 0;
         }
@@ -383 +380 @@
 
         trace_err.err_num = E_NOERROR;
-        // parse the URI to determine what sort of event we are dealing with
+        /* parse the URI to determine what sort of event we are dealing with */
 
         if ((uridata = trace_parse_uri(uri, &scan)) == 0) {
@@ -403 +400 @@
                 trace_err.err_num = E_BAD_FORMAT;
                 strcpy(trace_err.problem, scan);
-                //trace_err.problem = scan;     
                 return 0;
         }
@@ -409 +405 @@
 
 
-        // libtrace->format now contains the type of uri
-        // libtrace->uridata contains the appropriate data for this
+        /* libtrace->format now contains the type of uri
+         * libtrace->uridata contains the appropriate data for this
+         */
 
         if (libtrace->format->init_output) {
@@ -419 +416 @@
                 trace_err.err_num = E_NO_INIT_OUT;
                 strcpy(trace_err.problem, scan);
-                //trace_err.problem = scan;
                 return 0;
         }
@@ -458 +454 @@
  * @author Shane Alcock
  */
-int trace_config_output(struct libtrace_out_t *libtrace, char *options) {
-        char *opt_string = 0;
-        char *opt_argv[MAXOPTS];
-        int opt_argc = 0;
-        
-        assert(libtrace);
-        
-        if (!options) {
-                return 0;
-        }
-        asprintf(&opt_string, "%s %s", libtrace->format->name, options);
-        parse_cmd(opt_string, &opt_argc, opt_argv, MAXOPTS);
-        
+int trace_config_output(struct libtrace_out_t *libtrace, 
+                trace_option_output_t option,
+                void *value) {
         if (libtrace->format->config_output) {
-                return libtrace->format->config_output(libtrace, opt_argc, opt_argv);
+                return libtrace->format->config_output(libtrace, option, value);
         }
         return -1;
@@ -483 +469 @@
         assert(libtrace);
         libtrace->format->fin_input(libtrace);
-        // need to free things!
+        /* need to free things! */
         free(libtrace->uridata);
         destroy_tracefifo(libtrace->fifo);
@@ -508 +494 @@
 }
 
-/** Create a new packet object
- *
- * @ return a pointer to an initialised libtrace_packet_t structure
- */
-struct libtrace_packet_t *trace_create_packet() {
-        struct libtrace_packet_t *packet = calloc(1,sizeof(struct libtrace_packet_t));
-        packet->buffer = malloc(LIBTRACE_PACKET_BUFSIZE);
-        packet->buf_control = PACKET;
+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?
+         */
         return packet;
 }
@@ -607 +590 @@
                 case TRACE_TYPE_80211_PRISM:
                         {
-                                struct ieee_802_11_header *wifi = trace_get_link(packet)+144;
+                                struct ieee_802_11_header *wifi = (char*)trace_get_link(packet)+144;
                                 if (!wifi) {
                                         ipptr = NULL;
@@ -613 +596 @@
                                 }
 
-                                // Data packet?
+                                /* Data packet? */
                                 if (wifi->type != 2) {
                                         ipptr = NULL;
@@ -644 +627 @@
                                 }
 
-                                // Data packet?
+                                /* Data packet? */
                                 if (wifi->type != 2) {
                                         ipptr = NULL;
@@ -727 +710 @@
                 case TRACE_TYPE_LEGACY_POS:
                         {
-                                // 64 byte capture. 
+                                /* 64 byte capture. */
                                 struct libtrace_pos *pos = 
                                         trace_get_link(packet);
@@ -741 +724 @@
                 case TRACE_TYPE_ATM:
                         {
-                                // 64 byte capture.
+                                /* 64 byte capture. */
                                 struct libtrace_llcsnap *llc = 
                                         trace_get_link(packet);
 
-                                // advance the llc ptr +4 into the link layer.
-                                // need to check what is in these 4 bytes.
-                                // don't have time!
+                                /* advance the llc ptr +4 into the link layer.
+                                 * need to check what is in these 4 bytes.
+                                 * don't have time!
+                                 */
                                 llc = (void *)llc + 4;
                                 if (ntohs(llc->type) == 0x0800) {
@@ -796 +780 @@
  * Skipped can be NULL, in which case it will be ignored
  */
-void *trace_get_transport_from_ip(const struct libtrace_ip *ip, int *skipped) {
+void *trace_get_transport_from_ip(const libtrace_ip_t *ip, int *skipped) {
         void *trans_ptr = 0;    
 
@@ -814 +798 @@
  * @returns a pointer to the TCP header, or NULL if there is not a TCP packet
  */
-struct libtrace_tcp *trace_get_tcp(const struct libtrace_packet_t *packet) {
+libtrace_tcp_t *trace_get_tcp(const libtrace_packet_t *packet) {
         struct libtrace_tcp *tcpptr = 0;
         struct libtrace_ip *ipptr = 0;
@@ -835 +819 @@
  * Skipped can be NULL, in which case it will be ignored by the program.
  */
-struct libtrace_tcp *trace_get_tcp_from_ip(const struct libtrace_ip *ip, int *skipped)
+libtrace_tcp_t *trace_get_tcp_from_ip(const libtrace_ip_t *ip, int *skipped)
 {
-#define SW_IP_OFFMASK 0xff1f
         struct libtrace_tcp *tcpptr = 0;
 
@@ -958 +941 @@
                         *optlen = *(*ptr+1);
                         if (*optlen<2)
-                                return 0; // I have no idea wtf is going on
-                                          // with these packets
+                                return 0; /* I have no idea wtf is going on
+                                           * with these packets
+                                           */
                         (*len)-=*optlen;
                         (*data)=(*ptr+2);
@@ -985 +969 @@
 
         if (packet->trace->format->get_erf_timestamp) {
-                // timestamp -> timestamp
+                /* timestamp -> timestamp */
                 timestamp = packet->trace->format->get_erf_timestamp(packet);
         } else if (packet->trace->format->get_timeval) {
-                // timeval -> timestamp
+                /* timeval -> timestamp */
                 ts = packet->trace->format->get_timeval(packet);
                 timestamp = ((((uint64_t)ts.tv_sec) << 32) + \
                                 (((uint64_t)ts.tv_usec * UINT_MAX)/1000000));
         } else if (packet->trace->format->get_seconds) {
-                // seconds -> timestamp
+                /* seconds -> timestamp */
                 seconds = packet->trace->format->get_seconds(packet);
                 timestamp = ((uint64_t)((uint32_t)seconds) << 32) + \
@@ -1014 +998 @@
         assert(packet->size>0 && packet->size<65536);
         if (packet->trace->format->get_timeval) {
-                // timeval -> timeval
+                /* timeval -> timeval */
                 tv = packet->trace->format->get_timeval(packet);
         } else if (packet->trace->format->get_erf_timestamp) {
-                // timestamp -> timeval
+                /* timestamp -> timeval */
                 ts = packet->trace->format->get_erf_timestamp(packet);
 #if __BYTE_ORDER == __BIG_ENDIAN
@@ -1034 +1018 @@
                 }
         } else if (packet->trace->format->get_seconds) {
-                // seconds -> timeval
+                /* seconds -> timeval */
                 seconds = packet->trace->format->get_seconds(packet);
                 tv.tv_sec = (uint32_t)seconds;
@@ -1056 +1040 @@
         
         if (packet->trace->format->get_seconds) {
-                // seconds->seconds
+                /* seconds->seconds */
                 seconds = packet->trace->format->get_seconds(packet);
         } else if (packet->trace->format->get_erf_timestamp) {
-                // timestamp -> seconds
+                /* timestamp -> seconds */
                 ts = packet->trace->format->get_erf_timestamp(packet);
                 seconds =  (ts>>32) + ((ts & UINT_MAX)*1.0 / UINT_MAX);
         } else if (packet->trace->format->get_timeval) {
-                // timeval -> seconds
+                /* timeval -> seconds */
                 tv = packet->trace->format->get_timeval(packet);
                 seconds = tv.tv_sec + ((tv.tv_usec * UINT_MAX * 1.0)/1000000);
@@ -1265 +1249 @@
                 pcap_t *pcap;
                 struct bpf_program bpfprog;
-
-                switch (trace_get_link_type(packet)) {
-                        case TRACE_TYPE_ETH:
-                                pcap = (pcap_t *)pcap_open_dead(DLT_EN10MB, 1500);
-                                break;
-#ifdef DLT_LINUX_SLL
-                        case TRACE_TYPE_LINUX_SLL:
-                                pcap = (pcap_t *)pcap_open_dead(DLT_LINUX_SLL, 1500);
-                                break;
-#endif
-#ifdef DLT_PFLOG
-                        case TRACE_TYPE_PFLOG:
-                                pcap = (pcap_t *)pcap_open_dead(DLT_PFLOG, 1500);
-                                break;
-#endif
-                        default:
-                                printf("only works for ETH and LINUX_SLL (ppp) at the moment\n");
-                                assert(0);
-                }               
-
-                // build filter
+                pcap=(pcap_t *)pcap_open_dead(
+                                libtrace_to_pcap_dlt(trace_get_link_type(packet)),
+                                1500);
+                /* build filter */
                 if (pcap_compile( pcap, &bpfprog, filter->filterstring, 1, 0)) {
                         printf("bpf compilation error: %s: %s\n", 
@@ -1481 +1448 @@
                 return USE_DEST;
         */
-        // failing that test...
+        /* failing that test... */
         if (source < dest) {
                 return USE_SOURCE;
@@ -1516 +1483 @@
         
         if((uridata = strchr(uri,':')) == NULL) {
-                // badly formed URI - needs a :
+                /* badly formed URI - needs a : */
                 trace_err.err_num = E_URI_NOCOLON;
                 return 0;
@@ -1522 +1489 @@
 
         if ((uridata - uri) > URI_PROTO_LINE) {
-                // badly formed URI - uri type is too long
+                /* badly formed URI - uri type is too long */
                 trace_err.err_num = E_URI_LONG;
                 return 0;
@@ -1529 +1496 @@
         *format=xstrndup(uri, (uridata - uri));
 
-        // push uridata past the delimiter
+        /* push uridata past the delimiter */
         uridata++;
         

lib/wag.h

@@ -31 +31 @@
 #define _WAG_H_
 
-// Generic field breakdowns
+/* Generic field breakdowns */
 struct wag_frame_hdr {
   uint16_t magic;
@@ -44 +44 @@
 };
 
-// Received packet frame fields
+/* Received packet frame fields */
 struct wag_stream_info {
   uint16_t unused_1;
@@ -73 +73 @@
 };
 
-// Transmit packet frame fields
+/* Transmit packet frame fields */
 struct wag_txparams {
   uint8_t         gain;
@@ -90 +90 @@
 
 struct ieee_802_11_header {
-        uint8_t      protocol:2;
-        uint8_t      type:2;
-        uint8_t      subtype:4;
-        uint8_t      to_ds:1;
-        uint8_t      from_ds:1;
-        uint8_t      more_frag:1;
-        uint8_t      retry:1;
-        uint8_t      power:1;
-        uint8_t      more_data:1;
-        uint8_t      wep:1;
-        uint8_t      order:1;
+        unsigned int protocol:2;
+        unsigned int type:2;
+        unsigned int subtype:4;
+        unsigned int to_ds:1;
+        unsigned int from_ds:1;
+        unsigned int more_frag:1;
+        unsigned int retry:1;
+        unsigned int power:1;
+        unsigned int more_data:1;
+        unsigned int wep:1;
+        unsigned int order:1;
         uint16_t     duration;
         uint8_t      mac1[6];