Changeset 7068467 for lib/format_wag.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_wag.c

    r37195b4 r7068467  
    9999                gzFile *file;
    100100#else   
    101                 //FILE *file;
    102101                int file;
    103102#endif
     
    119118                gzFile *file;
    120119#else
    121                 //FILE *file;
    122120                int file;
    123121#endif
     
    127125static int wag_init_input(struct libtrace_t *libtrace) {
    128126        struct stat buf;
    129         //struct sockaddr_un unix_sock;
    130127        libtrace->format_data = (struct libtrace_format_data_t *)
    131128                calloc(1,sizeof(struct libtrace_format_data_t));
     
    151148
    152149static int wtf_init_input(struct libtrace_t *libtrace) {
    153         struct stat buf;
    154         struct sockaddr_un unix_sock;
    155150
    156151        libtrace->format_data = (struct libtrace_format_data_t *)
     
    159154
    160155        if (!strncmp(CONNINFO.path,"-",1)) {
    161                 // STDIN
     156                /* STDIN */
    162157                libtrace->sourcetype = STDIN;
    163158                INPUT.file = LIBTRACE_FDOPEN(fileno(stdin),"r");
    164159
    165160        } else {
    166 
    167 
    168                 // Do we need this socket stuff at all??
    169                 // If we do, put it into wag_init_input as it uses
    170                 // INPUT.fd
     161                /* Do we need this socket stuff at all??
     162                 * If we do, put it into wag_init_input as it uses
     163                 * INPUT.fd
     164                 */
    171165
    172166                /*
     
    197191                } else {
    198192                */
    199                         // TRACE
     193                        /* TRACE */
    200194                        libtrace->sourcetype = TRACE;
    201195                       
    202                         // we use an FDOPEN call to reopen an FD
    203                         // returned from open(), so that we can set
    204                         // O_LARGEFILE. This gets around gzopen not
    205                         // letting you do this...
     196                        /* we use an FDOPEN call to reopen an FD
     197                         * returned from open(), so that we can set
     198                         * O_LARGEFILE. This gets around gzopen not
     199                         * letting you do this...
     200                         */
    206201                        INPUT.file = LIBTRACE_FDOPEN(open(
    207202                                        CONNINFO.path,
    208203                                        O_LARGEFILE), "r");
    209204
    210                 //}
    211205        }
    212206        return 1;
     
    222216        asprintf(&filemode,"wb%d",OPTIONS.zlib.level);
    223217        if (!strncmp(libtrace->uridata,"-",1)) {
    224                 // STDOUT                               
     218                /* STDOUT */
    225219                OUTPUT.file = LIBTRACE_FDOPEN(dup(1), filemode);
    226220        } else {
    227                 // TRACE
     221                /* TRACE */
    228222                OUTPUT.file = LIBTRACE_FDOPEN(open(
    229223                                        libtrace->uridata,
     
    235229}
    236230
    237 static int wtf_config_output(struct libtrace_out_t *libtrace, int argc, char *argv[]) {
     231static int wtf_config_output(struct libtrace_out_t *libtrace,
     232                trace_option_output_t option,
     233                void *value) {
     234        switch(option) {
    238235#if HAVE_ZLIB
    239         int opt;
    240         int level = OPTIONS.zlib.level;
    241         optind = 1;
    242         while ((opt = getopt(argc, argv, "z:")) != EOF) {
    243                 switch (opt) {
    244                         case 'z':
    245                                 level = atoi(optarg);
    246                                 break;
    247                         default:
    248                                 printf("Bad argument to wag: %s\n", optarg);
    249                                 return -1;
    250                 }
    251         }
    252         if (level != OPTIONS.zlib.level) {
    253                 if (level > 9 || level < 0) {
    254                         // retarded level choice
    255                         printf("Compression level must be between 0 and 9 inclusive - you selected %i \n", level);
    256                 } else {
    257                         OPTIONS.zlib.level = level;
    258                         return gzsetparams(OUTPUT.file, level, Z_DEFAULT_STRATEGY);
    259                 }
    260         }
    261 #endif
    262         return 0;
     236                case TRACE_OPTION_OUTPUT_COMPRESS:
     237                        OPTIONS.zlib.level = *(int*)value;
     238                        assert(OPTIONS.zlib.level>=0
     239                                        && OPTIONS.zlib.level<=9);
     240                        break;
     241#else
     242                case TRACE_OPTION_OUTPUT_COMPRESS:
     243                        /* E feature unavailable */
     244                        return -1;
     245#endif
     246                default:
     247                        /* E unknown feature */
     248                        return -1;
     249        }
    263250}
    264251
     
    280267static int wag_read(struct libtrace_t *libtrace, void *buffer, size_t len) {
    281268        int numbytes;
    282         int framesize;
     269        size_t framesize;
    283270        assert(libtrace);
    284271
     
    286273                buffer = malloc(len);
    287274
    288         // read in wag_frame_hdr
     275        /* read in wag_frame_hdr */
    289276        if ((numbytes = read(INPUT.fd,
    290277                        buffer,
     
    299286        }
    300287
    301         // read in remainder of packet
     288        /* read in remainder of packet */
    302289        if((numbytes = read(INPUT.fd,
    303                         buffer + sizeof(struct wag_frame_hdr),
     290                        (char*)buffer + sizeof(struct wag_frame_hdr),
    304291                        framesize - sizeof(struct wag_frame_hdr))) !=
    305292                        (framesize - sizeof(struct wag_frame_hdr))) {
     
    316303        int numbytes;
    317304       
    318         char buf[RP_BUFSIZE];
    319305        if (packet->buf_control == EXTERNAL) {
    320306                packet->buf_control = PACKET;
     
    331317
    332318       
    333 //      memcpy(packet->buffer, buf, numbytes);
    334        
    335         packet->status.type = RT_DATA;
    336         packet->status.message = 0;
    337319        packet->size = numbytes;
    338320        packet->header = packet->buffer;
    339         packet->payload = packet->buffer + trace_get_framing_length(packet);
     321        packet->payload=(char*)packet->buffer+trace_get_framing_length(packet);
    340322        return numbytes;
    341323}
     
    364346
    365347        framesize = ntohs(((struct wag_frame_hdr *)buffer)->size);
    366         buffer2 = buffer + sizeof(struct wag_frame_hdr);
     348        buffer2 = (char*)buffer + sizeof(struct wag_frame_hdr);
    367349        size = framesize - sizeof(struct wag_frame_hdr);
    368350        assert(size < LIBTRACE_PACKET_BUFSIZE);
     
    374356        }
    375357
    376         packet->status.type = RT_DATA;
    377         packet->status.message = 0;
    378358        packet->size = framesize;
    379359        packet->header = packet->buffer;
    380         packet->payload = packet->buffer + trace_get_framing_length(packet);
     360        packet->payload=(char*)packet->buffer+trace_get_framing_length(packet);
    381361        return framesize;
    382362       
     
    406386}
    407387
    408 static void *wag_get_link(const struct libtrace_packet_t *packet) {
    409         /*
    410         struct wag_data_frame *wagptr = (struct wag_data_frame *)packet->buffer;
    411         void *payload = wagptr->data;
    412         return (void*)payload;
    413         */
    414         return (void *)packet->payload;
    415 }
    416 
    417388static libtrace_linktype_t wag_get_link_type(const struct libtrace_packet_t *packet __attribute__((unused))) {
    418389        return TRACE_TYPE_80211;
     
    436407static int wag_get_capture_length(const struct libtrace_packet_t *packet) {
    437408        struct wag_data_frame *wagptr = (struct wag_data_frame *)packet->buffer;
    438         //return (wagptr->hdr.size);
    439409        return ntohs(wagptr->hdr.size);
    440410}
     
    442412static int wag_get_wire_length(const struct libtrace_packet_t *packet) {
    443413        struct wag_data_frame *wagptr = (struct wag_data_frame *)packet->buffer;
    444         //return (wagptr->hdr.size);
    445414        return ntohs(wagptr->hdr.size);
    446415}
Note: See TracChangeset for help on using the changeset viewer.