Changeset 0a6638f


Ignore:
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:
6 edited

Legend:

Unmodified
Added
Removed
  • lib/format_erf.c

    r65a5900 r0a6638f  
    281281}
    282282
    283 static int erf_open_output(struct libtrace_out_t *libtrace) {
    284         char *filemode;
    285         int fd;
    286 
    287 #if HAVE_ZLIB
    288         asprintf(&filemode,"wb%d",OPTIONS.erf.level);
    289 #else
    290         asprintf(&filemode,"w");
    291 #endif
    292 
    293         if (!strncmp(libtrace->uridata,"-",1)) {
    294                 /* STDOUT */
    295                 OUTPUT.file = LIBTRACE_FDOPEN(fileno(stdout),filemode);
    296         }
    297         else {
    298                 /* TRACE */
    299                 fd = open(libtrace->uridata,
    300                                 OPTIONS.erf.fileflag,
    301                                 S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
    302                 if (fd <= 0) {
    303                         trace_set_err(errno,"OPEN(%s,\"w\")",
    304                                         libtrace->uridata);
    305                         return 0;
    306                 }
    307                 OUTPUT.file = LIBTRACE_FDOPEN(fd,filemode);
    308 
    309         }
    310         free(filemode);
    311         return 1;
    312 }
    313 
    314283static int erf_config_output(struct libtrace_out_t *libtrace, trace_option_t option, void *value) {
    315284
     
    428397        void *buffer2 = packet->buffer;
    429398        int rlen;
    430         if (packet->buf_control == EXTERNAL) {
    431                 packet->buf_control = PACKET;
    432                 packet->buffer = malloc(LIBTRACE_PACKET_BUFSIZE);
    433         }
    434         packet->header = packet->buffer;
    435 
    436         if (packet->buffer) {
     399
     400        if (!packet->buffer) {
    437401                packet->buffer = malloc(LIBTRACE_PACKET_BUFSIZE);
    438402                packet->buf_control = PACKET;
    439403        }
    440404
     405        packet->header = packet->buffer;
    441406
    442407        if ((numbytes=LIBTRACE_READ(INPUT.file,
     
    455420        size = rlen - dag_record_size;
    456421        assert(size < LIBTRACE_PACKET_BUFSIZE);
     422
    457423       
    458424        /* Unknown/corrupt */
     
    589555        }
    590556
    591         if (buffer) {
    592                 if ((numbytes=LIBTRACE_WRITE(OUTPUT.file, buffer, size)) == 0) {
    593                         trace_set_err(errno,"write(%s)",libtrace->uridata);
    594                         return -1;
    595                 }
    596        
    597                 return numbytes + pad + dag_record_size;
    598         }
    599         return numbytes;
     557        if ((numbytes=LIBTRACE_WRITE(OUTPUT.file, buffer, size)) == 0) {
     558                trace_set_err(errno,"write(%s)",libtrace->uridata);
     559                return -1;
     560        }
     561
     562        return numbytes + pad + dag_record_size;
     563}
     564
     565static int erf_start_output(libtrace_out_t *libtrace)
     566{
     567        OUTPUT.file = trace_open_file_out(libtrace,
     568                        OPTIONS.erf.level,
     569                        OPTIONS.erf.fileflag);
     570        if (!OUTPUT.file) {
     571                printf("%s\n",trace_err.problem);
     572                return -1;
     573        }
     574        return 0;
    600575}
    601576               
    602 static int erf_write_packet(struct libtrace_out_t *libtrace, const struct libtrace_packet_t *packet) {
     577static int erf_write_packet(libtrace_out_t *libtrace,
     578                const libtrace_packet_t *packet)
     579{
    603580        int numbytes = 0;
    604581        dag_record_t erfhdr;
     
    607584        void *payload = packet->payload;
    608585
    609         /* Because of configuration, we don't actually open the output file
    610            until we get the first packet. Not ideal, but it'll do for now */
    611         if (!OUTPUT.file) {
    612                 if (erf_open_output(libtrace) <= 0) {
    613                         trace_set_err(errno,"open(%s)",libtrace->uridata);
    614                         return -1;
    615                 }
    616         }
     586        assert(OUTPUT.file);
    617587
    618588        pad = erf_get_padding(packet);
     
    633603                                pad,
    634604                                payload,
    635                                 packet->size -
    636                                         (dag_record_size + pad));
     605                                trace_get_capture_length(packet)
     606                                );
    637607        } else {
    638608                /* convert format - build up a new erf header */
     
    810780        erf_init_output,                /* init_output */
    811781        erf_config_output,              /* config_output */
    812         NULL,                           /* start_output */
     782        erf_start_output,               /* start_output */
    813783        erf_fin_input,                  /* fin_input */
    814784        erf_fin_output,                 /* fin_output */
  • lib/format_helper.c

    r3d4d52d r0a6638f  
    4646
    4747#include <sys/ioctl.h>
     48#include <assert.h>
    4849
    4950struct libtrace_eventobj_t trace_event_device(struct libtrace_t *trace, struct libtrace_packet_t *packet) {
     
    165166        return ret;
    166167}
     168
     169LIBTRACE_FILE trace_open_file_out(libtrace_out_t *trace,int level, int fileflag)
     170{
     171        int fd;
     172        LIBTRACE_FILE ret;
     173        char filemode[4]; /* wb9\0 */
     174        assert(level<10);
     175        assert(level>=0);
     176#if HAVE_ZLIB
     177        sprintf(filemode,"wb%d",level);
     178#else
     179        sprintf(filemode,"w");
     180#endif
     181
     182        if (strcmp(trace->uridata,"-")==0) {
     183                ret=LIBTRACE_FDOPEN(fileno(stdout),filemode);
     184                return ret;
     185        }
     186
     187        /* We open the file with open(2), so we can provide O_LARGEFILE
     188         * as zlib doesn't always do it itself
     189         */
     190        fd=open(trace->uridata,fileflag,0666);
     191        if (fd==-1) {
     192                trace_set_err(errno,"Unable to open %s",trace->uridata);
     193                return 0;
     194        }
     195        ret=LIBTRACE_FDOPEN(fd,filemode);
     196        if (ret==NULL) {
     197                printf("%s\n",filemode);
     198                trace_set_err(TRACE_ERR_INIT_FAILED,"gz out of memory");
     199        }
     200        return ret;
     201}
     202
     203
     204
  • lib/format_helper.h

    r3d4d52d r0a6638f  
    3939
    4040LIBTRACE_FILE trace_open_file(libtrace_t *libtrace);
     41LIBTRACE_FILE trace_open_file_out(libtrace_out_t *libtrace,
     42                int level,
     43                int filemode);
    4144#endif /* FORMAT_HELPER_H */
  • lib/libtrace.h

    r3d4d52d r0a6638f  
    8686typedef struct libtrace_filter_t libtrace_filter_t;
    8787
    88 typedef enum {PACKET, EXTERNAL } buf_control_t;
     88/* the letters p and e are magic numbers used to detect if the packet
     89 * wasn't created properly
     90 */
     91typedef enum {PACKET='p', EXTERNAL='e' } buf_control_t;
    8992/** Structure holding information about a packet */
    9093#define LIBTRACE_PACKET_BUFSIZE 65536
  • lib/libtrace_int.h

    rdf338b3 r0a6638f  
    116116        char *uridata;
    117117        struct tracefifo_t *fifo;
     118        bool started;
    118119};
    119120
  • lib/trace.c

    rdf338b3 r0a6638f  
    331331 */
    332332       
    333 struct libtrace_out_t *trace_create_output(const char *uri) {
     333libtrace_out_t *trace_create_output(const char *uri) {
    334334        struct libtrace_out_t *libtrace = malloc(sizeof(struct libtrace_out_t));
    335335       
     
    382382        assert( libtrace->fifo);
    383383        free(scan);
     384        libtrace->started=false;
    384385        return libtrace;
    385386}
     
    403404
    404405        libtrace->started=true;
     406        return 0;
     407}
     408
     409int trace_start_output(libtrace_out_t *libtrace)
     410{
     411        assert(libtrace);
     412        if (libtrace->format->start_output) {
     413                int ret=libtrace->format->start_output(libtrace);
     414                if (ret < 0) {
     415                        return ret;
     416                }
     417        }
     418
     419        libtrace->started=false;
    405420        return 0;
    406421}
     
    495510libtrace_packet_t *trace_create_packet() {
    496511        libtrace_packet_t *packet = calloc(1,sizeof(libtrace_packet_t));
    497         /* This used to malloc a packet!  Why do we need to malloc a packet
    498          * if we're doing zero copy?
    499          */
     512        packet->buf_control=PACKET;
    500513        return packet;
    501514}
     
    525538        assert(libtrace->started && "BUG: You must call libtrace_start() before trace_read_packet()\n");
    526539        assert(packet);
     540        assert((packet->buf_control==PACKET || packet->buf_control==EXTERNAL)&&
     541                "BUG: You must allocate a packet using packet_create()");
    527542     
    528543        /* Store the trace we are reading from into the packet opaque
     
    15551570 * @param errcode either an Econstant from libc, or a LIBTRACE_ERROR
    15561571 * @param msg a plaintext error message
     1572 * @internal
    15571573 */
    15581574void trace_set_err(int errcode,const char *msg,...)
Note: See TracChangeset for help on using the changeset viewer.