Changeset cab58c5 for lib/format_rt.c


Ignore:
Timestamp:
11/14/06 13:21:39 (15 years ago)
Author:
Perry Lorier <perry@…>
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:
35e0869
Parents:
33d83d4
Message:

Move RT_* to TRACE_RT_* and put it in libtrace.h

File:
1 edited

Legend:

Unmodified
Added
Removed
  • lib/format_rt.c

    r33d83d4 rcab58c5  
    153153       
    154154        switch (connect_msg.type) {
    155                 case RT_DENY_CONN:
     155                case TRACE_RT_DENY_CONN:
    156156                       
    157157                        if (recv(RT_INFO->input_fd, (void*)&deny_hdr,
     
    165165                                rt_deny_reason(reason));       
    166166                        return -1;
    167                 case RT_HELLO:
     167                case TRACE_RT_HELLO:
    168168                        /* do something with options */
    169169                        if (recv(RT_INFO->input_fd, (void*)&hello_opts,
     
    171171                                        != sizeof(rt_hello_t)) {
    172172                                trace_set_err(libtrace, TRACE_ERR_INIT_FAILED,
    173                                         "Failed to receive RT_HELLO options");
     173                                        "Failed to receive TRACE_RT_HELLO options");
    174174                                return -1;
    175175                        }
     
    229229        rt_header_t start_msg;
    230230
    231         start_msg.type = RT_START;
     231        start_msg.type = TRACE_RT_START;
    232232        start_msg.length = 0;
    233233
     
    241241                return -1;
    242242        }
    243         RT_INFO->rt_hdr.type = RT_LAST;
     243        RT_INFO->rt_hdr.type = TRACE_RT_LAST;
    244244
    245245        return 0;
     
    254254        rt_header_t close_msg;
    255255
    256         close_msg.type = RT_CLOSE;
     256        close_msg.type = TRACE_RT_CLOSE;
    257257        close_msg.length = 0;
    258258       
     
    368368{
    369369       
    370         if (packet->type >= RT_DATA_PCAP) {
     370        if (packet->type >= TRACE_RT_DATA_DLT) {
    371371                if (!RT_INFO->dummy_pcap) {
    372372                        RT_INFO->dummy_pcap = trace_create_dead("pcap:-");
     
    377377
    378378        switch (packet->type) {
    379                 case RT_DUCK_2_4:
    380                 case RT_DUCK_2_5:
     379                case TRACE_RT_DUCK_2_4:
     380                case TRACE_RT_DUCK_2_5:
    381381                        if (!RT_INFO->dummy_duck) {
    382382                                RT_INFO->dummy_duck = trace_create_dead("duck:dummy");
     
    384384                        packet->trace = RT_INFO->dummy_duck;
    385385                        break;
    386                 case RT_DATA_ERF:
     386                case TRACE_RT_DATA_ERF:
    387387                        if (!RT_INFO->dummy_erf) {
    388388                                RT_INFO->dummy_erf = trace_create_dead("erf:-");
     
    390390                        packet->trace = RT_INFO->dummy_erf;
    391391                        break;
    392                 case RT_DATA_WAG:
     392                case TRACE_RT_DATA_WAG:
    393393                        if (!RT_INFO->dummy_wag) {
    394394                                RT_INFO->dummy_wag = trace_create_dead("wtf:-");
     
    396396                        packet->trace = RT_INFO->dummy_wag;
    397397                        break;
    398                 case RT_DATA_LINUX_NATIVE:
     398                case TRACE_RT_DATA_LINUX_NATIVE:
    399399                        if (!RT_INFO->dummy_linux) {
    400400                                RT_INFO->dummy_linux = trace_create_dead("int:");
     
    402402                        packet->trace = RT_INFO->dummy_linux;
    403403                        break;
    404                 case RT_DATA_LEGACY_ETH:
    405                 case RT_DATA_LEGACY_ATM:
    406                 case RT_DATA_LEGACY_POS:
     404                case TRACE_RT_DATA_LEGACY_ETH:
     405                case TRACE_RT_DATA_LEGACY_ATM:
     406                case TRACE_RT_DATA_LEGACY_POS:
    407407                        printf("Sending legacy over RT is currently not supported\n");
    408408                        trace_set_err(libtrace, TRACE_ERR_BAD_PACKET, "Legacy packet cannot be sent over rt");
     
    420420       
    421421        switch (packet->type) {
    422                 case RT_DATA_ERF:
     422                case TRACE_RT_DATA_ERF:
    423423                        erfptr = (dag_record_t *)packet->header;
    424424                       
     
    452452        ack_hdr = (rt_ack_t *) (ack_buffer + sizeof(rt_header_t));
    453453       
    454         hdr->type = RT_ACK;
     454        hdr->type = TRACE_RT_ACK;
    455455        hdr->length = sizeof(rt_ack_t);
    456456
     
    496496        /* RT_LAST means that the next bytes received should be a
    497497         * rt header - I know it's hax and maybe I'll fix it later on */
    498         if (RT_INFO->rt_hdr.type == RT_LAST) {
     498        if (RT_INFO->rt_hdr.type == TRACE_RT_LAST) {
    499499                void_hdr = (void *)pkt_hdr;
    500500               
     
    515515        packet->type = RT_INFO->rt_hdr.type;
    516516
    517         if (packet->type >= RT_DATA_SIMPLE) {
     517        if (packet->type >= TRACE_RT_DATA_SIMPLE) {
    518518                if (rt_read(libtrace, &packet->buffer, RT_INFO->rt_hdr.length,blocking) != RT_INFO->rt_hdr.length) {
    519519                        return -1;
     
    536536        } else {
    537537                switch(packet->type) {
    538                         case RT_STATUS:
     538                        case TRACE_RT_STATUS:
    539539                                if (rt_read(libtrace, &packet->buffer,
    540540                                        RT_INFO->rt_hdr.length, blocking) !=
     
    545545                                packet->payload = packet->buffer;
    546546                                break;
    547                         case RT_DUCK_2_4:
    548                         case RT_DUCK_2_5:
     547                        case TRACE_RT_DUCK_2_4:
     548                        case TRACE_RT_DUCK_2_5:
    549549                                if (rt_read(libtrace, &packet->buffer,
    550550                                        RT_INFO->rt_hdr.length, blocking) !=
     
    558558                                packet->payload = packet->buffer;
    559559                                break;
    560                         case RT_END_DATA:
     560                        case TRACE_RT_END_DATA:
    561561                                break;
    562                         case RT_PAUSE_ACK:
     562                        case TRACE_RT_PAUSE_ACK:
    563563                                /* FIXME: Do something useful */
    564564                                break;
    565                         case RT_OPTION:
     565                        case TRACE_RT_OPTION:
    566566                                /* FIXME: Do something useful here as well */
    567567                                break;
    568                         case RT_KEYCHANGE:
     568                        case TRACE_RT_KEYCHANGE:
    569569                                break;
    570                         case RT_LOSTCONN:
     570                        case TRACE_RT_LOSTCONN:
    571571                                break;
    572572                        default:
     
    577577        }
    578578        /* Return the number of bytes read from the stream */
    579         RT_INFO->rt_hdr.type = RT_LAST;
     579        RT_INFO->rt_hdr.type = TRACE_RT_LAST;
    580580        return RT_INFO->rt_hdr.length;
    581581}
     
    589589static int rt_get_capture_length(const libtrace_packet_t *packet) {
    590590        switch (packet->type) {
    591                 case RT_STATUS:
     591                case TRACE_RT_STATUS:
    592592                        return sizeof(rt_status_t);
    593                 case RT_HELLO:
     593                case TRACE_RT_HELLO:
    594594                        return sizeof(rt_hello_t);
    595                 case RT_START:
     595                case TRACE_RT_START:
    596596                        return 0;
    597                 case RT_ACK:
     597                case TRACE_RT_ACK:
    598598                        return sizeof(rt_ack_t);
    599                 case RT_END_DATA:
     599                case TRACE_RT_END_DATA:
    600600                        return 0;
    601                 case RT_CLOSE:
     601                case TRACE_RT_CLOSE:
    602602                        return 0;
    603                 case RT_DENY_CONN:
     603                case TRACE_RT_DENY_CONN:
    604604                        return sizeof(rt_deny_conn_t);
    605                 case RT_PAUSE:
     605                case TRACE_RT_PAUSE:
    606606                        return 0;
    607                 case RT_PAUSE_ACK:
     607                case TRACE_RT_PAUSE_ACK:
    608608                        return 0;
    609                 case RT_OPTION:
     609                case TRACE_RT_OPTION:
    610610                        return 0; /* FIXME */
    611                 case RT_KEYCHANGE:
     611                case TRACE_RT_KEYCHANGE:
    612612                        return 0;
    613                 case RT_LOSTCONN:
     613                case TRACE_RT_LOSTCONN:
    614614                        return 0;
    615615        }
     
    655655                }
    656656        } else if (event.size == 0) {
    657                 if (packet->type == RT_END_DATA)
     657                if (packet->type == TRACE_RT_END_DATA)
    658658                        event.type = TRACE_EVENT_TERMINATE;
    659659                else
Note: See TracChangeset for help on using the changeset viewer.