Changeset 9c4b5e3 for lib/format_rt.c


Ignore:
Timestamp:
03/20/06 18:29:00 (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:
c219603
Parents:
25efeac
Message:

Added support for nonblocking events for format_rt

File:
1 edited

Legend:

Unmodified
Added
Removed
  • lib/format_rt.c

    r2ffda28 r9c4b5e3  
    115115        rt_hello_t hello_opts;
    116116        uint8_t reason;
     117        int oldflags;
     118
    117119       
    118120        if ((he=gethostbyname(RT_INFO->hostname)) == NULL) {
     
    137139                return -1;
    138140        }
     141
     142       
     143#if 0
     144        oldflags = fcntl(RT_INFO->input_fd, F_GETFL, 0);
     145        if (oldflags == -1) {
     146                trace_set_err(libtrace, errno,
     147                                "Could not get fd flags from fd %d\n",
     148                                RT_INFO->input_fd);
     149                return -1;
     150        }
     151        oldflags |= O_NONBLOCK;
     152        if (fcntl(RT_INFO->input_fd, F_SETFL, oldflags) == -1) {
     153                trace_set_err(libtrace, errno,
     154                                "Could not set fd flags for fd %d\n",
     155                                RT_INFO->input_fd);
     156                return -1;
     157        }
     158#endif
     159       
    139160       
    140161        /* We are connected, now receive message from server */
     
    146167                return -1;
    147168        }
    148 
     169       
    149170        switch (connect_msg.type) {
    150171                case RT_DENY_CONN:
     
    264285#define RT_BUF_SIZE 4000
    265286
    266 static int rt_read(struct libtrace_t *libtrace, void **buffer, size_t len) {
     287static int rt_read(struct libtrace_t *libtrace, void **buffer, size_t len, int block) {
    267288        int numbytes;
     289        int i;
     290        char *buf_ptr;
    268291
    269292        assert(len <= RT_BUF_SIZE);
     
    274297                RT_INFO->buf_left = 0;
    275298        }
     299
     300        if (block)
     301                block=0;
     302        else
     303                block=MSG_DONTWAIT;
    276304
    277305       
     
    289317                                                RT_INFO->buf_left,
    290318                                                RT_BUF_SIZE-RT_INFO->buf_left,
    291                                                 MSG_NOSIGNAL)) == -1) {
     319                                                MSG_NOSIGNAL|block)) <= 0) {
     320                                if (numbytes == 0) {
     321                                        trace_set_err(libtrace, TRACE_ERR_BAD_PACKET,
     322                                                        "No data received");
     323                                        return -1;
     324                                }
     325                               
    292326                                if (errno == EINTR) {
    293327                                        /* ignore EINTR in case
     
    296330                                        continue;
    297331                                }
     332                                if (errno == EAGAIN) {
     333                                        trace_set_err(libtrace,
     334                                                        EAGAIN,
     335                                                        "EAGAIN");
     336                                        return -1;
     337                                }
     338                               
    298339                                perror("recv");
     340                                trace_set_err(libtrace, TRACE_ERR_RECV_FAILED,
     341                                                "Failed to read data into rt recv buffer");
    299342                                return -1;
    300343                        }
     344                        /*
     345                        buf_ptr = RT_INFO->pkt_buffer;
     346                        for (i = 0; i < RT_BUF_SIZE ; i++) {
     347                                       
     348                                printf("%02x", (unsigned char)*buf_ptr);
     349                                buf_ptr ++;
     350                        }
     351                        printf("\n");
     352                        */
    301353                        RT_INFO->buf_left+=numbytes;
    302354                }
     
    339391                case RT_DATA_LEGACY_POS:
    340392                        printf("Sending legacy over RT is currently not supported\n");
     393                        trace_set_err(libtrace, TRACE_ERR_BAD_PACKET, "Legacy packet cannot be sent over rt");
    341394                        return -1;
    342395                default:
    343396                        printf("Unrecognised format: %d\n", packet->type);
     397                        trace_set_err(libtrace, TRACE_ERR_BAD_PACKET, "Unrecognised packet format");
    344398                        return -1;
    345399        }
     
    400454                        else {
    401455                                printf("Error sending ack\n");
     456                                trace_set_err(libtrace, TRACE_ERR_BAD_PACKET,
     457                                                "Error sending ack");
    402458                                return -1;
    403459                        }
     
    410466        return 1;
    411467}
    412        
    413 static int rt_read_packet(libtrace_t *libtrace, libtrace_packet_t *packet) {
     468
     469       
     470static int rt_read_packet_versatile(libtrace_t *libtrace,
     471                libtrace_packet_t *packet,int blocking) {
    414472        rt_header_t rt_hdr;
    415473        rt_header_t *pkt_hdr = &rt_hdr;
     
    422480        }
    423481
    424         packet->header = packet->buffer;
    425482
    426483        /* FIXME: Better error handling required */
    427         if (rt_read(libtrace, (void **)&pkt_hdr, sizeof(rt_header_t)) !=
     484        if (rt_read(libtrace, (void **)&pkt_hdr, sizeof(rt_header_t),blocking) !=
    428485                        sizeof(rt_header_t)) {
    429                 printf("Error receiving rt header\n");
    430486                return -1;
    431487        }
     
    436492
    437493        if (packet->type >= RT_DATA_SIMPLE) {
    438                 if (rt_read(libtrace, &packet->buffer, pkt_size) != pkt_size) {
     494                if (rt_read(libtrace, &packet->buffer, pkt_size,1) != pkt_size) {
    439495                        printf("Error receiving packet\n");
    440496                        return -1;
    441497                }
     498                packet->header = packet->buffer;
    442499               
    443500                if (rt_set_format(libtrace, packet) < 0) {
     
    459516                        case RT_DUCK:
    460517                                if (rt_read(libtrace, &packet->buffer,
    461                                                         pkt_size) !=
     518                                                        pkt_size,1) !=
    462519                                                pkt_size) {
    463520                                        printf("Error receiving status packet\n");
     
    483540        }
    484541        /* Return the number of bytes read from the stream */
    485         return sizeof(rt_header_t) + packet->size;
    486 }
     542        return packet->size;
     543}
     544
     545static int rt_read_packet(libtrace_t *libtrace,
     546                libtrace_packet_t *packet) {
     547        rt_read_packet_versatile(libtrace,packet,1);
     548}
     549
    487550
    488551static int rt_get_capture_length(const struct libtrace_packet_t *packet) {
     
    516579        return 0;
    517580}
     581
     582static int rt_get_wire_length(const libtrace_packet_t *packet) {
     583        return 0;
     584}
    518585                       
    519586static int rt_get_framing_length(const libtrace_packet_t *packet) {
     
    521588}
    522589
    523 
    524590static int rt_get_fd(const libtrace_t *trace) {
    525591        return ((struct rt_format_data_t *)trace->format_data)->input_fd;
    526592}
    527593
    528 
     594struct libtrace_eventobj_t trace_event_rt(struct libtrace_t *trace, struct libtrace_packet_t *packet) {
     595        struct libtrace_eventobj_t event = {0,0,0.0,0};
     596        libtrace_err_t read_err;
     597        int data;
     598
     599        assert(trace);
     600        assert(packet);
     601       
     602        if (trace->format->get_fd) {
     603                event.fd = trace->format->get_fd(trace);
     604        } else {
     605                event.fd = 0;
     606        }
     607
     608        event.size = rt_read_packet_versatile(trace, packet, 0);
     609        if (event.size == -1) {
     610                read_err = trace_get_err(trace);
     611                if (read_err.err_num == EAGAIN) {
     612                        event.type = TRACE_EVENT_IOWAIT;
     613                }
     614                else {
     615                        printf("packet error\n");
     616                        event.type = TRACE_EVENT_PACKET;
     617                }
     618        } else if (event.size == 0) {
     619                event.type = TRACE_EVENT_TERMINATE;
     620               
     621        }       
     622        else {
     623                event.type = TRACE_EVENT_PACKET;
     624        }
     625       
     626        return event;
     627}
    529628
    530629static void rt_help() {
     
    567666        NULL,                           /* seek_seconds */
    568667        rt_get_capture_length,          /* get_capture_length */
    569         NULL,                           /* get_wire_length */
     668        rt_get_wire_length,                     /* get_wire_length */
    570669        rt_get_framing_length,          /* get_framing_length */
    571670        NULL,                           /* set_capture_length */
    572671        rt_get_fd,                      /* get_fd */
    573         trace_event_device,             /* trace_event */
     672        trace_event_rt,             /* trace_event */
    574673        rt_help,                        /* help */
    575674        NULL                            /* next pointer */
Note: See TracChangeset for help on using the changeset viewer.