Changeset 6dbc47a


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

Location:
lib
Files:
9 edited

Legend:

Unmodified
Added
Removed
  • lib/format_erf.c

    r0a6638f r6dbc47a  
    3030#define _GNU_SOURCE
    3131
    32 #define RT_MSG 2
    33 #define RT_DATA 1
    34 
    3532#include "config.h"
    3633#include "common.h"
     
    153150static int dag_start_input(struct libtrace_t *libtrace) {
    154151        struct stat buf;
    155         if (stat(packet->trace->uridata) == -1) {
     152        if (stat(libtrace->uridata, &buf) == -1) {
    156153                trace_set_err(errno,"stat(%s)",libtrace->uridata);
    157154                return 0;
     
    159156        if (S_ISCHR(buf.st_mode)) {
    160157                /* DEVICE */
    161                 if((INPUT.fd = dag_open(packet->trace->uridata)) < 0) {
     158                if((INPUT.fd = dag_open(libtrace->uridata)) < 0) {
    162159                        trace_set_err(errno,"Cannot open DAG %s",
    163                                         packet->trace->uridata);
     160                                        libtrace->uridata);
    164161                        return 0;
    165162                }
    166163                if((DAG.buf = (void *)dag_mmap(INPUT.fd)) == MAP_FAILED) {
    167164                        trace_set_err(errno,"Cannot mmap DAG %s",
    168                                         packet->trace->uridata);
     165                                        libtrace->uridata);
    169166                        return 0;
    170167                }
    171168                if(dag_start(INPUT.fd) < 0) {
    172169                        trace_set_err(errno,"Cannot start DAG %s",
    173                                         packet->trace->uridata);
     170                                        libtrace->uridata);
    174171                        return 0;
    175172                }
    176173        } else {
    177174                trace_set_err(errno,"Not a valid dag device: %s",
    178                                 packet->trace->uridata);
     175                                libtrace->uridata);
    179176                return 0;
    180177        }
     
    305302#endif
    306303
     304static int rtclient_fin_input(struct libtrace_t *libtrace) {
     305        close(INPUT.fd);
     306        return 0;
     307}
     308
    307309static int erf_fin_input(struct libtrace_t *libtrace) {
    308310        LIBTRACE_CLOSE(INPUT.file);
    309311        free(libtrace->format_data);
    310         return 0;
    311 }
    312 
    313 static int rtclient_fin_input(struct libtrace_t *libtrace) {
    314         close(INPUT.fd);
    315312        return 0;
    316313}
     
    376373        packet->buffer = erfptr;
    377374        packet->header = erfptr;
    378         if (((dag_record_t *)buffer)->flags.rxerror == 1) {
     375        if (((dag_record_t *)packet->buffer)->flags.rxerror == 1) {
    379376                packet->payload = NULL;
    380377        } else {
     
    470467}
    471468
     469#define RT_DATA 1
     470#define RT_MSG 2
     471
    472472static int rtclient_read_packet(struct libtrace_t *libtrace, struct libtrace_packet_t *packet) {
    473473        int numbytes = 0;
     
    594594        }
    595595       
    596         if (packet->trace->format == &erf ||
     596        if (packet->trace->format == &erf
    597597#if HAVE_DAG
    598                         packet->trace->format == &dag ||
    599 #endif
    600                         packet->trace->format == &rtclient ) {
     598                        || packet->trace->format == &dag
     599#endif
     600                        ) {
    601601                numbytes = erf_dump_packet(libtrace,
    602602                                (dag_record_t *)packet->buffer,
     
    751751
    752752static void rtclient_help() {
    753         printf("rtclient format module\n");
     753        printf("rtclient format module: $Revision$\n");
     754        printf("DEPRECATED - use rt module instead\n");
    754755        printf("Supported input URIs:\n");
    755         printf("\trtclient:hostname:port\n");
    756         printf("\trtclient:hostname (connects on default port)\n");
    757         printf("\n");
    758         printf("\te.g.: rtclient:localhost\n");
    759         printf("\te.g.: rtclient:localhost:32500\n");
    760         printf("\n");
    761         printf("Supported output URIs:\n");
    762         printf("\trtclient: \t(will output on default port on all available IP addresses) \n");
    763         printf("\trtclient:hostname:port\n");
    764         printf("\trtclient:port\n");
    765         printf("\n");
    766         printf("\te.g.: rtclient:32500\n");
    767         printf("\te.g.: rtclient:\n");
    768         printf("\n");
    769 
    770 }
     756        printf("\trtclient:host:port\n");
     757        printf("\n");
     758        printf("\te.g.:rtclient:localhost:3435\n");
     759        printf("\n");
     760        printf("Supported output URIs:\n");
     761        printf("\tnone\n");
     762        printf("\n");
     763}       
    771764
    772765static struct libtrace_format_t erf = {
    773766        "erf",
    774767        "$Id$",
    775         "erf",
     768        TRACE_FORMAT_ERF,
    776769        erf_init_input,                 /* init_input */       
    777770        NULL,                           /* config_input */
     
    807800        "dag",
    808801        "$Id$",
    809         "erf",
     802        TRACE_FORMAT_ERF,
    810803        dag_init_input,                 /* init_input */       
    811804        NULL,                           /* config_input */
    812805        dag_start_input,                /* start_input */
     806        NULL,                           /* pause_input */
    813807        NULL,                           /* init_output */
    814808        NULL,                           /* config_output */
     
    824818        NULL,                           /* get_timeval */
    825819        NULL,                           /* get_seconds */
     820        NULL,                           /* seek_erf */
     821        NULL,                           /* seek_timeval */
     822        NULL,                           /* seek_seconds */
    826823        erf_get_capture_length,         /* get_capture_length */
    827824        erf_get_wire_length,            /* get_wire_length */
     
    837834        "rtclient",
    838835        "$Id$",
    839         "erf",
     836        TRACE_FORMAT_ERF,
    840837        rtclient_init_input,            /* init_input */       
    841838        NULL,                           /* config_input */
     
    868865
    869866void __attribute__((constructor)) erf_constructor() {
     867        register_format(&rtclient);
    870868        register_format(&erf);
    871869#ifdef HAVE_DAG
  • lib/format_legacy.c

    r8ee7caa r6dbc47a  
    238238        "legacyatm",
    239239        "$Id$",
    240         "legacyatm",
     240        TRACE_FORMAT_LEGACY,
    241241        erf_init_input,                 /* init_input */       
    242242        NULL,                           /* config_input */
     
    271271        "legacyeth",
    272272        "$Id$",
    273         "legacyeth",
     273        TRACE_FORMAT_LEGACY,
    274274        erf_init_input,                 /* init_input */       
    275275        NULL,                           /* config_input */
     
    304304        "legacypos",
    305305        "$Id$",
    306         "legacypos",
     306        TRACE_FORMAT_LEGACY,
    307307        erf_init_input,                 /* init_input */       
    308308        NULL,                           /* config_input */
  • lib/format_pcap.c

    rdf338b3 r6dbc47a  
    446446        "pcap",
    447447        "$Id$",
    448         "pcap",
     448        TRACE_FORMAT_PCAP,
    449449        pcap_init_input,                /* init_input */
    450450        NULL,                           /* config_input */
     
    479479        "pcapint",
    480480        "$Id$",
    481         "pcap",
     481        TRACE_FORMAT_PCAP,
    482482        pcapint_init_input,             /* init_input */
    483483        pcapint_config_input,           /* config_input */
  • 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 */
  • lib/format_wag.c

    r8ee7caa r6dbc47a  
    434434        "wag",
    435435        "$Id$",
    436         "wtf",
     436        TRACE_FORMAT_WAG,
    437437        wag_init_input,                 /* init_input */       
    438438        NULL,                           /* config_input */
     
    469469        "wtf",
    470470        "$Id$",
    471         "wtf",
    472         wtf_init_input,                 /* init_input */
     471        TRACE_FORMAT_WAG,
     472        wtf_init_input,                 /* init_input */
    473473        NULL,                           /* config input */
    474474        NULL,                           /* start input */
  • lib/libtrace.h

    r0a6638f r6dbc47a  
    883883const char *trace_parse_uri(const char *uri, char **format);
    884884
     885/* Base format type definitions */
     886enum base_format_t {
     887        TRACE_FORMAT_ERF          =1,
     888        TRACE_FORMAT_PCAP         =2,
     889        TRACE_FORMAT_WAG          =3,
     890        TRACE_FORMAT_RT           =4,
     891        TRACE_FORMAT_LEGACY       =5
     892};
     893
     894/** Gets the framing header type for a given packet.
     895 * @param packet        the packet opaque pointer
     896 * @return the format of the packet
     897 */
     898enum base_format_t trace_get_format(struct libtrace_packet_t *packet);
     899
     900
    885901/** libtrace error information */
    886902extern struct trace_err_t{
  • lib/libtrace_int.h

    r0a6638f r6dbc47a  
    7272
    7373#include <stdbool.h>
    74 
    75 
    7674
    7775
     
    152150        char *name;
    153151        char *version;
    154         char *type;
     152        enum base_format_t type;
    155153        int (*init_input)(libtrace_t *libtrace);
    156154        int (*config_input)(libtrace_t *libtrace,trace_option_t option,void *value);
  • lib/rt_protocol.h

    r1fbd938 r6dbc47a  
    77#define COLLECTOR_PORT 3435
    88
     9#define RT_MAX_HDR_SIZE 256
     10#define MAX_SEQUENCE 2147483647
     11
    912/* Type field definitions */
     13/* NOTE: RT_DATA should always be zero */
    1014enum rt_field_t {
    11  RT_HELLO       =0,     /* Connection accepted */
    12  RT_DATA        =1,     /* Libtrace data packet */
     15 RT_DATA        =0,     /* Libtrace data packet */
     16 RT_HELLO       =1,     /* Connection accepted */
    1317 RT_START       =2,     /* Request for data transmission to begin */
    1418 RT_ACK         =3,     /* Data acknowledgement */
     
    2327};
    2428
    25 /* Format field definitions */
    26 enum rt_format_t {
    27  RT_FORMAT_ERF          =1,
    28  RT_FORMAT_PCAP         =2,
    29  RT_FORMAT_WAG          =3
    30 };
    31 
    32 typedef struct fifo_state {
     29typedef struct fifo_info {
    3330        uint64_t in;
    3431        uint64_t out;
     
    3633        uint64_t length;
    3734        uint64_t used;
    38 } fifo_state_t;
     35} fifo_info_t;
    3936
    4037/* RT packet header */
     
    4643typedef struct rt_data {
    4744        uint16_t format;
    48         char *data;
     45        uint32_t sequence;
    4946} rt_data_t;
    5047
     48/* TODO: Reorganise this struct once more hello info is added */
    5149typedef struct rt_hello {
    52 
     50        uint8_t reliable;
    5351} rt_hello_t;
    5452
     
    5856
    5957typedef struct rt_ack {
    60         uint64_t timestamp;
     58        uint32_t sequence;
    6159} rt_ack_t;
    6260
    6361typedef struct rt_status {
    64         fifo_state_t fifo_status;
     62        fifo_info_t fifo_status;
    6563} rt_status_t;
    6664
  • lib/trace.c

    r0a6638f r6dbc47a  
    116116#include "libtrace_int.h"
    117117#include "format_helper.h"
     118#include "rt_protocol.h"
    118119#include <err.h>
    119120
     
    544545         * structure */
    545546        packet->trace = libtrace;
    546 
     547        packet->type = RT_DATA;
     548       
    547549        if (libtrace->format->read_packet) {
    548550                do {
     
    15661568        return uridata;
    15671569}
     1570
     1571enum base_format_t trace_get_format(struct libtrace_packet_t *packet) {
     1572        assert(packet);
     1573
     1574        return packet->trace->format->type;
     1575}
    15681576       
    15691577/** Update the libtrace error
Note: See TracChangeset for help on using the changeset viewer.