Changeset cab58c5


Ignore:
Timestamp:
11/14/06 13:21:39 (14 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

Location:
lib
Files:
11 edited

Legend:

Unmodified
Added
Removed
  • lib/format_duck.c

    r33d83d4 rcab58c5  
    167167        packet->payload = packet->buffer;
    168168       
    169         if (INPUT->dag_version == RT_DUCK_2_4) {
     169        if (INPUT->dag_version == TRACE_RT_DUCK_2_4) {
    170170                duck_size = sizeof(duck2_4_t);
    171                 packet->type = RT_DUCK_2_4;
    172         } else if (INPUT->dag_version == RT_DUCK_2_5) {
     171                packet->type = TRACE_RT_DUCK_2_4;
     172        } else if (INPUT->dag_version == TRACE_RT_DUCK_2_5) {
    173173                duck_size = sizeof(duck2_5_t);
    174                 packet->type = RT_DUCK_2_5;
     174                packet->type = TRACE_RT_DUCK_2_5;
    175175        } else {
    176176                trace_set_err(libtrace, TRACE_ERR_BAD_PACKET,
     
    202202
    203203        int numbytes = 0;
    204         if (packet->type != RT_DUCK_2_4 && packet->type != RT_DUCK_2_5) {
     204        if (packet->type != TRACE_RT_DUCK_2_4
     205                        && packet->type != TRACE_RT_DUCK_2_5) {
    205206                trace_set_err_out(libtrace, TRACE_ERR_BAD_PACKET,
    206207                                "Only DUCK packets may be written to a DUCK file");
     
    232233static int duck_get_capture_length(const libtrace_packet_t *packet) {
    233234        switch(packet->type) {
    234                 case RT_DUCK_2_4:
     235                case TRACE_RT_DUCK_2_4:
    235236                        return sizeof(duck2_4_t);
    236                 case RT_DUCK_2_5:
     237                case TRACE_RT_DUCK_2_5:
    237238                        return sizeof(duck2_5_t);
    238239        }
  • lib/format_erf.c

    r33d83d4 rcab58c5  
    476476        }
    477477
    478         packet->type = RT_DUCK_2_4;
     478        packet->type = TRACE_RT_DUCK_2_4;
    479479        if (!DUCK.dummy_duck)
    480480                DUCK.dummy_duck = trace_create_dead("duck:dummy");
     
    561561        }
    562562       
    563         packet->type = RT_DATA_ERF;
     563        packet->type = TRACE_RT_DATA_ERF;
    564564       
    565565        if ((numbytes = dag_read(libtrace,0)) < 0)
     
    642642       
    643643        packet->header = packet->buffer;
    644         packet->type = RT_DATA_ERF;
     644        packet->type = TRACE_RT_DATA_ERF;
    645645
    646646        if ((numbytes=libtrace_io_read(INPUT.file,
     
    668668        if ((numbytes=libtrace_io_read(INPUT.file,
    669669                                        buffer2,
    670                                         size)) != size) {
     670                                        size)) != (int)size) {
    671671                if (numbytes==-1) {
    672672                        trace_set_err(libtrace,errno, "read(%s)", libtrace->uridata);
     
    686686
    687687static int erf_dump_packet(libtrace_out_t *libtrace,
    688                 dag_record_t *erfptr, int pad, void *buffer) {
     688                dag_record_t *erfptr, unsigned int pad, void *buffer) {
    689689        int numbytes = 0;
    690690        int size;
  • lib/format_legacy.c

    r33d83d4 rcab58c5  
    122122        switch(libtrace->format->type) {
    123123                case TRACE_FORMAT_LEGACY_ATM:
    124                         packet->type = RT_DATA_LEGACY_ATM;
     124                        packet->type = TRACE_RT_DATA_LEGACY_ATM;
    125125                        break;
    126126                case TRACE_FORMAT_LEGACY_POS:
    127                         packet->type = RT_DATA_LEGACY_POS;
     127                        packet->type = TRACE_RT_DATA_LEGACY_POS;
    128128                        break;
    129129                case TRACE_FORMAT_LEGACY_ETH:
    130                         packet->type = RT_DATA_LEGACY_ETH;
     130                        packet->type = TRACE_RT_DATA_LEGACY_ETH;
    131131                        break;
    132132                default:
  • lib/format_linux.c

    r33d83d4 rcab58c5  
    242242
    243243        packet->header = packet->buffer;
    244         packet->type = RT_DATA_LINUX_NATIVE;
     244        packet->type = TRACE_RT_DATA_LINUX_NATIVE;
    245245        packet->payload = (char*)packet->buffer+sizeof(*hdr);
    246246
  • 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
  • lib/format_wag.c

    r33d83d4 rcab58c5  
    327327       
    328328        packet->trace = libtrace;
    329         packet->type = RT_DATA_WAG;
     329        packet->type = TRACE_RT_DATA_WAG;
    330330       
    331331        if ((numbytes = wag_read(libtrace, (void *)packet->buffer,
     
    356356                packet->buffer = malloc(LIBTRACE_PACKET_BUFSIZE);
    357357        }
    358         packet->type = RT_DATA_WAG;
     358        packet->type = TRACE_RT_DATA_WAG;
    359359        buffer2 = buffer = packet->buffer;
    360360
  • lib/libtrace.h.in

    ra575f4b rcab58c5  
    233233} libtrace_linktype_t;
    234234
     235/** RT protocol base format identifiers
     236 * This is used to say what kind of packet is being sent over the rt protocol
     237 */
     238enum base_format_t {
     239        TRACE_FORMAT_ERF          =1,
     240        TRACE_FORMAT_PCAP         =2,
     241        TRACE_FORMAT_PCAPFILE     =3,
     242        TRACE_FORMAT_WAG          =4,
     243        TRACE_FORMAT_RT           =5,
     244        TRACE_FORMAT_LEGACY_ATM   =6,
     245        TRACE_FORMAT_LEGACY_POS   =7,
     246        TRACE_FORMAT_LEGACY_ETH   =8,
     247        TRACE_FORMAT_LINUX_NATIVE =9,
     248        TRACE_FORMAT_DUCK         =10,
     249        TRACE_FORMAT_BPF          =11
     250};
     251
     252/* RT protocol packet types */
    235253typedef enum {
    236         TRACE_RT_DLT_ATM_RFC1483 = 2000+TRACE_DLT_ATM_RFC1483,
    237         TRACE_RT_LAST   = (2<<31)
     254        TRACE_RT_HELLO          =1, /**< Connection accepted */
     255        TRACE_RT_START          =2, /**< Request for data transmission to begin
     256                                    */
     257        TRACE_RT_ACK            =3, /**< Data acknowledgement */
     258        TRACE_RT_STATUS         =4, /**< Fifo status packet */
     259        TRACE_RT_DUCK           =5, /**< Dag duck info packet */
     260        TRACE_RT_END_DATA       =6, /**< Server is exiting message */
     261        TRACE_RT_CLOSE          =7, /**< Client is exiting message */
     262        TRACE_RT_DENY_CONN      =8, /**< Connection has been denied */
     263        TRACE_RT_PAUSE          =9, /**< Request server to suspend sending data
     264                                     */
     265        TRACE_RT_PAUSE_ACK      =10,/**< Server is paused message */
     266        TRACE_RT_OPTION         =11,/**< Option request */
     267        TRACE_RT_KEYCHANGE      =12,/**< Anonymisation key has changed */
     268        TRACE_RT_DUCK_2_4       =13,/**< Dag 2.4 Duck */
     269        TRACE_RT_DUCK_2_5       =14,/**< Dag 2.5 Duck */
     270        TRACE_RT_LOSTCONN       =15,/**< Lost connection to server */
     271
     272        TRACE_RT_DATA_SIMPLE    = 1000, /**< Trace types that know their link
     273                                          * type
     274                                          */
     275        TRACE_RT_DATA_ERF       =TRACE_RT_DATA_SIMPLE+TRACE_FORMAT_ERF,
     276        TRACE_RT_DATA_WAG       =TRACE_RT_DATA_SIMPLE+TRACE_FORMAT_WAG,
     277        TRACE_RT_DATA_LEGACY_ATM=TRACE_RT_DATA_SIMPLE+TRACE_FORMAT_LEGACY_ATM,
     278        TRACE_RT_DATA_LEGACY_POS=TRACE_RT_DATA_SIMPLE+TRACE_FORMAT_LEGACY_POS,
     279        TRACE_RT_DATA_LEGACY_ETH=TRACE_RT_DATA_SIMPLE+TRACE_FORMAT_LEGACY_ETH,
     280        TRACE_RT_DATA_LINUX_NATIVE=TRACE_RT_DATA_SIMPLE+TRACE_FORMAT_LINUX_NATIVE,
     281
     282        TRACE_RT_DATA_DLT               = 2000, /**< Pcap doesn't store the
     283                                                  * linktype per packet, and
     284                                                  * thus we have to store it
     285                                                  * in here.  sigh.
     286                                                  */
     287        TRACE_RT_DLT_NULL               =TRACE_RT_DATA_DLT+TRACE_DLT_NULL,
     288        TRACE_RT_DLT_EN10MB             =TRACE_RT_DATA_DLT+TRACE_DLT_EN10MB,
     289        TRACE_RT_DLT_IEEE802_11         =TRACE_RT_DATA_DLT+TRACE_DLT_IEEE802_11,
     290        TRACE_RT_DLT_LINUX_SLL          =TRACE_RT_DATA_DLT+TRACE_DLT_LINUX_SLL,
     291        TRACE_RT_DLT_PFLOG              =TRACE_RT_DATA_DLT+TRACE_DLT_PFLOG,
     292        TRACE_RT_DLT_ATM_RFC1483        =TRACE_RT_DATA_DLT+TRACE_DLT_ATM_RFC1483,
     293        TRACE_RT_LAST                   = (2<<31)
    238294} libtrace_rt_types_t;
    239295
     
    13931449DLLEXPORT const char *trace_parse_uri(const char *uri, char **format);
    13941450
    1395 /** RT protocol base format identifiers
    1396  * This is used to say what kind of packet is being sent over the rt protocol
    1397  */
    1398 enum base_format_t {
    1399         TRACE_FORMAT_ERF          =1,
    1400         TRACE_FORMAT_PCAP         =2,
    1401         TRACE_FORMAT_PCAPFILE     =3,
    1402         TRACE_FORMAT_WAG          =4,
    1403         TRACE_FORMAT_RT           =5,
    1404         TRACE_FORMAT_LEGACY_ATM   =6,
    1405         TRACE_FORMAT_LEGACY_POS   =7,
    1406         TRACE_FORMAT_LEGACY_ETH   =8,
    1407         TRACE_FORMAT_LINUX_NATIVE =9,
    1408         TRACE_FORMAT_DUCK         =10,
    1409         TRACE_FORMAT_BPF          =11
    1410 };
    1411 
    14121451/** Gets the format type for a given packet.
    14131452 * @param packet        the packet opaque pointer
  • lib/libtrace_int.h

    r33d83d4 rcab58c5  
    357357libtrace_linktype_t pcap_dlt_to_libtrace(libtrace_dlt_t dlt);
    358358libtrace_dlt_t libtrace_to_pcap_dlt(libtrace_linktype_t type);
    359 enum rt_field_t pcap_dlt_to_rt(libtrace_dlt_t dlt);
    360 libtrace_dlt_t rt_to_pcap_dlt(enum rt_field_t rt_type);
     359libtrace_rt_types_t pcap_dlt_to_rt(libtrace_dlt_t dlt);
     360libtrace_dlt_t rt_to_pcap_dlt(libtrace_rt_types_t rt_type);
    361361libtrace_linktype_t erf_type_to_libtrace(char erf);
    362362char libtrace_to_erf_type(libtrace_linktype_t linktype);
     
    440440} libtrace_pcapfile_pkt_hdr_t;
    441441
     442void erf_constructor(void);
     443void legacy_constructor(void);
     444void linuxnative_constructor(void);
     445void pcap_constructor(void);
     446void pcapfile_constructor(void);
     447void rt_constructor(void);
     448void wag_constructor(void);
     449void duck_constructor(void);
     450
     451
    442452       
    443453#ifdef __cplusplus
  • lib/linktypes.c

    r33d83d4 rcab58c5  
    7575}
    7676
    77 enum rt_field_t pcap_dlt_to_rt(libtrace_dlt_t dlt)
     77libtrace_rt_types_t pcap_dlt_to_rt(libtrace_dlt_t dlt)
    7878{
    7979        /* For pcap the rt type is just the dlt + a fixed value */
    80         return dlt + RT_DATA_PCAP;
    81 }
    82 
    83 libtrace_dlt_t rt_to_pcap_dlt(enum rt_field_t rt_type)
    84 {
    85         assert(rt_type >= RT_DATA_PCAP);
    86         return rt_type - RT_DATA_PCAP;
     80        return dlt + TRACE_RT_DATA_DLT;
     81}
     82
     83libtrace_dlt_t rt_to_pcap_dlt(libtrace_rt_types_t rt_type)
     84{
     85        assert(rt_type >= TRACE_RT_DATA_DLT);
     86        return rt_type - TRACE_RT_DATA_DLT;
    8787}
    8888
  • lib/rt_protocol.h

    re502f76 rcab58c5  
    1010#define RT_MAX_HDR_SIZE 256
    1111#define MAX_SEQUENCE 2147483647
    12 
    13 #define RT_DATA_SIMPLE 1000
    14 #define RT_DATA_PCAP 2000
    1512
    1613/* Procedure for adding new RT control types
     
    3835 */
    3936
    40 /** Type field definitions */
    41 enum rt_field_t {
    42  RT_HELLO       =1,     /**< Connection accepted */
    43  RT_START       =2,     /**< Request for data transmission to begin */
    44  RT_ACK         =3,     /**< Data acknowledgement */
    45  RT_STATUS      =4,     /**< Fifo status packet */
    46  RT_DUCK        =5,     /**< Dag duck info packet */
    47  RT_END_DATA    =6,     /**< Server is exiting message */
    48  RT_CLOSE       =7,     /**< Client is exiting message */
    49  RT_DENY_CONN   =8,     /**< Connection has been denied */
    50  RT_PAUSE       =9,     /**< Request server to suspend sending data */
    51  RT_PAUSE_ACK   =10,    /**< Server is paused message */
    52  RT_OPTION      =11,    /**< Option request */
    53  RT_KEYCHANGE   =12,    /**< Anonymisation key has changed */
    54  RT_DUCK_2_4    =13,    /**< Dag 2.4 Duck */
    55  RT_DUCK_2_5    =14,    /**< Dag 2.5 Duck */
    56  RT_LOSTCONN    =15,    /**< Lost connection to server */
    57  
    58  RT_DATA_ERF            =RT_DATA_SIMPLE + TRACE_FORMAT_ERF,
    59  RT_DATA_WAG            =RT_DATA_SIMPLE + TRACE_FORMAT_WAG,
    60  RT_DATA_LEGACY_ATM     =RT_DATA_SIMPLE + TRACE_FORMAT_LEGACY_ATM,
    61  RT_DATA_LEGACY_POS     =RT_DATA_SIMPLE + TRACE_FORMAT_LEGACY_POS,
    62  RT_DATA_LEGACY_ETH     =RT_DATA_SIMPLE + TRACE_FORMAT_LEGACY_ETH,
    63  RT_DATA_LINUX_NATIVE   =RT_DATA_SIMPLE + TRACE_FORMAT_LINUX_NATIVE,
    64 
    65  RT_DATA_PCAP_NULL              =RT_DATA_PCAP + TRACE_DLT_NULL,
    66  RT_DATA_PCAP_EN10MB            =RT_DATA_PCAP + TRACE_DLT_EN10MB,
    67  RT_DATA_PCAP_ATM_RFC1483       =RT_DATA_PCAP + TRACE_DLT_ATM_RFC1483,
    68  RT_DATA_PCAP_IEEE802_11        =RT_DATA_PCAP + TRACE_DLT_IEEE802_11,
    69  RT_DATA_PCAP_LINUX_SLL         =RT_DATA_PCAP + TRACE_DLT_LINUX_SLL,
    70  RT_DATA_PCAP_PFLOG             =RT_DATA_PCAP + TRACE_DLT_PFLOG,
    71  RT_LAST = 3000
    72 };
    73 
    7437typedef struct fifo_info {
    7538        uint64_t in;
     
    8245/** RT packet header */
    8346typedef struct rt_header {
    84         enum rt_field_t type;
     47        libtrace_rt_types_t type;
    8548        uint16_t length;
    8649        uint32_t sequence;
  • lib/trace.c

    r33d83d4 rcab58c5  
    8585#include "libtrace.h"
    8686#include "libtrace_int.h"
    87 #include "parse_cmd.h"
    8887
    8988#ifdef HAVE_PCAP_BPF_H
     
    212211}
    213212
    214 void erf_constructor(void);
    215 void legacy_constructor(void);
    216 void linuxnative_constructor(void);
    217 void pcap_constructor(void);
    218 void pcapfile_constructor(void);
    219 void rt_constructor(void);
    220 void wag_constructor(void);
    221 void duck_constructor(void);
    222 
    223213/* call all the constructors if they haven't yet all been called */
    224214static void trace_init(void)
Note: See TracChangeset for help on using the changeset viewer.