Changeset 1246


Ignore:
Timestamp:
07/20/07 15:26:04 (6 years ago)
Author:
spa1
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:
trunk/lib
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • trunk/lib/format_dag24.c

    r1195 r1246  
    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; 

  • trunk/lib/format_dag25.c

    r1195 r1246  
    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; 

  • trunk/lib/format_erf.c

    r1244 r1246  
    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 */ 

  • trunk/lib/format_linux.c

    r1195 r1246  
    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 

  • trunk/lib/format_pcap.c

    r1179 r1246  
    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: 

  • trunk/lib/format_pcapfile.c

    r1208 r1246  
    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 

  • trunk/lib/libtrace.h.in

    r1245 r1246  
    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 

  • trunk/lib/trace.c

    r1242 r1246  
    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.