Changeset 641dc7c for lib


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

Location:
lib
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • lib/dagformat.h

    reaa5529 r641dc7c  
    8282#define dag_record_size         16
    8383
    84 /*
     84
    8585typedef struct legacy_cell {
    8686        uint64_t  ts;
     
    9898        uint32_t  wlen;
    9999} legacy_pos_t;
    100 */     
     100
    101101
    102102#endif // _DAGFORMAT_H_
  • 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 */
  • lib/format_helper.c

    r9c6aa95 r641dc7c  
    4444
    4545#include <sys/ioctl.h>
    46 /*
    47 int trace_read(struct libtrace_t *libtrace, void *buffer, size_t len) {
    48         int numbytes;
    49         static short lctr = 0;
    50         int rlen;
    51         assert(libtrace);
    52         assert(len >= 0);
    53 
    54         if (buffer == 0)
    55                 buffer = malloc(len);
    56 
    57         while(1) {
    58                 switch(libtrace->sourcetype) {
    59                         case DEVICE:
    60                                 if ((numbytes=read(INPUT.fd,
    61                                                                 buffer,
    62                                                                 len)) == -1) {
    63                                         perror("read");
    64                                         return -1;
    65                                 }
    66                                 break;
    67                         default:
    68 #if HAVE_ZLIB
    69                                 if ((numbytes=gzread(INPUT.file,
    70                                                                 buffer,
    71                                                                 len)) == -1) {
    72                                         perror("gzread");
    73                                         return -1;
    74                                 }
    75 #else
    76                                 if ((numbytes=fread(buffer,len,1,
    77                                         INPUT.file)) == 0 ) {
    78                                         if(feof(INPUT.file)) {
    79                                                 return 0;
    80                                         }
    81                                         if(ferror(INPUT.file)) {
    82                                                 perror("fread");
    83                                                 return -1;
    84                                         }
    85                                         return 0;
    86                                 }
    87 #endif
    88                 }
    89                 break;
    90         }
    91         return numbytes;
    92 
    93 }
    94 */
    9546
    9647struct libtrace_eventobj_t trace_event_device(struct libtrace_t *trace, struct libtrace_packet_t *packet) {
  • lib/format_wag.c

    r9c6aa95 r641dc7c  
    6262#include <string.h>
    6363#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
    6477
    6578#ifdef HAVE_LIMITS_H
     
    128141        CONNINFO.path = libtrace->uridata;
    129142        if (!strncmp(CONNINFO.path,"-",1)) {
     143                // STDIN
    130144                libtrace->sourcetype = STDIN;
    131                 // STDIN
    132 #if HAVE_ZLIB
    133                 INPUT.file = gzdopen(STDIN, "r");
    134 #else   
    135                 INPUT.file = stdin;
    136 #endif
     145                INPUT.file = LIBTRACE_FDOPEN(STDIN,"r");
    137146
    138147        } else {
     
    164173                        // TRACE
    165174                        libtrace->sourcetype = TRACE;
    166 #if HAVE_ZLIB
    167                         // using gzdopen means we can set O_LARGEFILE
    168                         // ourselves. However, this way is messy and
    169                         // we lose any error checking on "open"
    170                         INPUT.file =
    171                                 gzdopen(open(
     175                       
     176                        // we use an FDOPEN call to reopen an FD
     177                        // returned from open(), so that we can set
     178                        // O_LARGEFILE. This gets around gzopen not
     179                        // letting you do this...
     180                        INPUT.file = LIBTRACE_FDOPEN(open(
    172181                                        CONNINFO.path,
    173182                                        O_LARGEFILE), "r");
    174 #else
    175                         INPUT.file =
    176                                 fdopen(open(
    177                                         CONNINFO.path,
    178                                         O_LARGEFILE), "r");
    179 #endif
    180183
    181184                }
     
    193196        if (!strncmp(libtrace->uridata,"-",1)) {
    194197                // STDOUT                               
    195 #if HAVE_ZLIB
    196                 OUTPUT.file = gzdopen(dup(1), filemode);
    197 #else
    198                 OUTPUT.file = stdout;
    199 #endif
     198                OUTPUT.file = LIBTRACE_FDOPEN(dup(1), filemode);
    200199        } else {
    201200                // TRACE
    202 #if HAVE_ZLIB
    203                 OUTPUT.file = gzdopen(open(
     201                OUTPUT.file = LIBTRACE_FDOPEN(open(
    204202                                        libtrace->uridata,
    205203                                        O_CREAT | O_LARGEFILE | O_WRONLY,
    206204                                        S_IRUSR | S_IWUSR), filemode);
    207 #else
    208                 OUTPUT.file = fdopen(open(
    209                                         O_CREAT | O_LARGEFILE | O_WRONLY,
    210                                         S_IRUSR | S_IWUSR), "w");
    211 #endif
    212205        }
    213206
     
    244237
    245238static int wag_fin_input(struct libtrace_t *libtrace) {
    246 #if HAVE_ZLIB
    247         gzclose(INPUT.file);
    248 #else   
    249         fclose(INPUT.file);     
    250 #endif
     239        LIBTRACE_CLOSE(INPUT.file);
    251240        return 0;
    252241}
    253242
    254243static int wag_fin_output(struct libtrace_out_t *libtrace) {
    255 #if HAVE_ZLIB
    256         gzclose(OUTPUT.file);
    257 #else
    258         fclose(OUTPUT.file);
    259 #endif
     244        LIBTRACE_CLOSE(OUTPUT.file);
    260245        return 0;
    261246}
     
    279264                                break;
    280265                        default:
    281 #if HAVE_ZLIB
    282                                 if ((numbytes=gzread(INPUT.file,
     266                                if ((numbytes=LIBTRACE_READ(INPUT.file,
    283267                                                                buffer,
    284268                                                                len)) == -1) {
    285                                         perror("gzread");
     269                                        perror("libtrace_read");
    286270                                        return -1;
    287271                                }
    288 #else
    289                                 if ((numbytes=fread(buffer,len,1,
    290                                         INPUT.file)) == 0 ) {
    291                                         if(feof(INPUT.file)) {
    292                                                 return 0;
    293                                         }
    294                                         if(ferror(INPUT.file)) {
    295                                                 perror("fread");
    296                                                 return -1;
    297                                         }
    298                                         return 0;
    299                                 }
    300 #endif
    301272                }
    302273                break;
     
    368339                return -1;
    369340        }
    370 #if HAVE_ZLIB
    371         if ((numbytes = gzwrite(OUTPUT.file, packet->buffer, packet->size)) == 0) {
    372                 perror("gzwrite");
     341        if ((numbytes = LIBTRACE_WRITE(OUTPUT.file, packet->buffer, packet->size)) == 0) {
     342                perror("libtrace_write");
    373343                return -1;
    374344        }
    375 #else
    376         if ((numbytes = write(OUTPUT.file, packet->buffer, packet->size)) == 0) {
    377                 perror("write");
    378                 return -1;
    379         }
    380 #endif
    381345        return numbytes;
    382346}
Note: See TracChangeset for help on using the changeset viewer.