Changeset 7ac9705 for lib/format_rt.c


Ignore:
Timestamp:
03/06/06 15:31:15 (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:
e4e1635
Parents:
eeab9832
Message:

Changed rt types so that every pcap dlt has a matching rt type
Added functions for conversion between rt type and pcap dlt
format_rt now uses trace_set_err appropriately if rt_connect fails
format_pcap will check if a trace is dead before trying to look at

format data

Dead traces now have their format_data set to NULL
packet->type is now 32 bits, not 8

File:
1 edited

Legend:

Unmodified
Added
Removed
  • lib/format_rt.c

    reeab9832 r7ac9705  
    128128        if (connect(RT_INFO->input_fd, (struct sockaddr *)&remote,
    129129                                sizeof(struct sockaddr)) == -1) {
    130                 perror("connect (inet)");
    131                 return -1;
     130                trace_set_err(libtrace, TRACE_ERR_INIT_FAILED,
     131                                "Could not connect to host %s on port %d",
     132                                RT_INFO->hostname, RT_INFO->port);
     133                return -1;
    132134        }
    133135       
     
    135137       
    136138        if (recv(RT_INFO->input_fd, &connect_msg, sizeof(rt_header_t), 0) != sizeof(rt_header_t) ) {
    137                 printf("An error occured while connecting to %s\n", RT_INFO->hostname);
     139                trace_set_err(libtrace, TRACE_ERR_INIT_FAILED,
     140                                "Could not receive connection message from %s",
     141                                RT_INFO->hostname);
    138142                return -1;
    139143        }
     
    148152                        }       
    149153                        reason = deny_hdr.reason;
    150                         printf("Connection attempt is denied by the server: %s\n",
    151                                         rt_deny_reason(reason));
     154                        trace_set_err(libtrace, TRACE_ERR_INIT_FAILED,
     155                                "Connection attempt is denied: %s",
     156                                rt_deny_reason(reason));       
    152157                        return -1;
    153158                case RT_HELLO:
     
    157162                                                sizeof(rt_hello_t), 0)
    158163                                        != sizeof(rt_hello_t)) {
    159                                 printf("Failed to read hello options\n");
    160                                 return 0;
     164                                trace_set_err(libtrace, TRACE_ERR_INIT_FAILED,
     165                                        "Failed to receive RT_HELLO options");
     166                                return -1;
    161167                        }
    162168                        reliability = hello_opts.reliable;
     
    164170                        return 0;
    165171                default:
    166                         printf("Unexpected message type: %d\n", connect_msg.type);
     172                        trace_set_err(libtrace, TRACE_ERR_INIT_FAILED,
     173                                        "Unknown message type received: %d",
     174                                        connect_msg.type);
    167175                        return -1;
    168176        }
    169        
     177        trace_set_err(libtrace, TRACE_ERR_INIT_FAILED,
     178                        "Somehow you managed to reach this unreachable code");
    170179        return -1;
    171180}
     
    276285static int rt_set_format(libtrace_t *libtrace, libtrace_packet_t *packet)
    277286{
     287       
     288        if (packet->type >= RT_DATA_PCAP) {
     289                if (!RT_INFO->dummy_pcap) {
     290                        RT_INFO->dummy_pcap = trace_create_dead("pcap:-");
     291                }
     292                packet->trace = RT_INFO->dummy_pcap;
     293                return;
     294        }
     295
    278296        switch (packet->type) {
    279297                case RT_DATA_ERF:
     
    282300                        }
    283301                        packet->trace = RT_INFO->dummy_erf;
    284                         break;
    285                 case RT_DATA_PCAP:
    286                         if (!RT_INFO->dummy_pcap) {
    287                                 RT_INFO->dummy_pcap = trace_create_dead("pcap:-");
    288                         }
    289                         packet->trace = RT_INFO->dummy_pcap;
    290302                        break;
    291303                case RT_DATA_WAG:
     
    395407        packet->type = pkt_hdr.type;
    396408        pkt_size = pkt_hdr.length;
    397 
    398         switch(packet->type) {
    399                 case RT_DATA_ERF:
    400                 case RT_DATA_PCAP:
    401                 case RT_DATA_WAG:
    402                 case RT_DATA_LEGACY_ETH:
    403                 case RT_DATA_LEGACY_POS:
    404                 case RT_DATA_LEGACY_ATM:
    405                         if (rt_read(libtrace, buffer, pkt_size) != pkt_size) {
    406                                 printf("Error receiving packet\n");
    407                                 return -1;
    408                         }
    409                        
    410                         if (rt_set_format(libtrace, packet) < 0) {
    411                                 return -1;
     409        packet->size = pkt_hdr.length;
     410
     411        if (packet->type >= RT_DATA_SIMPLE) {
     412                if (rt_read(libtrace, buffer, pkt_size) != pkt_size) {
     413                        printf("Error receiving packet\n");
     414                        return -1;
     415                }
     416               
     417                if (rt_set_format(libtrace, packet) < 0) {
     418                        return -1;
     419                }
     420                rt_set_payload(packet);
     421
     422                if (reliability > 0) {
     423                       
     424                        if (rt_send_ack(libtrace, pkt_hdr.sequence)
     425                                        == -1)
     426                        {
     427                                return -1;
    412428                        }
    413                         rt_set_payload(packet);
    414 
    415                         if (reliability > 0) {
    416                                
    417                                 if (rt_send_ack(libtrace, pkt_hdr.sequence)
    418                                                 == -1)
    419                                 {
    420                                         return -1;
    421                                 }
    422                         }
    423                         break;
    424                 case RT_STATUS:
    425                 case RT_DUCK:
    426                         if (rt_read(libtrace, buffer, pkt_size) !=
    427                                         pkt_size) {
    428                                 printf("Error receiving status packet\n");
    429                                 return -1;
    430                         }
    431                         packet->header = 0;
    432                         packet->payload = buffer;
    433                         break;
    434                 case RT_END_DATA:
    435                         return 0;
    436                 case RT_PAUSE_ACK:
    437                         /* FIXME: Do something useful */
    438                         break;
    439                 case RT_OPTION:
    440                         /* FIXME: Do something useful here as well */
    441                         break;
    442                 default:
    443                         printf("Bad rt type for client receipt: %d\n",
     429                }
     430        } else {
     431                switch(packet->type) {
     432                        case RT_STATUS:
     433                        case RT_DUCK:
     434                                if (rt_read(libtrace, buffer, pkt_size) !=
     435                                                pkt_size) {
     436                                        printf("Error receiving status packet\n");
     437                                        return -1;
     438                                }
     439                                packet->header = 0;
     440                                packet->payload = buffer;
     441                                break;
     442                        case RT_END_DATA:
     443                                return 0;
     444                        case RT_PAUSE_ACK:
     445                                /* FIXME: Do something useful */
     446                                break;
     447                        case RT_OPTION:
     448                                /* FIXME: Do something useful here as well */
     449                                break;
     450                        default:
     451                                printf("Bad rt type for client receipt: %d\n",
    444452                                        pkt_hdr.type);
     453                }
    445454        }
    446455        return trace_get_capture_length(packet)+trace_get_framing_length(packet);
Note: See TracChangeset for help on using the changeset viewer.