Changeset d3b2234


Ignore:
Timestamp:
02/23/06 15:22:40 (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:
9836f12
Parents:
b7d2de5
Message:

depacket->sizeification

Location:
lib
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • lib/format_erf.c

    r52f8fc2 rd3b2234  
    381381        }
    382382
    383         packet->size = size;
    384383        DAG.offset += size;
    385384        DAG.diff -= size;
     
    431430                return -1;
    432431        }
    433         packet->size = rlen;
    434432        if (((dag_record_t *)packet->buffer)->flags.rxerror == 1) {
    435433                packet->payload = NULL;
     
    485483        do {
    486484                struct libtrace_packet_status status;
    487                 if (tracefifo_out_available(libtrace->fifo) == 0 || read_required) {
     485                int size;
     486                if (tracefifo_out_available(libtrace->fifo) == 0
     487                                || read_required) {
    488488                        if ((numbytes = rtclient_read(
    489489                                        libtrace,buf,RP_BUFSIZE))<=0) {
     
    502502                /* Read in packet size */
    503503                if (tracefifo_out_read(libtrace->fifo,
    504                                 &packet->size, sizeof(uint32_t)) == 0) {
     504                                &size, sizeof(uint32_t)) == 0) {
    505505                        tracefifo_out_reset(libtrace->fifo);
    506506                        read_required = 1;
     
    511511                if (status.type == 2 /* RT_MSG */) {
    512512                        /* Need to skip this packet as it is a message packet */
    513                         tracefifo_out_update(libtrace->fifo, packet->size);
    514                         tracefifo_ack_update(libtrace->fifo, packet->size +
     513                        tracefifo_out_update(libtrace->fifo, size);
     514                        tracefifo_ack_update(libtrace->fifo, size +
    515515                                        sizeof(uint32_t) +
    516516                                        sizeof(libtrace_packet_status_t));
     
    520520                /* read in the full packet */
    521521                if ((numbytes = tracefifo_out_read(libtrace->fifo,
    522                                                 buffer, packet->size)) == 0) {
     522                                                buffer, size)) == 0) {
    523523                        tracefifo_out_reset(libtrace->fifo);
    524524                        read_required = 1;
     
    527527
    528528                /* got in our whole packet, so... */
    529                 tracefifo_out_update(libtrace->fifo,packet->size);
    530 
    531                 tracefifo_ack_update(libtrace->fifo,packet->size +
     529                tracefifo_out_update(libtrace->fifo,size);
     530
     531                tracefifo_ack_update(libtrace->fifo,size +
    532532                                sizeof(uint32_t) +
    533533                                sizeof(libtrace_packet_status_t));
     
    666666        dag_record_t *erfptr = 0;
    667667        assert(packet);
    668         if((size + erf_get_framing_length(packet)) > packet->size) {
     668        if(size  > trace_get_capture_length(packet)) {
    669669                /* can't make a packet larger */
    670                 return (packet->size - erf_get_framing_length(packet));
     670                return trace_get_capture_length(packet);
    671671        }
    672672        erfptr = (dag_record_t *)packet->header;
    673673        erfptr->rlen = htons(size + erf_get_framing_length(packet));
    674         packet->size = size + erf_get_framing_length(packet);
    675         return packet->size;
     674        return trace_get_capture_length(packet);
    676675}
    677676
  • lib/format_helper.c

    r8ea5b38 rd3b2234  
    8383                trace->event.packet.size=
    8484                        trace_read_packet(trace,packet);
    85                 event.size = trace->event.packet.size;
     85                event.size = trace->event.packet.size = \
     86                             trace->event.packet.size;
    8687                if (trace->event.packet.size > 0 ) {
    8788                        memcpy(trace->event.packet.buffer,
     
    128129
    129130        /* This is the first packet, so just fire away. */
    130         packet->size = trace->event.packet.size;
    131131        memcpy(packet->buffer,
    132132                        trace->event.packet.buffer,
  • lib/format_legacy.c

    r52f8fc2 rd3b2234  
    162162                return -1;
    163163        }
    164         packet->size = 64;
    165164       
    166165        packet->header = packet->buffer;
  • lib/format_pcap.c

    rb7d2de5 rd3b2234  
    250250static void trace_pcap_handler(u_char *user, const struct pcap_pkthdr *pcaphdr, const u_char *pcappkt) {
    251251        struct libtrace_packet_t *packet = (struct libtrace_packet_t *)user;   
    252         int numbytes = 0;
    253 
    254252        /*
    255253        // pcap provides us with the right bits, in it's own buffers.
    256254        // We hijack them.
    257255        */
    258         numbytes = pcaphdr->len;
    259256
    260257        if (!packet->buffer || packet->buf_control==TRACE_CTRL_EXTERNAL) {
     
    271268        packet->payload = (void *)pcappkt;
    272269
    273         packet->size = numbytes + sizeof(struct pcap_pkthdr);
    274 
    275         printf("%i %i %i\n",pcaphdr->caplen,pcaphdr->len,packet->size);
    276 
    277270        assert(pcaphdr->caplen>=0 && pcaphdr->caplen<=65536);
    278271}
     
    289282                return pcapbytes;
    290283        }
    291         return (packet->size - sizeof(struct pcap_pkthdr));
     284        return ((struct pcap_pkthdr*)packet->header)->len+sizeof(struct pcap_pkthdr);
    292285}
    293286
     
    402395
    403396
    404 static int pcap_get_capture_length(const struct libtrace_packet_t *packet) {
     397static int pcap_get_capture_length(const libtrace_packet_t *packet) {
    405398        struct pcap_pkthdr *pcapptr = 0;
    406399        pcapptr = (struct pcap_pkthdr *)packet->header;
     
    409402}
    410403
    411 static int pcap_get_wire_length(const struct libtrace_packet_t *packet) {
     404static int pcap_get_wire_length(const libtrace_packet_t *packet) {
    412405        struct pcap_pkthdr *pcapptr = 0;
    413406        pcapptr = (struct pcap_pkthdr *)packet->header;
     
    415408}
    416409
    417 static int pcap_get_framing_length(const struct libtrace_packet_t *packet UNUSED) {
     410static int pcap_get_framing_length(const libtrace_packet_t *packet UNUSED) {
    418411        return sizeof(struct pcap_pkthdr);
    419412}
    420413
    421 static size_t pcap_set_capture_length(struct libtrace_packet_t *packet,size_t size) {
     414static size_t pcap_set_capture_length(libtrace_packet_t *packet,size_t size) {
    422415        struct pcap_pkthdr *pcapptr = 0;
    423416        assert(packet);
    424         if ((size + sizeof(struct pcap_pkthdr)) > packet->size) {
     417        if (size > trace_get_capture_length(packet)) {
    425418                /* can't make a packet larger */
    426                 return (packet->size - sizeof(struct pcap_pkthdr));
     419                return trace_get_capture_length(packet);
    427420        }
    428421        pcapptr = (struct pcap_pkthdr *)packet->header;
    429422        pcapptr->caplen = size;
    430         packet->size = size + sizeof(struct pcap_pkthdr);
    431         return packet->size;
     423        return trace_get_capture_length(packet);
    432424}
    433425
  • lib/format_rt.c

    r52f8fc2 rd3b2234  
    416416                tracefifo_out_update(libtrace->fifo, sizeof(rt_header_t));
    417417               
    418                 packet->size = pkt_hdr.length + sizeof(rt_header_t);
    419418                packet->type = pkt_hdr.type;
    420419               
     
    430429                                }
    431430                                if (tracefifo_out_read(libtrace->fifo, buffer,
    432                                                         packet->size - sizeof(rt_data_t) - sizeof(rt_header_t))== 0)
     431                                                        pkt_hdr.length-sizeof(rt_data_t))==0)
    433432                                {
    434433                                        tracefifo_out_reset(libtrace->fifo);
     
    497496               
    498497                /* got in our whole packet, so... */
    499                 tracefifo_out_update(libtrace->fifo,packet->size - sizeof(rt_header_t));
    500 
    501                 tracefifo_ack_update(libtrace->fifo,packet->size);
     498                tracefifo_out_update(libtrace->fifo,pkt_hdr.length);
     499
     500                tracefifo_ack_update(libtrace->fifo,pkt_hdr.length+
     501                                sizeof(rt_header_t));
    502502                return 1;
    503503        } while(1);
  • lib/format_wag.c

    r52f8fc2 rd3b2234  
    297297
    298298       
    299         packet->size = numbytes;
    300299        packet->header = packet->buffer;
    301300        packet->payload=(char*)packet->buffer+trace_get_framing_length(packet);
     
    342341        }
    343342
    344         packet->size = framesize;
    345343        packet->header = packet->buffer;
    346344        packet->payload=(char*)packet->buffer+trace_get_framing_length(packet);
     
    367365        }
    368366        if ((numbytes = LIBTRACE_WRITE(OUTPUT.file, packet->payload,
    369                         packet->size - trace_get_framing_length(packet))) == -1) {
     367                                trace_get_capture_length(packet)) == -1)) {
    370368                trace_set_err(errno,"write(%s)",packet->trace->uridata);
    371369                return -1;
  • lib/libtrace.h

    red7c716 rd3b2234  
    9292/** Structure holding information about a packet */
    9393#define LIBTRACE_PACKET_BUFSIZE 65536
     94
     95/** The libtrace structure, applications shouldn't be meddling around in here
     96 */
    9497typedef struct libtrace_packet_t {
    9598        struct libtrace_t *trace;
    9699        void *header;
    97100        void *payload;
     101        buf_control_t buf_control;
    98102        void *buffer;
    99         size_t size;
    100         uint8_t type;           /* rt protocol type for the packet */
    101         buf_control_t buf_control;
     103        size_t size;            /**< trace_get_framing_length()
     104                                 * +trace_get_capture_length() */
     105        uint8_t type;           /**< rt protocol type for the packet */
    102106} libtrace_packet_t;
    103107                     
     
    756760 * @param packet        the packet opaque pointer
    757761 * @param size          the new length of the packet
    758  * @return the new length of the packet, or the original length of the
    759  * packet if unchanged
    760  * @author Daniel Lawson
     762 * @return the new capture length of the packet, or the original capture
     763 * length of the packet if unchanged
    761764 */
    762765size_t trace_set_capture_length(libtrace_packet_t *packet, size_t size);
  • lib/trace.c

    r52f8fc2 rd3b2234  
    15481548
    15491549        if (packet->trace->format->set_capture_length) {
    1550                 return packet->trace->format->set_capture_length(packet,size);
     1550                int caplen=packet->trace->format->set_capture_length(packet,size);
     1551                if (caplen!=-1) {
     1552                        packet->size=trace_get_framing_length(packet)+caplen;
     1553                }
     1554                return caplen;
    15511555        }
    15521556
Note: See TracChangeset for help on using the changeset viewer.