Changeset df338b3 for lib/format_pcap.c


Ignore:
Timestamp:
02/20/06 13:52:09 (16 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:
8ee7caa
Parents:
548a9c2
Message:

Major restructuring of format_pcap

File:
1 edited

Legend:

Unmodified
Added
Removed
  • lib/format_pcap.c

    r3d4d52d rdf338b3  
    6969static struct libtrace_format_t pcapint;
    7070
    71 
    72 #define CONNINFO libtrace->format_data->conn_info
     71#define DATA(x) ((struct libtrace_format_data_t*)((x)->format_data))
     72
    7373#define INPUT libtrace->format_data->input
    7474#define OUTPUT libtrace->format_data->output
     
    8383                pcap_t *pcap;
    8484        } input;
     85        int snaplen;
     86        libtrace_filter_t *filter;
     87        int promisc;
    8588};
    8689
     
    100103
    101104static int pcap_init_input(struct libtrace_t *libtrace) {
    102         char errbuf[PCAP_ERRBUF_SIZE];
    103         struct stat buf;
    104105        libtrace->format_data = (struct libtrace_format_data_t *)
    105106                malloc(sizeof(struct libtrace_format_data_t));
    106         CONNINFO.path = libtrace->uridata;
    107 
    108         if (!strncmp(CONNINFO.path,"-",1)) {
    109                 if ((INPUT.pcap =
    110                         pcap_open_offline(CONNINFO.path,
    111                                                 errbuf)) == NULL) {
    112                         trace_set_err(TRACE_ERR_INIT_FAILED,"%s",errbuf);
     107
     108        INPUT.pcap = NULL;
     109        DATA(libtrace)->filter = NULL;
     110        DATA(libtrace)->snaplen = 0;
     111        DATA(libtrace)->promisc = 0;
     112
     113        return 1;
     114}
     115
     116static int pcap_start_input(struct libtrace_t *libtrace) {
     117        char errbuf[PCAP_ERRBUF_SIZE];
     118        if ((INPUT.pcap =
     119                pcap_open_offline(libtrace->uridata,
     120                        errbuf)) == NULL) {
     121                trace_set_err(TRACE_ERR_INIT_FAILED,"%s",
     122                                errbuf);
     123                return -1;
     124        }
     125        if (DATA(libtrace)->filter) {
     126                trace_bpf_compile(DATA(libtrace)->filter);
     127                if (pcap_setfilter(INPUT.pcap,&DATA(libtrace)->filter->filter)
     128                                == -1) {
     129                        trace_set_err(TRACE_ERR_INIT_FAILED,"%s",
     130                                        pcap_geterr(INPUT.pcap));
     131                        return -1;
     132                }
     133        }
     134        return 0;
     135}
     136
     137static int pcap_config_input(libtrace_t *libtrace,
     138                trace_option_t option,
     139                void *data)
     140{
     141        switch(option) {
     142                case TRACE_OPTION_FILTER:
     143                        DATA(libtrace)->filter=data;
    113144                        return 0;
    114                 }               
    115         } else {
    116                 if (stat(CONNINFO.path,&buf) == -1) {
    117                         trace_set_err(errno,"stat(%s)",CONNINFO.path);
    118                         return 0;
    119                 }
    120                 if (S_ISCHR(buf.st_mode)) {
    121                         if ((INPUT.pcap =
    122                                 pcap_open_live(CONNINFO.path,
    123                                         4096,
    124                                         1,
    125                                         1,
    126                                         errbuf)) == NULL) {
    127                                 trace_set_err(TRACE_ERR_INIT_FAILED,"%s",
    128                                                 errbuf);
    129                                 return 0;
    130                         }
    131                 } else {
    132                         if ((INPUT.pcap =
    133                                 pcap_open_offline(CONNINFO.path,
    134                                         errbuf)) == NULL) {
    135                                 trace_set_err(TRACE_ERR_INIT_FAILED,"%s",
    136                                                 errbuf);
    137                                 return 0;
    138                         }
    139                 }       
    140         }
    141         return 1;
    142        
     145                case TRACE_OPTION_SNAPLEN:
     146                        /* Snapping isn't supported directly, so fall thru
     147                         * and let libtrace deal with it
     148                         */
     149                case TRACE_OPTION_PROMISC:
     150                        /* can't do promisc on a trace! fall thru */
     151                default:
     152                        trace_set_err(TRACE_ERR_UNKNOWN_OPTION,
     153                                        "Unknown option %i", option);
     154                        return -1;
     155        }
     156        assert(0);
     157}
     158
     159static int pcap_pause_input(libtrace_t *libtrace) {
     160        pcap_close(INPUT.pcap);
     161        INPUT.pcap=NULL;
    143162}
    144163
     
    146165        libtrace->format_data = (struct libtrace_format_data_out_t *)
    147166                malloc(sizeof(struct libtrace_format_data_out_t));
    148         CONNINFO.path = libtrace->uridata;
    149167        OUTPUT.trace.pcap = NULL;
    150168        OUTPUT.trace.dump = NULL;
     
    153171
    154172static int pcapint_init_input(struct libtrace_t *libtrace) {
    155         char errbuf[PCAP_ERRBUF_SIZE];
    156173        libtrace->format_data = (struct libtrace_format_data_t *)
    157174                malloc(sizeof(struct libtrace_format_data_t));
    158         CONNINFO.path = libtrace->uridata;
     175        DATA(libtrace)->filter = NULL;
     176        DATA(libtrace)->snaplen = 0;
     177        DATA(libtrace)->promisc = 0;
     178        return 1;
     179}
     180
     181static int pcapint_config_input(libtrace_t *libtrace,
     182                trace_option_t option,
     183                void *data)
     184{
     185        switch(option) {
     186                case TRACE_OPTION_FILTER:
     187                        DATA(libtrace)->filter=data;
     188                        return 0;
     189                case TRACE_OPTION_SNAPLEN:
     190                        DATA(libtrace)->snaplen=*(int*)data;
     191                        return 0;
     192                case TRACE_OPTION_PROMISC:
     193                        DATA(libtrace)->promisc=*(int*)data;
     194                        return 0;
     195                default:
     196                        trace_set_err(TRACE_ERR_UNKNOWN_OPTION,
     197                                        "Unknown option %i", option);
     198                        return -1;
     199        }
     200        assert(0);
     201}
     202
     203static int pcapint_start_input(libtrace_t *libtrace) {
     204        char errbuf[PCAP_ERRBUF_SIZE];
    159205        if ((INPUT.pcap =
    160                         pcap_open_live(CONNINFO.path,
    161                         4096,
    162                         1,
     206                        pcap_open_live(libtrace->uridata,
     207                        DATA(libtrace)->snaplen,
     208                        DATA(libtrace)->promisc,
    163209                        1,
    164210                        errbuf)) == NULL) {
    165211                trace_set_err(TRACE_ERR_INIT_FAILED,"%s",errbuf);
     212                /* Set a filter if one is defined */
     213                if (DATA(libtrace)->filter)
     214                        if (pcap_setfilter(INPUT.pcap,&DATA(libtrace)->filter->filter)
     215                                == -1) {
     216                                trace_set_err(TRACE_ERR_INIT_FAILED,"%s",
     217                                                pcap_geterr(INPUT.pcap));
     218                                return -1;
     219                        }
    166220                return 0;
    167221        }
     
    228282                        libtrace_to_pcap_dlt(trace_get_link_type(packet)),
    229283                        65536);
    230                 OUTPUT.trace.dump = pcap_dump_open(OUTPUT.trace.pcap,CONNINFO.path);
     284                OUTPUT.trace.dump = pcap_dump_open(OUTPUT.trace.pcap,
     285                                libtrace->uridata);
    231286                fflush((FILE *)OUTPUT.trace.dump);
    232287        }
     
    394449        pcap_init_input,                /* init_input */
    395450        NULL,                           /* config_input */
    396         NULL,                           /* start_input */
    397         NULL,                           /* pause_input */
     451        pcap_start_input,               /* start_input */
     452        pcap_pause_input,               /* pause_input */
    398453        pcap_init_output,               /* init_output */
    399454        NULL,                           /* config_output */
     
    426481        "pcap",
    427482        pcapint_init_input,             /* init_input */
    428         NULL,                           /* config_input */
    429         NULL,                           /* start_input */
    430         NULL,                           /* pause_input */
     483        pcapint_config_input,           /* config_input */
     484        pcapint_start_input,            /* start_input */
     485        pcap_pause_input,               /* pause_input */
    431486        pcapint_init_output,            /* init_output */
    432487        NULL,                           /* config_output */
Note: See TracChangeset for help on using the changeset viewer.