Changeset afd0b73 for lib/format_rt.c


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

File:
1 edited

Legend:

Unmodified
Added
Removed
  • 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 */
Note: See TracChangeset for help on using the changeset viewer.