Changeset 9580a74


Ignore:
Timestamp:
11/12/04 10:07:29 (16 years ago)
Author:
Daniel Lawson <dlawson@…>
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:
1b2fd6f
Parents:
9338143
Message:

added conditional code paths for pcap / zlib inclusion, and an alternate path for non-zlib file access

File:
1 edited

Legend:

Unmodified
Added
Removed
  • lib/trace.c

    r35902e3 r9580a74  
    2828 *
    2929 */
     30
    3031
    3132/** @file
     
    8182#include "fifo.h"
    8283
    83 #ifdef HAVE_PCAP_BPF_H
     84#if HAVE_PCAP_BPF_H
    8485#  include <pcap-bpf.h>
     86#  ifndef HAVE_BPF
     87#    define HAVE_BPF 1
     88#  endif
    8589#else
    8690#  ifdef HAVE_NET_BPF_H
    8791#    include <net/bpf.h>
     92#    ifndef HAVE_BPF
     93#      define HAVE_BPF 1
     94#    endif
    8895#  endif
    8996#endif
    9097
    91 #include <zlib.h>
    92 #include <pcap.h>
    93 #include <zlib.h>
     98#if HAVE_PCAP_H
     99#  include <pcap.h>
     100#  ifndef HAVE_PCAP
     101#    define HAVE_PCAP 1
     102#  endif
     103#endif
     104
     105#ifdef HAVE_ZLIB_H
     106#  include <zlib.h>
     107#  ifndef HAVE_ZLIB
     108#    define HAVE_ZLIB 1
     109#  endif
     110#endif
    94111
    95112
     
    99116#  include "dagnew.h"
    100117#  include "dagapi.h"
    101 #  define DAGDEVICE 1
     118#  ifndef DAGDEVICE
     119#    define DAGDEVICE 1
     120#  endif
    102121#else
    103122#  include "dagformat.h"
     
    127146        union {
    128147                int fd;
     148#if HAVE_ZLIB
    129149                gzFile *file;
     150#else   
     151                FILE *file;
     152#endif
     153#if HAVE_PCAP
    130154                pcap_t *pcap;
     155#endif
    131156        } input;
    132157        struct fifo_t *fifo;   
     
    172197        if (!strncasecmp(scan,"erf",3)) {
    173198                (*libtrace)->format=ERF;
     199#if HAVE_PCAP
    174200        } else if (!strncasecmp(scan,"pcapint",7)) {
    175201                (*libtrace)->format=PCAPINT;
    176202        } else if (!strncasecmp(scan,"pcap",4)) {
    177203                (*libtrace)->format=PCAP;
     204#else
     205        } else if (!strncasecmp(scan,"pcap",4)) { // also catches pcapint
     206                fprintf(stderr,"This version of libtrace has been compiled without PCAP support\n");
     207                return 0;
     208#endif
     209       
    178210#ifdef DAGDEVICE
    179211        } else if (!strncasecmp(scan,"dag",3)) {
     
    202234       
    203235        switch((*libtrace)->format) {
     236#if HAVE_PCAP
    204237                case PCAPINT:
     238#endif
    205239                case WAGINT:
    206240                        /* Can have uridata of the following format
     
    212246                        (*libtrace)->conn_info.path = strdup(uridata);
    213247                        break;
     248#if HAVE_PCAP
    214249                case PCAP:
     250#endif
    215251                case ERF:
    216252                case WAG:
     
    359395                        break;
    360396                case TRACE:
     397#if HAVE_PCAP
    361398                        if (libtrace->format == PCAP) {
    362399                                if ((libtrace->input.pcap = pcap_open_offline(libtrace->conn_info.path, errbuf)) == NULL) {
     
    365402                                }
    366403                        } else {
     404#else
     405                        {
     406#endif
     407#if HAVE_ZLIB
    367408                                libtrace->input.file = gzopen(libtrace->conn_info.path, "r");
    368                         }
     409#else
     410                                libtrace->input.file = fopen(libtrace->conn_info.path, "r");
     411#endif
     412                        }
    369413                        break;
    370414                case STDIN:
     415#if HAVE_PCAP
    371416                        if (libtrace->format == PCAP) {
    372417                                libtrace->input.pcap = pcap_open_offline("-",errbuf);
    373418                        } else {
     419#else
     420                        {
     421#endif
     422#if HAVE_ZLIB
    374423                                libtrace->input.file = gzdopen(STDIN, "r");
     424#else   
     425                                libtrace->input.file = fdopen(STDIN, "r");
     426#endif
    375427                        }
    376428                        break;
     
    396448                case INTERFACE:
    397449                        switch (libtrace->format) {
     450#if HAVE_PCAP
    398451                                case PCAPINT:
    399452                                case PCAP:
     
    405458                                                errbuf);
    406459                                        break;
    407                                 default:
    408                                         fprintf(stderr,"Unknown format trace, hoping I can just read\n");
     460#endif
    409461                                case WAGINT:
    410462                                case WAG:
     
    429481                                        break;
    430482#endif
     483                                default:
     484                                        fprintf(stderr,"Unknown format trace, hoping I can just read\n");
     485                                        break;
    431486                                       
    432487                        }
     
    445500void trace_destroy(struct libtrace_t *libtrace) {
    446501        assert(libtrace);
     502#if HAVE_PCAP
    447503        if (libtrace->format == PCAP || libtrace->format == PCAPINT) {
    448504                pcap_close(libtrace->input.pcap);
     505#else
     506        if (0) {
     507#endif
    449508        } else if (libtrace->sourcetype == SOCKET || libtrace->sourcetype == RT) {
    450509                close(libtrace->input.fd);
     
    454513#endif
    455514        } else {
     515#if HAVE_ZLIB
    456516                gzclose(libtrace->input.file);
     517#else   
     518                fclose(libtrace->input.file);   
     519#endif
    457520        }       
    458521        // need to free things!
     
    518581                                break;
    519582                        default:
     583#if HAVE_ZLIB
    520584                                if ((numbytes=gzread(libtrace->input.file,
    521585                                                                buffer,
     
    524588                                        return -1;
    525589                                }
     590#else
     591                                if ((numbytes=fread(buffer,len,1,libtrace->input.file)) == 0 ) {
     592                                        if(feof(libtrace->input.file)) {
     593                                                return 0;
     594                                        }
     595                                        perror("fread");
     596                                        return -1;
     597                                }
     598#endif
    526599                }
    527600                break;
     
    553626        assert(libtrace);
    554627        assert(packet);
    555         //if(packet->buffer == 0) {
    556         //      packet->buffer = malloc(LIBTRACE_PACKET_BUFSIZE);
    557         //}
    558 
    559         //bzero(buffer,len);
    560628     
    561629        /* Store the trace we are reading from into the packet opaque
     
    564632
    565633        buffer = packet->buffer;
     634#if HAVE_PCAP
    566635        /* PCAP gives us it's own per-packet interface. Let's use it */
    567636        if (libtrace->format == PCAP || libtrace->format == PCAPINT) {
     
    576645                return numbytes;
    577646        }
     647#endif
    578648
    579649        /* If we're reading from an ERF input, it's an offline trace. We can make some assumptions */
     
    734804                                                dag_record_size + 2);
    735805                        break;
     806#if HAVE_PCAP
    736807                case PCAPINT:
    737808                case PCAP:
    738809                        ethptr = (struct ether_header *)(packet->buffer + sizeof(struct pcap_pkthdr));
    739810                        break;
     811#endif
    740812                case WAGINT:
    741813                case WAG:
     
    9301002struct timeval trace_get_timeval(struct libtrace_packet_t *packet) {
    9311003        struct timeval tv;
     1004#if HAVE_PCAP
    9321005        struct pcap_pkthdr *pcapptr = 0;
     1006#endif
    9331007        uint64_t ts;
    9341008        //uint32_t seconds;
    9351009        switch (packet->trace->format) {
     1010#if HAVE_PCAP
    9361011                case PCAPINT:
    9371012                case PCAP:
     
    9391014                        tv = pcapptr->ts;
    9401015                        break;
     1016#endif
    9411017                case WAGINT:
    9421018                case WAG:
     
    9861062int trace_get_capture_length(struct libtrace_packet_t *packet) {
    9871063        dag_record_t *erfptr = 0;
     1064#if HAVE_PCAP
    9881065        struct pcap_pkthdr *pcapptr = 0;
     1066#endif
    9891067        struct wag_event_t *wag_event;
    9901068        switch (packet->trace->format) {
     
    9941072                        erfptr = (dag_record_t *)packet->buffer;
    9951073                        return ntohs(erfptr->rlen);
     1074#if HAVE_PCAP
    9961075                case PCAPINT:
    9971076                case PCAP:
     
    9991078                        //return ntohs(pcapptr->caplen);
    10001079                        return pcapptr->caplen;
     1080#endif
    10011081                case WAGINT:
    10021082                case WAG:
     
    10291109int trace_get_wire_length(struct libtrace_packet_t *packet){
    10301110        dag_record_t *erfptr = 0;
     1111#if HAVE_PCAP
    10311112        struct pcap_pkthdr *pcapptr = 0;
     1113#endif
    10321114        struct wag_event_t *wag_event = 0;
    10331115        switch (packet->trace->format) {
     
    10381120                        return ntohs(erfptr->wlen);
    10391121                        break;
     1122#if HAVE_PCAP
    10401123                case PCAPINT:
    10411124                case PCAP:
     
    10431126                        return ntohs(pcapptr->len);
    10441127                        break;
     1128#endif
    10451129                case WAGINT:
    10461130                case WAG:
     
    10671151libtrace_linktype_t trace_get_link_type(struct libtrace_packet_t *packet ) {
    10681152        dag_record_t *erfptr = 0;
     1153#if HAVE_PCAP
    10691154        struct pcap_pkthdr *pcapptr = 0;
     1155#endif
    10701156        int linktype = 0;
    10711157        switch (packet->trace->format) {
     
    10821168                       
    10831169                        break;
     1170#if HAVE_PCAP
    10841171                case PCAPINT:
    10851172                case PCAP:
     
    10951182                        }
    10961183                        break;
     1184#endif
    10971185                case WAGINT:
    10981186                case WAG:
     
    11811269        /* Is there a packet ready? */
    11821270        switch (trace->sourcetype) {
     1271#if HAVE_PCAP
    11831272                case INTERFACE:
    11841273                        {
     
    11961285                                return event;
    11971286                        }
     1287#endif
    11981288                case SOCKET:
    11991289                case DEVICE:
     
    12571347 */
    12581348struct libtrace_filter_t *trace_bpf_setfilter(const char *filterstring) {
     1349#ifdef HAVE_BPF_H
    12591350        struct libtrace_filter_t *filter = malloc(sizeof(struct libtrace_filter_t));
    12601351        filter->filterstring = strdup(filterstring);
    12611352        filter->filter = 0;
    12621353        return filter;
     1354#else
     1355        fprintf(stderr,"This version of libtrace does not have bpf filter support\n");
     1356        return 0;
     1357#endif
    12631358}
    12641359
     
    12731368int trace_bpf_filter(struct libtrace_filter_t *filter,
    12741369                        struct libtrace_packet_t *packet) {
    1275        
     1370#ifdef HAVE_BPF_H
    12761371        void *linkptr = 0;
    12771372        int clen = 0;
     
    13081403        assert(filter->filter);
    13091404        return bpf_filter(filter->filter, linkptr, clen, clen);
    1310        
     1405#else
     1406        fprintf(stderr,"This version of libtrace does not have bpf filter support\n");
     1407        return 0;
     1408#endif
    13111409}
    13121410
     
    14951593size_t trace_truncate_packet(struct libtrace_packet_t *packet, size_t size) {
    14961594        dag_record_t *erfptr;
     1595#if HAVE_PCAP
    14971596        struct pcap_pkthdr *pcaphdr;
     1597#endif
    14981598
    14991599        assert(packet);
     
    15041604        }
    15051605        switch (packet->trace->format) {
     1606#if HAVE_PCAP
    15061607                case PCAPINT:
    15071608                case PCAP:
     
    15101611                        packet->size = pcaphdr->caplen;
    15111612                        break;
     1613#endif
    15121614                case ERF:
    15131615                case DAG:
Note: See TracChangeset for help on using the changeset viewer.