Changeset 6dbc47a for lib/format_rt.c


Ignore:
Timestamp:
02/21/06 15:48:53 (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:
9ff68ff
Parents:
1b4901a
Message:

Updated all formats to use TRACE_FORMAT_* instead of nasty strings
format_rt is in a state where it provides basic client services
Added trace_get_format() function
libtrace_packet_t has a type field for storing format now

File:
1 edited

Legend:

Unmodified
Added
Removed
  • lib/format_rt.c

    rf03fc17 r6dbc47a  
    6868#define RT_INFO libtrace->format_data
    6969
     70int reliability = 0;
     71
    7072char *rt_deny_reason(uint8_t reason) {
    7173        char *string = 0;
     
    106108        struct sockaddr_in remote;
    107109        rt_header_t connect_msg;
    108         uint8_t reason;
     110        rt_deny_conn_t deny_hdr;       
     111        rt_hello_t hello_opts;
     112        uint8_t reason;
    109113       
    110114        if ((he=gethostbyname(RT_INFO->hostname)) == NULL) {
     
    132136        if (recv(RT_INFO->input_fd, &connect_msg, sizeof(rt_header_t), 0) != sizeof(rt_header_t) ) {
    133137                printf("An error occured while connecting to %s\n", RT_INFO->hostname);
    134                 return -1;
     138                return 0;
    135139        }
    136140
     
    138142                case RT_DENY_CONN:
    139143                       
    140                         if (recv(RT_INFO->input_fd, &reason, 1, 0) != 1) {
     144                        if (recv(RT_INFO->input_fd, &deny_hdr,
     145                                                sizeof(rt_deny_conn_t),
     146                                                0) != sizeof(rt_deny_conn_t)) {
    141147                                reason = 0;
    142148                        }       
     149                        reason = deny_hdr.reason;
    143150                        printf("Connection attempt is denied by the server: %s\n",
    144151                                        rt_deny_reason(reason));
    145                         return -1;
     152                        return 0;
    146153                case RT_HELLO:
    147154                        // do something with options
    148                        
     155                        printf("Hello\n");     
     156                        if (recv(RT_INFO->input_fd, &hello_opts,
     157                                                sizeof(rt_hello_t), 0)
     158                                        != sizeof(rt_hello_t)) {
     159                                printf("Failed to read hello options\n");
     160                                return 0;
     161                        }
     162                        reliability = hello_opts.reliable;
    149163                       
    150164                        return 1;
    151165                case RT_DATA:
    152166                        printf("Server needs to send RT_HELLO before sending data to clients\n");
    153                         return -1;
     167                        return 0;
    154168                default:
    155169                        printf("Unexpected message type: %d\n", connect_msg.type);
    156                         return -1;
    157         }
    158        
    159         return -1;
     170                        return 0;
     171        }
     172       
     173        return 0;
    160174}
    161175
     
    198212
    199213        start_msg.type = RT_START;
    200         start_msg.length = sizeof(rt_header_t);
     214        start_msg.length = sizeof(rt_start_t);
     215
     216        printf("Sending start - len: %d\n", start_msg.length);
    201217       
    202218        // Need to send start message to server
     
    206222        }
    207223
    208         return 1;
     224        return 0;
    209225}
    210226
     
    213229
    214230        close_msg.type = RT_CLOSE;
    215         close_msg.length = sizeof(rt_header_t);
     231        close_msg.length = sizeof(rt_close_t);
    216232       
    217233        // Send a close message to the server
     
    263279                struct libtrace_packet_t *packet, uint16_t format) {
    264280        switch (format) {
    265                 case RT_FORMAT_ERF:
     281                case TRACE_FORMAT_ERF:
    266282                        if (!RT_INFO->dummy_erf) {
    267283                                RT_INFO->dummy_erf = trace_create_dead("erf:-");
     
    269285                        packet->trace = RT_INFO->dummy_erf;
    270286                        break;
    271                 case RT_FORMAT_PCAP:
     287                case TRACE_FORMAT_PCAP:
    272288                        if (!RT_INFO->dummy_pcap) {
    273289                                RT_INFO->dummy_pcap = trace_create_dead("pcap:-");
     
    275291                        packet->trace = RT_INFO->dummy_pcap;
    276292                        break;
    277                 case RT_FORMAT_WAG:
     293                case TRACE_FORMAT_WAG:
    278294                        if (!RT_INFO->dummy_wag) {
    279295                                RT_INFO->dummy_wag = trace_create_dead("wtf:-");
     
    281297                        packet->trace = RT_INFO->dummy_wag;
    282298                        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:
     303                        printf("Sending legacy over RT is currently not supported\n");
     304                        return -1;
    283305                default:
    284306                        printf("Unrecognised format: %d\n", format);
     
    292314       
    293315        switch (format) {
    294                 case RT_FORMAT_ERF:
     316                case TRACE_FORMAT_ERF:
    295317                        erfptr = (dag_record_t *)packet->header;
    296318                       
     
    310332
    311333static int rt_send_ack(struct libtrace_t *libtrace,
    312                 struct libtrace_packet_t *packet)  {
     334                struct libtrace_packet_t *packet, uint32_t seqno)  {
    313335       
    314336        static char *ack_buffer = 0;
     
    327349       
    328350        hdr->type = RT_ACK;
    329         hdr->length = sizeof(rt_header_t) + sizeof(rt_ack_t);
    330 
    331         ack_hdr->timestamp = trace_get_erf_timestamp(packet);
    332        
    333         to_write = hdr->length;
     351        hdr->length = sizeof(rt_ack_t);
     352
     353        ack_hdr->sequence = seqno;
     354       
     355        to_write = hdr->length + sizeof(rt_header_t);
    334356        buf_ptr = ack_buffer;
     357
    335358       
    336359        while (to_write > 0) {
     
    360383        int read_required = 0;
    361384        rt_header_t pkt_hdr;
    362         uint16_t format;
    363385        char msg_buf[RP_BUFSIZE];
    364386
    365        
     387        rt_data_t data_hdr;
    366388        void *buffer = 0;
    367389
     
    371393                packet->buf_control = PACKET;
    372394                packet->buffer = malloc(LIBTRACE_PACKET_BUFSIZE);
    373         }
     395        } else {
     396                if (!packet->buffer)
     397                        packet->buffer = malloc(LIBTRACE_PACKET_BUFSIZE);
     398        }
    374399
    375400        buffer = packet->buffer;
     
    394419                tracefifo_out_update(libtrace->fifo, sizeof(rt_header_t));
    395420               
    396                 packet->size = pkt_hdr.length;
     421                packet->size = pkt_hdr.length + sizeof(rt_header_t);
    397422                packet->type = pkt_hdr.type;
    398 
     423               
    399424                switch (packet->type) {
    400425                        case RT_DATA:
    401426                                if (tracefifo_out_read(libtrace->fifo,
    402                                                         &format,
    403                                                         sizeof(uint16_t)) == 0)
     427                                                        &data_hdr,
     428                                                        sizeof(rt_data_t)) == 0)
    404429                                {
    405430                                        tracefifo_out_reset(libtrace->fifo);
     
    408433                                }
    409434                                if (tracefifo_out_read(libtrace->fifo, buffer,
    410                                                         packet->size - sizeof(uint16_t))== 0)
     435                                                        packet->size - sizeof(rt_data_t) - sizeof(rt_header_t))== 0)
    411436                                {
    412437                                        tracefifo_out_reset(libtrace->fifo);
     
    415440                                }
    416441                                // set packet->trace
    417                                 if (rt_set_format(libtrace, packet, format) < 0) {
     442                                if (rt_set_format(libtrace, packet,
     443                                                        data_hdr.format) < 0) {
    418444                                        return -1;
    419445                                }
    420446                                // set packet->payload
    421                                 rt_set_payload(packet, format);
     447                                rt_set_payload(packet, data_hdr.format);
    422448                               
    423                                 // send ack
    424                                 if (rt_send_ack(libtrace, packet) == -1) {
    425                                         return -1;
    426                                 }
    427                                
     449                                if (reliability > 0) {
     450                                        // send ack
     451                                        if (rt_send_ack(libtrace, packet,
     452                                                                data_hdr.sequence)
     453                                                        == -1)
     454                                        {
     455                                                return -1;
     456                                        }
     457                                }       
    428458                                break;
    429459                        case RT_STATUS:
     
    471501               
    472502                // got in our whole packet, so...
    473                 tracefifo_out_update(libtrace->fifo,packet->size);
    474 
    475                 tracefifo_ack_update(libtrace->fifo,packet->size +
    476                                 sizeof(rt_header_t));
     503                tracefifo_out_update(libtrace->fifo,packet->size - sizeof(rt_header_t));
     504
     505                tracefifo_ack_update(libtrace->fifo,packet->size);
    477506                return 1;
    478507        } while(1);
     
    502531        "rt",
    503532        "$Id$",
    504         "rt",
     533        TRACE_FORMAT_RT,
    505534        rt_init_input,                  /* init_input */
    506535        NULL,                           /* config_input */
Note: See TracChangeset for help on using the changeset viewer.