Changeset 72bfe20


Ignore:
Timestamp:
08/08/05 16:33:16 (15 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:
c3274c6
Parents:
8184acc
Message:

trace_event fixed

Location:
lib
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • lib/format_erf.c

    rdf2dff9 r72bfe20  
    3131#include "libtrace.h"
    3232#include "libtrace_int.h"
     33#include "format_helper.h"
    3334#include "rtserver.h"
    3435#include "parse_cmd.h"
     
    136137        if (S_ISCHR(buf.st_mode)) {
    137138                // DEVICE
     139                libtrace->sourcetype = DEVICE;
    138140                if((INPUT.fd =
    139141                                dag_open(CONNINFO.path)) < 0) {
     
    172174        if (!strncmp(CONNINFO.path,"-",1)) {
    173175                // STDIN
     176                libtrace->sourcetype = STDIN;
    174177#if HAVE_ZLIB
    175178                INPUT.file = gzdopen(STDIN, "r");
     
    184187                }
    185188                if (S_ISSOCK(buf.st_mode)) {
    186                         // SOCKET
     189                        libtrace->sourcetype = SOCKET;
    187190                        if ((INPUT.fd = socket(
    188191                                        AF_UNIX, SOCK_STREAM, 0)) == -1) {
     
    203206                        }
    204207                } else {
    205                         // TRACE
     208                        libtrace->sourcetype = TRACE;
    206209#if HAVE_ZLIB
    207210                        // using gzdopen means we can set O_LARGEFILE
     
    230233        libtrace->format_data = (struct libtrace_format_data_t *)
    231234                malloc(sizeof(struct libtrace_format_data_t));
     235
     236        libtrace->sourcetype = RT;
    232237
    233238        if (strlen(uridata) == 0) {
     
    733738}
    734739
     740static int rtclient_get_fd(struct libtrace_packet_t *packet) {
     741        return packet->trace->format_data->input.fd;
     742}
     743
     744static int erf_get_fd(struct libtrace_packet_t *packet) {
     745        return packet->trace->format_data->input.fd;
     746}
     747
    735748static void dag_help() {
    736749        printf("dag format module: $Revision$\n");
     
    799812        erf_fin_input,                  /* fin_input */
    800813        erf_fin_output,                 /* fin_output */
    801         NULL,                           /* read */
    802814        erf_read_packet,                /* read_packet */
    803815        erf_write_packet,               /* write_packet */
     
    812824        erf_get_wire_length,            /* get_wire_length */
    813825        erf_set_capture_length,         /* set_capture_length */
     826        erf_get_fd,                     /* get_fd */
     827        trace_event_trace,              /* trace_event */
    814828        erf_help                        /* help */
    815829};
     
    824838        dag_fin_input,                  /* fin_input */
    825839        NULL,                           /* fin_output */
    826         dag_read,                       /* read */
    827840        dag_read_packet,                /* read_packet */
    828841        NULL,                           /* write_packet */
     
    837850        erf_get_wire_length,            /* get_wire_length */
    838851        erf_set_capture_length,         /* set_capture_length */
     852        NULL,                           /* get_fd */
     853        trace_event_trace,              /* trace_event */
    839854        dag_help                        /* help */
    840855};
     
    849864        rtclient_fin_input,             /* fin_input */
    850865        rtclient_fin_output,            /* fin_output */
    851         rtclient_read,                  /* read */
    852866        rtclient_read_packet,           /* read_packet */
    853867        rtclient_write_packet,          /* write_packet */
     
    862876        erf_get_wire_length,            /* get_wire_length */
    863877        erf_set_capture_length,         /* set_capture_length */
     878        rtclient_get_fd,                /* get_fd */
     879        trace_event_device,             /* trace_event */
    864880        rtclient_help                   /* help */
    865881};
  • lib/format_pcap.c

    r9e2a109 r72bfe20  
    3333#include "libtrace.h"
    3434#include "libtrace_int.h"
     35#include "format_helper.h"
    3536#include <inttypes.h>
    3637#include <sys/types.h>
     
    5657
    5758#if HAVE_PCAP
     59
     60#define CONNINFO libtrace->format_data->conn_info
     61#define INPUT libtrace->format_data->input
    5862
    5963struct libtrace_format_data_t {
     
    7680        libtrace->format_data = (struct libtrace_format_data_t *)
    7781                malloc(sizeof(struct libtrace_format_data_t));
    78         libtrace->format_data->conn_info.path = libtrace->uridata;
    79         if (!strncmp(libtrace->format_data->conn_info.path,"-",1)) {
    80                 if ((libtrace->format_data->input.pcap =
    81                         pcap_open_offline(libtrace->format_data->conn_info.path,
     82        CONNINFO.path = libtrace->uridata;
     83
     84        libtrace->sourcetype = TRACE;
     85        if (!strncmp(CONNINFO.path,"-",1)) {
     86                if ((INPUT.pcap =
     87                        pcap_open_offline(CONNINFO.path,
    8288                                                errbuf)) == NULL) {
    8389                        fprintf(stderr,"%s\n",errbuf);
     
    8591                }               
    8692        } else {
    87                 if (stat(libtrace->format_data->conn_info.path,&buf) == -1) {
     93                if (stat(CONNINFO.path,&buf) == -1) {
    8894                        perror("stat");
    8995                        return 0;
    9096                }
    9197                if (S_ISCHR(buf.st_mode)) {
    92                         if ((libtrace->format_data->input.pcap =
    93                                 pcap_open_live(libtrace->format_data->conn_info.path,
     98                        if ((INPUT.pcap =
     99                                pcap_open_live(CONNINFO.path,
    94100                                        4096,
    95101                                        1,
     
    100106                        }
    101107                } else {
    102                         if ((libtrace->format_data->input.pcap =
    103                                 pcap_open_offline(libtrace->format_data->conn_info.path,
     108                        if ((INPUT.pcap =
     109                                pcap_open_offline(CONNINFO.path,
    104110                                        errbuf)) == NULL) {
    105111                                fprintf(stderr,"%s\n",errbuf);
     
    110116        fprintf(stderr,
    111117                        "Unsupported scheme (%s) for format pcap\n",
    112                         libtrace->format_data->conn_info.path);
     118                        CONNINFO.path);
    113119        return 0;
    114120       
     
    117123static int pcapint_init_input(struct libtrace_t *libtrace) {
    118124        char errbuf[PCAP_ERRBUF_SIZE];
    119         if ((libtrace->format_data->input.pcap =
    120                         pcap_open_live(libtrace->format_data->conn_info.path,
     125        libtrace->format_data = (struct libtrace_format_data_t *)
     126                malloc(sizeof(struct libtrace_format_data_t));
     127        CONNINFO.path = libtrace->uridata;
     128        libtrace->sourcetype = INTERFACE;
     129        if ((INPUT.pcap =
     130                        pcap_open_live(CONNINFO.path,
    121131                        4096,
    122132                        1,
     
    149159        int pcapbytes = 0;
    150160
    151         while ((pcapbytes = pcap_dispatch(libtrace->format_data->input.pcap,
     161        while ((pcapbytes = pcap_dispatch(INPUT.pcap,
    152162                                        1, /* number of packets */
    153163                                        &trace_pcap_handler,
     
    274284}
    275285
     286static int pcap_get_fd(struct libtrace_packet_t *packet) {
     287        return pcap_fileno(packet->trace->format_data->input.pcap);
     288}
     289
    276290static void pcap_help() {
    277291        printf("pcap format module: $Revision$\n");
     
    307321        pcap_fin_input,                 /* fin_input */
    308322        NULL,                           /* fin_output */
    309         NULL,                           /* read */
    310323        pcap_read_packet,               /* read_packet */
    311324        NULL,                           /* write_packet */
     
    320333        pcap_get_wire_length,           /* get_wire_length */
    321334        pcap_set_capture_length,        /* set_capture_length */
     335        NULL,                           /* get_fd */
     336        trace_event_trace,              /* trace_event */
    322337        pcap_help                       /* help */
    323338};
     
    331346        pcap_fin_input,                 /* fin_input */
    332347        NULL,                           /* fin_output */
    333         NULL,                           /* read */
    334348        pcap_read_packet,               /* read_packet */
    335349        NULL,                           /* write_packet */
     
    344358        pcap_get_wire_length,           /* get_wire_length */
    345359        pcap_set_capture_length,        /* set_capture_length */
     360        pcap_get_fd,                    /* get_fd */
     361        trace_event_device,             /* trace_event */
    346362        pcapint_help                    /* help */
    347363};
  • lib/format_template.c

    r9e2a109 r72bfe20  
    3131#include "libtrace.h"
    3232#include "libtrace_int.h"
     33#include "format_helper.h"
    3334#include <inttypes.h>
    3435
     
    5859}
    5960
    60 static int template_read(struct libtrace_t *libtrace, void *buffer, size_t len) {
    61         return -1;
    62 }
    6361static int template_read_packet(struct libtrace_t *libtrace, struct libtrace_packet_t *packet) {
    6462        return -1;
     
    110108}
    111109
     110static int template_get_fd(const struct libtrace_packet_t *packet) {
     111        return -1;
     112}
     113
    112114static void template_help() {
    113115        return;
     
    121123        template_fin_input,             /* fin_input */
    122124        template_fin_output,            /* fin_output */
    123         template_read,                  /* read */
    124125        template_read_packet,           /* read_packet */
    125126        template_write_packet,          /* write_packet */
     
    134135        template_get_wire_length,       /* get_wire_length */
    135136        template_set_capture_length,    /* set_capture_length */
     137        template_get_fd,                /* get_fd */
     138        trace_event_trace,              /* trace_event */
    136139        template_help                   /* help */
    137140};
  • lib/format_wag.c

    r9e2a109 r72bfe20  
    3131#include "libtrace.h"
    3232#include "libtrace_int.h"
     33#include "format_helper.h"
    3334#include "wag.h"
    3435
     
    5960#endif
    6061
     62#define CONNINFO libtrace->format_data->conn_info
     63#define INPUT libtrace->format_data->input
    6164struct libtrace_format_data_t {
    6265        union {
     
    8689        libtrace->format_data = (struct libtrace_format_data_t *)
    8790                calloc(1,sizeof(struct libtrace_format_data_t));
    88         libtrace->format_data->conn_info.path = libtrace->uridata;
    89         if (!strncmp(libtrace->format_data->conn_info.path,"-",1)) {
     91        CONNINFO.path = libtrace->uridata;
     92        if (!strncmp(CONNINFO.path,"-",1)) {
     93                libtrace->sourcetype = STDIN;
    9094                // STDIN
    9195#if HAVE_ZLIB
    92                 libtrace->format_data->input.file = gzdopen(STDIN, "r");
     96                INPUT.file = gzdopen(STDIN, "r");
    9397#else   
    94                 libtrace->format_data->input.file = stdin;
     98                INPUT.file = stdin;
    9599#endif
    96100
    97101        } else {
    98                 if (stat(libtrace->format_data->conn_info.path,&buf) == -1 ) {
     102                if (stat(CONNINFO.path,&buf) == -1 ) {
    99103                        perror("stat");
    100104                        return 0;
    101105                }
    102106                if (S_ISSOCK(buf.st_mode)) {
     107                        libtrace->sourcetype = SOCKET;
    103108                        // SOCKET
    104                         if ((libtrace->format_data->input.fd = socket(
     109                        if ((INPUT.fd = socket(
    105110                                        AF_UNIX, SOCK_STREAM, 0)) == -1) {
    106111                                perror("socket");
     
    111116                        snprintf(unix_sock.sun_path,
    112117                                        108,"%s"
    113                                         ,libtrace->format_data->conn_info.path);
    114 
    115                         if (connect(libtrace->format_data->input.fd,
     118                                        ,CONNINFO.path);
     119
     120                        if (connect(INPUT.fd,
    116121                                        (struct sockaddr *)&unix_sock,
    117122                                        sizeof(struct sockaddr)) == -1) {
     
    121126                } else {
    122127                        // TRACE
     128                        libtrace->sourcetype = TRACE;
    123129#if HAVE_ZLIB
    124130                        // using gzdopen means we can set O_LARGEFILE
    125131                        // ourselves. However, this way is messy and
    126132                        // we lose any error checking on "open"
    127                         libtrace->format_data->input.file =
     133                        INPUT.file =
    128134                                gzdopen(open(
    129                                         libtrace->format_data->conn_info.path,
     135                                        CONNINFO.path,
    130136                                        O_LARGEFILE), "r");
    131137#else
    132                         libtrace->format_data->input.file =
     138                        INPUT.file =
    133139                                fdopen(open(
    134                                         libtrace->format_data->conn_info.path,
     140                                        CONNINFO.path,
    135141                                        O_LARGEFILE), "r");
    136142#endif
     
    142148static int wag_fin_input(struct libtrace_t *libtrace) {
    143149#if HAVE_ZLIB
    144         gzclose(libtrace->format_data->input.file);
     150        gzclose(INPUT.file);
    145151#else   
    146         fclose(libtrace->format_data->input.file);     
     152        fclose(INPUT.file);     
    147153#endif
    148154}
     
    161167                switch(libtrace->sourcetype) {
    162168                        case DEVICE:
    163                                 if ((numbytes=read(libtrace->format_data->input.fd,
     169                                if ((numbytes=read(INPUT.fd,
    164170                                                                buffer,
    165171                                                                len)) == -1) {
     
    170176                        default:
    171177#if HAVE_ZLIB
    172                                 if ((numbytes=gzread(libtrace->format_data->input.file,
     178                                if ((numbytes=gzread(INPUT.file,
    173179                                                                buffer,
    174180                                                                len)) == -1) {
     
    178184#else
    179185                                if ((numbytes=fread(buffer,len,1,
    180                                         libtrace->format_data->input.file)) == 0 ) {
    181                                         if(feof(libtrace->format_data->input.file)) {
     186                                        INPUT.file)) == 0 ) {
     187                                        if(feof(INPUT.file)) {
    182188                                                return 0;
    183189                                        }
    184                                         if(ferror(libtrace->format_data->input.file)) {
     190                                        if(ferror(INPUT.file)) {
    185191                                                perror("fread");
    186192                                                return -1;
     
    291297}
    292298
     299static int wag_get_fd(const struct libtrace_packet_t *packet) {
     300        return packet->trace->format_data->input.fd;
     301}
     302
     303static struct libtrace_eventobj_t wag_event_trace(struct libtrace_t *trace, struct libtrace_packet_t *packet) {
     304        switch(trace->sourcetype) {
     305                case DEVICE:
     306                        return trace_event_device(trace,packet);
     307                default:
     308                        return trace_event_trace(trace,packet);
     309        }
     310}
    293311static int wag_help() {
    294312        printf("wag format module: $Revision$\n");
     
    315333        wag_fin_input,                  /* fin_input */
    316334        NULL,                           /* fin_output */
    317         NULL,                           /* read */
    318335        wag_read_packet,                /* read_packet */
    319336        NULL,                           /* write_packet */
     
    328345        wag_get_wire_length,            /* get_wire_length */
    329346        NULL,                           /* set_capture_length */
     347        wag_get_fd,                     /* get_fd */
     348        wag_event_trace,                /* trace_event */
    330349        wag_help                        /* help */
    331350};
  • lib/libtrace_int.h

    r9e2a109 r72bfe20  
    8383        } packet;
    8484        double tdelta;
    85         double trace_start_ts;
    86         double real_start_ts;
     85//      double trace_start_ts;
     86//      double real_start_ts;
    8787        double trace_last_ts;
    8888
    89         double last_ts;
    90         double start_ts;
     89//      double last_ts;
     90//      double start_ts;
    9191};
    9292
     
    151151        int (*fin_input)(struct libtrace_t *libtrace);
    152152        int (*fin_output)(struct libtrace_out_t *libtrace);
    153         int (*read)(struct libtrace_t *libtrace, void *buffer, size_t len);
     153//      int (*read)(struct libtrace_t *libtrace, void *buffer, size_t len);
    154154        int (*read_packet)(struct libtrace_t *libtrace, struct libtrace_packet_t *packet);
    155155        int (*write_packet)(struct libtrace_out_t *libtrace, struct libtrace_packet_t *packet);
     
    164164        int (*get_wire_length)(const struct libtrace_packet_t *packet);
    165165        size_t (*truncate_packet)(const struct libtrace_packet_t *packet,size_t size);
     166        int (*get_fd)(struct libtrace_packet_t *packet);
     167        struct libtrace_eventobj_t (*trace_event)(struct libtrace_t *trace, struct libtrace_packet_t *packet); 
    166168        void (*help)();
    167169};
  • lib/trace.c

    ra114d8b5 r72bfe20  
    113113#endif
    114114
    115 #if HAVE_PCAP_H
    116 #  include <pcap.h>
    117 #  ifdef HAVE_PCAP_INT_H
    118 #    include <pcap-int.h>
    119 #  endif
    120 #endif
    121 
    122 #ifdef HAVE_ZLIB_H
    123 #  include <zlib.h>
    124 #endif
    125 
    126 
    127 #include "wag.h"
    128 
    129 #ifdef HAVE_DAG_API
    130 #  include "dagnew.h"
    131 #  include "dagapi.h"
    132 #else
    133 #  include "dagformat.h"
    134 #endif
     115//#if HAVE_PCAP_H
     116//#  include <pcap.h>
     117//#  ifdef HAVE_PCAP_INT_H
     118//#    include <pcap-int.h>
     119//#  endif
     120//#endif
     121
     122//#ifdef HAVE_ZLIB_H
     123//#  include <zlib.h>
     124//#endif
     125
     126
     127//#include "wag.h"
     128
     129//#ifdef HAVE_DAG_API
     130//#  include "dagnew.h"
     131//#  include "dagapi.h"
     132//#else
     133//#  include "dagformat.h"
     134//#endif
    135135
    136136#include "libtrace_int.h"
     137#include "format_helper.h"
    137138//#include "format/format_list.h"
    138139#include <err.h>
     
    977978        packet->trace = trace;
    978979
    979         /* Is there a packet ready? */
    980         switch (trace->sourcetype) {
    981 #if HAVE_PCAP
    982                 case INTERFACE:
    983                         {
    984                                 int data;
    985                                 // XXX FIXME
    986                                 //event.fd = pcap_fileno(trace->input.pcap);
    987                                 if(ioctl(event.fd,FIONREAD,&data)==-1){
    988                                         perror("ioctl(FIONREAD)");
    989                                 }
    990                                 if (data>0) {
    991                                         event.size = trace_read_packet(trace,packet);
    992                                         event.type = TRACE_EVENT_PACKET;
    993                                         return event;
    994                                 }
    995                                 event.type = TRACE_EVENT_IOWAIT;
    996                                 return event;
    997                         }
    998 #endif
    999                 case SOCKET:
    1000                 case DEVICE:
    1001                 case RT:
    1002                         {
    1003                                 int data;
    1004                                 // XXX FIXME
    1005                                 //event.fd = trace->input.fd;
    1006                                 if(ioctl(event.fd,FIONREAD,&data)==-1){
    1007                                         perror("ioctl(FIONREAD)");
    1008                                 }
    1009                                 if (data>0) {
    1010                                         event.size = trace_read_packet(trace,packet);
    1011                                         event.type = TRACE_EVENT_PACKET;
    1012                                         return event;
    1013                                 }
    1014                                 event.type = TRACE_EVENT_IOWAIT;
    1015                                 return event;
    1016                         }
    1017                 case STDIN:
    1018                 case TRACE:
    1019                         {
    1020                                 double ts;
    1021                                 double now;
    1022                                 struct timeval stv;
    1023                                 /* "Prime" the pump */
    1024                                 if (!trace->event.packet.buffer) {
    1025                                         trace->event.packet.buffer = malloc(4096);
    1026                                         trace->event.packet.size=
    1027                                                 trace_read_packet(trace,packet);
    1028                                         event.size = trace->event.packet.size;
    1029                                         if (trace->event.packet.size > 0 ) {
    1030                                                 memcpy(trace->event.packet.buffer,packet->buffer,trace->event.packet.size);
    1031                                         } else {
    1032                                                 // return here, the test for event.size will sort out the error
    1033                                                 event.type = TRACE_EVENT_PACKET;
    1034                                                 return event;
    1035                                         }
    1036                                 }
    1037 
    1038                                 ts=trace_get_seconds(packet);
    1039                                 if (trace->event.tdelta!=0) {
    1040                                         // Get the adjusted current time
    1041                                         gettimeofday(&stv, NULL);
    1042                                         now = stv.tv_sec + ((double)stv.tv_usec / 1000000.0);
    1043                                         now -= trace->event.tdelta; // adjust for trace delta
    1044                                        
    1045                                        
    1046                                         // if the trace timestamp is still in the future,
    1047                                         // return a SLEEP event, otherwise fire the packet
    1048                                         if (ts > now) {
    1049                                                 event.seconds = ts - trace->event.trace_last_ts;
    1050                                                 event.type = TRACE_EVENT_SLEEP;
    1051                                                 return event;
    1052                                         }
    1053                                 } else {
    1054                                         gettimeofday(&stv, NULL);
    1055                                         // work out the difference between the start of trace replay,
    1056                                         // and the first packet in the trace
    1057                                         trace->event.tdelta = stv.tv_sec + ((double)stv.tv_usec / 1000000.0);
    1058                                         trace->event.tdelta -= ts;
    1059 
    1060                                 }
    1061                                
    1062                                         // This is the first packet, so just fire away.
    1063                                 packet->size = trace->event.packet.size;
    1064                                 memcpy(packet->buffer,trace->event.packet.buffer,trace->event.packet.size);
    1065 
    1066                                 free(trace->event.packet.buffer);
    1067                                 trace->event.packet.buffer = 0;
    1068                                 event.type = TRACE_EVENT_PACKET;
    1069                                
    1070                                 trace->event.trace_last_ts = ts;
    1071 
    1072                                 return event;
    1073                         }
    1074                 default:
    1075                         assert(0);
    1076         }
    1077         assert(0);
     980        if (packet->trace->format->trace_event) {
     981                return packet->trace->format->trace_event(trace,packet);
     982        } else {
     983                return event;
     984        }
     985
    1078986}
    1079987
Note: See TracChangeset for help on using the changeset viewer.