Changeset 641dc7c for lib/format_erf.c


Ignore:
Timestamp:
10/14/05 12:43:17 (16 years ago)
Author:
Daniel Lawson <dlawson@…>
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:
5395ce6
Parents:
c9caf07
Message:

fixup for bad dag_root detection in configure
tidied up the gzread/read calls through use of a macro
added get_wire_length to the legacy formats

File:
1 edited

Legend:

Unmodified
Added
Removed
  • lib/format_erf.c

    r0f7f688 r641dc7c  
    3131
    3232#include "config.h"
     33#include "common.h"
    3334#include "libtrace.h"
    3435#include "libtrace_int.h"
     
    6162#include <string.h>
    6263#include <stdlib.h>
     64
     65#if HAVE_ZLIB
     66#  include <zlib.h>
     67#  define LIBTRACE_READ gzread
     68#  define LIBTRACE_FDOPEN gzdopen
     69#  define LIBTRACE_CLOSE gzclose
     70#  define LIBTRACE_WRITE gzwrite
     71#else
     72#  define LIBTRACE_READ read
     73#  define LIBTRACE_FDOPEN open
     74#  define LIBTRACE_CLOSE close
     75#  define LIBTRACE_WRITE write
     76#endif
    6377
    6478/* Catch undefined O_LARGEFILE on *BSD etc */
     
    188202                // STDIN
    189203                libtrace->sourcetype = STDIN;
    190 #if HAVE_ZLIB
    191                 INPUT.file = gzdopen(STDIN, "r");
    192 #else   
    193                 INPUT.file = stdin;
    194 #endif
     204                INPUT.file = LIBTRACE_FDOPEN(STDIN, "r");
    195205
    196206        } else {
     
    219229                        }
    220230                } else {
     231
    221232                        libtrace->sourcetype = TRACE;
    222 #if HAVE_ZLIB
    223                         // using gzdopen means we can set O_LARGEFILE
    224                         // ourselves. However, this way is messy and
    225                         // we lose any error checking on "open"
    226                         INPUT.file =
    227                                 gzdopen(open(
    228                                         CONNINFO.path,
    229                                         O_LARGEFILE), "r");
    230 #else
    231                         INPUT.file =
    232                                 fdopen(open(
    233                                         CONNINFO.path,
    234                                         O_LARGEFILE), "r");
    235 #endif
    236 
     233
     234                        // we use an FDOPEN call to reopen an FD
     235                        // returned from open(), so that we can set
     236                        // O_LARGEFILE. This gets around gzopen not
     237                        // letting you do this...
     238                        INPUT.file = LIBTRACE_FDOPEN(open(
     239                                                CONNINFO.path,
     240                                                O_LARGEFILE),"r");
    237241                }
    238242        }
     
    299303
    300304        OPTIONS.erf.level = 0;
     305#if HAVE_ZLIB
    301306        asprintf(&filemode,"wb%d",OPTIONS.erf.level);
     307#else
     308        asprintf(&filemode,"w");
     309#endif
    302310
    303311        if (!strncmp(libtrace->uridata,"-",1)) {
    304312                // STDOUT
    305 #if HAVE_ZLIB
    306                 OUTPUT.file = gzdopen(dup(1), filemode);
    307 #else
    308                 OUTPUT.file = stdout;
    309 #endif
     313                OUTPUT.file = LIBTRACE_FDOPEN(dup(1),filemode);
    310314        }
    311315        else {
     
    315319                        return 0;
    316320                }
    317 #if HAVE_ZLIB
    318                 // using gzdopen means we can set O_LARGEFILE
    319                 // ourselves. However, this way is messy and
    320                 // we lose any error checking on "open"
    321                 OUTPUT.file =  gzdopen(fd, filemode);
    322 #else
    323                 OUTPUT.file =  fdopen(fd, "w");
    324 #endif
     321                OUTPUT.file = LIBTRACE_FDOPEN(fd,filemode);
    325322                 
    326323        }
     
    370367
    371368static int erf_fin_input(struct libtrace_t *libtrace) {
    372 #if HAVE_ZLIB
    373         gzclose(INPUT.file);
    374 #else   
    375         fclose(INPUT.file);     
    376 #endif
     369        LIBTRACE_CLOSE(INPUT.file);
    377370        free(libtrace->format_data);
    378371        return 0;
     
    385378
    386379static int erf_fin_output(struct libtrace_out_t *libtrace) {
    387 #if HAVE_ZLIB
    388         gzclose(OUTPUT.file);
    389 #else
    390         fclose(OUTPUT.file);
    391 #endif
     380        LIBTRACE_CLOSE(OUTPUT.file);
    392381        free(libtrace->format_data);
    393382
     
    467456        int rlen;
    468457
    469 #if HAVE_ZLIB
    470         if ((numbytes=gzread(INPUT.file,
     458        if ((numbytes=LIBTRACE_READ(INPUT.file,
    471459                                        buffer,
    472460                                        dag_record_size)) == -1) {
    473                 perror("gzread");
     461                perror("libtrace_read");
    474462                return -1;
    475463        }
    476 #else
    477         if ((numbytes = read(INPUT.file, buffer, dag_record_size)) == -1) {
    478                 perror("read");
    479                 return -1;
    480         }
    481 #endif
    482464        if (numbytes == 0) {
    483465                return 0;
     
    490472        buffer2 = buffer + dag_record_size;
    491473       
    492 #ifdef HAVE_ZLIB
    493         if ((numbytes=gzread(INPUT.file,
     474        if ((numbytes=LIBTRACE_READ(INPUT.file,
    494475                                        buffer2,
    495476                                        size)) == -1) {
    496                 perror("gzread");
     477                perror("libtrace_read");
    497478                return -1;
    498479        }
    499 #else
    500         if ((numbytes = read(INPUT.file,buffer2,size)) == -1) {
    501                 perror("gzread");
    502                 return -1;
    503         }
    504 #endif
    505480        packet->status = 0;
    506481        packet->size = rlen;
     
    513488        void *buffer2 = buffer;
    514489        int rlen;
    515 #if HAVE_ZLIB
    516         if ((numbytes=gzread(INPUT.file,
     490        if ((numbytes=LIBTRACE_READ(INPUT.file,
    517491                                        buffer,
    518492                                        dag_record_size)) == -1) {
    519                 perror("gzread");
     493                perror("libtrace_read");
    520494                return -1;
    521495        }
    522 #else
    523         if ((numbytes = read(INPUT.file, buffer, dag_record_size)) == -1) {
    524                 perror("read");
    525                 return -1;
    526         }
    527 #endif
    528496        if (numbytes == 0) {
    529497                return 0;
     
    542510       
    543511        // read in the rest of the packet
    544 #ifdef HAVE_ZLIB
    545         if ((numbytes=gzread(INPUT.file,
     512        if ((numbytes=LIBTRACE_READ(INPUT.file,
    546513                                        buffer2,
    547514                                        size)) == -1) {
    548                 perror("gzread");
     515                perror("libtrace_read");
    549516                return -1;
    550517        }
    551 #else
    552         if ((numbytes = read(INPUT.file,buffer2,size)) == -1) {
    553                 perror("gzread");
    554                 return -1;
    555         }
    556 #endif
    557518        packet->status = 0;
    558519        packet->size = rlen;
     
    644605static int erf_dump_packet(struct libtrace_out_t *libtrace, dag_record_t *erfptr, void *buffer, size_t size) {
    645606        int numbytes = 0;
    646 #if HAVE_ZLIB
    647         if ((numbytes = gzwrite(OUTPUT.file, erfptr, dag_record_size + 2)) == 0) {
    648                 perror("gzwrite");
     607        if ((numbytes = LIBTRACE_WRITE(OUTPUT.file, erfptr, dag_record_size + 2)) == 0) {
     608                perror("libtrace_write");
    649609                return -1;
    650610        }
    651         if ((numbytes = gzwrite(OUTPUT.file, buffer, size)) == 0) {
    652                 perror("gzwrite");
     611        if ((numbytes = LIBTRACE_WRITE(OUTPUT.file, buffer, size)) == 0) {
     612                perror("libtrace_write");
    653613                return -1;
    654614        }
    655 #else
    656         if ((numbytes = write(OUTPUT.file, erfptr, dag_record_size + 2)) == 0) {
    657                 perror("write");
    658                 return -1;
    659         }
    660         if ((numbytes = write(OUTPUT.file, buffer, size)) == 0) {
    661                 perror("write");
    662                 return -1;
    663         }
    664 #endif
    665615        return numbytes + sizeof(dag_record_t);
    666616
     
    715665
    716666static void *legacy_get_link(const struct libtrace_packet_t *packet) {
    717         const void *posptr = 0;
    718         posptr = ((uint8_t *)packet->buffer);
    719         return (void *)posptr;
     667        return (void *)packet->buffer;
    720668}
    721669
     
    784732
    785733static int legacypos_get_wire_length(const struct libtrace_packet_t *packet) {
    786        
     734        legacy_pos_t *lpos = (legacy_pos_t *)packet->buffer;
     735        return ntohs(lpos->wlen);
     736}
     737
     738static int legacyatm_get_wire_length(const struct libtrace_packet_t *packet) {
     739        return 53;
     740}
     741
     742static int legacyeth_get_wire_length(const struct libtrace_packet_t *packet) {
     743        legacy_ether_t *leth = (legacy_ether_t *)packet->buffer;
     744        return ntohs(leth->wlen);
    787745}
    788746static int erf_get_capture_length(const struct libtrace_packet_t *packet) {
     
    929887        NULL,                           /* get_seconds */
    930888        legacy_get_capture_length,      /* get_capture_length */
    931         NULL,                           /* get_wire_length */
     889        legacyatm_get_wire_length,      /* get_wire_length */
    932890        NULL,                           /* set_capture_length */
    933891        NULL,                           /* get_fd */
     
    955913        NULL,                           /* get_seconds */
    956914        legacy_get_capture_length,      /* get_capture_length */
    957         NULL,                           /* get_wire_length */
     915        legacyeth_get_wire_length,      /* get_wire_length */
    958916        NULL,                           /* set_capture_length */
    959917        NULL,                           /* get_fd */
    960918        trace_event_trace,              /* trace_event */
    961         legacyatm_help                  /* help */
     919        legacyeth_help                  /* help */
    962920};
    963921
     
    981939        NULL,                           /* get_seconds */
    982940        legacy_get_capture_length,      /* get_capture_length */
    983         NULL,                           /* get_wire_length */
     941        legacypos_get_wire_length,      /* get_wire_length */
    984942        NULL,                           /* set_capture_length */
    985943        NULL,                           /* get_fd */
Note: See TracChangeset for help on using the changeset viewer.