Changeset d5879cc


Ignore:
Timestamp:
02/27/06 16:40:19 (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:
8a8e54b
Parents:
ab4cb04
Message:

Fix various issues

Location:
lib
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • lib/fifo.c

    rf0d19d4 rd5879cc  
    247247                                size);
    248248                increment_pointer(fifo,IN,size);
    249                 buffer += size;
     249                buffer = (char*)buffer+size;
    250250                lenleft -= size;
    251251        }
  • lib/format_erf.c

    rab4cb04 rd5879cc  
    7272#endif
    7373
    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)
     74#define DATA(x) ((struct erf_format_data_t *)x->format_data)
     75#define DATAOUT(x) ((struct erf_format_data_out_t *)x->format_data)
     76
    7677#define CONNINFO DATA(libtrace)->conn_info
    7778#define INPUT DATA(libtrace)->input
     
    8182#endif
    8283#define OPTIONS DATAOUT(libtrace)->options
    83 struct libtrace_format_data_t {
     84struct erf_format_data_t {
    8485        union {
    8586                struct {
     
    106107};
    107108
    108 struct libtrace_format_data_out_t {
     109struct erf_format_data_out_t {
    109110        union {
    110111                struct {
     
    154155        if (stat(libtrace->uridata, &buf) == -1) {
    155156                trace_set_err(libtrace,errno,"stat(%s)",libtrace->uridata);
    156                 return 0;
     157                return -1;
    157158        }
    158159        if (S_ISCHR(buf.st_mode)) {
     
    161162                        trace_set_err(libtrace,errno,"Cannot open DAG %s",
    162163                                        libtrace->uridata);
    163                         return 0;
     164                        return -1;
    164165                }
    165166                if((DAG.buf = (void *)dag_mmap(INPUT.fd)) == MAP_FAILED) {
    166167                        trace_set_err(libtrace,errno,"Cannot mmap DAG %s",
    167168                                        libtrace->uridata);
    168                         return 0;
     169                        return -1;
    169170                }
    170171                if(dag_start(INPUT.fd) < 0) {
    171172                        trace_set_err(libtrace,errno,"Cannot start DAG %s",
    172173                                        libtrace->uridata);
    173                         return 0;
     174                        return -1;
    174175                }
    175176        } else {
    176177                trace_set_err(libtrace,errno,"Not a valid dag device: %s",
    177178                                libtrace->uridata);
    178                 return 0;
    179         }
    180         return 1;
     179                return -1;
     180        }
     181        return 0;
    181182}
    182183#endif
     
    201202static int erf_init_input(struct libtrace_t *libtrace)
    202203{
    203         libtrace->format_data = (struct libtrace_format_data_t *)
    204                 malloc(sizeof(struct libtrace_format_data_t));
    205 
     204        libtrace->format_data = malloc(sizeof(struct erf_format_data_t));
     205
     206        return 0; /* success */
    206207}
    207208
     
    213214                return -1;
    214215
    215         return 0;
     216        return 0; /* success */
    216217}
    217218
    218219static int rtclient_init_input(struct libtrace_t *libtrace) {
    219220        char *scan;
    220         libtrace->format_data = (struct libtrace_format_data_t *)
    221                 malloc(sizeof(struct libtrace_format_data_t));
     221        libtrace->format_data = malloc(sizeof(struct erf_format_data_t));
    222222
    223223
     
    241241                }
    242242        }
    243        
     243
     244        return 0; /* success */
    244245}
    245246
     
    267268                trace_set_err(libtrace,errno,"connect(%s)",
    268269                                CONNINFO.rt.hostname);
    269                 return 0;
    270         }
    271         return -1;
     270                return -1;
     271        }
     272        return 0;
    272273}
    273274
    274275static int erf_init_output(struct libtrace_out_t *libtrace) {
    275         libtrace->format_data = (struct libtrace_format_data_out_t *)
    276                 calloc(1,sizeof(struct libtrace_format_data_out_t));
     276        libtrace->format_data = calloc(1,sizeof(struct erf_format_data_out_t));
    277277
    278278        OPTIONS.erf.level = 0;
  • lib/format_helper.h

    r0a6638f rd5879cc  
    3838struct libtrace_eventobj_t trace_event_trace(libtrace_t *trace, libtrace_packet_t *packet);
    3939
     40int trace_bpf_compile(libtrace_filter_t *filter,
     41                const libtrace_packet_t *packet);
     42
    4043LIBTRACE_FILE trace_open_file(libtrace_t *libtrace);
    4144LIBTRACE_FILE trace_open_file_out(libtrace_out_t *libtrace,
  • lib/format_pcap.c

    rab4cb04 rd5879cc  
    111111        DATA(libtrace)->promisc = 0;
    112112
    113         return 1;
     113        return 0;
    114114}
    115115
     
    124124        }
    125125        if (DATA(libtrace)->filter) {
    126                 trace_bpf_compile(DATA(libtrace)->filter);
     126                pcap_compile(INPUT.pcap, &DATA(libtrace)->filter->filter,
     127                                DATA(libtrace)->filter->filterstring, 1, 0);
    127128                if (pcap_setfilter(INPUT.pcap,&DATA(libtrace)->filter->filter)
    128129                                == -1) {
     
    278279}
    279280
    280 static 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 
    288281static int pcap_write_packet(libtrace_out_t *libtrace, const libtrace_packet_t *packet) {
    289282        struct pcap_pkthdr pcap_pkt_hdr;
     
    293286                        libtrace_to_pcap_dlt(trace_get_link_type(packet)),
    294287                        65536);
     288                OUTPUT.trace.dump = pcap_dump_open(OUTPUT.trace.pcap,
     289                                libtrace->uridata);
     290                fflush((FILE *)OUTPUT.trace.dump);
    295291        }
    296292        if (libtrace->format == &pcap ||
     
    457453        pcap_init_output,               /* init_output */
    458454        NULL,                           /* config_output */
    459         pcap_start_output,              /* start_output */
     455        NULL,                           /* start_output */
    460456        pcap_fin_input,                 /* fin_input */
    461457        pcap_fin_output,                /* fin_output */
  • lib/libtrace_int.h

    rab4cb04 rd5879cc  
    7878
    7979#define RP_BUFSIZE 65536
    80 
    81 struct libtrace_format_data_t;
    8280
    8381struct libtrace_event_t {
     
    114112struct libtrace_out_t {
    115113        struct libtrace_format_t *format;       /**< format driver */
    116         struct libtrace_format_data_out_t *format_data; /**< format data */
     114        void *format_data;              /**< format data */
    117115        bool started;                   /**< trace started */
    118116        libtrace_err_t err;             /**< Associated error */
     
    152150};
    153151
     152
     153
    154154/** Module definition structure */
     155/* all of these should return -1, or NULL on failure */
    155156struct libtrace_format_t {
    156157        /** the uri name of this module */
  • lib/trace.c

    rab4cb04 rd5879cc  
    158158        }
    159159        format_list[nformats] = f;
     160        /* Now, verify things */
     161        if (format_list[nformats]->init_input) {
     162#define REQUIRE(x) \
     163                if (!format_list[nformats]->x) \
     164                        fprintf(stderr,"%s: Input format should provide " #x "\n",format_list[nformats]->name)
     165                REQUIRE(read_packet);
     166                REQUIRE(start_input);
     167                REQUIRE(config_input);
     168                REQUIRE(pause_input);
     169                REQUIRE(fin_input);
     170                REQUIRE(get_link_type);
     171                REQUIRE(get_capture_length);
     172                REQUIRE(get_wire_length);
     173                REQUIRE(get_framing_length);
     174                REQUIRE(trace_event);
     175                if (!format_list[nformats]->get_erf_timestamp
     176                        && !format_list[nformats]->get_seconds
     177                        && !format_list[nformats]->get_timeval) {
     178                        fprintf(stderr,"%s: A trace format capable of input, should provide at least one of\n"
     179"get_erf_timestamp, get_seconds or trace_timeval\n",format_list[nformats]->name);
     180                }
     181#undef REQUIRE
     182        }
     183        else {
     184#define REQUIRE(x) \
     185                if (format_list[nformats]->x) \
     186                        fprintf(stderr,"%s: Non Input format shouldn't need " #x "\n",format_list[nformats]->name)
     187                REQUIRE(read_packet);
     188                REQUIRE(start_input);
     189                REQUIRE(pause_input);
     190                REQUIRE(fin_input);
     191                REQUIRE(get_link_type);
     192                REQUIRE(get_capture_length);
     193                REQUIRE(get_wire_length);
     194                REQUIRE(get_framing_length);
     195                REQUIRE(trace_event);
     196#undef REQUIRE
     197        }
     198        if (format_list[nformats]->init_output) {
     199#define REQUIRE(x) \
     200                if (!format_list[nformats]->x) \
     201                        fprintf(stderr,"%s: Output format should provide " #x "\n",format_list[nformats]->name)
     202                REQUIRE(write_packet);
     203                REQUIRE(start_output);
     204                REQUIRE(config_output);
     205                REQUIRE(fin_output);
     206#undef REQUIRE
     207        }
     208        else {
     209#define REQUIRE(x) \
     210                if (format_list[nformats]->x) \
     211                        fprintf(stderr,"%s: Non Output format shouldn't need " #x "\n",format_list[nformats]->name)
     212                REQUIRE(write_packet);
     213                REQUIRE(start_output);
     214                REQUIRE(config_output);
     215                REQUIRE(fin_output);
     216#undef REQUIRE
     217        }
    160218        nformats++;
    161219}
     
    256314       
    257315        if (libtrace->format->init_input) {
    258                 if (!libtrace->format->init_input(libtrace)) {
     316                int err=libtrace->format->init_input(libtrace);
     317                assert (err==-1 || err==0);
     318                if (err==-1) {
    259319                        /* init_input should call trace_set_err to set
    260320                         * the error message
     
    615675}
    616676
    617 /* get a pointer to the link layer
    618  * @param packet        a pointer to a libtrace_packet structure
    619  *
    620  * @returns a pointer to the link layer, or NULL if there is no link layer
    621  *
    622  * @note you should call trace_get_link_type() to find out what type of link layer this is
    623  */
    624677void *trace_get_link(const struct libtrace_packet_t *packet) {
    625678        return (void *)packet->payload;
     
    12931346        if (filter->filterstring && ! filter->flag) {
    12941347                pcap_t *pcap;
     1348                libtrace_linktype_t linktype=trace_get_link_type(packet);
     1349                if (linktype==(libtrace_linktype_t)-1) {
     1350                        trace_set_err(packet->trace,TRACE_ERR_BAD_PACKET,
     1351                                        "Packet has an unknown linktype");
     1352                        return -1;
     1353                }
     1354                if (libtrace_to_pcap_dlt(linktype) == -1) {
     1355                        trace_set_err(packet->trace,TRACE_ERR_BAD_PACKET,
     1356                                        "Unknown pcap equivilent linktype");
     1357                        return -1;
     1358                }
    12951359                pcap=(pcap_t *)pcap_open_dead(
    1296                                 libtrace_to_pcap_dlt(trace_get_link_type(packet)),
     1360                                libtrace_to_pcap_dlt(linktype),
    12971361                                1500);
    12981362                /* build filter */
Note: See TracChangeset for help on using the changeset viewer.