Changeset ab4cb04


Ignore:
Timestamp:
02/27/06 14:31: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:
d5879cc
Parents:
afd0b73
Message:

Cleanup struct libtrace_Format_data_t

Location:
lib
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • lib/format_erf.c

    rafd0b73 rab4cb04  
    7272#endif
    7373
    74 #define CONNINFO libtrace->format_data->conn_info
    75 #define INPUT libtrace->format_data->input
    76 #define OUTPUT libtrace->format_data->output
     74#define DATA(x) ((struct libtrace_format_data_t *)x->format_data)
     75#define DATAOUT(x) ((struct libtrace_format_data_out_t *)x->format_data)
     76#define CONNINFO DATA(libtrace)->conn_info
     77#define INPUT DATA(libtrace)->input
     78#define OUTPUT DATAOUT(libtrace)->output
    7779#if HAVE_DAG
    78 #define DAG libtrace->format_data->dag
    79 #endif
    80 #define OPTIONS libtrace->format_data->options
     80#define DAG DATA(libtrace)->dag
     81#endif
     82#define OPTIONS DATAOUT(libtrace)->options
    8183struct libtrace_format_data_t {
    8284        union {
     
    206208static int erf_start_input(struct libtrace_t *libtrace)
    207209{
    208         libtrace->format_data->input.file = trace_open_file(libtrace);
    209 
    210         if (libtrace->format_data->input.file)
    211                 return 1;
     210        INPUT.file = trace_open_file(libtrace);
     211
     212        if (!INPUT.file)
     213                return -1;
    212214
    213215        return 0;
     
    216218static int rtclient_init_input(struct libtrace_t *libtrace) {
    217219        char *scan;
    218         char *uridata = libtrace->uridata;
    219         struct hostent *he;
    220         struct sockaddr_in remote;
    221220        libtrace->format_data = (struct libtrace_format_data_t *)
    222221                malloc(sizeof(struct libtrace_format_data_t));
    223222
    224223
    225         if (strlen(uridata) == 0) {
     224        if (strlen(libtrace->uridata) == 0) {
    226225                CONNINFO.rt.hostname =
    227226                        strdup("localhost");
     
    229228                        COLLECTOR_PORT;
    230229        } else {
    231                 if ((scan = strchr(uridata,':')) == NULL) {
     230                if ((scan = strchr(libtrace->uridata,':')) == NULL) {
    232231                        CONNINFO.rt.hostname =
    233                                 strdup(uridata);
     232                                strdup(libtrace->uridata);
    234233                        CONNINFO.rt.port =
    235234                                COLLECTOR_PORT;
    236235                } else {
    237236                        CONNINFO.rt.hostname =
    238                                 (char *)strndup(uridata,
    239                                                 (scan - uridata));
     237                                (char *)strndup(libtrace->uridata,
     238                                                (scan - libtrace->uridata));
    240239                        CONNINFO.rt.port =
    241240                                atoi(++scan);
     
    243242        }
    244243       
     244}
     245
     246static int rtclient_start_input(libtrace_t *libtrace)
     247{
     248        struct hostent *he;
     249        struct sockaddr_in remote;
    245250        if ((he=gethostbyname(CONNINFO.rt.hostname)) == NULL) { 
    246251                trace_set_err(libtrace,errno,"failed to resolve %s",
    247252                                CONNINFO.rt.hostname);
    248                 return 0;
     253                return -1;
    249254        }
    250255        if ((INPUT.fd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
    251256                trace_set_err(libtrace,errno,"socket(AF_INET,SOCK_STREAM)");
    252                 return 0;
     257                return -1;
    253258        }
    254259
     
    264269                return 0;
    265270        }
    266         return 1;
     271        return -1;
    267272}
    268273
     
    683688}
    684689
    685 static int rtclient_get_fd(const libtrace_t *trace) {
    686         return trace->format_data->input.fd;
    687 }
    688 
    689 static int erf_get_fd(const libtrace_t *trace) {
    690         return trace->format_data->input.fd;
     690static int rtclient_get_fd(const libtrace_t *libtrace) {
     691        return INPUT.fd;
     692}
     693
     694static int erf_get_fd(const libtrace_t *libtrace) {
     695        return INPUT.fd;
    691696}
    692697
     
    841846        rtclient_init_input,            /* init_input */       
    842847        NULL,                           /* config_input */
    843         NULL,                           /* start_input */
     848        rtclient_start_input,           /* start_input */
    844849        NULL,                           /* pause_input */
    845850        NULL,                           /* init_output */
  • lib/format_legacy.c

    rafd0b73 rab4cb04  
    7575static struct libtrace_format_t legacyatm;
    7676
    77 #define INPUT libtrace->format_data->input
    78 #define OUTPUT libtrace->format_data->output
     77#define DATA(x) ((struct legacy_format_data_t *)x->format_data)
     78
     79#define INPUT DATA(libtrace)->input
    7980#if HAVE_DAG
    80 #define DAG libtrace->format_data->dag
     81#define DAG DATA(libtrace)->dag
    8182#endif
    82 #define OPTIONS libtrace->format_data->options
    83 struct libtrace_format_data_t {
    84         union {
    85                 struct {
    86                         char *hostname;
    87                         short port;
    88                 } rt;
    89                 char *path;             
    90         } conn_info;
     83
     84struct legacy_format_data_t {
    9185        union {
    9286                int fd;
     
    10094};
    10195
    102 struct libtrace_format_data_out_t {
    103         union {
    104                 struct {
    105                         char *hostname;
    106                         short port;
    107                 } rt;
    108                 char *path;
    109         } conn_info;
    110 };
    111 
    112 
    11396static int legacyeth_get_framing_length(const struct libtrace_packet_t *packet UNUSED)
    11497{
     
    128111static int erf_init_input(struct libtrace_t *libtrace)
    129112{
    130         libtrace->format_data = (struct libtrace_format_data_t *)
    131                 malloc(sizeof(struct libtrace_format_data_t));
    132 
    133         libtrace->format_data->input.file = trace_open_file(libtrace);
    134 
    135         if (libtrace->format_data->input.file)
    136                 return 1;
     113        libtrace->format_data = malloc(sizeof(struct legacy_format_data_t));
    137114
    138115        return 0;
    139 
     116}
     117
     118static int erf_start_input(libtrace_t *libtrace)
     119{
     120        DATA(libtrace)->input.file = trace_open_file(libtrace);
     121
     122        if (DATA(libtrace)->input.file)
     123                return 0;
     124
     125        return -1;
    140126}
    141127
     
    258244        erf_init_input,                 /* init_input */       
    259245        NULL,                           /* config_input */
    260         NULL,                           /* start_input */
     246        erf_start_input,                /* start_input */
    261247        NULL,                           /* pause_input */
    262248        NULL,                           /* init_output */
     
    291277        erf_init_input,                 /* init_input */       
    292278        NULL,                           /* config_input */
    293         NULL,                           /* start_input */
     279        erf_start_input,                /* start_input */
    294280        NULL,                           /* pause_input */
    295281        NULL,                           /* init_output */
     
    324310        erf_init_input,                 /* init_input */       
    325311        NULL,                           /* config_input */
    326         NULL,                           /* start_input */
     312        erf_start_input,                /* start_input */
    327313        NULL,                           /* pause_input */
    328314        NULL,                           /* init_output */
  • lib/format_pcap.c

    rafd0b73 rab4cb04  
    6969static struct libtrace_format_t pcapint;
    7070
    71 #define DATA(x) ((struct libtrace_format_data_t*)((x)->format_data))
    72 
    73 #define INPUT libtrace->format_data->input
    74 #define OUTPUT libtrace->format_data->output
    75 struct libtrace_format_data_t {
     71#define DATA(x) ((struct pcap_format_data_t*)((x)->format_data))
     72#define DATAOUT(x) ((struct pcap_format_data_out_t*)((x)->format_data))
     73
     74#define INPUT DATA(libtrace)->input
     75#define OUTPUT DATAOUT(libtrace)->output
     76struct pcap_format_data_t {
    7677        union {
    7778                char *path;             /**< information for local sockets */
     
    8889};
    8990
    90 struct libtrace_format_data_out_t {
     91struct pcap_format_data_out_t {
    9192        union {
    9293                char *path;
     
    103104
    104105static int pcap_init_input(struct libtrace_t *libtrace) {
    105         libtrace->format_data = (struct libtrace_format_data_t *)
    106                 malloc(sizeof(struct libtrace_format_data_t));
     106        libtrace->format_data = malloc(sizeof(struct pcap_format_data_t));
    107107
    108108        INPUT.pcap = NULL;
     
    163163
    164164static int pcap_init_output(struct libtrace_out_t *libtrace) {
    165         libtrace->format_data = (struct libtrace_format_data_out_t *)
    166                 malloc(sizeof(struct libtrace_format_data_out_t));
     165        libtrace->format_data = malloc(sizeof(struct pcap_format_data_out_t));
    167166        OUTPUT.trace.pcap = NULL;
    168167        OUTPUT.trace.dump = NULL;
     
    171170
    172171static int pcapint_init_input(struct libtrace_t *libtrace) {
    173         libtrace->format_data = (struct libtrace_format_data_t *)
    174                 malloc(sizeof(struct libtrace_format_data_t));
     172        libtrace->format_data = malloc(sizeof(struct pcap_format_data_t));
    175173        DATA(libtrace)->filter = NULL;
    176174        DATA(libtrace)->snaplen = LIBTRACE_PACKET_BUFSIZE;
     
    225223}
    226224
    227 static int pcapint_init_output(struct libtrace_out_t *libtrace) {
    228         trace_set_err_out(libtrace,TRACE_ERR_NO_INIT_OUT,
    229                         "Writing to a pcap interface not implemented yet");
    230         return -1;
    231 }
    232 
    233225static int pcap_fin_input(struct libtrace_t *libtrace) {
    234         pcap_close(INPUT.pcap);
     226        /* we don't need to close the pcap object since libtrace will have
     227         * paused the trace for us.
     228         */
    235229        free(libtrace->format_data);
    236230        return 0;
    237231}
    238232
    239 static int pcap_fin_output(struct libtrace_out_t *libtrace) {
     233static int pcap_fin_output(libtrace_out_t *libtrace) {
    240234        pcap_dump_flush(OUTPUT.trace.dump);
    241235        pcap_dump_close(OUTPUT.trace.dump);
     
    243237        free(libtrace->format_data);
    244238        return 0;
    245 }
    246 
    247 static int pcapint_fin_output(struct libtrace_out_t *libtrace __attribute__((unused))) {
    248         return -1;
    249239}
    250240
     
    288278}
    289279
    290 static int pcap_write_packet(struct libtrace_out_t *libtrace, const struct libtrace_packet_t *packet) {
     280static int pcap_start_output(libtrace_out_t *libtrace)
     281{
     282        assert(!OUTPUT.trace.dump);
     283        OUTPUT.trace.dump = pcap_dump_open(OUTPUT.trace.pcap,
     284                        libtrace->uridata);
     285        fflush((FILE *)OUTPUT.trace.dump);
     286}
     287
     288static int pcap_write_packet(libtrace_out_t *libtrace, const libtrace_packet_t *packet) {
    291289        struct pcap_pkthdr pcap_pkt_hdr;
    292290
     
    295293                        libtrace_to_pcap_dlt(trace_get_link_type(packet)),
    296294                        65536);
    297                 OUTPUT.trace.dump = pcap_dump_open(OUTPUT.trace.pcap,
    298                                 libtrace->uridata);
    299                 fflush((FILE *)OUTPUT.trace.dump);
    300295        }
    301296        if (libtrace->format == &pcap ||
     
    318313}
    319314
    320 static int pcapint_write_packet(struct libtrace_out_t *libtrace __attribute__((unused)), const struct libtrace_packet_t *packet __attribute__((unused))) {
    321 
    322         assert(0);
    323         return 0;
    324 }
    325 
    326315static libtrace_linktype_t pcap_get_link_type(const struct libtrace_packet_t *packet) {
    327316        struct pcap_pkthdr *pcapptr = 0;
    328317        int linktype = 0;
    329318        pcapptr = (struct pcap_pkthdr *)packet->header;
    330         linktype = pcap_datalink(packet->trace->format_data->input.pcap);
     319        linktype = pcap_datalink(DATA(packet->trace)->input.pcap);
    331320        return pcap_dlt_to_libtrace(linktype);
    332321}
     
    430419
    431420static int pcap_get_fd(const libtrace_t *trace) {
    432         return pcap_fileno(trace->format_data->input.pcap);
     421        return pcap_fileno(DATA(trace)->input.pcap);
    433422}
    434423
     
    463452        TRACE_FORMAT_PCAP,
    464453        pcap_init_input,                /* init_input */
    465         NULL,                           /* config_input */
     454        pcap_config_input,              /* config_input */
    466455        pcap_start_input,               /* start_input */
    467456        pcap_pause_input,               /* pause_input */
    468457        pcap_init_output,               /* init_output */
    469458        NULL,                           /* config_output */
    470         NULL,                           /* start_output */
     459        pcap_start_output,              /* start_output */
    471460        pcap_fin_input,                 /* fin_input */
    472461        pcap_fin_output,                /* fin_output */
     
    499488        pcapint_start_input,            /* start_input */
    500489        pcap_pause_input,               /* pause_input */
    501         pcapint_init_output,            /* init_output */
     490        NULL,                           /* init_output */
    502491        NULL,                           /* config_output */
    503492        NULL,                           /* start_output */
    504493        pcap_fin_input,                 /* fin_input */
    505         pcapint_fin_output,             /* fin_output */
     494        NULL,                           /* fin_output */
    506495        pcap_read_packet,               /* read_packet */
    507         pcapint_write_packet,           /* write_packet */
     496        NULL,                           /* write_packet */
    508497        pcap_get_link_type,             /* get_link_type */
    509498        pcap_get_direction,             /* get_direction */
  • lib/format_rt.c

    rafd0b73 rab4cb04  
    6666#include <stdlib.h>
    6767
    68 #define RT_INFO libtrace->format_data
     68#define RT_INFO ((struct rt_format_data_t*)libtrace->format_data)
    6969
    7070int reliability = 0;
     
    9191
    9292
    93 struct libtrace_format_data_t {
     93struct rt_format_data_t {
    9494        char *hostname;
    9595        int port;
     
    175175        char *scan;
    176176        char *uridata = libtrace->uridata;
    177         libtrace->format_data = (struct libtrace_format_data_t *)
    178                 malloc(sizeof(struct libtrace_format_data_t));
     177        libtrace->format_data = malloc(sizeof(struct rt_format_data_t));
    179178
    180179        RT_INFO->dummy_erf = NULL;
     
    486485
    487486static int rt_get_fd(const struct libtrace_t *trace) {
    488         return trace->format_data->input_fd;
     487        return ((struct rt_format_data_t *)trace->format_data)->input_fd;
    489488}
    490489
  • lib/format_wag.c

    rafd0b73 rab4cb04  
    7979static struct libtrace_format_t wag_trace;
    8080
    81 #define INPUT libtrace->format_data->input
    82 #define OUTPUT libtrace->format_data->output
    83 #define OPTIONS libtrace->format_data->options
    84 
    85 struct libtrace_format_data_t {
    86         union {
    87                 char *path;             /**< information for local sockets */
    88         } conn_info;
     81#define DATA(x)         ((struct wag_format_data_t *)x->format_data)
     82#define DATAOUT(x)      ((struct wag_format_data_out_t *)x->format_data)
     83
     84#define INPUT DATA(libtrace)->input
     85#define OUTPUT DATAOUT(libtrace)->output
     86#define OPTIONS DATAOUT(libtrace)->options
     87
     88struct wag_format_data_t {
    8989        /** Information about the current state of the input device */
    9090        union {
     
    9898};
    9999
    100 struct libtrace_format_data_out_t {
    101         union {
    102                 char *path;
    103         } conn_info;
     100struct wag_format_data_out_t {
    104101        union {
    105102                struct {
     
    118115};
    119116
    120 static int wag_init_input(struct libtrace_t *libtrace) {
     117static int wag_init_input(libtrace_t *libtrace) {
     118        libtrace->format_data = calloc(1, sizeof(struct wag_format_data_t));
     119
     120        return 0;
     121}
     122
     123static int wag_start_input(libtrace_t *libtrace)
     124{
    121125        struct stat buf;
    122         libtrace->format_data = (struct libtrace_format_data_t *)
    123                 calloc(1,sizeof(struct libtrace_format_data_t));
    124        
    125126        if (stat(libtrace->uridata,&buf) == -1 ) {
    126127                trace_set_err(libtrace,errno,"stat(%s)",libtrace->uridata);
    127                 return 0;
     128                return -1;
    128129        }
    129130        if (S_ISCHR(buf.st_mode)) {
    130                                
    131131                INPUT.fd = open(libtrace->uridata, O_RDONLY);
    132 
    133132        } else {
    134133                trace_set_err(libtrace,TRACE_ERR_INIT_FAILED,
    135134                                "%s is not a valid char device",
    136135                                libtrace->uridata);
    137                 return 0;
    138                
    139         }
    140         return 1;
     136                return -1;
     137        }
     138        return 0;
    141139}
    142140
    143141static int wtf_init_input(struct libtrace_t *libtrace)
    144142{
    145         libtrace->format_data = (struct libtrace_format_data_t *)
    146                 malloc(sizeof(struct libtrace_format_data_t));
    147 
    148         return 1;
     143        libtrace->format_data = malloc(sizeof(struct wag_format_data_t));
     144
     145        return 0;
    149146}
    150147
    151148static int wtf_start_input(libtrace_t *libtrace)
    152149{
    153         libtrace->format_data->input.file = trace_open_file(libtrace);
    154 
    155         if (libtrace->format_data->input.file)
    156                 return 1;
    157 
    158         return 0;
     150        DATA(libtrace)->input.file = trace_open_file(libtrace);
     151
     152        if (DATA(libtrace)->input.file)
     153                return 0;
     154
     155        return -1;
    159156}
    160157
    161158static int wtf_init_output(struct libtrace_out_t *libtrace) {
    162         libtrace->format_data = (struct libtrace_format_data_out_t *)
    163                 calloc(1,sizeof(struct libtrace_format_data_out_t));
     159        libtrace->format_data = calloc(1,sizeof(struct wag_format_data_out_t));
    164160
    165161        OUTPUT.file = 0;
     
    205201}
    206202
     203static int wag_pause_input(libtrace_t *libtrace)
     204{
     205        close(INPUT.fd);
     206}
     207
    207208static int wag_fin_input(struct libtrace_t *libtrace) {
    208         close(INPUT.fd);
    209209        free(libtrace->format_data);
    210210        return 0;
     
    417417
    418418static int wag_get_fd(const libtrace_t *trace) {
    419         return trace->format_data->input.fd;
     419        return DATA(trace)->input.fd;
    420420}
    421421
     
    454454        wag_init_input,                 /* init_input */       
    455455        NULL,                           /* config_input */
    456         NULL,                           /* start_input */
    457         NULL,                           /* pause_input */
     456        wag_start_input,                /* start_input */
     457        wag_pause_input,                /* pause_input */
    458458        NULL,                           /* init_output */
    459459        NULL,                           /* config_output */
  • lib/libtrace_int.h

    rafd0b73 rab4cb04  
    9595struct libtrace_t {
    9696        struct libtrace_format_t *format; /**< format driver pointer */
    97         struct libtrace_format_data_t *format_data; /**<format data pointer */
     97        void *format_data; /**<format data pointer */
    9898        bool started;                   /**< if this trace has started */
    9999        libtrace_err_t err;             /**< error information */
     
    181181        int (*start_output)(libtrace_out_t *libtrace);
    182182        /** @} */
    183         /** finish an input trace, cleanup (or NULL if input not supported) */
     183        /** finish an input trace, cleanup (or NULL if input not supported)
     184         * if the trace is not paused, libtrace will pause the trace before
     185         * calling this function.
     186         */
    184187        int (*fin_input)(libtrace_t *libtrace);
    185188        /** finish an output trace, cleanup (or NULL if output not supported) */
     
    200203        libtrace_linktype_t (*get_link_type)(const libtrace_packet_t *packet);
    201204        /** return the direction of this packet
    202          * This function pointer may be NULL if the format does not support
    203          * getting a direction.
     205         * @note This callback may be NULL if not supported.
    204206         */
    205207        int8_t (*get_direction)(const libtrace_packet_t *packet);
    206208        /** set the direction of this packet
    207          * This function pointer may be NULL if the format does not support
    208          * setting a direction.
     209         * @note This callback may be NULL if not supported.
    209210         */
    210211        int8_t (*set_direction)(const libtrace_packet_t *packet, int8_t direction);
  • lib/trace.c

    rafd0b73 rab4cb04  
    487487void trace_destroy(struct libtrace_t *libtrace) {
    488488        assert(libtrace);
     489        if (libtrace->started && libtrace->format->pause_input)
     490                libtrace->format->pause_input(libtrace);
    489491        libtrace->format->fin_input(libtrace);
    490492        /* need to free things! */
Note: See TracChangeset for help on using the changeset viewer.