Changeset 646aca1 for lib


Ignore:
Timestamp:
07/20/07 15:26:04 (14 years ago)
Author:
Shane Alcock <salcock@…>
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:
708f9ae
Parents:
a43a2bd
Message:
  • Added a new config option for input traces which will specify whether the event framework should retain the time gaps between packets or not.
  • Updated erf and pcapfile to support the new option, other formats can be updated as required.
  • Renamed the TRACE_META_FREQ option to match the option naming scheme
Location:
lib
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • lib/format_dag24.c

    r293999b r646aca1  
    137137                                void *data) {
    138138        switch(option) {
    139                 case TRACE_META_FREQ:
     139                case TRACE_OPTION_META_FREQ:
    140140                        DUCK.duck_freq = *(int *)data;
    141141                        return 0;
  • lib/format_dag25.c

    r293999b r646aca1  
    112112                                void *data) {
    113113        switch(option) {
    114                 case TRACE_META_FREQ:
     114                case TRACE_OPTION_META_FREQ:
    115115                        DUCK.duck_freq = *(int *)data;
    116116                        return 0;
  • lib/format_erf.c

    r721c0e4 r646aca1  
    6565
    6666#define INPUT DATA(libtrace)->input
     67#define IN_OPTIONS DATA(libtrace)->options
    6768#define OUTPUT DATAOUT(libtrace)->output
    68 #define OPTIONS DATAOUT(libtrace)->options
     69#define OUT_OPTIONS DATAOUT(libtrace)->options
    6970struct erf_format_data_t {
    7071       
     
    7475        } input;
    7576
     77       
    7678        struct {
    7779                enum { INDEX_UNKNOWN=0, INDEX_NONE, INDEX_EXISTS } exists;
     
    8082        } seek;
    8183
     84        struct {
     85                int real_time;
     86        } options;
    8287};
    8388
     
    142147       
    143148        INPUT.file = 0;
    144 
     149        IN_OPTIONS.real_time = 0;
     150       
    145151        return 0; /* success */
     152}
     153
     154static int erf_config_input(libtrace_t *libtrace, trace_option_t option,
     155                void *value) {
     156
     157        switch (option) {
     158                case TRACE_OPTION_EVENT_REALTIME:
     159                        IN_OPTIONS.real_time = *(int *)value;
     160                        return 0;
     161                default:
     162                        /* Unknown option */
     163                        trace_set_err(libtrace,TRACE_ERR_UNKNOWN_OPTION,
     164                                        "Unknown option");
     165                        return -1;
     166        }
    146167}
    147168
     
    267288        libtrace->format_data = malloc(sizeof(struct erf_format_data_out_t));
    268289
    269         OPTIONS.erf.level = 0;
    270         OPTIONS.erf.fileflag = O_CREAT | O_WRONLY;
     290        OUT_OPTIONS.erf.level = 0;
     291        OUT_OPTIONS.erf.fileflag = O_CREAT | O_WRONLY;
    271292        OUTPUT.file = 0;
    272293
     
    279300        switch (option) {
    280301                case TRACE_OPTION_OUTPUT_COMPRESS:
    281                         OPTIONS.erf.level = *(int*)value;
     302                        OUT_OPTIONS.erf.level = *(int*)value;
    282303                        return 0;
    283304                case TRACE_OPTION_OUTPUT_FILEFLAGS:
    284                         OPTIONS.erf.fileflag = *(int*)value;
     305                        OUT_OPTIONS.erf.fileflag = *(int*)value;
    285306                        return 0;
    286307                default:
     
    405426{
    406427        OUTPUT.file = trace_open_file_out(libtrace,
    407                         OPTIONS.erf.level,
    408                         OPTIONS.erf.fileflag);
     428                        OUT_OPTIONS.erf.level,
     429                        OUT_OPTIONS.erf.fileflag);
    409430        if (!OUTPUT.file) {
    410431                return -1;
     
    578599        erfptr->rlen = htons(size + erf_get_framing_length(packet));
    579600        return trace_get_capture_length(packet);
     601}
     602
     603static struct libtrace_eventobj_t erf_event(struct libtrace_t *libtrace, struct libtrace_packet_t *packet) {
     604        struct libtrace_eventobj_t event = {0,0,0.0,0};
     605       
     606        if (IN_OPTIONS.real_time) {
     607                event.size = erf_read_packet(libtrace, packet);
     608                if (event.size < 1)
     609                        event.type = TRACE_EVENT_TERMINATE;
     610                else
     611                        event.type = TRACE_EVENT_PACKET;
     612                return event;
     613               
     614        } else {
     615                return trace_event_trace(libtrace, packet);
     616        }
     617       
    580618}
    581619
     
    609647        TRACE_FORMAT_ERF,
    610648        erf_init_input,                 /* init_input */       
    611         NULL,                           /* config_input */
     649        erf_config_input,               /* config_input */
    612650        erf_start_input,                /* start_input */
    613651        NULL,                           /* pause_input */
     
    634672        erf_set_capture_length,         /* set_capture_length */
    635673        NULL,                           /* get_fd */
    636         trace_event_trace,              /* trace_event */
     674        erf_event,                      /* trace_event */
    637675        erf_help,                       /* help */
    638676        NULL                            /* next pointer */
  • lib/format_linux.c

    r293999b r646aca1  
    212212                         */
    213213                        break;
    214                 case TRACE_META_FREQ:
     214                case TRACE_OPTION_META_FREQ:
    215215                        /* No meta-data for this format */
     216                        break;
     217                case TRACE_OPTION_EVENT_REALTIME:
    216218                        break;
    217219                /* Avoid default: so that future options will cause a warning
  • lib/format_pcap.c

    r73dd29f r646aca1  
    130130                case TRACE_OPTION_PROMISC:
    131131                        /* can't do promisc on a trace! fall thru */
    132                 case TRACE_META_FREQ:
     132                case TRACE_OPTION_META_FREQ:
    133133                        /* No meta data for this format */
    134134                default:
     
    189189                        DATA(libtrace)->promisc=*(int*)data;
    190190                        return 0;
    191                 case TRACE_META_FREQ:
     191                case TRACE_OPTION_META_FREQ:
    192192                        /* No meta-data for this format */
    193193                default:
  • lib/format_pcapfile.c

    rce0bf2c r646aca1  
    4545#define DATA(x) ((struct pcapfile_format_data_t*)((x)->format_data))
    4646#define DATAOUT(x) ((struct pcapfile_format_data_out_t*)((x)->format_data))
     47#define IN_OPTIONS DATA(libtrace)->options
    4748
    4849typedef struct pcapfile_header_t {
     
    5859struct pcapfile_format_data_t {
    5960        libtrace_io_t *file;
     61        struct {
     62                int real_time;
     63        } options;
    6064        pcapfile_header_t header;
    6165};
     
    7781
    7882        DATA(libtrace)->file=NULL;
    79 
     83        IN_OPTIONS.real_time = 0;
    8084        return 0;
    8185}
     
    163167static int pcapfile_config_input(libtrace_t *libtrace,
    164168                trace_option_t option,
    165                 void *data UNUSED)
    166 {
     169                void *data)
     170{
     171        switch(option) {
     172                case TRACE_OPTION_EVENT_REALTIME:
     173                        IN_OPTIONS.real_time = *(int *)data;
     174                        return 0;
     175                case TRACE_OPTION_META_FREQ:
     176                case TRACE_OPTION_SNAPLEN:
     177                case TRACE_OPTION_PROMISC:
     178                case TRACE_OPTION_FILTER:
     179                        /* all these are either unsupported or handled
     180                         * by trace_config */
     181                        break;
     182        }
     183       
    167184        trace_set_err(libtrace,TRACE_ERR_UNKNOWN_OPTION,
    168185                        "Unknown option %i", option);
     
    460477        pcapptr->caplen = swapl(packet->trace,(uint32_t)size);
    461478        return trace_get_capture_length(packet);
     479}
     480
     481static struct libtrace_eventobj_t pcapfile_event(libtrace_t *libtrace, libtrace_packet_t *packet) {
     482       
     483        libtrace_eventobj_t event = {0,0,0.0,0};
     484       
     485        if (IN_OPTIONS.real_time) {
     486                event.size = pcapfile_read_packet(libtrace, packet);
     487                if (event.size < 1)
     488                        event.type = TRACE_EVENT_TERMINATE;
     489                else
     490                        event.type = TRACE_EVENT_PACKET;
     491                return event;
     492        } else {
     493                return trace_event_trace(libtrace, packet);
     494        }
    462495}
    463496
  • lib/libtrace.h.in

    ra43a2bd r646aca1  
    745745/** Valid trace capture options */
    746746typedef enum {
    747         TRACE_OPTION_SNAPLEN, /**< Number of bytes captured */
    748         TRACE_OPTION_PROMISC, /**< Capture packets to other hosts */
    749         TRACE_OPTION_FILTER,  /**< Apply this filter to all packets recieved */
    750         TRACE_META_FREQ       /**< Frequency of meta-data information, e.g. DUCK packets */
     747        TRACE_OPTION_SNAPLEN,   /**< Number of bytes captured */
     748        TRACE_OPTION_PROMISC,   /**< Capture packets to other hosts */
     749        TRACE_OPTION_FILTER,    /**< Apply this filter to all packets */
     750        TRACE_OPTION_META_FREQ, /**< Frequency of meta-data information, e.g. DUCK packets */
     751        /** trace_event ignores gaps between packets when reading traces off disk */
     752        TRACE_OPTION_EVENT_REALTIME
    751753} trace_option_t;
    752754
  • lib/trace.c

    re1fdc05 r646aca1  
    561561                        }
    562562                        return -1;
    563                 case TRACE_META_FREQ:
     563                case TRACE_OPTION_META_FREQ:
    564564                        if (!trace_is_err(libtrace)) {
    565565                                trace_set_err(libtrace,
     
    568568                        }
    569569                        return -1;
     570                case TRACE_OPTION_EVENT_REALTIME:
     571                        if (!trace_is_err(libtrace)) {
     572                                trace_set_err(libtrace,
     573                                                TRACE_ERR_OPTION_UNAVAIL,
     574                                                "This format does not support meta-data gathering");
     575                        }
     576                        return -1;
     577                       
    570578        }
    571579        if (!trace_is_err(libtrace)) {
Note: See TracChangeset for help on using the changeset viewer.