Changeset edb18ce


Ignore:
Timestamp:
04/21/06 00:42:17 (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:
d0906e7
Parents:
671566a
Message:

Rewrote libtrace's IO handling to use shim functions when needing to do
zlib io

Files:
3 added
9 edited

Legend:

Unmodified
Added
Removed
  • configure.in

    r14d8a63 redb18ce  
    349349AM_CONDITIONAL([DAG2_4], [test "$libtrace_dag2_4" = true])
    350350AM_CONDITIONAL([HAVE_CXX], [test "$libtrace_cxx" = true])
     351AM_CONDITIONAL([HAVE_ZLIB], [test "$libtrace_zlib" = true])
    351352AM_CONDITIONAL([LIBPACKETDUMP], [test "$libtrace_libpacketdump" = true])
    352353AM_CONDITIONAL([LIBTRACE_TOOLS], [test "$libtrace_tools" = true])
  • lib/Makefile.am

    r97e39a7 redb18ce  
    77                format_helper.c format_helper.h format_linux.c \
    88                parse_cmd.c parse_cmd.h libtrace_int.h lt_inttypes.h \
    9                 linktypes.c protocols.c
     9                linktypes.c protocols.c
     10if HAVE_ZLIB
     11libtrace_la_SOURCES+=libtraceio-zlib.c
     12else
     13libtrace_la_SOURCES+=libtraceio-stdio.c
     14endif
    1015
    1116if DAG2_4
  • lib/common.h

    r9e830d4 redb18ce  
    1212#endif /* __cplusplus */
    1313
    14 #if HAVE_ZLIB
    15 #  include <zlib.h>
    16 #  define LIBTRACE_READ(file,buf,len) gzread(file,buf,len)
    17 #  define LIBTRACE_FDOPEN(fd,mode) gzdopen(fd,mode)
    18 #  define LIBTRACE_OPEN(path,mode) gzopen(path,mode)
    19 #  define LIBTRACE_CLOSE(file) gzclose(file)
    20 #  define LIBTRACE_WRITE(file,buf,len) gzwrite(file,buf,len)
    21 #  define LIBTRACE_FILE gzFile*
    22 #  define LIBTRACE_SEEK(file,offset,whence) gzseek(file,offset,whence)
    23 #  define LIBTRACE_TELL(file) gztell(file)
    24 #else
    25 #  define LIBTRACE_READ(file,buf,len) read(file,buf,len)
    26 #  define LIBTRACE_FDOPEN(fd,mode) dup(fd)
    27 #  define LIBTRACE_OPEN(path,mode) open(path,mode)
    28 #  define LIBTRACE_CLOSE(file) close(file)
    29 #  define LIBTRACE_WRITE(file,buf,len) write(file,buf,len)
    30 #  define LIBTRACE_FILE int
    31 #  define LIBTRACE_SEEK(file,offset,whence) lseek(file,offset,whence)
    32 #  define LIBTRACE_TELL(file) lseek(file,0,SEEK_CUR)
    33 #endif
    3414
    3515#endif /* COMMON_H */
  • lib/format_erf.c

    r9e830d4 redb18ce  
    8282        union {
    8383                int fd;
    84                 LIBTRACE_FILE file;
     84                libtrace_io_t *file;
    8585        } input;
    8686
    8787        struct {
    8888                enum { INDEX_UNKNOWN=0, INDEX_NONE, INDEX_EXISTS } exists;
    89                 LIBTRACE_FILE index;
     89                libtrace_io_t *index;
    9090                off_t index_len;
    9191        } seek;
     
    123123                int fd;
    124124                struct rtserver_t * rtserver;
    125 #if HAVE_ZLIB
    126                 gzFile *file;
    127 #else
    128                 int file;
    129 #endif
     125                libtrace_io_t *file;
    130126        } output;
    131127};
     
    227223                current=(max_off+min_off)>>2;
    228224
    229                 LIBTRACE_SEEK(DATA(libtrace)->seek.index,
     225                libtrace_io_seek(DATA(libtrace)->seek.index,
    230226                                current*sizeof(record),
    231227                                SEEK_SET);
    232                 LIBTRACE_READ(DATA(libtrace)->seek.index,
     228                libtrace_io_read(DATA(libtrace)->seek.index,
    233229                                &record,sizeof(record));
    234230                if (record.timestamp < erfts) {
     
    246242         */
    247243        do {
    248                 LIBTRACE_SEEK(DATA(libtrace)->seek.index,
     244                libtrace_io_seek(DATA(libtrace)->seek.index,
    249245                                current*sizeof(record),SEEK_SET);
    250                 LIBTRACE_READ(DATA(libtrace)->seek.index,
     246                libtrace_io_read(DATA(libtrace)->seek.index,
    251247                                &record,sizeof(record));
    252248                current--;
     
    254250
    255251        /* We've found our location in the trace, now use it. */
    256         LIBTRACE_SEEK(INPUT.file,record.offset,SEEK_SET);
     252        libtrace_io_seek(INPUT.file,record.offset,SEEK_SET);
    257253
    258254        return 0; /* success */
     
    265261{
    266262        if (INPUT.file) {
    267                 LIBTRACE_CLOSE(INPUT.file);
     263                libtrace_io_close(INPUT.file);
    268264        }
    269265        INPUT.file = trace_open_file(libtrace);
     
    281277                char buffer[PATH_MAX];
    282278                snprintf(buffer,sizeof(buffer),"%s.idx",libtrace->uridata);
    283                 DATA(libtrace)->seek.index=LIBTRACE_OPEN(buffer,"r");
     279                DATA(libtrace)->seek.index=libtrace_io_open(buffer,"r");
    284280                if (DATA(libtrace)->seek.index) {
    285281                        DATA(libtrace)->seek.exists=INDEX_EXISTS;
     
    312308                if (trace_get_erf_timestamp(packet)==erfts)
    313309                        break;
    314                 off=LIBTRACE_TELL(INPUT.file);
     310                off=libtrace_io_tell(INPUT.file);
    315311        } while(trace_get_erf_timestamp(packet)<erfts);
    316312
    317         LIBTRACE_SEEK(INPUT.file,off,SEEK_SET);
     313        libtrace_io_seek(INPUT.file,off,SEEK_SET);
    318314
    319315        return 0;
     
    432428
    433429static int erf_fin_input(libtrace_t *libtrace) {
    434         LIBTRACE_CLOSE(INPUT.file);
     430        libtrace_io_close(INPUT.file);
    435431        free(libtrace->format_data);
    436432        return 0;
     
    438434
    439435static int erf_fin_output(libtrace_out_t *libtrace) {
    440         LIBTRACE_CLOSE(OUTPUT.file);
     436        libtrace_io_close(OUTPUT.file);
    441437        free(libtrace->format_data);
    442438        return 0;
     
    535531        packet->type = RT_DATA_ERF;
    536532
    537         if ((numbytes=LIBTRACE_READ(INPUT.file,
     533        if ((numbytes=libtrace_io_read(INPUT.file,
    538534                                        packet->buffer,
    539535                                        dag_record_size)) == -1) {
     
    557553       
    558554        /* read in the rest of the packet */
    559         if ((numbytes=LIBTRACE_READ(INPUT.file,
     555        if ((numbytes=libtrace_io_read(INPUT.file,
    560556                                        buffer2,
    561557                                        size)) != size) {
     
    682678        assert(size<=65536);
    683679
    684         if ((numbytes = LIBTRACE_WRITE(OUTPUT.file, erfptr, dag_record_size + pad)) != dag_record_size+pad) {
     680        if ((numbytes = libtrace_io_write(OUTPUT.file, erfptr, dag_record_size + pad)) != dag_record_size+pad) {
    685681                trace_set_err_out(libtrace,errno,
    686682                                "write(%s)",libtrace->uridata);
     
    688684        }
    689685
    690         if ((numbytes=LIBTRACE_WRITE(OUTPUT.file, buffer, size)) != size) {
     686        if ((numbytes=libtrace_io_write(OUTPUT.file, buffer, size)) != size) {
    691687                trace_set_err_out(libtrace,errno,
    692688                                "write(%s)",libtrace->uridata);
  • lib/format_helper.c

    rdd4b39b redb18ce  
    157157 * @internal
    158158 */
    159 LIBTRACE_FILE trace_open_file(libtrace_t *trace)
     159libtrace_io_t *trace_open_file(libtrace_t *trace)
    160160{
    161161        int fd;
    162         LIBTRACE_FILE ret;
     162        libtrace_io_t *ret;
    163163
    164164
    165165        if (strcmp(trace->uridata,"-")==0) {
    166                 ret=LIBTRACE_FDOPEN(fileno(stdin),"r");
     166                ret=libtrace_io_fdopen(fileno(stdin),"r");
    167167                return ret;
    168168        }
     
    176176                return 0;
    177177        }
    178         ret=LIBTRACE_FDOPEN(fd,"r");
     178        ret=libtrace_io_fdopen(fd,"r");
    179179        return ret;
    180180}
     
    183183 * @internal
    184184 */
    185 LIBTRACE_FILE trace_open_file_out(libtrace_out_t *trace,int level, int fileflag)
     185libtrace_io_t *trace_open_file_out(libtrace_out_t *trace,int level, int fileflag)
    186186{
    187187        int fd;
    188         LIBTRACE_FILE ret;
     188        libtrace_io_t *ret;
    189189        char filemode[4]; /* wb9\0 */
    190190        assert(level<10);
     
    197197
    198198        if (strcmp(trace->uridata,"-")==0) {
    199                 ret=LIBTRACE_FDOPEN(fileno(stdout),filemode);
     199                ret=libtrace_io_fdopen(fileno(stdout),filemode);
    200200                return ret;
    201201        }
     
    210210                return 0;
    211211        }
    212         ret=LIBTRACE_FDOPEN(fd,filemode);
     212        ret=libtrace_io_fdopen(fd,filemode);
    213213        if (!ret) {
    214214                printf("%s\n",filemode);
  • lib/format_helper.h

    rd5879cc redb18ce  
    3232#define FORMAT_HELPER_H
    3333#include "common.h"
     34#include "libtraceio.h"
    3435
    3536int trace_read(libtrace_t *libtrace, void *buffer, size_t len);
     
    4142                const libtrace_packet_t *packet);
    4243
    43 LIBTRACE_FILE trace_open_file(libtrace_t *libtrace);
    44 LIBTRACE_FILE trace_open_file_out(libtrace_out_t *libtrace,
     44libtrace_io_t *trace_open_file(libtrace_t *libtrace);
     45libtrace_io_t *trace_open_file_out(libtrace_out_t *libtrace,
    4546                int level,
    4647                int filemode);
  • lib/format_legacy.c

    r33e1501 redb18ce  
    7171        union {
    7272                int fd;
    73 #if HAVE_ZLIB
    74                 gzFile *file;
    75 #else   
    76                 /*FILE  *file; */
    77                 int file;
    78 #endif
     73                libtrace_io_t *file;
    7974        } input;
    8075};
     
    113108
    114109static int erf_fin_input(struct libtrace_t *libtrace) {
    115         LIBTRACE_CLOSE(INPUT.file);
     110        libtrace_io_close(INPUT.file);
    116111        free(libtrace->format_data);
    117112        return 0;
     
    142137        }
    143138       
    144         if ((numbytes=LIBTRACE_READ(INPUT.file,
     139        if ((numbytes=libtrace_io_read(INPUT.file,
    145140                                        buffer,
    146141                                        64)) == -1) {
  • lib/format_linux.c

    r566e404 redb18ce  
    4545#include <net/ethernet.h>
    4646#include <net/if_arp.h>
     47
     48#include <string.h>
     49#include <net/if.h>
     50#include <sys/ioctl.h>
    4751
    4852static struct libtrace_format_t linuxnative;
     
    113117static int linuxnative_read_packet(struct libtrace_t *libtrace, struct libtrace_packet_t *packet) {
    114118        struct libtrace_linuxnative_header *hdr;
     119        socklen_t socklen;
    115120        if (!packet->buffer || packet->buf_control == TRACE_CTRL_EXTERNAL) {
    116121                packet->buffer = malloc(LIBTRACE_PACKET_BUFSIZE);
     
    120125        packet->header = packet->buffer;
    121126        packet->type = RT_DATA_LINUX_NATIVE;
    122         packet->payload = packet->buffer+sizeof(*hdr);
     127        packet->payload = (char*)packet->buffer+sizeof(*hdr);
    123128
    124129        hdr=(void*)packet->buffer;
    125         socklen_t socklen=sizeof(hdr->hdr);
     130        socklen=sizeof(hdr->hdr);
    126131        hdr->wirelen = recvfrom(FORMAT(libtrace->format_data)->fd,
    127132                        (void*)packet->payload,
     
    141146
    142147static libtrace_linktype_t linuxnative_get_link_type(const struct libtrace_packet_t *packet) {
    143         switch htons((((struct libtrace_linuxnative_header*)(packet->buffer))->hdr.sll_protocol)) {
     148        switch (htons((((struct libtrace_linuxnative_header*)(packet->buffer))->hdr.sll_protocol))) {
    144149                case ETH_P_IP:
    145150                case ETH_P_IPV6:
     
    171176static int linuxnative_get_framing_length(const struct libtrace_packet_t *packet) {
    172177        return sizeof(struct libtrace_linuxnative_header);
    173 }
    174 
    175 static size_t linuxnative_set_capture_length(struct libtrace_packet_t *packet,size_t size) {
    176         return -1;
    177178}
    178179
  • lib/format_wag.c

    r671566a redb18ce  
    7272        union {
    7373                int fd;
    74 #if HAVE_ZLIB
    75                 gzFile *file;
    76 #else   
    77                 int file;
    78 #endif
     74                libtrace_io_t *file;
    7975        } input;       
    8076};
     
    8985        union {
    9086                int fd;
    91 #if HAVE_ZLIB
    92                 gzFile *file;
    93 #else
    94                 int file;
    95 #endif
     87                libtrace_io_t *file;
    9688        } output;
    9789};
     
    198190
    199191static int wtf_fin_input(struct libtrace_t *libtrace) {
    200         LIBTRACE_CLOSE(INPUT.file);
     192        libtrace_io_close(INPUT.file);
    201193        free(libtrace->format_data);
    202194        return 0;
     
    204196
    205197static int wtf_fin_output(struct libtrace_out_t *libtrace) {
    206         LIBTRACE_CLOSE(OUTPUT.file);
     198        libtrace_io_close(OUTPUT.file);
    207199        free(libtrace->format_data);
    208200        return 0;
     
    306298        buffer2 = buffer = packet->buffer;
    307299       
    308         if ((numbytes = LIBTRACE_READ(INPUT.file, buffer, sizeof(struct frame_t))) == -1) {
     300        if ((numbytes = libtrace_io_read(INPUT.file, buffer, sizeof(struct frame_t))) == -1) {
    309301                trace_set_err(libtrace,errno,
    310302                                "read(%s,frame_t)",packet->trace->uridata);
     
    328320
    329321       
    330         if ((numbytes=LIBTRACE_READ(INPUT.file, buffer2, size)) != size) {
     322        if ((numbytes=libtrace_io_read(INPUT.file, buffer2, size)) != size) {
    331323                trace_set_err(libtrace,
    332324                                errno,"read(%s,buffer)",packet->trace->uridata);
     
    352344         * technically correct to read from the header and payload pointers
    353345         */
    354         if ((numbytes = LIBTRACE_WRITE(OUTPUT.file, packet->header,
     346        if ((numbytes = libtrace_io_write(OUTPUT.file, packet->header,
    355347                                trace_get_framing_length(packet))) == -1) {
    356348                trace_set_err_out(libtrace,errno,
     
    358350                return -1;
    359351        }
    360         if ((numbytes = LIBTRACE_WRITE(OUTPUT.file, packet->payload,
     352        if ((numbytes = libtrace_io_write(OUTPUT.file, packet->payload,
    361353                                trace_get_capture_length(packet)) == -1)) {
    362354                trace_set_err_out(libtrace,
Note: See TracChangeset for help on using the changeset viewer.