Changeset cd7eec7


Ignore:
Timestamp:
05/16/06 14:37:22 (15 years ago)
Author:
Shane Alcock <salcock@…>
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:
abc66e7
Parents:
da34e20
Message:

Added a new format for reading and writing DUCK packets
Added corresponding test cases for DUCK
Removed references to RT_DUCK_* from format_rt
Added a configuration option for meta-data frequency (used solely for DUCK frequency at the moment) and updated other formats to ignore the option

Files:
2 added
12 edited

Legend:

Unmodified
Added
Removed
  • lib/Makefile.am

    re5f1431 rcd7eec7  
    77                format_rt.c format_helper.c format_helper.h format_pcapfile.c \
    88                parse_cmd.c parse_cmd.h libtrace_int.h lt_inttypes.h \
    9                 linktypes.c protocols.c libtraceio.h
     9                linktypes.c protocols.c libtraceio.h format_duck.c
    1010if HAVE_NETPACKET_PACKET_H
    1111libtrace_la_SOURCES+=format_linux.c
  • lib/format_erf.c

    rda34e20 rcd7eec7  
    104104                uint32_t duck_freq;
    105105                uint32_t last_pkt;
    106                 libtrace_t *dummy_rt;
     106                libtrace_t *dummy_duck;
    107107        } duck;
    108108       
     
    183183
    184184        DUCK.last_duck = 0;
    185         DUCK.duck_freq = 60;  /** 5 minutes */
     185        DUCK.duck_freq = 0; 
    186186        DUCK.last_pkt = 0;
    187         DUCK.dummy_rt = NULL;
     187        DUCK.dummy_duck = NULL;
    188188       
    189189        return 0;
    190190}
    191191
     192static int dag_config_input(libtrace_t *libtrace, trace_option_t option,
     193                                void *data) {
     194        switch(option) {
     195                case TRACE_META_FREQ:
     196                        DUCK.duck_freq = *(int *)data;
     197                        return 0;
     198                case TRACE_OPTION_SNAPLEN:
     199                        /* Surely we can set this?? Fall through for now*/
     200               
     201                case TRACE_OPTION_PROMISC:
     202                        /* DAG already operates in a promisc fashion */
     203
     204                case TRACE_OPTION_FILTER:
     205
     206                default:
     207                        trace_set_err(libtrace, TRACE_ERR_UNKNOWN_OPTION,
     208                                        "Unknown or unsupported option: %i",
     209                                        option);
     210                        return -1;
     211        }
     212        assert (0);
     213}
    192214#endif
    193215
     
    436458        /* dag pause input implicitly called to cleanup before this */
    437459        dag_close(INPUT.fd);
    438         if (DUCK.dummy_rt)
    439                 trace_destroy_dead(DUCK.dummy_rt);
     460        if (DUCK.dummy_duck)
     461                trace_destroy_dead(DUCK.dummy_duck);
    440462        free(libtrace->format_data);
    441463        return 0; /* success */
     
    500522        packet->type = RT_DUCK_2_4;
    501523        packet->size = sizeof(duck_inf);
    502         if (!DUCK.dummy_rt)
    503                 DUCK.dummy_rt = trace_create_dead("rt:localhost:3434");
    504         packet->trace = DUCK.dummy_rt; 
     524        if (!DUCK.dummy_duck)
     525                DUCK.dummy_duck = trace_create_dead("duck:dummy");
     526        packet->trace = DUCK.dummy_duck;
     527        return packet->size;
    505528}       
    506529#else
     
    541564        packet->type = RT_DUCK_2_5;
    542565        packet->size = sizeof(duckinf_t);
    543         if (!DUCK.dummy_rt)
    544                 DUCK.dummy_rt = trace_create_dead("rt:localhost:3434");
    545         packet->trace = DUCK.dummy_rt; 
     566        if (!DUCK.dummy_duck)
     567                DUCK.dummy_duck = trace_create_dead("rt:localhost:3434");
     568        packet->trace = DUCK.dummy_duck;       
     569        return packet->size;
    546570}       
    547571#endif
     
    843867        assert(OUTPUT.file);
    844868
     869        if (!packet->header) {
     870                //trace_set_err_output(libtrace, TRACE_ERR_BAD_PACKET,
     871                //              "Packet has no header - probably an RT packet");
     872                return -1;
     873        }
     874       
    845875        pad = erf_get_padding(packet);
    846876
     
    10651095        TRACE_FORMAT_ERF,
    10661096        dag_init_input,                 /* init_input */       
    1067         NULL,                           /* config_input */
     1097        dag_config_input,               /* config_input */
    10681098        dag_start_input,                /* start_input */
    10691099        dag_pause_input,                /* pause_input */
  • lib/format_linux.c

    r431548c5 rcd7eec7  
    188188                         * emulating it
    189189                         */
     190                        break;
     191                case TRACE_META_FREQ:
     192                        /* No meta-data for this format */
    190193                        break;
    191194                /* Avoid default: so that future options will cause a warning
  • lib/format_pcap.c

    rda34e20 rcd7eec7  
    138138                case TRACE_OPTION_PROMISC:
    139139                        /* can't do promisc on a trace! fall thru */
     140                case TRACE_META_FREQ:
     141                        /* No meta data for this format */
    140142                default:
    141143                        trace_set_err(libtrace,TRACE_ERR_UNKNOWN_OPTION,
     
    195197                        DATA(libtrace)->promisc=*(int*)data;
    196198                        return 0;
     199                case TRACE_META_FREQ:
     200                        /* No meta-data for this format */
    197201                default:
    198202                        trace_set_err(libtrace,TRACE_ERR_UNKNOWN_OPTION,
  • lib/format_rt.c

    rda34e20 rcd7eec7  
    8484        int buf_filled;
    8585
    86        
     86        libtrace_t *dummy_duck;
    8787        libtrace_t *dummy_erf;
    8888        libtrace_t *dummy_pcap;
     
    192192        libtrace->format_data = malloc(sizeof(struct rt_format_data_t));
    193193
     194        RT_INFO->dummy_duck = NULL;
    194195        RT_INFO->dummy_erf = NULL;
    195196        RT_INFO->dummy_pcap = NULL;
     
    252253       
    253254        }
     255        if (RT_INFO->dummy_duck)
     256                trace_destroy_dead(RT_INFO->dummy_duck);
     257
    254258        if (RT_INFO->dummy_erf)
    255259                trace_destroy_dead(RT_INFO->dummy_erf);
     
    360364
    361365        switch (packet->type) {
     366                case RT_DUCK_2_4:
     367                case RT_DUCK_2_5:
     368                        if (!RT_INFO->dummy_duck) {
     369                                RT_INFO->dummy_duck = trace_create_dead("duck:dummy");
     370                        }
     371                        packet->trace = RT_INFO->dummy_duck;
     372                        break;
    362373                case RT_DATA_ERF:
    363374                        if (!RT_INFO->dummy_erf) {
     
    375386                case RT_DATA_LEGACY_ATM:
    376387                case RT_DATA_LEGACY_POS:
     388                case RT_DATA_LINUX_NATIVE:
    377389                        printf("Sending legacy over RT is currently not supported\n");
    378390                        trace_set_err(libtrace, TRACE_ERR_BAD_PACKET, "Legacy packet cannot be sent over rt");
     
    502514                switch(packet->type) {
    503515                        case RT_STATUS:
    504                         case RT_DUCK:
    505516                                if (rt_read(libtrace, &packet->buffer,
    506517                                                        pkt_size,1) !=
    507518                                                pkt_size) {
    508519                                        printf("Error receiving status packet\n");
     520                                        return -1;
     521                                }
     522                                packet->header = 0;
     523                                packet->payload = packet->buffer;
     524                                break;
     525                        case RT_DUCK_2_4:
     526                        case RT_DUCK_2_5:
     527                                if (rt_read(libtrace, &packet->buffer,
     528                                                        pkt_size, 1) !=
     529                                                pkt_size) {
     530                                        printf("Error receiving DUCK packet\n");
     531                                        return -1;
     532                                }
     533                                if (rt_set_format(libtrace, packet) < 0) {
    509534                                        return -1;
    510535                                }
     
    525550                                printf("Bad rt type for client receipt: %d\n",
    526551                                        packet->type);
     552                                return -1;
    527553                }
    528554        }
     
    539565static int rt_get_capture_length(const libtrace_packet_t *packet) {
    540566        switch (packet->type) {
    541                 case RT_DUCK_2_4:
    542                         return sizeof(duck2_4_t);
    543                 case RT_DUCK_2_5:
    544                         return sizeof(duck2_5_t);
    545567                case RT_STATUS:
    546568                        return sizeof(rt_status_t);
  • lib/libtrace.h.in

    r83445f0 rcd7eec7  
    533533        TRACE_OPTION_SNAPLEN, /**< Number of bytes captured */
    534534        TRACE_OPTION_PROMISC, /**< Capture packets to other hosts */
    535         TRACE_OPTION_FILTER   /**< Apply this filter to all packets recieved */
     535        TRACE_OPTION_FILTER,  /**< Apply this filter to all packets recieved */
     536        TRACE_META_FREQ       /**< Frequency of meta-data information, e.g. DUCK packets */
    536537} trace_option_t;
    537538
     
    12181219        TRACE_FORMAT_LEGACY_POS   =7,
    12191220        TRACE_FORMAT_LEGACY_ETH   =8,
    1220         TRACE_FORMAT_LINUX_NATIVE =9
     1221        TRACE_FORMAT_LINUX_NATIVE =9,
     1222        TRACE_FORMAT_DUCK         =10
    12211223};
    12221224
  • lib/rt_protocol.h

    rda34e20 rcd7eec7  
    219219} duck2_5_t;
    220220
     221/*
    221222typedef struct rt_duck_2_4 {
    222223        duck2_4_t duck;
     
    226227        duck2_5_t duck;
    227228} rt_duck_2_5_t;
    228 
    229 #endif
     229*/
     230
     231#endif
  • lib/trace.c

    r83445f0 rcd7eec7  
    220220{
    221221        if (!formats_list) {
     222                duck_constructor();
    222223                erf_constructor();
    223224                legacy_constructor();
     
    535536                        trace_set_err(libtrace,TRACE_ERR_OPTION_UNAVAIL,
    536537                                "Promisc mode is not supported by this format module");
     538                        return -1;
     539                case TRACE_META_FREQ:
     540                        trace_set_err(libtrace, TRACE_ERR_OPTION_UNAVAIL,
     541                                "This format does not support meta-data gathering");
    537542                        return -1;
    538543        }
  • test/Makefile

    raf1e721 rcd7eec7  
    2525
    2626test-format-all: test-format
    27         @for i in erf pcap wtf pcapfile; do                     \
     27        @for i in erf pcap wtf pcapfile duck; do                        \
    2828                echo \* $$i;                                    \
    2929                LD_LIBRARY_PATH=$(libdir)                       \
     
    4242        @LD_LIBRARY_PATH=$(libdir) ./test-convert wtf pcap
    4343        @LD_LIBRARY_PATH=$(libdir) ./test-convert wtf wtf
     44        @LD_LIBRARY_PATH=$(libdir) ./test-convert duck duck
    4445 
    4546clean:
  • test/test-convert.c

    r8f851f3 rcd7eec7  
    8080        if (!strcmp(type,"pcapfile"))
    8181                return "pcapfile:traces/100_packets.pcap";
     82        if (!strcmp(type, "duck"))
     83                return "duck:traces/100_packets.duck";
    8284        return "unknown";
    8385}
     
    9092        if (!strcmp(type,"wtf"))
    9193                return "wtf:traces/wed.out.wtf";
     94        if (!strcmp(type,"duck"))
     95                return "duck:traces/100_packets.out.duck";
    9296        return "unknown";
    9397}
  • test/test-format.c

    r8f851f3 rcd7eec7  
    7171        if (!strcmp(type,"pcapfile"))
    7272                return "pcapfile:traces/100_packets.pcap";
     73        if (!strcmp(type, "duck"))
     74                return "duck:traces/100_packets.duck";
    7375        return "unknown";
    7476}
     
    9294
    9395        if (strcmp(argv[1],"rtclient")==0) expected=101;
    94 
     96       
    9597        level=0;
    9698
  • tools/tracesplit/tracesplit.c

    r5ad7ad0 rcd7eec7  
    136136                }
    137137
    138                 pktcount++;
    139138                if (output && pktcount%count==0) {
    140139                        trace_destroy_output(output);
     
    142141                }
    143142
     143                pktcount++;
    144144                totbytes+=trace_get_capture_length(packet);
    145145                if (output && totbytes-totbyteslast>=bytes) {
Note: See TracChangeset for help on using the changeset viewer.