Changeset 8f4152b


Ignore:
Timestamp:
10/21/05 12:17:08 (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:
41660d5
Parents:
b4cb91f
Message:

Moved legacy headers into daglegacy.h
Fixed some prototypes that were missing const's
Added a erf_get_erf_headersize that accoutns for the random +2 for erf
ethernet padding.
Removed a lot of hard coded constants for padding.

Location:
lib
Files:
1 added
5 edited

Legend:

Unmodified
Added
Removed
  • lib/dagformat.h

    r641dc7c r8f4152b  
    8282#define dag_record_size         16
    8383
    84 
    85 typedef struct legacy_cell {
    86         uint64_t  ts;
    87         uint32_t  crc;
    88 } legacy_cell_t;
    89 
    90 typedef struct legacy_ether {
    91         uint64_t  ts;
    92         uint16_t  wlen;
    93 } legacy_ether_t;
    94 
    95 typedef struct legacy_pos {
    96         uint64_t  ts;
    97         uint32_t  slen;
    98         uint32_t  wlen;
    99 } legacy_pos_t;
    100 
    101 
    10284#endif // _DAGFORMAT_H_
  • lib/format_erf.c

    ref90843 r8f4152b  
    192192#endif
    193193
     194/* Dag erf ether packets have a 2 byte padding before the packet
     195 * so that the ip header is aligned on a 32 bit boundary.
     196 */
     197static int erf_get_padding(const struct libtrace_packet_t *packet)
     198{
     199        switch(trace_get_link_type(packet)) {
     200                case TRACE_TYPE_ETH:    return 2;
     201                default:                return 0;
     202        }
     203}
     204
     205static int erf_get_erf_headersize(const struct libtrace_packet_t *packet)
     206{
     207        return dag_record_size + erf_get_padding(packet);
     208}
     209
     210
    194211static int erf_init_input(struct libtrace_t *libtrace) {
    195212        struct stat buf;
     
    498515        }
    499516        rlen = ntohs(((dag_record_t *)buffer)->rlen);
     517        buffer2 = buffer + dag_record_size;
    500518        size = rlen - dag_record_size;
    501519        assert(size < LIBTRACE_PACKET_BUFSIZE);
    502         buffer2 = buffer + dag_record_size;
    503520        /* If your trace is legacy, or corrupt, then this assert may fire. */
    504521        assert(ntohs(((dag_record_t *)buffer)->rlen) <=
    505                         ntohs(((dag_record_t*)buffer)->wlen)+dag_record_size);
     522                        ntohs(((dag_record_t*)buffer)->wlen)+erf_get_erf_headersize(packet));
    506523        /* If it's an unknown type, your trace is legacy */
    507524        assert(((dag_record_t *)buffer)->type != 0);
     
    512529        if ((numbytes=LIBTRACE_READ(INPUT.file,
    513530                                        buffer2,
    514                                         size)) == -1) {
     531                                        size)) != size) {
    515532                perror("libtrace_read");
    516533                return -1;
     
    578595                // read in the ERF header
    579596                if ((numbytes = tracefifo_out_read(libtrace->fifo, buffer,
    580                                                 sizeof(dag_record_t))) == 0) {
     597                                                dag_record_size)) == 0) {
    581598                        tracefifo_out_reset(libtrace->fifo);
    582599                        read_required = 1;
     
    603620}
    604621
    605 static int erf_dump_packet(struct libtrace_out_t *libtrace, dag_record_t *erfptr, void *buffer, size_t size) {
     622static int erf_dump_packet(struct libtrace_out_t *libtrace, dag_record_t *erfptr, int pad, void *buffer, size_t size) {
    606623        int numbytes = 0;
    607         if ((numbytes = LIBTRACE_WRITE(OUTPUT.file, erfptr, dag_record_size + 2)) == 0) {
     624        if ((numbytes = LIBTRACE_WRITE(OUTPUT.file, erfptr, dag_record_size + pad)) == 0) {
    608625                perror("libtrace_write");
    609626                return -1;
     
    613630                return -1;
    614631        }
    615         return numbytes + sizeof(dag_record_t);
    616 
     632        return numbytes + pad + dag_record_size;
    617633}
    618634               
     
    620636        int numbytes = 0;
    621637        dag_record_t erfhdr;
     638        int pad = 0;
    622639        void *payload = (void *)trace_get_link(packet);
    623640
     641        pad = erf_get_padding(packet);
    624642        if (packet->trace->format == erf_ptr ||
    625643#if HAVE_DAG
     
    629647                numbytes = erf_dump_packet(libtrace,
    630648                                (dag_record_t *)packet->buffer,
     649                                pad,
    631650                                payload,
    632651                                packet->size -
    633                                         (dag_record_size + 2));
     652                                        (dag_record_size + pad));
    634653        } else {
    635654                // convert format - build up a new erf header
    636655                // Timestamp
    637656                erfhdr.ts = trace_get_erf_timestamp(packet);
    638                 // Link type
    639                 switch(trace_get_link_type(packet)) {
    640                 case TRACE_TYPE_ETH:
    641                         erfhdr.type=TYPE_ETH; break;
    642                 case TRACE_TYPE_ATM:
    643                         erfhdr.type=TYPE_ATM; break;
    644                 default:
    645                         erfhdr.type=0;
    646                 }
    647657                // Flags. Can't do this
    648658                memset(&erfhdr.flags,1,1);
    649659                // Packet length (rlen includes format overhead)
    650                 erfhdr.rlen = trace_get_capture_length(packet) + sizeof(dag_record_t);
     660                erfhdr.rlen = trace_get_capture_length(packet) + erf_get_erf_headersize(packet);
    651661                // loss counter. Can't do this
    652662                erfhdr.lctr = 0;
     
    657667                numbytes = erf_dump_packet(libtrace,
    658668                                &erfhdr,
     669                                pad,
    659670                                payload,
    660671                                erfhdr.rlen);
     
    693704        }
    694705        ethptr = ((uint8_t *)packet->buffer +
    695                         dag_record_size + 2);
     706                        erf_get_erf_headersize(packet));
    696707        return (void *)ethptr;
    697708}
     
    747758        dag_record_t *erfptr = 0;
    748759        erfptr = (dag_record_t *)packet->buffer;
    749         return (ntohs(erfptr->rlen) - sizeof(dag_record_t));
     760        return (ntohs(erfptr->rlen) - erf_get_erf_headersize(packet));
    750761}
    751762
     
    759770        dag_record_t *erfptr = 0;
    760771        assert(packet);
    761         if((size + sizeof(dag_record_t)) > packet->size) {
     772        if((size + erf_get_erf_headersize(packet)) > packet->size) {
    762773                // can't make a packet larger
    763                 return (packet->size - sizeof(dag_record_t));
     774                return (packet->size - erf_get_erf_headersize(packet));
    764775        }
    765776        erfptr = (dag_record_t *)packet->buffer;
    766         erfptr->rlen = htons(size + sizeof(dag_record_t));
    767         packet->size = size + sizeof(dag_record_t);
     777        erfptr->rlen = htons(size + erf_get_erf_headersize(packet));
     778        packet->size = size + erf_get_erf_headersize(packet);
    768779        return size;
    769780}
  • lib/format_pcap.c

    r194d49b r8f4152b  
    232232}
    233233
    234 static int pcap_write_packet(struct libtrace_out_t *libtrace, struct libtrace_packet_t *packet) {
     234static int pcap_write_packet(struct libtrace_out_t *libtrace, const struct libtrace_packet_t *packet) {
    235235        struct pcap_pkthdr pcap_pkt_hdr;
    236236        void *link = trace_get_link(packet);
  • lib/format_template.c

    r9c6aa95 r8f4152b  
    7070}
    7171
    72 static int template_write_packet(struct libtrace_out_t *libtrace, struct libtrace_packet_t *packet) {
     72static int template_write_packet(struct libtrace_out_t *libtrace, const struct libtrace_packet_t *packet) {
    7373        return -1;
    7474}
  • lib/libtrace_int.h

    rc95b923 r8f4152b  
    6969#  include "dagformat.h"
    7070#endif
     71#include "daglegacy.h"
    7172
    7273typedef enum {SOCKET, TRACE, STDIN, DEVICE, INTERFACE, RT } source_t;
Note: See TracChangeset for help on using the changeset viewer.