Changeset 91b72d3


Ignore:
Timestamp:
01/05/09 11:29:11 (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:
ad36006
Parents:
9d0049cf
Message:

Try to autoguess the tracetype if the format uri specify is not present

Location:
lib
Files:
16 edited

Legend:

Unmodified
Added
Removed
  • lib/format_atmhdr.c

    rc66068d r91b72d3  
    1616#include <stdlib.h>
    1717
    18 
    19 
    20 #define DATA(x) ((struct atmhdr_format_data_t *)x->format_data)
    21 
    22 #define INPUT DATA(libtrace)->input
    23 
    24 struct atmhdr_format_data_t {
    25         union {
    26                 int fd;
    27                 io_t *file;
    28         } input;
    29 };
    30 
    3118static int atmhdr_get_framing_length(const libtrace_packet_t *packet UNUSED)
    3219{
     
    3522
    3623static int atmhdr_init_input(libtrace_t *libtrace) {
    37         libtrace->format_data = malloc(sizeof(struct atmhdr_format_data_t));
    38         DATA(libtrace)->input.file = NULL;
     24        libtrace->format_data = NULL; /* No format data needed */
    3925        return 0;
    4026}
     
    4228static int atmhdr_start_input(libtrace_t *libtrace)
    4329{
    44         if (DATA(libtrace)->input.file)
     30        if (libtrace->io) /* Already open? */
    4531                return 0;
    46         DATA(libtrace)->input.file = trace_open_file(libtrace);
    47         if (DATA(libtrace)->input.file)
     32        libtrace->io = trace_open_file(libtrace);
     33        if (libtrace->io)
    4834                return 0;
    4935        return -1;
     
    5238static int atmhdr_fin_input(libtrace_t *libtrace)
    5339{
    54         wandio_destroy(INPUT.file);
    55         free(libtrace->format_data);
     40        wandio_destroy(libtrace->io);
    5641        return 0;
    5742}
     
    9782        packet->type = TRACE_RT_DATA_ATMHDR;
    9883
    99         if ((numbytes=wandio_read(INPUT.file, buffer, (size_t)12)) != 12)
     84        if ((numbytes=wandio_read(libtrace->io, buffer, (size_t)12)) != 12)
    10085        {
    10186                if (numbytes != 0) {
     
    138123        "$Id$",
    139124        TRACE_FORMAT_ATMHDR,
     125        NULL,                           /* probe filename */
     126        NULL,                           /* probe magic */
    140127        atmhdr_init_input,              /* init_input */
    141128        NULL,                           /* config_input */
  • lib/format_bpf.c

    rc0dba7a r91b72d3  
    6969
    7070#define BPFHDR(x) ((struct bpf_hdr *)((x)->header))
     71
     72static int bpf_start_filename(const char *filename)
     73{
     74        return 0;
     75}
    7176
    7277static int bpf_init_input(libtrace_t *libtrace)
     
    429434        "$Id$",
    430435        TRACE_FORMAT_BPF,
     436        bpf_probe_filename,     /* probe filename */
     437        NULL,                   /* probe magic */
    431438        bpf_init_input,         /* init_input */
    432439        bpf_config_input,       /* config_input */
  • lib/format_dag24.c

    rc0dba7a r91b72d3  
    8282        uint64_t drops;
    8383};
     84
     85static void dag_probe_filename(const char *filename)
     86{
     87        struct stat statbuf;
     88        /* Can we stat the file? */
     89        if (stat(filename, &statbuf) != 0) {
     90                return 0;
     91        }
     92        /* Is it a character device? */
     93        if (!S_ISCHR(statbuf.st_mode)) {
     94                return 0;
     95        }
     96        /* Yeah, it's probably us. */
     97        return 1;
     98}
    8499
    85100static void dag_init_format_data(libtrace_t *libtrace) {
     
    407422        "$Id$",
    408423        TRACE_FORMAT_ERF,
     424        dag_probe_filename,             /* probe filename */
     425        NULL,                           /* probe magic */
    409426        dag_init_input,                 /* init_input */
    410427        dag_config_input,               /* config_input */
  • lib/format_dag25.c

    rc0dba7a r91b72d3  
    9898pthread_mutex_t open_dag_mutex;
    9999struct dag_dev_t *open_dags = NULL;
     100
     101static void dag_probe_filename(const char *filename)
     102{
     103        struct stat statbuf;
     104        /* Can we stat the file? */
     105        if (stat(filename, &statbuf) != 0) {
     106                return 0;
     107        }
     108        /* Is it a character device? */
     109        if (!S_ISCHR(statbuf.st_mode)) {
     110                return 0;
     111        }
     112        /* Yeah, it's probably us. */
     113        return 1;
     114}
    100115
    101116static void dag_init_format_data(libtrace_t *libtrace) {
     
    572587        "$Id$",
    573588        TRACE_FORMAT_ERF,
     589        dag_probe_filename,             /* probe filename */
     590        NULL,                           /* probe magic */
    574591        dag_init_input,                 /* init_input */
    575592        dag_config_input,               /* config_input */
  • lib/format_duck.c

    r099d112 r91b72d3  
    4545#define DATAOUT(x) ((struct duck_format_data_out_t *)x->format_data)
    4646
    47 #define INPUT DATA(libtrace)
    4847#define OUTPUT DATAOUT(libtrace)
    4948
    5049struct duck_format_data_t {
    5150        char *path;
    52         io_t *file;
    5351        int dag_version;
    5452};
     
    6563        libtrace->format_data = malloc(sizeof(struct duck_format_data_t));
    6664
    67         INPUT->file = 0;
    68         INPUT->dag_version = 0;
     65        DATA(libtrace)->dag_version = 0;
    6966        return 0;
    7067}
     
    10097static int duck_start_input(libtrace_t *libtrace) {
    10198       
    102         if (INPUT->file)
     99        if (libtrace->io)
    103100                /* File already open */
    104101                return 0;
    105102       
    106         INPUT->file = trace_open_file(libtrace);
    107         if (!INPUT->file)
     103        libtrace->io = trace_open_file(libtrace);
     104        if (!libtrace->io)
    108105                return -1;
    109106
     
    121118
    122119static int duck_fin_input(libtrace_t *libtrace) {
    123         wandio_destroy(INPUT->file);
     120        wandio_destroy(libtrace->io);
    124121        free(libtrace->format_data);
    125122
     
    178175        flags |= TRACE_PREP_OWN_BUFFER;
    179176       
    180         if (INPUT->dag_version == 0) {
     177        if (DATA(libtrace)->dag_version == 0) {
    181178                /* Read in the duck version from the start of the trace */
    182                 if ((numbytes = wandio_read(INPUT->file, &version,
     179                if ((numbytes = wandio_read(libtrace->io, &version,
    183180                                        sizeof(version))) != sizeof(uint32_t)) {
    184181                        trace_set_err(libtrace, errno,
     
    189186                        return 0;
    190187                }
    191                 INPUT->dag_version = bswap_le_to_host32(version);
    192         }
    193        
    194 
    195         if (INPUT->dag_version == TRACE_RT_DUCK_2_4) {
     188                DATA(libtrace)->dag_version = bswap_le_to_host32(version);
     189        }
     190       
     191
     192        if (DATA(libtrace)->dag_version == TRACE_RT_DUCK_2_4) {
    196193                duck_size = sizeof(duck2_4_t);
    197194                packet->type = TRACE_RT_DUCK_2_4;
    198         } else if (INPUT->dag_version == TRACE_RT_DUCK_2_5) {
     195        } else if (DATA(libtrace)->dag_version == TRACE_RT_DUCK_2_5) {
    199196                duck_size = sizeof(duck2_5_t);
    200197                packet->type = TRACE_RT_DUCK_2_5;
     
    202199                trace_set_err(libtrace, TRACE_ERR_BAD_PACKET,
    203200                                "Unrecognised DUCK version %i",
    204                                 INPUT->dag_version);
    205                 return -1;
    206         }
    207 
    208         if ((numbytes = wandio_read(INPUT->file, packet->buffer,
     201                                DATA(libtrace)->dag_version);
     202                return -1;
     203        }
     204
     205        if ((numbytes = wandio_read(libtrace->io, packet->buffer,
    209206                                        (size_t)duck_size)) != (int)duck_size) {
    210207                if (numbytes == -1) {
     
    304301        "$Id$",
    305302        TRACE_FORMAT_DUCK,
     303        NULL,                           /* probe filename */
     304        NULL,                           /* probe magic */
    306305        duck_init_input,                /* init_input */
    307306        NULL,                           /* config_input */
  • lib/format_erf.c

    rc66068d r91b72d3  
    6565#define DATAOUT(x) ((struct erf_format_data_out_t *)x->format_data)
    6666
    67 #define INPUT DATA(libtrace)->input
    6867#define IN_OPTIONS DATA(libtrace)->options
    6968#define OUTPUT DATAOUT(libtrace)->output
     
    7170struct erf_format_data_t {
    7271       
    73         union {
    74                 int fd;
    75                 io_t *file;
    76         } input;
    77 
    78        
    7972        struct {
    8073                enum { INDEX_UNKNOWN=0, INDEX_NONE, INDEX_EXISTS } exists;
     
    145138}
    146139
     140static int erf_probe_magic(io_t *io)
     141{
     142        char buffer[4096];
     143        int len;
     144        dag_record_t *erf;
     145        len = wandio_peek(io, buffer, sizeof(buffer));
     146        if (len < dag_record_size) {
     147                return 0; /* False */
     148        }
     149        erf = (dag_record_t *) buffer;
     150        /* If the record is too short */
     151        if (ntohs(erf->rlen) < dag_record_size) {
     152                return 0;
     153        }
     154        /* There aren't any erf traces before 1995-01-01 */
     155        if (bswap_le_to_host64(erf->ts) < 0x2f0539b000000000ULL) {
     156                return 0;
     157        }
     158        /* And not pcap! */
     159        if (bswap_le_to_host64(erf->ts) >>32 == 0xa1b2c3d4) {
     160                return 0;
     161        }
     162        /* And not the other pcap! */
     163        if (bswap_le_to_host64(erf->ts) >>32 == 0xd4c3b2a1) {
     164                return 0;
     165        }
     166        /* Is this a proper typed packet */
     167        if (erf->type > TYPE_AAL2) {
     168                return 0;
     169        }
     170        /* We should put some more tests in here. */
     171        /* Yeah, this is probably ERF */
     172        return 1;
     173}
    147174
    148175static int erf_init_input(libtrace_t *libtrace)
     
    150177        libtrace->format_data = malloc(sizeof(struct erf_format_data_t));
    151178       
    152         INPUT.file = 0;
    153179        IN_OPTIONS.real_time = 0;
    154180        DATA(libtrace)->drops = 0;
     
    181207static int erf_start_input(libtrace_t *libtrace)
    182208{
    183         if (INPUT.file)
    184                 return 0; /* success */
    185 
    186         INPUT.file = trace_open_file(libtrace);
    187 
    188         if (!INPUT.file)
     209        if (libtrace->io)
     210                return 0; /* Success -- already done. */
     211
     212        libtrace->io = trace_open_file(libtrace);
     213
     214        if (!libtrace->io)
    189215                return -1;
    190216
     
    233259
    234260        /* We've found our location in the trace, now use it. */
    235         wandio_seek(INPUT.file,(int64_t) record.offset,SEEK_SET);
     261        wandio_seek(libtrace->io,(int64_t) record.offset,SEEK_SET);
    236262
    237263        return 0; /* success */
     
    243269static int erf_slow_seek_start(libtrace_t *libtrace,uint64_t erfts UNUSED)
    244270{
    245         if (INPUT.file) {
    246                 wandio_destroy(INPUT.file);
    247         }
    248         INPUT.file = trace_open_file(libtrace);
    249         if (!INPUT.file)
     271        if (libtrace->io) {
     272                wandio_destroy(libtrace->io);
     273        }
     274        libtrace->io = trace_open_file(libtrace);
     275        if (!libtrace->io)
    250276                return -1;
    251277        return 0;
     
    291317                if (trace_get_erf_timestamp(packet)==erfts)
    292318                        break;
    293                 off=wandio_tell(INPUT.file);
     319                off=wandio_tell(libtrace->io);
    294320        } while(trace_get_erf_timestamp(packet)<erfts);
    295321
    296         wandio_seek(INPUT.file,off,SEEK_SET);
     322        wandio_seek(libtrace->io,off,SEEK_SET);
    297323
    298324        return 0;
     
    330356
    331357static int erf_fin_input(libtrace_t *libtrace) {
    332         if (INPUT.file)
    333                 wandio_destroy(INPUT.file);
     358        if (libtrace->io)
     359                wandio_destroy(libtrace->io);
    334360        free(libtrace->format_data);
    335361        return 0;
     
    409435        flags |= TRACE_PREP_OWN_BUFFER;
    410436       
    411         if ((numbytes=wandio_read(INPUT.file,
     437        if ((numbytes=wandio_read(libtrace->io,
    412438                                        packet->buffer,
    413439                                        (size_t)dag_record_size)) == -1) {
     
    437463       
    438464        /* read in the rest of the packet */
    439         if ((numbytes=wandio_read(INPUT.file,
     465        if ((numbytes=wandio_read(libtrace->io,
    440466                                        buffer2,
    441467                                        (size_t)size)) != (int)size) {
     
    714740        "$Id$",
    715741        TRACE_FORMAT_ERF,
     742        NULL,                           /* probe filename */
     743        erf_probe_magic,                /* probe magic */
    716744        erf_init_input,                 /* init_input */       
    717745        erf_config_input,               /* config_input */
  • lib/format_helper.c

    rc66068d r91b72d3  
    201201io_t *trace_open_file(libtrace_t *trace)
    202202{
    203         return wandio_create(trace->uridata);
     203        io_t *io=wandio_create(trace->uridata);
     204        if (!io) {
     205                trace_set_err(trace,errno,"Unable to open %s",trace->uridata);
     206        }
     207        return io;
    204208}
    205209
  • lib/format_legacy.c

    rc66068d r91b72d3  
    6262
    6363#define DATA(x) ((struct legacy_format_data_t *)x->format_data)
    64 #define INPUT DATA(libtrace)->input
    6564
    6665struct legacy_format_data_t {
    67         union {
    68                 int fd;
    69                 io_t *file;
    70         } input;
    7166        time_t starttime;       /* Used for legacy_nzix */
    7267        uint64_t ts_high;       /* Used for legacy_nzix */
     
    7772        libtrace->format_data = malloc(sizeof(struct legacy_format_data_t));
    7873       
    79         DATA(libtrace)->input.file = NULL;
    8074        DATA(libtrace)->ts_high = 0;
    8175        DATA(libtrace)->ts_old = 0;
     
    164158static int erf_start_input(libtrace_t *libtrace)
    165159{
    166         if (DATA(libtrace)->input.file)
     160        if (libtrace->io)
     161                return 0; /* Already open */
     162
     163        libtrace->io = trace_open_file(libtrace);
     164
     165        if (libtrace->io)
    167166                return 0;
    168167
    169         DATA(libtrace)->input.file = trace_open_file(libtrace);
    170 
    171         if (DATA(libtrace)->input.file)
    172                 return 0;
    173 
    174168        return -1;
    175169}
    176170
    177171static int erf_fin_input(libtrace_t *libtrace) {
    178         wandio_destroy(INPUT.file);
     172        wandio_destroy(libtrace->io);
    179173        free(libtrace->format_data);
    180174        return 0;
     
    238232        while (1) {
    239233       
    240                 if ((numbytes=wandio_read(INPUT.file,
     234                if ((numbytes=wandio_read(libtrace->io,
    241235                                                buffer,
    242236                                                (size_t)64)) != 64) {
     
    280274       
    281275        while (1) {
    282                 if ((numbytes = wandio_read(INPUT.file, buffer,
     276                if ((numbytes = wandio_read(libtrace->io, buffer,
    283277                                                (size_t)68)) != 68) {
    284278                        if (numbytes < 0) {
     
    466460        "$Id$",
    467461        TRACE_FORMAT_LEGACY_ATM,
     462        NULL,                           /* probe filename */
     463        NULL,                           /* probe magic */
    468464        erf_init_input,                 /* init_input */       
    469465        NULL,                           /* config_input */
     
    506502        "$Id$",
    507503        TRACE_FORMAT_LEGACY_ETH,
     504        NULL,                           /* probe filename */
     505        NULL,                           /* probe magic */
    508506        erf_init_input,                 /* init_input */       
    509507        NULL,                           /* config_input */
     
    546544        "$Id$",
    547545        TRACE_FORMAT_LEGACY_POS,
     546        NULL,                           /* probe filename */
     547        NULL,                           /* probe magic */
    548548        erf_init_input,                 /* init_input */       
    549549        NULL,                           /* config_input */
     
    586586        "$Id$",
    587587        TRACE_FORMAT_LEGACY_NZIX,
     588        NULL,                           /* probe filename */
     589        NULL,                           /* probe magic */
    588590        legacynzix_init_input,          /* init_input */       
    589591        NULL,                           /* config_input */
  • lib/format_linux.c

    r1f44884 r91b72d3  
    3333#include "format_helper.h"
    3434#include "config.h"
    35 #include "stdlib.h"
     35#include <stdlib.h>
    3636
    3737#ifdef HAVE_INTTYPES_H
     
    5050#include <sys/ioctl.h>
    5151#include <errno.h>
     52#include <unistd.h>
    5253
    5354#include <assert.h>
     
    8586#define FORMAT(x) ((struct libtrace_format_data_t*)(x))
    8687#define DATAOUT(x) ((struct libtrace_linuxnative_format_data_t*)((x)->format_data))
     88
     89static int linuxnative_probe_filename(const char *filename)
     90{
     91        int sock;
     92
     93        /* Is this an interface? */
     94        return (if_nametoindex(filename) != 0);
     95}
    8796
    8897static int linuxnative_init_input(libtrace_t *libtrace)
     
    614623        "$Id$",
    615624        TRACE_FORMAT_LINUX_NATIVE,
     625        linuxnative_probe_filename,     /* probe filename */
     626        NULL,                           /* probe magic */
    616627        linuxnative_init_input,         /* init_input */
    617628        linuxnative_config_input,       /* config_input */
  • lib/format_pcap.c

    rf0fb38f r91b72d3  
    657657        "$Id$",
    658658        TRACE_FORMAT_PCAP,
     659        NULL,                           /* probe filename */
     660        NULL,                           /* probe magic */
    659661        pcap_init_input,                /* init_input */
    660662        pcap_config_input,              /* config_input */
     
    697699        "$Id$",
    698700        TRACE_FORMAT_PCAP,
     701        NULL,                           /* probe filename */
     702        NULL,                           /* probe magic */
    699703        pcapint_init_input,             /* init_input */
    700704        pcapint_config_input,           /* config_input */
  • lib/format_pcapfile.c

    rc66068d r91b72d3  
    4242#include <errno.h>
    4343#include <fcntl.h>
     44#include <stdbool.h>
    4445
    4546#define DATA(x) ((struct pcapfile_format_data_t*)((x)->format_data))
     
    5859
    5960struct pcapfile_format_data_t {
    60         io_t *file;
    6161        struct {
    6262                int real_time;
    6363        } options;
     64        bool started;
    6465        pcapfile_header_t header;
    6566};
     
    7273};
    7374
     75static int pcapfile_probe_magic(io_t *io)
     76{
     77        pcapfile_header_t header;
     78        int len;
     79        len = wandio_peek(io, &header, sizeof(header));
     80        /* Is this long enough? */
     81        if (len < (int)sizeof(header)) {
     82                return 0;
     83        }
     84        /* Pcap magic? */
     85        if (header.magic_number == 0xa1b2c3d4 || header.magic_number == 0xd4c3b2a1) {
     86                return 1;
     87        }
     88        /* Nope, not pcap */
     89        return 0;
     90}
     91
    7492static int pcapfile_init_input(libtrace_t *libtrace) {
    7593        libtrace->format_data = malloc(sizeof(struct pcapfile_format_data_t));
     
    8098        }
    8199
    82         DATA(libtrace)->file=NULL;
    83100        IN_OPTIONS.real_time = 0;
     101        DATA(libtrace)->started = false;
    84102        return 0;
    85103}
     
    127145        int err;
    128146
    129         if (!DATA(libtrace)->file) {
    130                 DATA(libtrace)->file=trace_open_file(libtrace);
    131 
    132                 if (!DATA(libtrace)->file)
     147        if (!libtrace->io) {
     148                libtrace->io=trace_open_file(libtrace);
     149                DATA(libtrace)->started=false;
     150        }
     151
     152        if (!DATA(libtrace)->started) {
     153
     154                if (!libtrace->io)
    133155                        return -1;
    134156
    135                 err=wandio_read(DATA(libtrace)->file,
     157                err=wandio_read(libtrace->io,
    136158                                &DATA(libtrace)->header,
    137159                                sizeof(DATA(libtrace)->header));
     
    189211static int pcapfile_fin_input(libtrace_t *libtrace)
    190212{
    191         if (DATA(libtrace)->file)
    192                 wandio_destroy(DATA(libtrace)->file);
     213        if (libtrace->io)
     214                wandio_destroy(libtrace->io);
    193215        free(libtrace->format_data);
    194216        return 0; /* success */
     
    197219static int pcapfile_fin_output(libtrace_out_t *libtrace)
    198220{
    199         if (DATA(libtrace)->file)
     221        if (DATAOUT(libtrace)->file)
    200222                wandio_wdestroy(DATAOUT(libtrace)->file);
    201223        free(libtrace->format_data);
     
    269291        flags |= TRACE_PREP_OWN_BUFFER;
    270292       
    271         err=wandio_read(DATA(libtrace)->file,
     293        err=wandio_read(libtrace->io,
    272294                        packet->buffer,
    273295                        sizeof(libtrace_pcapfile_pkt_hdr_t));
     
    284306        }
    285307
    286         err=wandio_read(DATA(libtrace)->file,
     308        err=wandio_read(libtrace->io,
    287309                        (char*)packet->buffer+sizeof(libtrace_pcapfile_pkt_hdr_t),
    288310                        (size_t)swapl(libtrace,((libtrace_pcapfile_pkt_hdr_t*)packet->buffer)->caplen)
     
    322344        /* Silently discard RT metadata packets and packets with an
    323345         * unknown linktype. */
    324         if (linktype == TRACE_TYPE_METADATA || linktype == -1) {
     346        if (linktype == TRACE_TYPE_METADATA || linktype == ~0U) {
    325347                return 0;
    326348        }
     
    570592        "$Id$",
    571593        TRACE_FORMAT_PCAPFILE,
     594        NULL,                           /* probe filename */
     595        pcapfile_probe_magic,           /* probe magic */
    572596        pcapfile_init_input,            /* init_input */
    573597        pcapfile_config_input,          /* config_input */
  • lib/format_rt.c

    rc0dba7a r91b72d3  
    712712        "$Id$",
    713713        TRACE_FORMAT_RT,
     714        NULL,                           /* probe filename */
     715        NULL,                           /* probe magic */
    714716        rt_init_input,                  /* init_input */
    715717        NULL,                           /* config_input */
  • lib/format_tsh.c

    rc66068d r91b72d3  
    4242static struct libtrace_format_t tshformat;
    4343
    44 #define DATA(x) ((struct tsh_format_data_t *)x->format_data)
    45 
    46 struct tsh_format_data_t {
    47         io_t *file;
    48 };
    49 
    5044typedef struct tsh_pkt_header_t {
    5145        uint32_t seconds;
     
    6155static int tsh_init_input(libtrace_t *libtrace)
    6256{
    63         libtrace->format_data = malloc(sizeof(struct tsh_format_data_t));
     57        libtrace->format_data = NULL; /* No format data */
    6458       
    65         DATA(libtrace)->file = 0;
    66 
    6759        return 0; /* success */
    6860}
     
    7062static int tsh_start_input(libtrace_t *libtrace)
    7163{
    72         if (DATA(libtrace)->file)
     64        if (libtrace->io)
    7365                return 0; /* success */
    7466
    75         DATA(libtrace)->file = trace_open_file(libtrace);
    76 
    77         if (!DATA(libtrace)->file)
     67        libtrace->io = trace_open_file(libtrace);
     68
     69        if (!libtrace->io)
    7870                return -1;
    7971
     
    8274
    8375static int tsh_fin_input(libtrace_t *libtrace) {
    84         if (DATA(libtrace)->file)
    85                 wandio_destroy(DATA(libtrace)->file);
    86         free(libtrace->format_data);
     76        if (libtrace->io)
     77                wandio_destroy(libtrace->io);
    8778        return 0;
    8879}
     
    134125
    135126        /* Read the TSH header */
    136         if ((numbytes=wandio_read(DATA(libtrace)->file,
     127        if ((numbytes=wandio_read(libtrace->io,
    137128                                        buffer2,
    138129                                        (size_t)sizeof(tsh_pkt_header_t))) == -1) {
     
    149140
    150141        /* Read the IP header */
    151         if ((numbytes=wandio_read(DATA(libtrace)->file,
     142        if ((numbytes=wandio_read(libtrace->io,
    152143                                buffer2,
    153144                                (size_t)sizeof(libtrace_ip_t)))
     
    164155
    165156        /* Read the transport header */
    166         if ((numbytes=wandio_read(DATA(libtrace)->file,
     157        if ((numbytes=wandio_read(libtrace->io,
    167158                                buffer2,
    168159                                16)) != 16) {
     
    225216        "$Id$",
    226217        TRACE_FORMAT_TSH,
     218        NULL,                           /* probe filename */
     219        NULL,                           /* probe magic */
    227220        tsh_init_input,                 /* init_input */       
    228221        NULL,                           /* config_input */
     
    270263        "$Id$",
    271264        TRACE_FORMAT_TSH,
     265        NULL,                           /* probe filename */
     266        NULL,                           /* probe magic */
    272267        tsh_init_input,                 /* init_input */       
    273268        NULL,                           /* config_input */
  • lib/libtrace_int.h

    r590fb30 r91b72d3  
    4040#include "config.h"
    4141#include "libtrace.h"
     42#include "wandio.h"
    4243
    4344#ifdef _MSC_VER
     
    146147                                          */
    147148        char *uridata;                  /**< the uri of this trace */
     149        io_t *io;                       /**< The tracefile (if applicable) */
    148150
    149151        libtrace_err_t err;             /**< error information */
     
    255257        enum base_format_t type;
    256258        /** stuff that deals with input @{ */
     259        /** Given a filename, return if this format is responsible
     260         * (used for devices)
     261         */
     262        int (*probe_filename)(const char *fname);
     263        /** Given a file, look for file magic. */
     264        int (*probe_magic)(io_t *io);
    257265        /** initialise an trace (or NULL if input is not supported) */
    258266        int (*init_input)(libtrace_t *libtrace);
  • lib/trace.c

    rb4a17c7 r91b72d3  
    260260#define URI_PROTO_LINE 16U
    261261
     262/* Try to guess which format module */
     263static void guess_format(libtrace_t *libtrace, const char *filename)
     264{
     265        struct libtrace_format_t *tmp;
     266       
     267        /* Try and guess based on filename */
     268        for(tmp = formats_list; tmp; tmp=tmp->next) {
     269                if (tmp->probe_filename && tmp->probe_filename(filename)) {
     270                        libtrace->format = tmp;
     271                        libtrace->uridata = malloc(strlen(tmp->name)+1+strlen(filename)+1);
     272                        strcpy(libtrace->uridata,tmp->name);
     273                        strcat(libtrace->uridata,":");
     274                        strcat(libtrace->uridata,filename);
     275                        return;
     276                }
     277        }
     278
     279        libtrace->io = wandio_create(filename);
     280        if (!libtrace->io)
     281                return;
     282
     283        /* Try and guess based on file magic */
     284        for(tmp = formats_list; tmp; tmp=tmp->next) {
     285                if (tmp->probe_magic && tmp->probe_magic(libtrace->io)) {
     286                        libtrace->format = tmp;
     287                        libtrace->uridata = malloc(strlen(tmp->name)+1+strlen(filename)+1);
     288                        strcpy(libtrace->uridata,tmp->name);
     289                        strcat(libtrace->uridata,":");
     290                        strcat(libtrace->uridata,filename);
     291                        return;
     292                }
     293        }
     294       
     295        /* Oh well */
     296        return;
     297}
    262298
    263299/* Create a trace file from a URI
     
    286322        char *scan = 0;
    287323        const char *uridata = 0;                 
    288         struct libtrace_format_t *tmp;
    289324
    290325        trace_init();
     
    308343        libtrace->started=false;
    309344        libtrace->uridata = NULL;
     345        libtrace->io = NULL;
    310346        libtrace->filtered_packets = 0;
    311347
    312348        /* parse the URI to determine what sort of event we are dealing with */
    313349        if ((uridata = trace_parse_uri(uri, &scan)) == 0) {
    314                 trace_set_err(libtrace,TRACE_ERR_BAD_FORMAT,"Bad uri format (%s)",uri);
    315                 return libtrace;
    316         }
    317        
    318         for (tmp=formats_list;tmp;tmp=tmp->next) {
    319                 if (strlen(scan) == strlen(tmp->name) &&
    320                                 strncasecmp(scan, tmp->name, strlen(scan)) == 0
    321                                 ) {
    322                         libtrace->format=tmp;
    323                         break;
    324                 }
    325         }
    326         if (libtrace->format == 0) {
    327                 trace_set_err(libtrace, TRACE_ERR_BAD_FORMAT,
    328                                 "Unknown format (%s)",scan);
    329                 return libtrace;
    330         }
    331 
    332         libtrace->uridata = strdup(uridata);
     350                guess_format(libtrace,uri);
     351                if (!libtrace->format) {
     352                        trace_set_err(libtrace,TRACE_ERR_BAD_FORMAT,"Unable to guess format (%s)",uri);
     353                        return libtrace;
     354                }
     355        }
     356        else {
     357                struct libtrace_format_t *tmp;
     358
     359                for (tmp=formats_list;tmp;tmp=tmp->next) {
     360                        if (strlen(scan) == strlen(tmp->name) &&
     361                                        strncasecmp(scan, tmp->name, strlen(scan)) == 0
     362                                        ) {
     363                                libtrace->format=tmp;
     364                                break;
     365                        }
     366                }
     367                if (libtrace->format == 0) {
     368                        trace_set_err(libtrace, TRACE_ERR_BAD_FORMAT,
     369                                        "Unknown format (%s)",scan);
     370                        return libtrace;
     371                }
     372
     373                libtrace->uridata = strdup(uridata);
     374        }
    333375        /* libtrace->format now contains the type of uri
    334376         * libtrace->uridata contains the appropriate data for this
     
    381423        }
    382424       
    383         libtrace->format = 0;   
     425        libtrace->err.err_num = TRACE_ERR_NOERROR;
     426        libtrace->format=NULL;
     427       
     428        libtrace->event.tdelta = 0.0;
     429        libtrace->event.packet = NULL;
     430        libtrace->event.psize = 0;
     431        libtrace->event.trace_last_ts = 0.0;
     432        libtrace->filter = NULL;
     433        libtrace->snaplen = 0;
     434        libtrace->started=false;
     435        libtrace->uridata = NULL;
     436        libtrace->io = NULL;
     437        libtrace->filtered_packets = 0;
    384438       
    385439        for(tmp=formats_list;tmp;tmp=tmp->next) {
  • lib/wandio.c

    rcf30639 r91b72d3  
    3838        }
    3939#endif
    40         return thread_open(io);
     40        return peek_open(thread_open(io));
    4141}
    4242
Note: See TracChangeset for help on using the changeset viewer.