Changeset 1974620 for lib/format_erf.c


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.

File:
1 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}
Note: See TracChangeset for help on using the changeset viewer.