Changeset afd0b73


Ignore:
Timestamp:
02/27/06 14:19:41 (16 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:
ab4cb04
Parents:
9de8150
Message:

Changed rt protocol to not require subheaders

Location:
lib
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • lib/format_erf.c

    r0ea3526 rafd0b73  
    360360                packet->buffer = 0;
    361361        }
    362    
     362       
     363        packet->type = RT_DATA_ERF;
     364       
    363365        if ((numbytes = dag_read(libtrace,0)) <= 0)
    364366                return numbytes;
    … …  
    402404
    403405        packet->header = packet->buffer;
     406        packet->type = RT_DATA_ERF;
    404407
    405408        if ((numbytes=LIBTRACE_READ(INPUT.file,
    … …  
    479482        buffer = packet->buffer;
    480483        packet->header = packet->buffer;
     484       
     485        packet->type = RT_DATA_ERF;
    481486
    482487       

  • lib/format_legacy.c

    r0ea3526 rafd0b73  
    155155        }
    156156        buffer = packet->buffer;
     157
     158        switch(libtrace->format->type) {
     159                case TRACE_FORMAT_LEGACY_ATM:
     160                        packet->type = RT_DATA_LEGACY_ATM;
     161                        break;
     162                case TRACE_FORMAT_LEGACY_POS:
     163                        packet->type = RT_DATA_LEGACY_POS;
     164                        break;
     165                case TRACE_FORMAT_LEGACY_ETH:
     166                        packet->type = RT_DATA_LEGACY_ETH;
     167                        break;
     168        }
    157169       
    158170        if ((numbytes=LIBTRACE_READ(INPUT.file,

  • lib/format_pcap.c

    r0ea3526 rafd0b73  
    274274static int pcap_read_packet(struct libtrace_t *libtrace, struct libtrace_packet_t *packet) {
    275275        int pcapbytes = 0;
    276 
     276       
     277        packet->type = RT_DATA_PCAP;
     278       
    277279        pcapbytes = pcap_dispatch(INPUT.pcap,
    278280                                        1, /* number of packets */

  • lib/format_rt.c

    r9836f12 rafd0b73  
    163163                       
    164164                        return 1;
    165                 case RT_DATA:
    166                         printf("Server needs to send RT_HELLO before sending data to clients\n");
    167                         return 0;
    168165                default:
    169166                        printf("Unexpected message type: %d\n", connect_msg.type);
    … …  
    217214       
    218215        /* Need to send start message to server */
    219         if (send(RT_INFO->input_fd, &start_msg, sizeof(rt_header_t), 0) != sizeof(rt_header_t)) {
     216        if (send(RT_INFO->input_fd, &start_msg, sizeof(rt_header_t) +
     217                                start_msg.length, 0) != sizeof(rt_header_t)) {
    220218                printf("Failed to send start message to server\n");
    221219                return -1;
    … …  
    232230       
    233231        /* Send a close message to the server */
    234         if (send(RT_INFO->input_fd, &close_msg, sizeof(rt_header_t), 0) != sizeof(rt_header_t)) {
     232        if (send(RT_INFO->input_fd, &close_msg, sizeof(rt_header_t) +
     233                                close_msg.length, 0) != sizeof(rt_header_t)) {
    235234                printf("Failed to send close message to server\n");
    236235       
    … …  
    277276
    278277static int rt_set_format(struct libtrace_t *libtrace,
    279                 struct libtrace_packet_t *packet, uint16_t format) {
    280         switch (format) {
    281                 case TRACE_FORMAT_ERF:
     278                struct libtrace_packet_t *packet) {
     279        switch (packet->type) {
     280                case RT_DATA_ERF:
    282281                        if (!RT_INFO->dummy_erf) {
    283282                                RT_INFO->dummy_erf = trace_create_dead("erf:-");
    … …  
    285284                        packet->trace = RT_INFO->dummy_erf;
    286285                        break;
    287                 case TRACE_FORMAT_PCAP:
     286                case RT_DATA_PCAP:
    288287                        if (!RT_INFO->dummy_pcap) {
    289288                                RT_INFO->dummy_pcap = trace_create_dead("pcap:-");
    … …  
    291290                        packet->trace = RT_INFO->dummy_pcap;
    292291                        break;
    293                 case TRACE_FORMAT_WAG:
     292                case RT_DATA_WAG:
    294293                        if (!RT_INFO->dummy_wag) {
    295294                                RT_INFO->dummy_wag = trace_create_dead("wtf:-");
    … …  
    297296                        packet->trace = RT_INFO->dummy_wag;
    298297                        break;
    299                 case TRACE_FORMAT_RT:
    300                         printf("Format in a data packet should NOT be set to RT\n");
    301                         return -1;
    302                 case TRACE_FORMAT_LEGACY_ETH:
    303                 case TRACE_FORMAT_LEGACY_ATM:
    304                 case TRACE_FORMAT_LEGACY_POS:
     298                case RT_DATA_LEGACY_ETH:
     299                case RT_DATA_LEGACY_ATM:
     300                case RT_DATA_LEGACY_POS:
    305301                        printf("Sending legacy over RT is currently not supported\n");
    306302                        return -1;
    307303                default:
    308                         printf("Unrecognised format: %d\n", format);
     304                        printf("Unrecognised format: %d\n", packet->type);
    309305                        return -1;
    310306        }
    … …  
    312308}               
    313309
    314 static void rt_set_payload(struct libtrace_packet_t *packet, uint16_t format) {
     310static void rt_set_payload(struct libtrace_packet_t *packet) {
    315311        dag_record_t *erfptr;
    316312       
    317         switch (format) {
    318                 case TRACE_FORMAT_ERF:
     313        switch (packet->type) {
     314                case RT_DATA_ERF:
    319315                        erfptr = (dag_record_t *)packet->header;
    320316                       
    321317                        if (erfptr->flags.rxerror == 1) {
    322318                                packet->payload = NULL;
    323                         } else {
    324                                 packet->payload = (char *)packet->buffer
    325                                         + trace_get_framing_length(packet);
    326                         }
    327                         break;
     319                                break;
     320                        }
     321                        /* else drop into the default case */
    328322                default:
    329323                        packet->payload = (char *)packet->buffer +
    … …  
    387381        int pkt_size = 0;
    388382       
    389         rt_data_t data_hdr;
    390383        void *buffer = 0;
    391384
    … …  
    409402
    410403        switch(packet->type) {
    411                 case RT_DATA:   
    412                         if (rt_read(libtrace, &data_hdr, sizeof(rt_data_t))
    413                                         != sizeof(rt_data_t)) {
    414                                 printf("Error receiving rt data header\n");
    415                                 return -1;
    416                         }
    417                        
    418                         if (rt_read(libtrace, buffer,
    419                                         pkt_size - sizeof(rt_data_t)) !=
    420                                         pkt_size - sizeof(rt_data_t)) {
     404                case RT_DATA_ERF:
     405                case RT_DATA_PCAP:
     406                case RT_DATA_WAG:
     407                case RT_DATA_LEGACY_ETH:
     408                case RT_DATA_LEGACY_POS:
     409                case RT_DATA_LEGACY_ATM:
     410                        if (rt_read(libtrace, buffer, pkt_size) != pkt_size) {
    421411                                printf("Error receiving packet\n");
    422412                                return -1;
    423413                        }
    424414                       
    425                         if (rt_set_format(libtrace, packet,
    426                                         data_hdr.format) < 0) {
     415                        if (rt_set_format(libtrace, packet) < 0) {
    427416                                return -1;
    428417                        }
    429                         rt_set_payload(packet, data_hdr.format);
     418                        rt_set_payload(packet);
    430419
    431420                        if (reliability > 0) {
    432421                               
    433422                                if (rt_send_ack(libtrace, packet,
    434                                        data_hdr.sequence) == -1)
     423                                       pkt_hdr.sequence) == -1)
    435424                                {
    436425                                        return -1;
    … …  
    461450       
    462451}
     452
     453static int rt_get_capture_length(const struct libtrace_packet_t *packet) {
     454        switch (packet->type) {
     455                case RT_DUCK:
     456                        return sizeof(rt_duck_t);
     457                case RT_STATUS:
     458                        return sizeof(rt_status_t);
     459                case RT_HELLO:
     460                        return sizeof(rt_hello_t);
     461                case RT_START:
     462                        return sizeof(rt_start_t);
     463                case RT_ACK:
     464                        return sizeof(rt_ack_t);
     465                case RT_END_DATA:
     466                        return sizeof(rt_end_data_t);
     467                case RT_CLOSE:
     468                        return sizeof(rt_close_t);
     469                case RT_DENY_CONN:
     470                        return sizeof(rt_deny_conn_t);
     471                case RT_PAUSE:
     472                        return sizeof(rt_pause_t);
     473                case RT_PAUSE_ACK:
     474                        return sizeof(rt_pause_ack_t);
     475                case RT_OPTION:
     476                        return sizeof(rt_option_t);
     477        }
     478        printf("Unknown type: %d\n", packet->type);
     479        return 0;
     480}
     481                       
     482static int rt_get_framing_length(const struct libtrace_packet_t *packet) {
     483        return 0;
     484}
     485
    463486
    464487static int rt_get_fd(const struct libtrace_t *trace) {
    … …  
    505528        NULL,                           /* seek_timeval */
    506529        NULL,                           /* seek_seconds */
    507         NULL,                           /* get_capture_length */
     530        rt_get_capture_length,          /* get_capture_length */
    508531        NULL,                           /* get_wire_length */
    509         NULL,                           /* get_framing_length */
     532        rt_get_framing_length,          /* get_framing_length */
    510533        NULL,                           /* set_capture_length */
    511534        rt_get_fd,                      /* get_fd */

  • lib/format_wag.c

    r0ea3526 rafd0b73  
    295295       
    296296        packet->trace = libtrace;
     297        packet->type = RT_DATA_WAG;
    297298       
    298299        if ((numbytes = wag_read(libtrace, (void *)packet->buffer, RP_BUFSIZE)) <= 0) {
    … …  
    318319                packet->buffer = malloc(LIBTRACE_PACKET_BUFSIZE);
    319320        }
    320 
     321        packet->type = RT_DATA_WAG;
    321322        buffer2 = buffer = packet->buffer;
    322323       

  • lib/libtrace_int.h

    r9de8150 rafd0b73  
    4141#include "libtrace.h"
    4242#include "fifo.h"
     43#include "rt_protocol.h"
    4344       
    4445#if HAVE_PCAP_BPF_H

  • lib/rt_protocol.h

    r6dbc47a rafd0b73  
    1111
    1212/* Type field definitions */
    13 /* NOTE: RT_DATA should always be zero */
    1413enum rt_field_t {
    15  RT_DATA        =0,     /* Libtrace data packet */
    1614 RT_HELLO       =1,     /* Connection accepted */
    1715 RT_START       =2,     /* Request for data transmission to begin */
    … …  
    2422 RT_PAUSE       =9,     /* Request server to suspend sending data */
    2523 RT_PAUSE_ACK   =10,    /* Server is paused message */
    26  RT_OPTION      =11     /* Option request */
     24 RT_OPTION      =11,    /* Option request */
     25 
     26 RT_DATA_ERF            =12,    /* Erf data packet */
     27 RT_DATA_PCAP           =13,    /* Pcap data packet */
     28 RT_DATA_WAG            =14,    /* Wag data packet */
     29 RT_DATA_LEGACY_ATM     =15,    /* Legacy ATM packet */
     30 RT_DATA_LEGACY_POS     =16,    /* Legacy POS packet */
     31 RT_DATA_LEGACY_ETH     =17     /* Legacy ETH packet */
    2732};
    2833
    … …  
    3944        enum rt_field_t type;
    4045        uint16_t length;
     46        uint32_t sequence;
    4147} rt_header_t;
    42 
    43 typedef struct rt_data {
    44         uint16_t format;
    45         uint32_t sequence;
    46 } rt_data_t;
    4748
    4849/* TODO: Reorganise this struct once more hello info is added */

  • lib/trace.c

    r2e223eca rafd0b73  
    564564         * structure */
    565565        packet->trace = libtrace;
    566         packet->type = RT_DATA;
    567        
     566
     567
    568568        if (libtrace->format->read_packet) {
    569569                do {
Note: See TracChangeset for help on using the changeset viewer.