Changeset 9836f12 for lib/format_rt.c


Ignore:
Timestamp:
02/23/06 15:27:51 (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:
c1f2553
Parents:
d3b2234
Message:

Fixed get_fd call in format_helper to use trace as a parameter instead of packet
pcap_get_wire_length no longer ntohs() the len field of the pcap header
rt_read_packet no longer requires the tracefifo

File:
1 edited

Legend:

Unmodified
Added
Removed
  • lib/format_rt.c

    rd3b2234 r9836f12  
    381381                struct libtrace_packet_t *packet) {
    382382       
    383         int numbytes = 0;
    384383        char buf[RP_BUFSIZE];
    385384        int read_required = 0;
    386385        rt_header_t pkt_hdr;
    387386        char msg_buf[RP_BUFSIZE];
    388 
     387        int pkt_size = 0;
     388       
    389389        rt_data_t data_hdr;
    390390        void *buffer = 0;
     
    398398        packet->header = packet->buffer;
    399399
    400 
    401         do {
    402                 if (tracefifo_out_available(libtrace->fifo) == 0 || read_required) {
    403                         if ((numbytes = rt_read(
    404                                         libtrace,buf,RP_BUFSIZE))<=0) {
    405                                 return numbytes;
     400        /* FIXME: Better error handling required */
     401        if (rt_read(libtrace, &pkt_hdr, sizeof(rt_header_t)) !=
     402                        sizeof(rt_header_t)) {
     403                printf("Error receiving rt header\n");
     404                return -1;
     405        }
     406
     407        packet->type = pkt_hdr.type;
     408        pkt_size = pkt_hdr.length;
     409
     410        switch(packet->type) {
     411                case RT_DATA:   
     412                        if (rt_read(libtrace, &data_hdr, sizeof(rt_data_t))
     413                                        != sizeof(rt_data_t)) {
     414                                printf("Error receiving rt data header\n");
     415                                return -1;
     416                        }
     417                       
     418                        if (rt_read(libtrace, buffer,
     419                                        pkt_size - sizeof(rt_data_t)) !=
     420                                        pkt_size - sizeof(rt_data_t)) {
     421                                printf("Error receiving packet\n");
     422                                return -1;
     423                        }
     424                       
     425                        if (rt_set_format(libtrace, packet,
     426                                        data_hdr.format) < 0) {
     427                                return -1;
    406428                        }
    407                         tracefifo_write(libtrace->fifo,buf,numbytes);
    408                         read_required = 0;
    409                 }
    410                 /* Read rt header */
    411                 if (tracefifo_out_read(libtrace->fifo,
    412                                 &pkt_hdr, sizeof(rt_header_t)) == 0) {
    413                         read_required = 1;
    414                         continue;
    415                 }
    416                 tracefifo_out_update(libtrace->fifo, sizeof(rt_header_t));
    417                
    418                 packet->type = pkt_hdr.type;
    419                
    420                 switch (packet->type) {
    421                         case RT_DATA:
    422                                 if (tracefifo_out_read(libtrace->fifo,
    423                                                         &data_hdr,
    424                                                         sizeof(rt_data_t)) == 0)
     429                        rt_set_payload(packet, data_hdr.format);
     430
     431                        if (reliability > 0) {
     432                               
     433                                if (rt_send_ack(libtrace, packet,
     434                                       data_hdr.sequence) == -1)
    425435                                {
    426                                         tracefifo_out_reset(libtrace->fifo);
    427                                         read_required = 1;
    428                                         break;
    429                                 }
    430                                 if (tracefifo_out_read(libtrace->fifo, buffer,
    431                                                         pkt_hdr.length-sizeof(rt_data_t))==0)
    432                                 {
    433                                         tracefifo_out_reset(libtrace->fifo);
    434                                         read_required = 1;
    435                                         break;
    436                                 }
    437                                 /* set packet->trace */
    438                                 if (rt_set_format(libtrace, packet,
    439                                                         data_hdr.format) < 0) {
    440                                         return -1;
    441                                 }
    442                                 /* set packet->payload */
    443                                 rt_set_payload(packet, data_hdr.format);
    444                                
    445                                 if (reliability > 0) {
    446                                         /* send ack */
    447                                         if (rt_send_ack(libtrace, packet,
    448                                                                 data_hdr.sequence)
    449                                                         == -1)
    450                                         {
    451                                                 return -1;
    452                                         }
    453                                 }       
    454                                 break;
    455                         case RT_STATUS:
    456                                 if (tracefifo_out_read(libtrace->fifo, buffer,
    457                                                 sizeof(rt_status_t)) == 0)
    458                                 {
    459                                         tracefifo_out_reset(libtrace->fifo);
    460                                         read_required = 1;
    461                                         break;
    462                                 }
    463                                 break;
    464                         case RT_DUCK:
    465                                 if (tracefifo_out_read(libtrace->fifo, buffer,
    466                                                 sizeof(rt_duck_t)) == 0)
    467                                 {
    468                                         tracefifo_out_reset(libtrace->fifo);
    469                                         read_required = 1;
    470                                         break;
    471                                 }
    472                                 break;
    473 
    474                         case RT_END_DATA:
    475                                 /* need to do something sensible here */
    476                                 return 0;       
    477 
    478                         case RT_PAUSE_ACK:
    479                                 /* Check if we asked for a pause */
    480                                
    481                                 break;
    482 
    483                         case RT_OPTION:
    484                                 /* Server is requesting some option? */
    485 
    486                                 break;
    487 
    488                         default:
    489                                 printf("Bad rt client type: %d\n", packet->type);
     436                                        return -1;
     437                                }
     438                        }
     439                        break;
     440                case RT_STATUS:
     441                case RT_DUCK:
     442                        if (rt_read(libtrace, buffer, pkt_size) !=
     443                                        pkt_size) {
     444                                printf("Error receiving status packet\n");
    490445                                return -1;
    491                                
    492                 }
    493                 if (read_required)
    494                         continue;
    495                                
    496                
    497                 /* got in our whole packet, so... */
    498                 tracefifo_out_update(libtrace->fifo,pkt_hdr.length);
    499 
    500                 tracefifo_ack_update(libtrace->fifo,pkt_hdr.length+
    501                                 sizeof(rt_header_t));
    502                 return 1;
    503         } while(1);
     446                        }
     447                        break;
     448                case RT_END_DATA:
     449                        return 0;
     450                case RT_PAUSE_ACK:
     451                        /* FIXME: Do something useful */
     452                        break;
     453                case RT_OPTION:
     454                        /* FIXME: Do something useful here as well */
     455                        break;
     456                default:
     457                        printf("Bad rt type for client receipt: %d\n",
     458                                        pkt_hdr.type);
     459        }
     460        return 1;
    504461       
    505462}
Note: See TracChangeset for help on using the changeset viewer.