Changeset 277442c


Ignore:
Timestamp:
07/16/04 17:48:50 (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:
bb313ef
Parents:
27615e9
Message:

fixed bad initialisor problem

Location:
lib
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • lib/Makefile

    r7acdf97 r277442c  
    1111CURRENT=1
    1212AGE=0
    13 REVISION=5
     13REVISION=8
    1414
    1515INCLIBS=/usr/local/wand/lib/libzl.a /usr/local/wand/lib/libpcapl.a
  • lib/trace.c

    r14a9d05 r277442c  
    230230 *
    231231 * Valid URI's are:
    232  *  - erf:/path/to/erf/file
    233  *  - erf:/path/to/erf/file.gz
    234  *  - erf:/path/to/rtclient/socket
    235  *  - erf:-  (stdin)
    236  *  - dag:/dev/dagcard                  (not implementd)
    237  *  - pcap:pcapinterface                (eg: pcap:eth0)
    238  *  - pcap:/path/to/pcap/file
    239  *  - pcap:/path/to/pcap/file.gz
    240  *  - pcap:/path/to/pcap/socket         (not implemented)
    241  *  - pcap:-
    242  *  - rtclient:hostname
    243  *  - rtclient:hostname:port
    244  *  - wag:/path/to/wag/file
    245  *  - wag:/path/to/wag/file.gz
    246  *  - wag:/path/to/wag/socket
    247  *  - wag:/dev/device
    248  *
    249  *  If an error occured why attempting to open the trace file, NULL is returned
    250  *  and an error is output to stdout.
     232 *  erf:/path/to/erf/file
     233 *  erf:/path/to/erf/file.gz
     234 *  erf:/path/to/rtclient/socket
     235 *  erf:-                       (stdin)
     236 *  pcap:pcapinterface          (eg: pcap:eth0)
     237 *  pcap:/path/to/pcap/file
     238 *  pcap:/path/to/pcap/file.gz
     239 *  pcap:-
     240 *  rtclient:hostname
     241 *  rtclient:hostname:port
     242 *  wag:-
     243 *  wag:/path/to/wag/file
     244 *  wag:/path/to/wag/file.gz
     245 *  wag:/path/to/wag/socket
     246 *  wag:/dev/device
     247 *
     248 * URIs which have yet to be implemented are:
     249 * dag:/dev/dagcard
     250 * pcap:/path/to/pcap/socket
     251 *
     252 * If an error occured when attempting to open a trace, NULL is returned
     253 * and an error is output to stdout.
    251254 */
    252255struct libtrace_t *create_trace(char *uri) {
     
    407410 * @param buffer        the buffer to read into
    408411 * @param len           the length of the buffer
     412 * @param status        a pointer to the status byte
    409413 * @returns number of bytes copied.
    410414 *
     
    529533                case DAG:
    530534                case RTCLIENT:
    531                         // DAG people are insane, deal with ethernet having
    532                         // some extra padding and crap
    533535                        if (get_link_type(libtrace,buffer,buflen)==TRACE_TYPE_ETH)
    534                                 ethptr = ((uint8_t *)buffer + 16 + 2);
     536                                ethptr = ((uint8_t *)buffer +
     537                                                dag_record_size + 2);
    535538                        else
    536                                 ethptr = ((uint8_t *)buffer + 16 + 2);
     539                                ethptr = ((uint8_t *)buffer +
     540                                                dag_record_size + 2);
    537541                        break;
    538542                case PCAPINT:
     
    801805                case PCAP:
    802806                        pcapptr = (struct pcap_pkthdr *)buffer;
    803                         return ntohs(pcapptr->caplen);
     807                        //return ntohs(pcapptr->caplen);
     808                        return pcapptr->caplen;
    804809                case WAGINT:
    805810                case WAG:
     
    963968
    964969/** process a libtrace event
     970 * @param libtrace the libtrace opaque pointer
     971 * @param fd a pointer to a file descriptor to listen on
     972 * @param seconds a pointer the time in seconds since to the next event
     973 * @param buffer a pointer to a filled in buffer
     974 * @param len the length of the buffer
     975 * @param size the size of the event
    965976 * @returns
    966977 *  TRACE_EVENT_IOWAIT  Waiting on I/O on <fd>
    967978 *  TRACE_EVENT_SLEEP   Next event in <seconds>
    968979 *  TRACE_EVENT_PACKET  Packet arrived in <buffer> with size <size>
    969  */
    970 libtrace_event_t libtrace_event(struct libtrace_t *trace,
     980 * @author Perry Lorier
     981 */
     982libtrace_event_t libtrace_event(struct libtrace_t *libtrace,
    971983                        int *fd,double *seconds,
    972                         void *buffer, int *size)
     984                        void *buffer, size_t len, int *size)
    973985{
    974986        *seconds = 0;
    975987        *fd = 0;
    976988        /* Is there a packet ready? */
    977         switch (trace->sourcetype) {
     989        switch (libtrace->sourcetype) {
    978990                case INTERFACE:
    979991                        {
    980992                                int data;
    981                                 *fd = pcap_fileno(trace->input.pcap);
     993                                *fd = pcap_fileno(libtrace->input.pcap);
    982994                                if(ioctl(*fd,FIONREAD,&data)==-1){
    983995                                        perror("ioctl(FIONREAD)");
     
    9931005                        {
    9941006                                int data;
    995                                 if(ioctl(trace->input.fd,FIONREAD,&data)==-1){
     1007                                if(ioctl(libtrace->input.fd,FIONREAD,&data)==-1){
    9961008                                        perror("ioctl(FIONREAD)");
    9971009                                }
     
    9991011                                        return TRACE_EVENT_PACKET;
    10001012                                }
    1001                                 *fd = trace->input.fd;
     1013                                *fd = libtrace->input.fd;
    10021014                                return TRACE_EVENT_IOWAIT;
    10031015                        }
     
    10081020                                double ts;
    10091021                                /* "Prime" the pump */
    1010                                 if (!trace->packet.buffer) {
    1011                                         trace->packet.buffer = malloc(4096);
    1012                                         trace->packet.size=libtrace_read_packet(trace,
    1013                                                         trace->packet.buffer,
     1022                                if (!libtrace->packet.buffer) {
     1023                                        libtrace->packet.buffer = malloc(4096);
     1024                                        libtrace->packet.size=
     1025                                                libtrace_read_packet(libtrace,
     1026                                                        libtrace->packet.buffer,
    10141027                                                        4096,
    10151028                                                        &status);
    10161029                                }
    1017                                 ts=get_seconds(trace,
    1018                                         trace->packet.buffer,
    1019                                         trace->packet.size);
    1020                                 if (trace->last_ts!=0) {
    1021                                         *seconds = ts - trace->last_ts;
    1022                                         if (*seconds>time(NULL)-trace->start_ts)
     1030                                ts=get_seconds(libtrace,
     1031                                        libtrace->packet.buffer,
     1032                                        libtrace->packet.size);
     1033                                if (libtrace->last_ts!=0) {
     1034                                        *seconds = ts - libtrace->last_ts;
     1035                                        if (*seconds>time(NULL)-libtrace->start_ts)
    10231036                                                return TRACE_EVENT_SLEEP;
    10241037                                }
    10251038                                else {
    1026                                         trace->start_ts = time(NULL);
    1027                                         trace->last_ts = ts;
    1028                                 }
    1029 
    1030                                 *size = trace->packet.size;
    1031                                 memcpy(buffer,trace->packet.buffer,*size);
    1032 
    1033                                 free(trace->packet.buffer);
    1034                                 trace->packet.buffer = 0;
     1039                                        libtrace->start_ts = time(NULL);
     1040                                        libtrace->last_ts = ts;
     1041                                }
     1042
     1043                                *size = libtrace->packet.size;
     1044                                memcpy(buffer,libtrace->packet.buffer,*size);
     1045
     1046                                free(libtrace->packet.buffer);
     1047                                libtrace->packet.buffer = 0;
    10351048                                return TRACE_EVENT_PACKET;
    10361049                        }
     
    10501063        struct libtrace_filter_t *filter = malloc(sizeof(struct libtrace_filter_t));
    10511064        filter->filterstring = strdup(filterstring);
     1065        filter->filter = 0;
    10521066        return filter;
    10531067}
     
    10611075 * @author Daniel Lawson
    10621076 */
    1063 int libtrace_bpf_filter(struct libtrace_t *trace,
     1077int libtrace_bpf_filter(struct libtrace_t *libtrace,
    10641078                        struct libtrace_filter_t *filter,
    10651079                        void *buffer,
    10661080                        int buflen) {
    10671081       
    1068         int linktype = get_link_type(trace,buffer,buflen);
    1069         void *linkptr = get_link(trace,buffer,buflen); 
    1070         int clen = get_capture_length(trace,buffer,buflen);
    1071         assert(trace);
     1082        int linktype = get_link_type(libtrace,buffer,buflen);
     1083        void *linkptr = get_link(libtrace,buffer,buflen);       
     1084        int clen = get_capture_length(libtrace,buffer,buflen);
     1085        assert(libtrace);
    10721086        assert(filter);
    10731087        assert(buffer);
     1088        assert(linkptr);
    10741089       
    10751090
     
    10791094
    10801095                switch (linktype) {
    1081                         case TYPE_ETH:
     1096                        case TRACE_TYPE_ETH:
    10821097                                pcap = pcap_open_dead(DLT_EN10MB, 1500);
    10831098                                break;
     
    10971112        }
    10981113
     1114        assert(filter->filter);
     1115        printf("%d %d\n",clen,ntohs(clen));
    10991116        return bpf_filter(filter->filter, linkptr, clen, clen);
     1117       
    11001118}
    11011119
Note: See TracChangeset for help on using the changeset viewer.