Changeset 9e2a109 for lib/trace.c


Ignore:
Timestamp:
08/04/05 15:37:08 (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:
ef55d05
Parents:
fe43699
Message:

moved format.h to libtrace_int.h

pulled out all the format-specific libtrace_t stuff into an opaque pointer which is defined inside each format_*.o file, for both input and output

This seems to work, it compiles at least, and wag and erf both work

rtclient input is currently broken, I suspect it's not stepping over the status properly

File:
1 edited

Legend:

Unmodified
Added
Removed
  • lib/trace.c

    rfe43699 r9e2a109  
    102102#include "libtrace.h"
    103103#include "fifo.h"
    104 #include "format.h"
     104#include "libtrace_int.h"
    105105#include "parse_cmd.h"
    106106
     
    134134#endif
    135135
    136 #include "format.h"
     136#include "libtrace_int.h"
    137137//#include "format/format_list.h"
    138138#include <err.h>
     
    157157#endif
    158158
    159 struct format_t **format_list = 0;
     159struct libtrace_format_t **format_list = 0;
    160160int format_size = 0;
    161161int nformats = 0;
    162162
    163 void register_format(struct format_t *f) {
     163void register_format(struct libtrace_format_t *f) {
    164164        fprintf(stderr,"Registering input format %s\n",f->name);
    165165        if (format_list == 0) {
    166166                format_size = 10;
    167                 format_list = malloc(sizeof(struct format_t *) * format_size);
     167                format_list = malloc(sizeof(struct libtrace_format_t *) * format_size);
    168168        } else if (format_size == nformats) {
    169169                format_size = format_size + 10;
    170170                format_list = realloc(format_list,
    171                                 sizeof(struct format_t *) * format_size);
     171                                sizeof(struct libtrace_format_t *) * format_size);
    172172        }
    173173        format_list[nformats] = f;
     
    192192
    193193#define RP_BUFSIZE 65536
    194 
    195194#define URI_PROTO_LINE 16
    196 static int init_trace(struct libtrace_t **libtrace, char *uri) {
    197         char *scan = calloc(sizeof(char),URI_PROTO_LINE);
    198         char *uridata = 0;                 
    199         int i = 0;
    200         struct stat buf;
    201        
    202         // parse the URI to determine what sort of event we are dealing with
    203        
    204         // want snippet before the : to get the uri base type.
    205 
    206         if((uridata = strchr(uri,':')) == NULL) {
    207                 // badly formed URI - needs a :
    208                 return 0;
    209         }
    210 
    211         if ((*uridata - *uri) > URI_PROTO_LINE) {
    212                 // badly formed URI - uri type is too long
    213                 return 0;
    214         }
    215         strncpy(scan,uri, (uridata - uri));
    216 
    217         (*libtrace)->tdelta = 0.0;
    218 
    219 
    220         (*libtrace)->format = 0;
    221         for (i = 0; i < nformats; i++) {
    222                 if (strlen(scan) == strlen(format_list[i]->name) &&
    223                                 !strncasecmp(scan,
    224                                         format_list[i]->name,
    225                                         strlen(scan))) {
    226                                 (*libtrace)->format=format_list[i];
    227                                 break;
    228                                 }
    229         }
    230         if ((*libtrace)->format == 0) {
    231                 fprintf(stderr,
    232                         "libtrace has no support for this format (%s)\n",scan);
    233                 return 0;
    234         }
    235 
    236         // push uridata past the delimiter
    237         uridata++;
    238         (*libtrace)->conn_info.path = strdup(uridata);
    239 
    240         // libtrace->format now contains the type of uri
    241         // libtrace->uridata contains the appropriate data for this
    242        
    243         if ((*libtrace)->format->init_input) {
    244                 (*libtrace)->format->init_input( (*libtrace));
    245         } else {
    246                 fprintf(stderr,
    247                         "No init function for format %s\n",scan);
    248                 return 0;
    249         }
    250        
    251 
    252         (*libtrace)->fifo = create_fifo(1048576);
    253         assert( (*libtrace)->fifo);
    254         //(*libtrace)->packet.buffer = 0;
    255         //(*libtrace)->packet.size = 0;
    256 
    257         return 1;
    258 }
    259195
    260196/** Initialises the data contained within the libtrace_out_t structure, based on the provided uri.
     
    354290struct libtrace_t *trace_create(char *uri) {
    355291        struct libtrace_t *libtrace = malloc(sizeof(struct libtrace_t));
    356 
    357         if(init_trace(&libtrace,uri) == 0) {
     292        char *scan = calloc(sizeof(char),URI_PROTO_LINE);
     293        char *uridata = 0;                 
     294        int i = 0;
     295        struct stat buf;
     296       
     297        // parse the URI to determine what sort of event we are dealing with
     298       
     299        // want snippet before the : to get the uri base type.
     300
     301        if((uridata = strchr(uri,':')) == NULL) {
     302                // badly formed URI - needs a :
    358303                return 0;
    359304        }
    360        
     305
     306        if ((*uridata - *uri) > URI_PROTO_LINE) {
     307                // badly formed URI - uri type is too long
     308                return 0;
     309        }
     310        strncpy(scan,uri, (uridata - uri));
     311
     312        libtrace->event.tdelta = 0.0;
     313
     314
     315        libtrace->format = 0;
     316        for (i = 0; i < nformats; i++) {
     317                if (strlen(scan) == strlen(format_list[i]->name) &&
     318                                !strncasecmp(scan,
     319                                        format_list[i]->name,
     320                                        strlen(scan))) {
     321                                libtrace->format=format_list[i];
     322                                break;
     323                                }
     324        }
     325        if (libtrace->format == 0) {
     326                fprintf(stderr,
     327                        "libtrace has no support for this format (%s)\n",scan);
     328                return 0;
     329        }
     330
     331        // push uridata past the delimiter
     332        uridata++;
     333        libtrace->uridata = strdup(uridata);
     334
     335        // libtrace->format now contains the type of uri
     336        // libtrace->uridata contains the appropriate data for this
     337       
     338        if (libtrace->format->init_input) {
     339                libtrace->format->init_input( libtrace);
     340        } else {
     341                fprintf(stderr,
     342                        "No init function for format %s\n",scan);
     343                return 0;
     344        }
     345       
     346
     347        libtrace->fifo = create_fifo(1048576);
     348        assert( libtrace->fifo);
     349
    361350        return libtrace;
    362351}
     
    958947                        {
    959948                                int data;
    960                                 event.fd = pcap_fileno(trace->input.pcap);
     949                                // XXX FIXME
     950                                //event.fd = pcap_fileno(trace->input.pcap);
    961951                                if(ioctl(event.fd,FIONREAD,&data)==-1){
    962952                                        perror("ioctl(FIONREAD)");
     
    976966                        {
    977967                                int data;
    978                                 event.fd = trace->input.fd;
     968                                // XXX FIXME
     969                                //event.fd = trace->input.fd;
    979970                                if(ioctl(event.fd,FIONREAD,&data)==-1){
    980971                                        perror("ioctl(FIONREAD)");
     
    995986                                struct timeval stv;
    996987                                /* "Prime" the pump */
    997                                 if (!trace->packet.buffer) {
    998                                         trace->packet.buffer = malloc(4096);
    999                                         trace->packet.size=
     988                                if (!trace->event.packet.buffer) {
     989                                        trace->event.packet.buffer = malloc(4096);
     990                                        trace->event.packet.size=
    1000991                                                trace_read_packet(trace,packet);
    1001                                         event.size = trace->packet.size;
    1002                                         if (trace->packet.size > 0 ) {
    1003                                                 memcpy(trace->packet.buffer,packet->buffer,trace->packet.size);
     992                                        event.size = trace->event.packet.size;
     993                                        if (trace->event.packet.size > 0 ) {
     994                                                memcpy(trace->event.packet.buffer,packet->buffer,trace->event.packet.size);
    1004995                                        } else {
    1005996                                                // return here, the test for event.size will sort out the error
     
    10101001
    10111002                                ts=trace_get_seconds(packet);
    1012                                 if (trace->tdelta!=0) {
     1003                                if (trace->event.tdelta!=0) {
    10131004                                        // Get the adjusted current time
    10141005                                        gettimeofday(&stv, NULL);
    10151006                                        now = stv.tv_sec + ((double)stv.tv_usec / 1000000.0);
    1016                                         now -= trace->tdelta; // adjust for trace delta
     1007                                        now -= trace->event.tdelta; // adjust for trace delta
    10171008                                       
    10181009                                       
     
    10201011                                        // return a SLEEP event, otherwise fire the packet
    10211012                                        if (ts > now) {
    1022                                                 event.seconds = ts - trace->trace_last_ts;
     1013                                                event.seconds = ts - trace->event.trace_last_ts;
    10231014                                                event.type = TRACE_EVENT_SLEEP;
    10241015                                                return event;
     
    10281019                                        // work out the difference between the start of trace replay,
    10291020                                        // and the first packet in the trace
    1030                                         trace->tdelta = stv.tv_sec + ((double)stv.tv_usec / 1000000.0);
    1031                                         trace->tdelta -= ts;
     1021                                        trace->event.tdelta = stv.tv_sec + ((double)stv.tv_usec / 1000000.0);
     1022                                        trace->event.tdelta -= ts;
    10321023
    10331024                                }
    10341025                               
    10351026                                        // This is the first packet, so just fire away.
    1036                                 packet->size = trace->packet.size;
    1037                                 memcpy(packet->buffer,trace->packet.buffer,trace->packet.size);
    1038 
    1039                                 free(trace->packet.buffer);
    1040                                 trace->packet.buffer = 0;
     1027                                packet->size = trace->event.packet.size;
     1028                                memcpy(packet->buffer,trace->event.packet.buffer,trace->event.packet.size);
     1029
     1030                                free(trace->event.packet.buffer);
     1031                                trace->event.packet.buffer = 0;
    10411032                                event.type = TRACE_EVENT_PACKET;
    10421033                               
    1043                                 trace->trace_last_ts = ts;
     1034                                trace->event.trace_last_ts = ts;
    10441035
    10451036                                return event;
Note: See TracChangeset for help on using the changeset viewer.