Changeset c66068d


Ignore:
Timestamp:
12/03/08 13:24:55 (12 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:
f66a2dca
Parents:
7157db8
Message:

Rewrite the libtrace io subsystem to use the new wandio abstraction layer.

Files:
12 added
3 deleted
10 edited

Legend:

Unmodified
Added
Removed
  • configure.in

    rf20d66c rc66068d  
    262262
    263263
    264 AC_CHECK_LIB(z, gzopen)
     264AC_CHECK_LIB(z, deflate)
     265AC_CHECK_LIB(bz2, BZ2_bzDecompressInit)
    265266
    266267AM_CONDITIONAL([HAVE_BPF_CAPTURE], [test "$ac_cv_have_decl_BIOCSETIF" = yes ])
     
    269270AM_CONDITIONAL([DAG2_5], [test "$libtrace_dag_version" = 25])
    270271AM_CONDITIONAL([DAG3_0], [test "$libtrace_dag_version" = 30])
    271 AM_CONDITIONAL([HAVE_ZLIB], [test "$ac_cv_lib_z_gzopen" = yes])
     272AM_CONDITIONAL([HAVE_ZLIB], [test "$ac_cv_lib_z_deflate" = yes])
     273AM_CONDITIONAL([HAVE_BZLIB], [test "$ac_cv_lib_bz_BZ2_bzDecompressInit" = yes])
    272274AM_CONDITIONAL([HAVE_NETPACKET_PACKET_H], [test "$libtrace_netpacket_packet_h" = true])
    273275AM_CONDITIONAL([HAVE_LIBGDC], [test "$ac_cv_header_gdc_h" = yes])
     
    304306AC_MSG_NOTICE([Libtrace version $PACKAGE_VERSION])
    305307reportopt "Compiled with PCAP 0.8 support" $ac_cv_lib_pcap_pcap_next_ex
    306 reportopt "Compiled with compressed trace (zlib) support" $ac_cv_lib_z_gzopen
     308reportopt "Compiled with compressed trace (zlib) support" $ac_cv_lib_z_deflate
     309reportopt "Compiled with compressed trace (bz2) support" $ac_cv_lib_bz2_BZ2_bzDecompressInit
    307310if test x"$libtrace_dag" = xtrue; then
    308311        if test "$libtrace_dag_version" = 24; then
  • lib/Makefile.am

    r2faa57e rc66068d  
    11lib_LTLIBRARIES = libtrace.la
    2 include_HEADERS = libtrace.h dagformat.h lt_inttypes.h daglegacy.h rt_protocol.h libtraceio.h erftypes.h
     2include_HEADERS = libtrace.h dagformat.h lt_inttypes.h daglegacy.h rt_protocol.h erftypes.h wandio.h
    33
    44extra_DIST = format_template.c
     
    1616
    1717if HAVE_ZLIB
    18 LIBTRACEIO=libtraceio-zlib.c
     18LIBTRACEIO_ZLIB=ior-zlib.c iow-zlib.c
    1919else
    20 LIBTRACEIO=libtraceio-stdio.c
     20LIBTRACEIO_ZLIB=
     21endif
     22
     23if HAVE_BZLIB
     24LIBTRACEIO_BZLIB=ior-bzip.c iow-bzip.c
     25else
     26LIBTRACEIO_BZLIB=
    2127endif
    2228
     
    3238EXTRA_DIST=format_dag24.c format_dag25.c
    3339
    34 libtrace_la_SOURCES = $(LIBTRACEIO) trace.c common.h \
     40libtrace_la_SOURCES = trace.c common.h \
    3541                format_erf.c format_pcap.c format_legacy.c \
    3642                format_rt.c format_helper.c format_helper.h format_pcapfile.c \
     
    4147                protocols_pktmeta.c protocols_l2.c protocols_l3.c \
    4248                protocols_transport.c protocols.h \
    43                 libtraceio.h \
    44                 $(DAGSOURCE) format_erf.h
     49                $(DAGSOURCE) format_erf.h \
     50                $(LIBTRACEIO_ZLIB) $(LIBTRACEIO_BZLIB) ior-peek.c ior-stdio.c ior-thread.c \
     51                iow-stdio.c iow-thread.c wandio.c \
     52                wandio.h
    4553
    4654if DAG2_4
  • lib/format_atmhdr.c

    rf0fb38f rc66068d  
    66#include "libtrace_int.h"
    77#include "format_helper.h"
     8#include "wandio.h"
    89
    910#include <sys/stat.h>
     
    2425        union {
    2526                int fd;
    26                 libtrace_io_t *file;
     27                io_t *file;
    2728        } input;
    2829};
     
    5152static int atmhdr_fin_input(libtrace_t *libtrace)
    5253{
    53         libtrace_io_close(INPUT.file);
     54        wandio_destroy(INPUT.file);
    5455        free(libtrace->format_data);
    5556        return 0;
     
    9697        packet->type = TRACE_RT_DATA_ATMHDR;
    9798
    98         if ((numbytes=libtrace_io_read(INPUT.file, buffer, (size_t)12)) != 12)
     99        if ((numbytes=wandio_read(INPUT.file, buffer, (size_t)12)) != 12)
    99100        {
    100101                if (numbytes != 0) {
  • lib/format_duck.c

    rf0fb38f rc66068d  
    3333#include "format_helper.h"
    3434#include "config.h"
     35#include "wandio.h"
    3536#include <stdlib.h>
    3637#include "libtraceio.h"
     
    5051struct duck_format_data_t {
    5152        char *path;
    52         libtrace_io_t *file;
     53        io_t *file;
    5354        int dag_version;
    5455};
     
    5859        int level;
    5960        int fileflag;
    60         libtrace_io_t *file;
     61        iow_t *file;
    6162        int dag_version;       
    6263};
     
    121122
    122123static int duck_fin_input(libtrace_t *libtrace) {
    123         libtrace_io_close(INPUT->file);
     124        wandio_destroy(INPUT->file);
    124125        free(libtrace->format_data);
    125126
     
    128129
    129130static int duck_fin_output(libtrace_out_t *libtrace) {
    130         libtrace_io_close(OUTPUT->file);
     131        wandio_wdestroy(OUTPUT->file);
    131132        free(libtrace->format_data);
    132133        return 0;
     
    180181        if (INPUT->dag_version == 0) {
    181182                /* Read in the duck version from the start of the trace */
    182                 if ((numbytes = libtrace_io_read(INPUT->file, &version,
     183                if ((numbytes = wandio_read(INPUT->file, &version,
    183184                                        sizeof(version))) != sizeof(uint32_t)) {
    184185                        trace_set_err(libtrace, errno,
     
    206207        }
    207208
    208         if ((numbytes = libtrace_io_read(INPUT->file, packet->buffer,
     209        if ((numbytes = wandio_read(INPUT->file, packet->buffer,
    209210                                        (size_t)duck_size)) != (int)duck_size) {
    210211                if (numbytes == -1) {
     
    243244        if (OUTPUT->dag_version == 0) {
    244245        /* Writing the DUCK version will help with reading it back in later! */
    245                 if ((numbytes = libtrace_io_write(OUTPUT->file, &packet->type,
     246                if ((numbytes = wandio_wwrite(OUTPUT->file, &packet->type,
    246247                                sizeof(packet->type))) != sizeof(uint32_t)){
    247248                        trace_set_err_out(libtrace, errno,
     
    252253        }
    253254       
    254         if ((numbytes = libtrace_io_write(OUTPUT->file, packet->payload,
     255        if ((numbytes = wandio_wwrite(OUTPUT->file, packet->payload,
    255256                                        trace_get_capture_length(packet))) !=
    256257                                (int)trace_get_capture_length(packet)) {
  • lib/format_erf.c

    rf0fb38f rc66068d  
    3636#include "format_helper.h"
    3737#include "format_erf.h"
     38#include "wandio.h"
    3839
    3940#include <assert.h>
     
    7273        union {
    7374                int fd;
    74                 libtrace_io_t *file;
     75                io_t *file;
    7576        } input;
    7677
     
    7879        struct {
    7980                enum { INDEX_UNKNOWN=0, INDEX_NONE, INDEX_EXISTS } exists;
    80                 libtrace_io_t *index;
     81                io_t *index;
    8182                off_t index_len;
    8283        } seek;
     
    100101                int fd;
    101102                struct rtserver_t * rtserver;
    102                 libtrace_io_t *file;
     103                iow_t *file;
    103104        } output;
    104105};
     
    205206                current=(max_off+min_off)>>2;
    206207
    207                 libtrace_io_seek(DATA(libtrace)->seek.index,
     208                wandio_seek(DATA(libtrace)->seek.index,
    208209                                (int64_t)(current*sizeof(record)),
    209210                                SEEK_SET);
    210                 libtrace_io_read(DATA(libtrace)->seek.index,
     211                wandio_read(DATA(libtrace)->seek.index,
    211212                                &record,sizeof(record));
    212213                if (record.timestamp < erfts) {
     
    224225         */
    225226        do {
    226                 libtrace_io_seek(DATA(libtrace)->seek.index,
     227                wandio_seek(DATA(libtrace)->seek.index,
    227228                                (int64_t)(current*sizeof(record)),SEEK_SET);
    228                 libtrace_io_read(DATA(libtrace)->seek.index,
     229                wandio_read(DATA(libtrace)->seek.index,
    229230                                &record,sizeof(record));
    230231                current--;
     
    232233
    233234        /* We've found our location in the trace, now use it. */
    234         libtrace_io_seek(INPUT.file,(int64_t) record.offset,SEEK_SET);
     235        wandio_seek(INPUT.file,(int64_t) record.offset,SEEK_SET);
    235236
    236237        return 0; /* success */
     
    243244{
    244245        if (INPUT.file) {
    245                 libtrace_io_close(INPUT.file);
     246                wandio_destroy(INPUT.file);
    246247        }
    247248        INPUT.file = trace_open_file(libtrace);
     
    259260                char buffer[PATH_MAX];
    260261                snprintf(buffer,sizeof(buffer),"%s.idx",libtrace->uridata);
    261                 DATA(libtrace)->seek.index=libtrace_io_open(buffer,"rb");
     262                DATA(libtrace)->seek.index=wandio_create(buffer);
    262263                if (DATA(libtrace)->seek.index) {
    263264                        DATA(libtrace)->seek.exists=INDEX_EXISTS;
     
    290291                if (trace_get_erf_timestamp(packet)==erfts)
    291292                        break;
    292                 off=libtrace_io_tell(INPUT.file);
     293                off=wandio_tell(INPUT.file);
    293294        } while(trace_get_erf_timestamp(packet)<erfts);
    294295
    295         libtrace_io_seek(INPUT.file,off,SEEK_SET);
     296        wandio_seek(INPUT.file,off,SEEK_SET);
    296297
    297298        return 0;
     
    330331static int erf_fin_input(libtrace_t *libtrace) {
    331332        if (INPUT.file)
    332                 libtrace_io_close(INPUT.file);
     333                wandio_destroy(INPUT.file);
    333334        free(libtrace->format_data);
    334335        return 0;
     
    337338static int erf_fin_output(libtrace_out_t *libtrace) {
    338339        if (OUTPUT.file)
    339                 libtrace_io_close(OUTPUT.file);
     340                wandio_wdestroy(OUTPUT.file);
    340341        free(libtrace->format_data);
    341342        return 0;
     
    408409        flags |= TRACE_PREP_OWN_BUFFER;
    409410       
    410         if ((numbytes=libtrace_io_read(INPUT.file,
     411        if ((numbytes=wandio_read(INPUT.file,
    411412                                        packet->buffer,
    412413                                        (size_t)dag_record_size)) == -1) {
     
    436437       
    437438        /* read in the rest of the packet */
    438         if ((numbytes=libtrace_io_read(INPUT.file,
     439        if ((numbytes=wandio_read(INPUT.file,
    439440                                        buffer2,
    440441                                        (size_t)size)) != (int)size) {
     
    460461
    461462        if ((numbytes =
    462                 libtrace_io_write(OUTPUT.file,
     463                wandio_wwrite(OUTPUT.file,
    463464                                erfptr,
    464465                                (size_t)(dag_record_size + pad)))
     
    470471
    471472        size=ntohs(erfptr->rlen)-(dag_record_size+pad);
    472         numbytes=libtrace_io_write(OUTPUT.file, buffer, (size_t)size);
     473        numbytes=wandio_wwrite(OUTPUT.file, buffer, (size_t)size);
    473474        if (numbytes != size) {
    474475                trace_set_err_out(libtrace,errno,
  • lib/format_helper.c

    rf3f3558 rc66068d  
    3535#include "libtrace.h"
    3636#include "libtrace_int.h"
     37#include "wandio.h"
    3738
    3839#include <stdlib.h>
     
    198199 * @internal
    199200 */
    200 libtrace_io_t *trace_open_file(libtrace_t *trace)
    201 {
    202         int fd;
    203         libtrace_io_t *ret;
    204 
    205 
    206         if (strcmp(trace->uridata,"-")==0) {
    207                 ret=libtrace_io_fdopen(fileno(stdin),"rb");
    208                 return ret;
    209         }
    210 
    211         /* We open the file with open(2), so we can provide O_LARGEFILE
    212          * as zlib doesn't always do it itself
    213          */
    214         fd=open(trace->uridata,O_LARGEFILE|O_RDONLY|O_BINARY);
    215         if (fd==-1) {
    216                 trace_set_err(trace,errno,"Unable to open %s",trace->uridata);
    217                 return 0;
    218         }
    219         ret=libtrace_io_fdopen(fd,"rb");
    220         return ret;
     201io_t *trace_open_file(libtrace_t *trace)
     202{
     203        return wandio_create(trace->uridata);
    221204}
    222205
     
    224207 * @internal
    225208 */
    226 libtrace_io_t *trace_open_file_out(libtrace_out_t *trace,int level, int fileflag)
    227 {
    228         int fd;
    229         libtrace_io_t *ret;
    230         char filemode[4]; /* wb9\0 */
     209iow_t *trace_open_file_out(libtrace_out_t *trace,int level, int fileflag)
     210{
    231211        assert(level<10);
    232212        assert(level>=0);
    233 #ifdef HAVE_LIBZ
    234         snprintf(filemode,sizeof(filemode),"wb%d",level);
    235 #else
    236         snprintf(filemode,sizeof(filemode),"wb");
    237 #endif
    238 
    239         if (strcmp(trace->uridata,"-")==0) {
    240                 ret=libtrace_io_fdopen(fileno(stdout),filemode);
    241                 return ret;
    242         }
    243 
    244         /* We open the file with open(2), so we can provide O_LARGEFILE
    245          * as zlib doesn't always do it itself
    246          */
    247         fd=open(trace->uridata,fileflag|O_LARGEFILE|O_BINARY,0666);
    248         if (fd==-1) {
    249                 trace_set_err_out(trace,
    250                                 errno,"Unable to open %s",trace->uridata);
    251                 return 0;
    252         }
    253         ret=libtrace_io_fdopen(fd,filemode);
    254         if (!ret) {
    255                 trace_set_err_out(trace,
    256                                 TRACE_ERR_INIT_FAILED,"gz out of memory");
    257         }
    258         return ret;
     213
     214        return wandio_wcreate(trace->uridata, level, fileflag);
    259215}
    260216
  • lib/format_helper.h

    rf3f3558 rc66068d  
    3333#include "common.h"
    3434#include "libtraceio.h"
     35#include "wandio.h"
    3536
    3637int trace_read(libtrace_t *libtrace, void *buffer, size_t len);
     
    4243                const libtrace_packet_t *packet);
    4344
    44 libtrace_io_t *trace_open_file(libtrace_t *libtrace);
    45 libtrace_io_t *trace_open_file_out(libtrace_out_t *libtrace,
     45io_t *trace_open_file(libtrace_t *libtrace);
     46iow_t *trace_open_file_out(libtrace_out_t *libtrace,
    4647                int level,
    4748                int filemode);
  • lib/format_legacy.c

    r29c8666 rc66068d  
    3535#include "libtrace_int.h"
    3636#include "format_helper.h"
     37#include "wandio.h"
    3738
    3839#include <sys/stat.h>
     
    6667        union {
    6768                int fd;
    68                 libtrace_io_t *file;
     69                io_t *file;
    6970        } input;
    7071        time_t starttime;       /* Used for legacy_nzix */
     
    175176
    176177static int erf_fin_input(libtrace_t *libtrace) {
    177         libtrace_io_close(INPUT.file);
     178        wandio_destroy(INPUT.file);
    178179        free(libtrace->format_data);
    179180        return 0;
     
    237238        while (1) {
    238239       
    239                 if ((numbytes=libtrace_io_read(INPUT.file,
     240                if ((numbytes=wandio_read(INPUT.file,
    240241                                                buffer,
    241242                                                (size_t)64)) != 64) {
     
    279280       
    280281        while (1) {
    281                 if ((numbytes = libtrace_io_read(INPUT.file, buffer,
     282                if ((numbytes = wandio_read(INPUT.file, buffer,
    282283                                                (size_t)68)) != 68) {
    283284                        if (numbytes < 0) {
  • lib/format_pcapfile.c

    r5c4e0c0 rc66068d  
    5858
    5959struct pcapfile_format_data_t {
    60         libtrace_io_t *file;
     60        io_t *file;
    6161        struct {
    6262                int real_time;
     
    6666
    6767struct pcapfile_format_data_out_t {
    68         libtrace_io_t *file;
     68        iow_t *file;
    6969        int level;
    7070        int flag;
     
    133133                        return -1;
    134134
    135                 err=libtrace_io_read(DATA(libtrace)->file,
     135                err=wandio_read(DATA(libtrace)->file,
    136136                                &DATA(libtrace)->header,
    137137                                sizeof(DATA(libtrace)->header));
     
    190190{
    191191        if (DATA(libtrace)->file)
    192                 libtrace_io_close(DATA(libtrace)->file);
     192                wandio_destroy(DATA(libtrace)->file);
    193193        free(libtrace->format_data);
    194194        return 0; /* success */
     
    198198{
    199199        if (DATA(libtrace)->file)
    200                 libtrace_io_close(DATA(libtrace)->file);
     200                wandio_wdestroy(DATAOUT(libtrace)->file);
    201201        free(libtrace->format_data);
    202202        libtrace->format_data=NULL;
     
    269269        flags |= TRACE_PREP_OWN_BUFFER;
    270270       
    271         err=libtrace_io_read(DATA(libtrace)->file,
     271        err=wandio_read(DATA(libtrace)->file,
    272272                        packet->buffer,
    273273                        sizeof(libtrace_pcapfile_pkt_hdr_t));
     
    284284        }
    285285
    286         err=libtrace_io_read(DATA(libtrace)->file,
     286        err=wandio_read(DATA(libtrace)->file,
    287287                        (char*)packet->buffer+sizeof(libtrace_pcapfile_pkt_hdr_t),
    288288                        (size_t)swapl(libtrace,((libtrace_pcapfile_pkt_hdr_t*)packet->buffer)->caplen)
     
    362362                        libtrace_to_pcap_linktype(linktype);
    363363
    364                 libtrace_io_write(DATAOUT(out)->file,
     364                wandio_wwrite(DATAOUT(out)->file,
    365365                                &pcaphdr, sizeof(pcaphdr));
    366366        }
     
    384384
    385385
    386         numbytes=libtrace_io_write(DATAOUT(out)->file,
     386        numbytes=wandio_wwrite(DATAOUT(out)->file,
    387387                        &hdr, sizeof(hdr));
    388388
     
    390390                return -1;
    391391
    392         ret=libtrace_io_write(DATAOUT(out)->file,
     392        ret=wandio_wwrite(DATAOUT(out)->file,
    393393                        ptr,
    394394                        remaining);
  • lib/format_tsh.c

    r5d4e520 rc66068d  
    4545
    4646struct tsh_format_data_t {
    47         libtrace_io_t *file;
     47        io_t *file;
    4848};
    4949
     
    8383static int tsh_fin_input(libtrace_t *libtrace) {
    8484        if (DATA(libtrace)->file)
    85                 libtrace_io_close(DATA(libtrace)->file);
     85                wandio_destroy(DATA(libtrace)->file);
    8686        free(libtrace->format_data);
    8787        return 0;
     
    134134
    135135        /* Read the TSH header */
    136         if ((numbytes=libtrace_io_read(DATA(libtrace)->file,
     136        if ((numbytes=wandio_read(DATA(libtrace)->file,
    137137                                        buffer2,
    138138                                        (size_t)sizeof(tsh_pkt_header_t))) == -1) {
     
    149149
    150150        /* Read the IP header */
    151         if ((numbytes=libtrace_io_read(DATA(libtrace)->file,
     151        if ((numbytes=wandio_read(DATA(libtrace)->file,
    152152                                buffer2,
    153153                                (size_t)sizeof(libtrace_ip_t)))
     
    164164
    165165        /* Read the transport header */
    166         if ((numbytes=libtrace_io_read(DATA(libtrace)->file,
     166        if ((numbytes=wandio_read(DATA(libtrace)->file,
    167167                                buffer2,
    168168                                16)) != 16) {
Note: See TracChangeset for help on using the changeset viewer.