Changeset 7068467 for lib/format_erf.c


Ignore:
Timestamp:
02/10/06 18:02:32 (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:
6eb91ff
Parents:
7f32bb5
Message:

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

File:
1 edited

Legend:

Unmodified
Added
Removed
  • lib/format_erf.c

    r37195b4 r7068467  
    3030#define _GNU_SOURCE
    3131
     32#define RT_MSG 2
     33#define RT_DATA 1
     34
    3235#include "config.h"
    3336#include "common.h"
     
    98101                gzFile *file;
    99102#else   
    100                 //FILE  *file;
    101103                int file;
    102104#endif
     
    129131                struct {
    130132                        int level;
    131                         int append;
     133                        int fileflag;
    132134                } erf;
    133135               
     
    140142                gzFile *file;
    141143#else
    142                 //FILE *file;
    143144                int file;
    144145#endif
    145146        } output;
    146147};
     148
     149/** Structure holding status information for a packet */
     150typedef struct libtrace_packet_status {
     151        uint8_t type;
     152        uint8_t reserved;
     153        uint16_t message;
     154} libtrace_packet_status_t;
     155
    147156
    148157#ifdef HAVE_DAG
     
    158167        }
    159168        if (S_ISCHR(buf.st_mode)) {
    160                 // DEVICE
     169                /* DEVICE */
    161170                libtrace->sourcetype = DEVICE;
    162171                if((INPUT.fd = dag_open(CONNINFO.path)) < 0) {
     
    209218        CONNINFO.path = libtrace->uridata;
    210219        if (!strncmp(CONNINFO.path,"-",1)) {
    211                 // STDIN
     220                /* STDIN */
    212221                libtrace->sourcetype = STDIN;
    213222                INPUT.file = LIBTRACE_FDOPEN(fileno(stdin), "r");
     
    242251                        libtrace->sourcetype = TRACE;
    243252
    244                         // we use an FDOPEN call to reopen an FD
    245                         // returned from open(), so that we can set
    246                         // O_LARGEFILE. This gets around gzopen not
    247                         // letting you do this...
     253                        /* we use an FDOPEN call to reopen an FD
     254                         * returned from open(), so that we can set
     255                         * O_LARGEFILE. This gets around gzopen not
     256                         * letting you do this...
     257                         */
    248258                        INPUT.file = LIBTRACE_FDOPEN(open(
    249259                                                CONNINFO.path,
     
    307317
    308318static int erf_init_output(struct libtrace_out_t *libtrace) {
    309         int fd;
    310319        libtrace->format_data = (struct libtrace_format_data_out_t *)
    311320                calloc(1,sizeof(struct libtrace_format_data_out_t));
    312321
    313322        OPTIONS.erf.level = 0;
    314         OPTIONS.erf.append = 0;
     323        OPTIONS.erf.fileflag = O_CREAT | O_LARGEFILE | O_WRONLY;
    315324        OUTPUT.file = 0;
    316325
     
    320329static int erf_open_output(struct libtrace_out_t *libtrace) {
    321330        char *filemode;
    322         int trunc_flag = O_TRUNC;
    323331        int fd;
    324332
     
    329337#endif
    330338
    331         if (OPTIONS.erf.append) {
    332                 trunc_flag = O_APPEND;
    333         }               
    334 
    335339        if (!strncmp(libtrace->uridata,"-",1)) {
    336                 // STDOUT
     340                /* STDOUT */
    337341                OUTPUT.file = LIBTRACE_FDOPEN(fileno(stdout),filemode);
    338342        }
    339343        else {
    340                 // TRACE
    341                 fd = open(libtrace->uridata, O_CREAT | O_LARGEFILE | O_WRONLY | trunc_flag,
     344                /* TRACE */
     345                fd = open(libtrace->uridata,
     346                                OPTIONS.erf.fileflag,
    342347                                S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
    343348                if (fd <= 0) {
     
    351356}
    352357
    353 static int erf_config_output(struct libtrace_out_t *libtrace, int argc, char *argv[]) {
    354         int opt;
    355         int level = OPTIONS.erf.level;
    356         optind = 1;
    357 
    358 
    359         while ((opt = getopt(argc, argv, "z:a")) != EOF) {
    360                 switch (opt) {
    361                         case 'z':
    362                                 level = atoi(optarg);
    363                                 break;
    364                         case 'a':
    365                                 OPTIONS.erf.append = 1;
    366                                 break;
    367                         default:
    368                                 printf("Bad argument to erf: %s\n", optarg);
    369                                 // maybe spit out some help here
    370                                 return -1;
    371                 }
    372         }
    373        
    374         return 0;
    375 
     358static int erf_config_output(struct libtrace_out_t *libtrace, trace_option_t option, void *value) {
     359
     360        switch (option) {
     361                case TRACE_OPTION_OUTPUT_COMPRESS:
     362                        OPTIONS.erf.level = *(int*)value;
     363                        return 0;
     364                case TRACE_OPTION_OUTPUT_FILEFLAGS:
     365                        OPTIONS.erf.fileflag = *(int*)value;
     366                        return 0;
     367                default:
     368                        /* Unknown option */
     369                        return -1;
     370        }
    376371}
    377372
     
    443438                return numbytes;
    444439
    445         //DAG always gives us whole packets
     440        /*DAG always gives us whole packets */
    446441        erfptr = (dag_record_t *) ((void *)DAG.buf +
    447442                        (DAG.bottom + DAG.offset));
     
    460455        }
    461456
    462        
    463         packet->status.type = RT_DATA;
    464         packet->status.message = 0;
    465457        packet->size = size;
    466458        DAG.offset += size;
     
    476468        int numbytes;
    477469        int size;
    478         void *buffer = packet->buffer;
    479         void *buffer2 = buffer;
     470        void *buffer2 = packet->buffer;
    480471        int rlen;
    481472        if (packet->buf_control == EXTERNAL) {
     
    483474                packet->buffer = malloc(LIBTRACE_PACKET_BUFSIZE);
    484475        }
    485         buffer = packet->buffer;
    486476        packet->header = packet->buffer;
    487477
     478        if (packet->buffer) {
     479                packet->buffer = malloc(LIBTRACE_PACKET_BUFSIZE);
     480                packet->buf_control = PACKET;
     481        }
     482
    488483
    489484        if ((numbytes=LIBTRACE_READ(INPUT.file,
    490                                         buffer,
     485                                        packet->buffer,
    491486                                        dag_record_size)) == -1) {
    492487                perror("libtrace_read");
     
    497492        }
    498493
    499         rlen = ntohs(((dag_record_t *)buffer)->rlen);
    500         buffer2 = buffer + dag_record_size;
     494        rlen = ntohs(((dag_record_t *)packet->buffer)->rlen);
     495        buffer2 = (char*)packet->buffer + dag_record_size;
    501496        size = rlen - dag_record_size;
    502497        assert(size < LIBTRACE_PACKET_BUFSIZE);
     
    509504        */
    510505        /* Unknown/corrupt */
    511         assert(((dag_record_t *)buffer)->type < 10);
    512        
    513         // read in the rest of the packet
     506        assert(((dag_record_t *)packet->buffer)->type < 10);
     507       
     508        /* read in the rest of the packet */
    514509        if ((numbytes=LIBTRACE_READ(INPUT.file,
    515510                                        buffer2,
     
    518513                return -1;
    519514        }
    520         packet->status.type = RT_DATA;
    521         packet->status.message = 0;
    522515        packet->size = rlen;
    523         if (((dag_record_t *)buffer)->flags.rxerror == 1) {
     516        if (((dag_record_t *)packet->buffer)->flags.rxerror == 1) {
    524517                packet->payload = NULL;
    525518        } else {
    526                 packet->payload = packet->buffer + erf_get_framing_length(packet);
     519                packet->payload = (char*)packet->buffer + erf_get_framing_length(packet);
    527520        }
    528521        return rlen;
     
    543536                                                MSG_NOSIGNAL)) == -1) {
    544537                        if (errno == EINTR) {
    545                                 //ignore EINTR in case
    546                                 // a caller is using signals
     538                                /*ignore EINTR in case
     539                                 *a caller is using signals
     540                                 */
    547541                                continue;
    548542                        }
     
    575569       
    576570        do {
     571                struct libtrace_packet_status status;
    577572                if (tracefifo_out_available(libtrace->fifo) == 0 || read_required) {
    578573                        if ((numbytes = rtclient_read(
     
    583578                        read_required = 0;
    584579                }
    585                 // Read status byte
     580                /* Read status byte */
    586581                if (tracefifo_out_read(libtrace->fifo,
    587                                 &packet->status, sizeof(uint32_t)) == 0) {
     582                                &status, sizeof(uint32_t)) == 0) {
    588583                        read_required = 1;
    589584                        continue;
    590585                }
    591586                tracefifo_out_update(libtrace->fifo,sizeof(uint32_t));
    592                 // Read in packet size
     587                /* Read in packet size */
    593588                if (tracefifo_out_read(libtrace->fifo,
    594589                                &packet->size, sizeof(uint32_t)) == 0) {
     
    608603                }
    609604                */
    610                 if (packet->status.type == RT_MSG) {
    611                         // Need to skip this packet as it is a message packet
     605                if (status.type == RT_MSG) {
     606                        /* Need to skip this packet as it is a message packet */
    612607                        tracefifo_out_update(libtrace->fifo, packet->size);
    613608                        tracefifo_ack_update(libtrace->fifo, packet->size +
     
    617612                }
    618613               
    619                 //size = ntohs(((dag_record_t *)buffer)->rlen);
    620                
    621                 // read in the full packet
     614                /* read in the full packet */
    622615                if ((numbytes = tracefifo_out_read(libtrace->fifo,
    623616                                                buffer, packet->size)) == 0) {
     
    627620                }
    628621
    629                 // got in our whole packet, so...
     622                /* got in our whole packet, so... */
    630623                tracefifo_out_update(libtrace->fifo,packet->size);
    631624
     
    634627                                sizeof(libtrace_packet_status_t));
    635628
    636                 //packet->size = numbytes;
    637629                if (((dag_record_t *)buffer)->flags.rxerror == 1) {
    638630                        packet->payload = NULL;
    639631                } else {
    640                         packet->payload = packet->buffer + erf_get_framing_length(packet);
     632                        packet->payload = (char*)packet->buffer + erf_get_framing_length(packet);
    641633                }
    642634                return numbytes;
     
    698690                                        (dag_record_size + pad));
    699691        } else {
    700                 // convert format - build up a new erf header
    701                 // Timestamp
     692                /* convert format - build up a new erf header */
     693                /* Timestamp */
    702694                erfhdr.ts = trace_get_erf_timestamp(packet);
    703                 // Flags. Can't do this
     695                erfhdr.type = libtrace_to_erf_type(trace_get_link_type(packet));
     696                /* Flags. Can't do this */
    704697                memset(&erfhdr.flags,1,1);
    705                 // Packet length (rlen includes format overhead)
     698                /* Packet length (rlen includes format overhead) */
    706699                erfhdr.rlen = trace_get_capture_length(packet) + erf_get_framing_length(packet);
    707                 // loss counter. Can't do this
     700                /* loss counter. Can't do this */
    708701                erfhdr.lctr = 0;
    709                 // Wire length
     702                /* Wire length */
    710703                erfhdr.wlen = trace_get_wire_length(packet);
    711704               
    712                 // Write it out
     705                /* Write it out */
    713706                numbytes = erf_dump_packet(libtrace,
    714707                                &erfhdr,
     
    720713}
    721714
    722 static void *erf_get_link(const struct libtrace_packet_t *packet) {
    723         return (void *)packet->payload;
    724 }
    725 
    726715static libtrace_linktype_t erf_get_link_type(const struct libtrace_packet_t *packet) {
    727716        dag_record_t *erfptr = 0;
    728717        erfptr = (dag_record_t *)packet->header;
    729         switch (erfptr->type) {
    730                 case TYPE_LEGACY:       return TRACE_TYPE_LEGACY;
    731                 case TYPE_ETH:          return TRACE_TYPE_ETH;
    732                 case TYPE_ATM:          return TRACE_TYPE_ATM;
    733                 default:
    734                                fprintf(stderr,"Unknown erf type %02x\n",erfptr->type);
    735                                assert(0);
    736         }
    737         return erfptr->type;
     718        return erf_type_to_libtrace(erfptr->type);
    738719}
    739720
     
    773754        assert(packet);
    774755        if((size + erf_get_framing_length(packet)) > packet->size) {
    775                 // can't make a packet larger
     756                /* can't make a packet larger */
    776757                return (packet->size - erf_get_framing_length(packet));
    777758        }
Note: See TracChangeset for help on using the changeset viewer.