Changeset df338b3 for lib/trace.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/trace.c

    r65a5900 rdf338b3  
    120120#define MAXOPTS 1024
    121121
    122 #if HAVE_BPF
    123 /* A type encapsulating a bpf filter
    124  * This type covers the compiled bpf filter, as well as the original filter
    125  * string
    126  *
    127  */
    128 struct libtrace_filter_t {
    129         struct bpf_insn *filter;
    130         char * filterstring;
    131 };
    132 #endif
    133122
    134123struct trace_err_t trace_err;
     
    405394int trace_start(struct libtrace_t *libtrace)
    406395{
     396        assert(libtrace);
    407397        if (libtrace->format->start_input) {
    408398                int ret=libtrace->format->start_input(libtrace);
     
    543533                do {
    544534                        packet->size=libtrace->format->read_packet(libtrace,packet);
    545                         if (packet->size==-1)
     535                        if (packet->size==-1 || packet->size==0)
    546536                                return packet->size;
    547537                        if (libtrace->filter) {
     
    12521242        struct libtrace_filter_t *filter = malloc(sizeof(struct libtrace_filter_t));
    12531243        filter->filterstring = strdup(filterstring);
    1254         filter->filter = 0;
     1244        filter->flag = 0;
    12551245        return filter;
    12561246#else
    12571247        fprintf(stderr,"This version of libtrace does not have bpf filter support\n");
    12581248        return 0;
     1249#endif
     1250}
     1251
     1252/* compile a bpf filter, now we know what trace it's on
     1253 * @internal
     1254 *
     1255 * @returns -1 on error, 0 on success
     1256 */
     1257int trace_bpf_compile(libtrace_filter_t *filter,
     1258                const libtrace_packet_t *packet ) {
     1259#if HAVE_BPF
     1260        void *linkptr = 0;
     1261        assert(filter);
     1262
     1263        /* If this isn't a real packet, then fail */
     1264        linkptr = trace_get_link(packet);
     1265        if (!linkptr) {
     1266                return -1;
     1267        }
     1268       
     1269        if (filter->filterstring && ! filter->flag) {
     1270                pcap_t *pcap;
     1271                pcap=(pcap_t *)pcap_open_dead(
     1272                                libtrace_to_pcap_dlt(trace_get_link_type(packet)),
     1273                                1500);
     1274                /* build filter */
     1275                if (pcap_compile( pcap, &filter->filter, filter->filterstring,
     1276                                        1, 0)) {
     1277                        pcap_close(pcap);
     1278                        return -1;
     1279                }
     1280                pcap_close(pcap);
     1281                filter->flag=1;
     1282        }
     1283        return 0;
     1284#else
     1285        assert(!"This should never be called when BPF not enabled");
    12591286#endif
    12601287}
     
    12771304                return 0;
    12781305        }
     1306
     1307        /* We need to compile it now, because before we didn't know what the
     1308         * link type was
     1309         */
     1310        trace_bpf_compile(filter,packet);
    12791311       
    12801312        clen = trace_get_capture_length(packet);
    1281        
    1282 
    1283         if (filter->filterstring && ! filter->filter) {
    1284                 pcap_t *pcap;
    1285                 struct bpf_program bpfprog;
    1286                 pcap=(pcap_t *)pcap_open_dead(
    1287                                 libtrace_to_pcap_dlt(trace_get_link_type(packet)),
    1288                                 1500);
    1289                 /* build filter */
    1290                 if (pcap_compile( pcap, &bpfprog, filter->filterstring, 1, 0)) {
    1291                         printf("bpf compilation error: %s: %s\n",
    1292                                 pcap_geterr(pcap),filter->filterstring);
    1293                         assert(0);
    1294                 }
    1295                 pcap_close(pcap);
    1296                 filter->filter = bpfprog.bf_insns;     
    1297         }
    1298 
    1299         assert(filter->filter);
    1300         return bpf_filter(filter->filter, linkptr, clen, clen);
     1313
     1314        assert(filter->flag);
     1315        return bpf_filter(filter->filter.bf_insns, linkptr, clen, clen);
    13011316#else
    13021317        fprintf(stderr,"This version of libtrace does not have bpf filter support\n");
Note: See TracChangeset for help on using the changeset viewer.