Changeset 1974620 for lib


Ignore:
Timestamp:
08/25/05 20:01:13 (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:
b5cd711
Parents:
3073c04
Message:

added format conversion into pcap and erf formats, and have tested the writers for these formats.

Added a 'type' field to the format_t structure, which specifies the type of trace we're dealing with - erf, pcap, wag.

updated munge to use the new functions.

Location:
lib
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • lib/format_erf.c

    r3073c04 r1974620  
    6464#endif
    6565
     66static struct libtrace_format_t *erf_ptr = 0;
     67static struct libtrace_format_t *rtclient_ptr = 0;
     68#if HAVE_DAG
     69static struct libtrace_format_t *dag_ptr = 0;
     70#endif
     71
    6672#define CONNINFO libtrace->format_data->conn_info
    6773#define INPUT libtrace->format_data->input
    6874#define OUTPUT libtrace->format_data->output
     75#if HAVE_DAG
    6976#define DAG libtrace->format_data->dag
     77#endif
    7078#define OPTIONS libtrace->format_data->options
    7179struct libtrace_format_data_t {
    7280        union {
    73                 /** Information about rtclients */
    7481                struct {
    7582                        char *hostname;
    7683                        short port;
    7784                } rt;
    78                 char *path;             /**< information for local sockets */
     85                char *path;             
    7986        } conn_info;
    80         /** Information about the current state of the input device */
    81         union {
     87       
     88        union {
    8289                int fd;
    8390#if HAVE_ZLIB
     
    8895        } input;
    8996
     97#if HAVE_DAG
    9098        struct {
    9199                void *buf;
     
    96104                unsigned offset;
    97105        } dag;
     106#endif
    98107};
    99108
     
    452461        int rlen;
    453462       
    454         if (libtrace->dag.diff == 0) {
     463        if (DAG.diff == 0) {
    455464                if ((numbytes = dag_read(libtrace,buf,RP_BUFSIZE)) <= 0)
    456465                        return numbytes;
     
    458467
    459468        //DAG always gives us whole packets
    460         erfptr = (dag_record_t *) ((void *)libtrace->dag.buf +
    461                         (libtrace->dag.bottom + libtrace->dag.offset));
     469        erfptr = (dag_record_t *) ((void *)DAG.buf +
     470                        (DAG.bottom + DAG.offset));
    462471        size = ntohs(erfptr->rlen);
    463472
     
    471480
    472481        packet->size = size;
    473         libtrace->dag.offset += size;
    474         libtrace->dag.diff -= size;
    475 
    476         assert(libtrace->dag.diff >= 0);
     482        DAG.offset += size;
     483        DAG.diff -= size;
     484
     485        assert(DAG.diff >= 0);
    477486
    478487        return (size);
     
    606615}
    607616
     617static int erf_dump_packet(struct libtrace_out_t *libtrace, dag_record_t *erfptr, void *buffer, size_t size) {
     618        int numbytes = 0;
     619#if HAVE_ZLIB
     620        if ((numbytes = gzwrite(OUTPUT.file, erfptr, sizeof(dag_record_t))) == 0) {
     621                perror("gzwrite");
     622                return -1;
     623        }
     624        if ((numbytes = gzwrite(OUTPUT.file, buffer, size)) == 0) {
     625                perror("gzwrite");
     626                return -1;
     627        }
     628#else
     629        if ((numbytes = write(OUTPUT.file, erfptr, sizeof(dag_record_t))) == 0) {
     630                perror("write");
     631                return -1;
     632        }
     633        if ((numbytes = write(OUTPUT.file, buffer, size)) == 0) {
     634                perror("write");
     635                return -1;
     636        }
     637#endif
     638        return numbytes + sizeof(dag_record_t);
     639
     640}
     641               
    608642static int erf_write_packet(struct libtrace_out_t *libtrace, struct libtrace_packet_t *packet) {
    609643        int numbytes = 0;
    610 #if HAVE_ZLIB
    611         if ((numbytes = gzwrite(OUTPUT.file, packet->buffer, packet->size)) == 0) {
    612                 perror("gzwrite");
    613                 return -1;
    614         }
    615 #else
    616         if ((numbytes = write(OUTPUT.file, packet->buffer, packet->size)) == 0) {
    617                 perror("write");
    618                 return -1;
    619         }
    620 #endif
     644        dag_record_t erfhdr;
     645        void *payload = (void *)trace_get_link(packet);
     646
     647        if (packet->trace->format == erf_ptr
     648#if HAVE_DAG
     649                        || packet->trace->format == dag_ptr
     650#endif
     651                        ) {
     652                numbytes = erf_dump_packet(libtrace,
     653                                (dag_record_t *)packet->buffer,
     654                                payload,
     655                                packet->size -
     656                                        sizeof(dag_record_t));
     657        } else {
     658                // convert format - build up a new erf header
     659                // Timestamp
     660                erfhdr.ts = trace_get_erf_timestamp(packet);
     661                // Link type
     662                switch(trace_get_link_type(packet)) {
     663                case TRACE_TYPE_ETH:
     664                        erfhdr.type=TYPE_ETH; break;
     665                case TRACE_TYPE_ATM:
     666                        erfhdr.type=TYPE_ATM; break;
     667                default:
     668                        erfhdr.type=0;
     669                }
     670                // Flags. Can't do this
     671                memset(&erfhdr.flags,1,1);
     672                // Packet length
     673                erfhdr.rlen = trace_get_capture_length(packet);
     674                // loss counter. Can't do this
     675                erfhdr.lctr = 0;
     676                // Wire length
     677                erfhdr.wlen = trace_get_wire_length(packet);
     678               
     679                // Write it out
     680                numbytes = erf_dump_packet(libtrace,
     681                                &erfhdr,
     682                                payload,
     683                                erfhdr.rlen);
     684        }
    621685        return numbytes;
    622686}
     
    751815}
    752816
     817#if HAVE_DAG
    753818static void dag_help() {
    754819        printf("dag format module: $Revision$\n");
     
    761826        printf("\tnone\n");
    762827        printf("\n");
    763 
    764 }
     828}
     829#endif
     830
    765831
    766832static void erf_help() {
     
    812878        "erf",
    813879        "$Id$",
     880        "erf",
    814881        erf_init_input,                 /* init_input */       
    815882        erf_init_output,                /* init_output */
     
    838905        "dag",
    839906        "$Id$",
     907        "erf",
    840908        dag_init_input,                 /* init_input */       
    841909        NULL,                           /* init_output */
     
    864932        "rtclient",
    865933        "$Id$",
     934        "erf",
    866935        rtclient_init_input,            /* init_input */       
    867936        rtclient_init_output,           /* init_output */
     
    887956
    888957void __attribute__((constructor)) erf_constructor() {
    889         register_format(&erf);
     958        erf_ptr = &erf;
     959        register_format(erf_ptr);
    890960#ifdef HAVE_DAG
    891         register_format(&dag);
    892 #endif
    893         register_format(&rtclient);
    894 }
     961        dag_ptr = &dag;
     962        register_format(dag_ptr);
     963#endif
     964        rtclient_ptr = &rtclient;
     965        register_format(rtclient_ptr);
     966}
  • lib/format_pcap.c

    r3073c04 r1974620  
    8787                char *interface;
    8888        } conn_info;
    89         struct {
    90                 pcap_t *pcap;
    91                 pcap_dumper_t *dump;
     89        union {
     90                struct {
     91                        pcap_t *pcap;
     92                        pcap_dumper_t *dump;
     93                } trace;
     94
    9295        } output;
    9396};
     
    159162                malloc(sizeof(struct libtrace_format_data_out_t));
    160163        CONNINFO.path = libtrace->uridata;
    161         OUTPUT.pcap = NULL;
    162         OUTPUT.dump = NULL;
     164        OUTPUT.trace.pcap = NULL;
     165        OUTPUT.trace.dump = NULL;
     166        return 1;
    163167}
    164168
     
    181185}
    182186
     187static int pcapint_init_output(struct libtrace_out_t *libtrace) {
     188        return -1;
     189}
     190
    183191static int pcap_fin_input(struct libtrace_t *libtrace) {
    184192        pcap_close(INPUT.pcap);
     
    188196
    189197static int pcap_fin_output(struct libtrace_out_t *libtrace) {
    190         pcap_dump_flush(OUTPUT.dump);
    191         pcap_dump_close(OUTPUT.dump);
     198        pcap_dump_flush(OUTPUT.trace.dump);
     199        pcap_dump_close(OUTPUT.trace.dump);
    192200        return 0;
     201}
     202
     203static int pcapint_fin_output(struct libtrace_out_t *libtrace) {
     204        return -1;
    193205}
    194206
     
    224236        void *link = trace_get_link(packet);
    225237
    226         if (!OUTPUT.pcap) {
    227                 OUTPUT.pcap = pcap_open_dead(
     238        if (!OUTPUT.trace.pcap) {
     239                OUTPUT.trace.pcap = pcap_open_dead(
    228240                                linktype_to_dlt(trace_get_link_type(packet)),
    229241                                65536);
    230                 OUTPUT.dump = pcap_dump_open(OUTPUT.pcap,CONNINFO.path);
    231                 fflush((FILE *)OUTPUT.dump);
     242                OUTPUT.trace.dump = pcap_dump_open(OUTPUT.trace.pcap,CONNINFO.path);
     243                fflush((FILE *)OUTPUT.trace.dump);
    232244        }
    233245        if (packet->trace->format == pcap_ptr ||
     
    236248                // this is a pcap trace anyway
    237249               
    238                 pcap_dump((u_char*)OUTPUT.dump,(struct pcap_pkthdr *)packet->buffer,link);
     250                pcap_dump((u_char*)OUTPUT.trace.dump,(struct pcap_pkthdr *)packet->buffer,link);
    239251        } else {
    240252                pcap_pkt_hdr.ts = trace_get_timeval(packet);
     
    242254                pcap_pkt_hdr.len = trace_get_wire_length(packet);
    243255
    244                 pcap_dump((u_char*)OUTPUT.pcap, &pcap_pkt_hdr, link);
     256                pcap_dump((u_char*)OUTPUT.trace.dump, &pcap_pkt_hdr, link);
    245257        }
    246258        return 0;
     259}
     260
     261static int pcapint_write_packet(struct libtrace_out_t *libtrace, struct libtrace_packet_t *packet) {
     262        void *link = trace_get_link(packet);
     263
    247264}
    248265
     
    393410        "pcap",
    394411        "$Id$",
     412        "pcap",
    395413        pcap_init_input,                /* init_input */
    396414        pcap_init_output,               /* init_output */
     
    418436        "pcapint",
    419437        "$Id$",
     438        "pcap",
    420439        pcapint_init_input,             /* init_input */
    421         NULL,                           /* init_output */
     440        pcapint_init_output,            /* init_output */
    422441        NULL,                           /* config_output */
    423442        pcap_fin_input,                 /* fin_input */
    424         NULL,                           /* fin_output */
     443        pcapint_fin_output,             /* fin_output */
    425444        pcap_read_packet,               /* read_packet */
    426         NULL,                           /* write_packet */
     445        pcapint_write_packet,           /* write_packet */
    427446        pcap_get_link,                  /* get_link */
    428447        pcap_get_link_type,             /* get_link_type */
  • lib/format_template.c

    rffc8c8d r1974620  
    124124        "template",
    125125        "$Id$",
     126        "template",
    126127        template_init_input,            /* init_input */
    127128        template_init_output,           /* init_output */
  • lib/format_wag.c

    r3073c04 r1974620  
    444444        "wag",
    445445        "$Id$",
     446        "wag",
    446447        wag_init_input,                 /* init_input */       
    447448        wag_init_output,                /* init_output */
  • lib/libtrace_int.h

    rffc8c8d r1974620  
    153153        char *name;
    154154        char *version;
     155        char *type;
    155156        int (*init_input)(struct libtrace_t *libtrace);
    156157        int (*init_output)(struct libtrace_out_t *libtrace);
     
    158159        int (*fin_input)(struct libtrace_t *libtrace);
    159160        int (*fin_output)(struct libtrace_out_t *libtrace);
    160 //      int (*read)(struct libtrace_t *libtrace, void *buffer, size_t len);
    161161        int (*read_packet)(struct libtrace_t *libtrace, struct libtrace_packet_t *packet);
    162162        int (*write_packet)(struct libtrace_out_t *libtrace, struct libtrace_packet_t *packet);
     
    170170        int (*get_capture_length)(const struct libtrace_packet_t *packet);
    171171        int (*get_wire_length)(const struct libtrace_packet_t *packet);
    172         size_t (*truncate_packet)(const struct libtrace_packet_t *packet,size_t size);
     172        size_t (*truncate_packet)(struct libtrace_packet_t *packet,size_t size);
    173173        int (*get_fd)(struct libtrace_packet_t *packet);
    174174        struct libtrace_eventobj_t (*trace_event)(struct libtrace_t *trace, struct libtrace_packet_t *packet); 
  • lib/trace.c

    re01bfa8 r1974620  
    794794                // seconds -> timestamp
    795795                seconds = packet->trace->format->get_seconds(packet);
    796                 timestamp = (((uint32_t)seconds) << 32) + \
     796                timestamp = ((uint64_t)((uint32_t)seconds) << 32) + \
    797797                            (( seconds - (uint32_t)seconds   ) * UINT_MAX);
    798798        }
Note: See TracChangeset for help on using the changeset viewer.