Changeset f0fb38f


Ignore:
Timestamp:
03/26/08 10:45:36 (14 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:
f52bcdd
Parents:
e632f2f
Message:
  • Added prepare_packet functions to all formats, primarily to support translating RT packets into the appropriate format. These functions are all used internally as well, as most formats still need to "prepare" packets that have been read by setting pointers, updating loss counters etc.
  • Also added a trace_prepare_packet function, but this is not made available externally at this stage
  • Added init_format_data functions to some formats to initialise format data structures in cases where the init_trace function does more than just that
  • Refactored rt packet reading code to use the new trace_prepare_packet functionality - also did a lot of tidying of the code
  • Added missing RT type for BPF format
Location:
lib
Files:
15 edited

Legend:

Unmodified
Added
Removed
  • lib/format_atmhdr.c

    rf2fae49 rf0fb38f  
    5656}
    5757
     58static int atmhdr_prepare_packet(libtrace_t *libtrace,
     59                libtrace_packet_t *packet, void *buffer,
     60                libtrace_rt_types_t rt_type, uint32_t flags) {
     61
     62        if (packet->buffer != buffer &&
     63                        packet->buf_control == TRACE_CTRL_PACKET) {
     64                free(packet->buffer);
     65        }
     66
     67        if ((flags & TRACE_PREP_OWN_BUFFER) == TRACE_PREP_OWN_BUFFER) {
     68                packet->buf_control = TRACE_CTRL_PACKET;
     69        } else
     70                packet->buf_control = TRACE_CTRL_EXTERNAL;
     71
     72        packet->buffer = buffer;
     73        packet->header = buffer;
     74        packet->payload = (void*)((char*)packet->buffer +
     75                        libtrace->format->get_framing_length(packet));
     76        packet->type = rt_type;
     77
     78        if (libtrace->format_data == NULL) {
     79                if (atmhdr_init_input(libtrace))
     80                        return -1;
     81        }
     82        return 0;
     83}
     84
    5885static int atmhdr_read_packet(libtrace_t *libtrace, libtrace_packet_t *packet) {
    5986        int numbytes;
    6087        void *buffer;
    61 
     88        uint32_t flags = 0;
     89       
    6290        if (!packet->buffer || packet->buf_control == TRACE_CTRL_EXTERNAL) {
    63                 packet->buf_control = TRACE_CTRL_PACKET;
    6491                packet->buffer=malloc((size_t)LIBTRACE_PACKET_BUFSIZE);
    6592        }
    6693        buffer = packet->buffer;
    67 
     94        flags |= TRACE_PREP_OWN_BUFFER;
     95       
    6896        packet->type = TRACE_RT_DATA_ATMHDR;
    6997
     
    76104        }
    77105
    78         packet->header = packet->buffer;
    79         packet->payload = (void*)((char*)packet->buffer +
    80                         libtrace->format->get_framing_length(packet));
    81 
     106        if (atmhdr_prepare_packet(libtrace, packet, buffer,
     107                                TRACE_RT_DATA_ATMHDR, flags)) {
     108                return -1;
     109        }
     110                               
     111       
    82112        return 12;
    83113}
     
    117147        NULL,                           /* fin_output */
    118148        atmhdr_read_packet,             /* read_packet */
    119         NULL,                           /* fin_packet */
     149        atmhdr_prepare_packet,          /* prepare_packet */
     150        NULL,                           /* fin_packet */
    120151        NULL,                           /* write_packet */
    121152        atmhdr_get_link_type,           /* get_link_type */
  • lib/format_bpf.c

    r95fee28 rf0fb38f  
    206206static uint64_t bpf_get_received_packets(libtrace_t *trace)
    207207{
     208        if (trace->format_data == NULL)
     209                return (uint64_t)-1;
     210
     211        if (FORMATIN(trace)->fd == -1) {
     212                /* Almost certainly a 'dead' trace so there is no socket
     213                 * for us to query */
     214                return (uint64_t) -1;
     215        }
    208216        /* If we're called with stats_valid == 0, or we're called again
    209217         * then refresh the stats.  Don't refresh the stats if we're called
     
    221229static uint64_t bpf_get_dropped_packets(libtrace_t *trace)
    222230{
     231        if (trace->format_data == NULL)
     232                return (uint64_t)-1;
     233
     234        if (FORMATIN(trace)->fd == -1) {
     235                /* Almost certainly a 'dead' trace so there is no socket
     236                 * for us to query */
     237                return (uint64_t) -1;
     238        }
    223239        /* If we're called with stats_valid == 0, or we're called again
    224240         * then refresh the stats.  Don't refresh the stats if we're called
     
    282298}
    283299
     300static int bpf_prepare_packet(libtrace_t *libtrace, libtrace_packet_t *packet,
     301                void *buffer, libtrace_rt_types_t rt_type, uint32_t flags) {
     302        if (packet->buffer != buffer &&
     303                        packet->buf_control == TRACE_CTRL_PACKET) {
     304                free(packet->buffer);
     305        }
     306
     307        if ((flags & TRACE_PREP_OWN_BUFFER) == TRACE_PREP_OWN_BUFFER) {
     308                packet->buf_control = TRACE_CTRL_PACKET;
     309        } else
     310                packet->buf_control = TRACE_CTRL_EXTERNAL;
     311
     312
     313        packet->buffer = buffer;
     314        packet->header = buffer;
     315        packet->type = rt_type;
     316
     317        /* Find the payload */
     318        /* TODO: Pcap deals with a padded FDDI linktype here */
     319        packet->payload=(char *)buffer + BPFHDR(packet)->bh_hdrlen;
     320
     321        if (libtrace->format_data == NULL) {
     322                if (bpf_init_input(libtrace))
     323                        return -1;
     324        }
     325
     326        return 0;
     327}
     328       
    284329static int bpf_read_packet(libtrace_t *libtrace, libtrace_packet_t *packet)
    285330{
     331        uint32_t flags = 0;
     332       
    286333        /* Fill the buffer */
    287334        if (FORMATIN(libtrace)->remaining<=0) {
     
    311358        if (packet->buf_control == TRACE_CTRL_PACKET)
    312359                free(packet->buffer);
    313         packet->buf_control = TRACE_CTRL_EXTERNAL;
    314 
    315         /* Find the bpf header */
    316         packet->header=FORMATIN(libtrace)->bufptr;
    317 
    318         /* Find the payload */
    319         /* TODO: Pcap deals with a padded FDDI linktype here */
    320         packet->payload=FORMATIN(libtrace)->bufptr+BPFHDR(packet)->bh_hdrlen;
     360
     361        if (bpf_prepare_packet(libtrace, packet, FORMATIN(libtrace)->bufptr,
     362                TRACE_RT_DATA_BPF, flags)) {
     363                return -1;
     364        }
     365       
    321366
    322367        /* Now deal with any padding */
     
    389434        NULL,                   /* fin_output */
    390435        bpf_read_packet,        /* read_packet */
     436        bpf_prepare_packet,     /* prepare_packet */
    391437        NULL,                   /* fin_packet */
    392438        NULL,                   /* write_packet */
  • lib/format_dag24.c

    r121b7e2 rf0fb38f  
    8383};
    8484
     85static void dag_init_format_data(libtrace_t *libtrace) {
     86        libtrace->format_data = (struct dag_format_data_t *)
     87                malloc(sizeof(struct dag_format_data_t));
     88
     89        DUCK.last_duck = 0;
     90        DUCK.duck_freq = 0;
     91        DUCK.last_pkt = 0;
     92        DUCK.dummy_duck = NULL;
     93        FORMAT_DATA->drops = 0;
     94        FORMAT_DATA->top = 0;
     95        FORMAT_DATA->bottom = 0;
     96        FORMAT_DATA->buf = NULL;
     97        FORMAT_DATA->fd = -1;
     98        FORMAT_DATA->offset = 0;
     99        FORMAT_DATA->diff = 0;
     100}
     101
    85102static int dag_available(libtrace_t *libtrace) {
    86103
     
    120137        }
    121138       
    122         libtrace->format_data = (struct dag_format_data_t *)
    123                 malloc(sizeof(struct dag_format_data_t));
    124         FORMAT_DATA->top = 0;
    125         FORMAT_DATA->bottom = 0;
     139        dag_init_format_data(libtrace);
    126140        if (S_ISCHR(buf.st_mode)) {
    127141                /* DEVICE */
     
    145159        }
    146160
    147         DUCK.last_duck = 0;
    148         DUCK.duck_freq = 0;
    149         DUCK.last_pkt = 0;
    150         DUCK.dummy_duck = NULL;
    151         FORMAT_DATA->drops = 0;
    152161        free(dag_dev_name);
    153162
     
    259268}
    260269
    261 static void dag_form_packet(dag_record_t *erfptr, libtrace_packet_t *packet) {
     270static int dag_prepare_packet(libtrace_t *libtrace, libtrace_packet_t *packet,
     271                void *buffer, libtrace_rt_types_t rt_type, uint32_t flags) {
     272
     273        dag_record_t *erfptr;
     274        if (packet->buffer != buffer &&
     275                        packet->buf_control == TRACE_CTRL_PACKET) {
     276                free(packet->buffer);
     277        }
     278
     279        if ((flags & TRACE_PREP_OWN_BUFFER) == TRACE_PREP_OWN_BUFFER) {
     280                packet->buf_control = TRACE_CTRL_PACKET;
     281        } else
     282                packet->buf_control = TRACE_CTRL_EXTERNAL;
     283       
     284        erfptr = (dag_record_t *)packet->buffer;
    262285        packet->buffer = erfptr;
    263286        packet->header = erfptr;
    264         packet->type = TRACE_RT_DATA_ERF;
     287        packet->type = rt_type;
     288
    265289        if (erfptr->flags.rxerror == 1) {
    266290                /* rxerror means the payload is corrupt - drop it
     
    273297        }
    274298
     299        if (libtrace->format_data == NULL) {
     300                dag_init_format_data(libtrace);
     301        }
     302
     303        DATA(libtrace)->drops += ntohs(erfptr->lctr);
     304
     305        return 0;
     306
    275307}
    276308
     
    278310        int numbytes;
    279311        int size = 0;
    280         struct timeval tv;
     312        uint32_t flags = 0;
     313        struct timeval tv;
    281314        dag_record_t *erfptr = NULL;
    282315
     
    307340                erfptr = dag_get_record(libtrace);
    308341        } while (erfptr == NULL);
    309         dag_form_packet(erfptr, packet);
    310         tv = trace_get_timeval(packet);
     342       
     343       
     344        if (dag_prepare_packet(libtrace, packet, erfptr, TRACE_RT_DATA_ERF,
     345                                flags))
     346                return -1;
     347        tv = trace_get_timeval(packet);
    311348        DUCK.last_pkt = tv.tv_sec;
    312         DATA(libtrace)->drops += ntohs(erfptr->lctr);
    313349        return packet->payload ? htons(erfptr->rlen) : erf_get_framing_length(packet);
    314350}
     
    348384static uint64_t dag_get_dropped_packets(libtrace_t *trace)
    349385{
     386        if (!trace->format_data)
     387                return (uint64_t)-1;
    350388        return DATA(trace)->drops;
    351389}
     
    377415        NULL,                           /* fin_output */
    378416        dag_read_packet,                /* read_packet */
    379         NULL,                           /* fin_packet */
     417        dag_prepare_packet,             /* prepare_packet */
     418        NULL,                           /* fin_packet */
    380419        NULL,                           /* write_packet */
    381420        erf_get_link_type,              /* get_link_type */
  • lib/format_dag25.c

    r2faa57e rf0fb38f  
    9999struct dag_dev_t *open_dags = NULL;
    100100
     101static void dag_init_format_data(libtrace_t *libtrace) {
     102        libtrace->format_data = (struct dag_format_data_t *)
     103                malloc(sizeof(struct dag_format_data_t));
     104        DUCK.last_duck = 0;
     105        DUCK.duck_freq = 0;
     106        DUCK.last_pkt = 0;
     107        DUCK.dummy_duck = NULL;
     108        FORMAT_DATA->stream_attached = 0;
     109        FORMAT_DATA->drops = 0;
     110        FORMAT_DATA->device = NULL;
     111        FORMAT_DATA->dagstream = 0;
     112        FORMAT_DATA->processed = 0;
     113        FORMAT_DATA->bottom = NULL;
     114        FORMAT_DATA->top = NULL;
     115}
     116
    101117/* NOTE: This function assumes the open_dag_mutex is held by the caller */
    102118static struct dag_dev_t *dag_find_open_device(char *dev_name) {
     
    187203        struct dag_dev_t *dag_device = NULL;
    188204       
     205        dag_init_format_data(libtrace);
    189206        pthread_mutex_lock(&open_dag_mutex);
    190207        if ((scan = strchr(libtrace->uridata,',')) == NULL) {
     
    197214       
    198215       
    199         libtrace->format_data = (struct dag_format_data_t *)
    200                 malloc(sizeof(struct dag_format_data_t));
    201216
    202217        /* For now, we don't offer the ability to select the stream */
     
    219234        }
    220235
    221 
    222 
    223         DUCK.last_duck = 0;
    224         DUCK.duck_freq = 0;
    225         DUCK.last_pkt = 0;
    226         DUCK.dummy_duck = NULL;
    227236        FORMAT_DATA->device = dag_device;
    228         FORMAT_DATA->stream_attached = 0;
    229         FORMAT_DATA->drops = 0;
    230237       
    231238        pthread_mutex_unlock(&open_dag_mutex);
     
    402409}
    403410
    404 static void dag_form_packet(dag_record_t *erfptr, libtrace_packet_t *packet) {
    405         packet->buffer = erfptr;
     411static int dag_prepare_packet(libtrace_t *libtrace, libtrace_packet_t *packet,
     412                void *buffer, libtrace_rt_types_t rt_type, uint32_t flags) {
     413       
     414        dag_record_t *erfptr;
     415       
     416        if (packet->buffer != buffer &&
     417                        packet->buf_control == TRACE_CTRL_PACKET) {
     418                free(packet->buffer);
     419        }
     420       
     421        if ((flags & TRACE_PREP_OWN_BUFFER) == TRACE_PREP_OWN_BUFFER) {
     422                packet->buf_control = TRACE_CTRL_PACKET;
     423        } else
     424                packet->buf_control = TRACE_CTRL_EXTERNAL;
     425       
     426        erfptr = (dag_record_t *)packet->buffer;
     427        packet->buffer = erfptr;
    406428        packet->header = erfptr;
    407         packet->type = TRACE_RT_DATA_ERF;
    408         if (erfptr->flags.rxerror == 1) {
     429        packet->type = rt_type;
     430       
     431        if (erfptr->flags.rxerror == 1) {
    409432                /* rxerror means the payload is corrupt - drop it
    410433                 * by tweaking rlen */
     
    415438                        + erf_get_framing_length(packet);
    416439        }
    417 
     440       
     441        if (libtrace->format_data == NULL) {
     442                dag_init_format_data(libtrace);
     443        }
     444       
     445        /* No loss counter for DSM coloured records - have to use
     446         * some other API */
     447        if (erfptr->type == TYPE_DSM_COLOR_ETH) {
     448               
     449        } else {
     450                DATA(libtrace)->drops += ntohs(erfptr->lctr);
     451        }
     452
     453        return 0;
    418454}
    419455
     
    424460        dag_record_t *erfptr = NULL;
    425461        int numbytes = 0;
     462        uint32_t flags = 0;
    426463       
    427464        if (DUCK.last_pkt - DUCK.last_duck > DUCK.duck_freq &&
     
    437474
    438475        if (packet->buf_control == TRACE_CTRL_PACKET) {
    439                 packet->buf_control = TRACE_CTRL_EXTERNAL;
    440476                free(packet->buffer);
    441477                packet->buffer = 0;
     
    452488        } while (erfptr == NULL);
    453489
    454         dag_form_packet(erfptr, packet);
     490        //dag_form_packet(erfptr, packet);
     491        if (dag_prepare_packet(libtrace, packet, erfptr, TRACE_RT_DATA_ERF,
     492                                flags))
     493                return -1;
    455494        tv = trace_get_timeval(packet);
    456495        DUCK.last_pkt = tv.tv_sec;
    457496       
    458         /* No loss counter for DSM coloured records - have to use
    459          * some other API */
    460         if (erfptr->type == TYPE_DSM_COLOR_ETH) {
    461                
    462         } else {
    463                 DATA(libtrace)->drops += ntohs(erfptr->lctr);
    464         }
    465497        return packet->payload ? htons(erfptr->rlen) :
    466498                                erf_get_framing_length(packet);
     
    472504        dag_record_t *erfptr = NULL;
    473505        int numbytes;
     506        uint32_t flags = 0;
    474507       
    475508        /* Need to call dag_available so that the top pointer will get
     
    487520                return event;
    488521        }
    489         dag_form_packet(erfptr, packet);
     522        //dag_form_packet(erfptr, packet);
     523        if (dag_prepare_packet(trace, packet, erfptr, TRACE_RT_DATA_ERF,
     524                                flags)) {
     525                event.type = TRACE_EVENT_TERMINATE;
     526                return event;
     527        }
     528               
     529               
    490530        event.size = trace_get_capture_length(packet) + trace_get_framing_length(packet);
    491531        if (trace->filter) {
     
    509549
    510550static uint64_t dag_get_dropped_packets(libtrace_t *trace) {
     551        if (trace->format_data == NULL)
     552                return (uint64_t)-1;
    511553        return DATA(trace)->drops;
    512554}
     
    538580        NULL,                           /* fin_output */
    539581        dag_read_packet,                /* read_packet */
    540         NULL,                           /* fin_packet */
     582        dag_prepare_packet,             /* prepare_packet */
     583        NULL,                           /* fin_packet */
    541584        NULL,                           /* write_packet */
    542585        erf_get_link_type,              /* get_link_type */
  • lib/format_duck.c

    rf3f3558 rf0fb38f  
    133133}
    134134
     135static int duck_prepare_packet(libtrace_t *libtrace, libtrace_packet_t *packet,
     136                void *buffer, libtrace_rt_types_t rt_type, uint32_t flags) {
     137
     138        if (packet->buffer != buffer &&
     139                        packet->buf_control == TRACE_CTRL_PACKET) {
     140                free(packet->buffer);
     141        }
     142
     143        if ((flags & TRACE_PREP_OWN_BUFFER) == TRACE_PREP_OWN_BUFFER) {
     144                packet->buf_control = TRACE_CTRL_PACKET;
     145        } else
     146                packet->buf_control = TRACE_CTRL_EXTERNAL;
     147
     148
     149        packet->buffer = buffer;
     150        packet->header = NULL;
     151        packet->payload = buffer;
     152        packet->type = rt_type;
     153
     154        if (libtrace->format_data == NULL) {
     155                if (duck_init_input(libtrace))
     156                        return -1;
     157        }
     158
     159        return 0;
     160}
     161
    135162static int duck_read_packet(libtrace_t *libtrace, libtrace_packet_t *packet) {
    136163
     
    138165        uint32_t version = 0;
    139166        unsigned int duck_size;
     167        uint32_t flags = 0;
    140168       
    141169        if (!packet->buffer || packet->buf_control == TRACE_CTRL_EXTERNAL) {
    142170                packet->buffer = malloc((size_t)LIBTRACE_PACKET_BUFSIZE);
    143                 packet->buf_control = TRACE_CTRL_PACKET;
    144171                if (!packet->buffer) {
    145172                        trace_set_err(libtrace, errno,
     
    149176        }
    150177
     178        flags |= TRACE_PREP_OWN_BUFFER;
     179       
    151180        if (INPUT->dag_version == 0) {
    152181                /* Read in the duck version from the start of the trace */
     
    164193       
    165194
    166         packet->header = 0;
    167         packet->payload = packet->buffer;
    168        
    169195        if (INPUT->dag_version == TRACE_RT_DUCK_2_4) {
    170196                duck_size = sizeof(duck2_4_t);
     
    180206        }
    181207
    182         if ((numbytes = libtrace_io_read(INPUT->file, packet->payload,
     208        if ((numbytes = libtrace_io_read(INPUT->file, packet->buffer,
    183209                                        (size_t)duck_size)) != (int)duck_size) {
    184210                if (numbytes == -1) {
     
    194220        }
    195221
     222        if (duck_prepare_packet(libtrace, packet, packet->buffer, packet->type,
     223                                flags))
     224                return -1;
     225       
    196226        return numbytes;
    197227}
     
    284314        duck_fin_output,                /* fin_output */
    285315        duck_read_packet,               /* read_packet */
    286         NULL,                           /* fin_packet */
     316        duck_prepare_packet,            /* prepare_packet */
     317        NULL,                           /* fin_packet */
    287318        duck_write_packet,              /* write_packet */
    288319        duck_get_link_type,             /* get_link_type */
  • lib/format_erf.c

    re632f2f rf0fb38f  
    342342}
    343343 
     344static int erf_prepare_packet(libtrace_t *libtrace, libtrace_packet_t *packet,
     345                void *buffer, libtrace_rt_types_t rt_type, uint32_t flags) {
     346       
     347        dag_record_t *erfptr;
     348       
     349        if (packet->buffer != buffer &&
     350                packet->buf_control == TRACE_CTRL_PACKET) {
     351                free(packet->buffer);
     352        }
     353
     354        if ((flags & TRACE_PREP_OWN_BUFFER) == TRACE_PREP_OWN_BUFFER) {
     355                packet->buf_control = TRACE_CTRL_PACKET;
     356        } else
     357                packet->buf_control = TRACE_CTRL_EXTERNAL;
     358       
     359       
     360        packet->type = rt_type;
     361        packet->buffer = buffer;
     362        packet->header = buffer;
     363        erfptr = (dag_record_t *)packet->buffer;
     364        if (erfptr->flags.rxerror == 1) {
     365                packet->payload = NULL;
     366                /* XXX: Do we want to do this? We never used to do this
     367                 
     368                erfptr->rlen = htons(erf_get_framing_length(packet));
     369                */
     370        } else {
     371                packet->payload = (char*)packet->buffer + erf_get_framing_length(packet);
     372        }
     373       
     374        if (libtrace->format_data == NULL) {
     375                /* Allocates the format_data structure */
     376                if (erf_init_input(libtrace))
     377                        return -1;
     378        }
     379
     380        /* Check for loss */
     381        if (erfptr->type == TYPE_DSM_COLOR_ETH) {
     382                /* No idea how we get this yet */
     383
     384        } else {
     385                DATA(libtrace)->drops += ntohs(erfptr->lctr);
     386        }
     387
     388        return 0;
     389}
    344390
    345391static int erf_read_packet(libtrace_t *libtrace, libtrace_packet_t *packet) {
     
    348394        void *buffer2 = packet->buffer;
    349395        unsigned int rlen;
    350 
     396        uint32_t flags = 0;
     397       
     398       
    351399        if (!packet->buffer || packet->buf_control == TRACE_CTRL_EXTERNAL) {
    352400                packet->buffer = malloc((size_t)LIBTRACE_PACKET_BUFSIZE);
    353                 packet->buf_control = TRACE_CTRL_PACKET;
    354401                if (!packet->buffer) {
    355402                        trace_set_err(libtrace, errno,
     
    359406        }
    360407
    361        
    362        
    363         packet->header = packet->buffer;
    364         packet->type = TRACE_RT_DATA_ERF;
    365 
     408        flags |= TRACE_PREP_OWN_BUFFER;
     409       
    366410        if ((numbytes=libtrace_io_read(INPUT.file,
    367411                                        packet->buffer,
     
    403447                return -1;
    404448        }
    405         if (((dag_record_t *)packet->buffer)->flags.rxerror == 1) {
    406                 packet->payload = NULL;
    407         } else {
    408                 packet->payload = (char*)packet->buffer + erf_get_framing_length(packet);
    409         }
     449       
     450        if (erf_prepare_packet(libtrace, packet, packet->buffer, TRACE_RT_DATA_ERF, flags))
     451                return -1;
     452       
    410453        return rlen;
    411454}
     
    637680static uint64_t erf_get_dropped_packets(libtrace_t *trace)
    638681{
     682        if (trace->format_data == NULL)
     683                return (uint64_t)-1;
    639684        return DATA(trace)->drops;
    640685}
     
    678723        erf_fin_output,                 /* fin_output */
    679724        erf_read_packet,                /* read_packet */
     725        erf_prepare_packet,             /* prepare_packet */
    680726        NULL,                           /* fin_packet */
    681727        erf_write_packet,               /* write_packet */
  • lib/format_legacy.c

    rf3f3558 rf0fb38f  
    6969};
    7070
     71static void legacy_init_format_data(libtrace_t *libtrace) {
     72        libtrace->format_data = malloc(sizeof(struct legacy_format_data_t));
     73       
     74        DATA(libtrace)->input.file = NULL;
     75        DATA(libtrace)->ts_high = 0;
     76        DATA(libtrace)->ts_old = 0;
     77        DATA(libtrace)->starttime = 0;
     78}
     79
    7180static int legacyeth_get_framing_length(const libtrace_packet_t *packet UNUSED)
    7281{
     
    91100static int erf_init_input(libtrace_t *libtrace)
    92101{
    93         libtrace->format_data = malloc(sizeof(struct legacy_format_data_t));
    94 
    95         DATA(libtrace)->input.file = NULL;
     102        legacy_init_format_data(libtrace);
    96103
    97104        return 0;
     
    136143        regmatch_t match;
    137144
    138         libtrace->format_data = malloc(sizeof(struct legacy_format_data_t));
    139 
    140         DATA(libtrace)->input.file = NULL;
    141        
     145
     146        legacy_init_format_data(libtrace);     
    142147        if((retval = regcomp(&reg, "[0-9]{8}-[0-9]{6}", REG_EXTENDED)) != 0) {
    143148                trace_set_err(libtrace, errno, "Failed to compile regex");
     
    149154        }
    150155        DATA(libtrace)->starttime = trtime(&filename[match.rm_so]);
    151         DATA(libtrace)->ts_high = 0;
    152         DATA(libtrace)->ts_old = 0;
    153156        return 0;
    154157}
     
    173176}
    174177
     178static int legacy_prepare_packet(libtrace_t *libtrace,
     179                libtrace_packet_t *packet, void *buffer,
     180                libtrace_rt_types_t rt_type, uint32_t flags) {
     181
     182        if (packet->buffer != buffer &&
     183                        packet->buf_control == TRACE_CTRL_PACKET) {
     184                free(packet->buffer);
     185        }
     186
     187        if ((flags & TRACE_PREP_OWN_BUFFER) == TRACE_PREP_OWN_BUFFER) {
     188                packet->buf_control = TRACE_CTRL_PACKET;
     189        } else
     190                packet->buf_control = TRACE_CTRL_EXTERNAL;
     191
     192
     193        packet->buffer = buffer;
     194        packet->header = buffer;
     195        packet->type = rt_type;
     196        packet->payload = (void*)((char*)packet->buffer +
     197                libtrace->format->get_framing_length(packet));
     198
     199
     200        if (libtrace->format_data == NULL) {
     201                legacy_init_format_data(libtrace);
     202        }
     203        return 0;
     204}
     205
    175206static int legacy_read_packet(libtrace_t *libtrace, libtrace_packet_t *packet) {
    176207        int numbytes;
    177208        void *buffer;
    178 
     209        uint32_t flags = 0;
     210       
    179211        if (!packet->buffer || packet->buf_control == TRACE_CTRL_EXTERNAL) {
    180                 packet->buf_control = TRACE_CTRL_PACKET;
    181212                packet->buffer=malloc((size_t)LIBTRACE_PACKET_BUFSIZE);
    182213        }
     214        flags |= TRACE_PREP_OWN_BUFFER;
    183215        buffer = packet->buffer;
    184216
     
    215247        }
    216248       
    217         packet->header = packet->buffer;
    218         packet->payload = (void*)((char*)packet->buffer +
    219                 libtrace->format->get_framing_length(packet));
     249        if (legacy_prepare_packet(libtrace, packet, packet->buffer,
     250                                packet->type, flags)) {
     251                return -1;
     252        }
    220253       
    221254        return 64;
     
    231264        void *buffer;
    232265        char *data_ptr;
     266        uint32_t flags = 0;
    233267       
    234268        if (!packet->buffer || packet->buf_control == TRACE_CTRL_EXTERNAL) {
    235                 packet->buf_control = TRACE_CTRL_PACKET;
    236269                packet->buffer=malloc((size_t)LIBTRACE_PACKET_BUFSIZE);
    237270        }
     271        flags |= TRACE_PREP_OWN_BUFFER;
     272       
    238273        buffer = packet->buffer;
    239 
    240274        packet->type = TRACE_RT_DATA_LEGACY_NZIX;
    241275       
     
    263297        memmove(data_ptr + 2, data_ptr, 26);
    264298
    265         packet->header = packet->buffer;
    266         packet->payload = (void*)((char*)packet->buffer +
    267                         libtrace->format->get_framing_length(packet));
     299        if (legacy_prepare_packet(libtrace, packet, packet->buffer,
     300                                packet->type, flags)) {
     301                return -1;
     302        }
    268303        return 68;
    269304}
     
    432467        NULL,                           /* fin_output */
    433468        legacy_read_packet,             /* read_packet */
     469        legacy_prepare_packet,          /* prepare_packet */
    434470        NULL,                           /* fin_packet */
    435471        NULL,                           /* write_packet */
     
    471507        NULL,                           /* fin_output */
    472508        legacy_read_packet,             /* read_packet */
     509        legacy_prepare_packet,          /* prepare_packet */
    473510        NULL,                           /* fin_packet */
    474511        NULL,                           /* write_packet */
     
    510547        NULL,                           /* fin_output */
    511548        legacy_read_packet,             /* read_packet */
     549        legacy_prepare_packet,          /* prepare_packet */
    512550        NULL,                           /* fin_packet */
    513551        NULL,                           /* write_packet */
     
    549587        NULL,                           /* fin_output */
    550588        legacynzix_read_packet,         /* read_packet */
     589        legacy_prepare_packet,          /* prepare_packet */
    551590        NULL,                           /* fin_packet */
    552591        NULL,                           /* write_packet */
  • lib/format_linux.c

    r95fee28 rf0fb38f  
    331331}
    332332
     333static int linuxnative_prepare_packet(libtrace_t *libtrace,
     334                libtrace_packet_t *packet, void *buffer,
     335                libtrace_rt_types_t rt_type, uint32_t flags) {
     336
     337        if (packet->buffer != buffer &&
     338                        packet->buf_control == TRACE_CTRL_PACKET) {
     339                free(packet->buffer);
     340        }
     341
     342        if ((flags & TRACE_PREP_OWN_BUFFER) == TRACE_PREP_OWN_BUFFER) {
     343                packet->buf_control = TRACE_CTRL_PACKET;
     344        } else
     345                packet->buf_control = TRACE_CTRL_EXTERNAL;
     346
     347
     348        packet->buffer = buffer;
     349        packet->header = buffer;
     350        packet->payload = (char *)buffer +
     351                sizeof(struct libtrace_linuxnative_header);
     352        packet->type = rt_type;
     353
     354        if (libtrace->format_data == NULL) {
     355                if (linuxnative_init_input(libtrace))
     356                        return -1;
     357        }
     358        return 0;
     359       
     360}
     361
    333362#define LIBTRACE_MIN(a,b) ((a)<(b) ? (a) : (b))
    334363
     
    344373        socklen_t socklen;
    345374        int snaplen;
    346 
     375        uint32_t flags = 0;
     376       
    347377        if (!packet->buffer || packet->buf_control == TRACE_CTRL_EXTERNAL) {
    348378                packet->buffer = malloc((size_t)LIBTRACE_PACKET_BUFSIZE);
    349                 packet->buf_control = TRACE_CTRL_PACKET;
    350         }
    351 
    352         packet->header = packet->buffer;
     379        }
     380
     381        flags |= TRACE_PREP_OWN_BUFFER;
     382       
    353383        packet->type = TRACE_RT_DATA_LINUX_NATIVE;
    354         packet->payload = (char*)packet->buffer+sizeof(*hdr);
    355384
    356385        hdr=(struct libtrace_linuxnative_header*)packet->buffer;
     
    398427                perror("ioctl(SIOCGSTAMP)");
    399428
     429        if (linuxnative_prepare_packet(libtrace, packet, packet->buffer,
     430                                packet->type, flags))
     431                return -1;
     432       
    400433        return hdr->wirelen+sizeof(*hdr);
    401434}
     
    490523
    491524static int linuxnative_get_fd(const libtrace_t *trace) {
     525        if (trace->format_data == NULL)
     526                return -1;
    492527        return FORMAT(trace->format_data)->fd;
    493528}
     
    506541/* Number of packets that past filtering */
    507542static uint64_t linuxnative_get_captured_packets(libtrace_t *trace) {
     543        if (trace->format_data == NULL)
     544                return UINT64_MAX;
     545        if (FORMAT(trace->format_data)->fd == -1) {
     546                /* This is probably a 'dead' trace so obviously we can't query
     547                 * the socket for capture counts, can we? */
     548                return UINT64_MAX;
     549        }
     550       
    508551        if ((FORMAT(trace->format_data)->stats_valid & 1)
    509552                        || FORMAT(trace->format_data)->stats_valid == 0) {
     
    524567 */
    525568static uint64_t linuxnative_get_dropped_packets(libtrace_t *trace) {
     569        if (trace->format_data == NULL)
     570                return UINT64_MAX;
     571        if (FORMAT(trace->format_data)->fd == -1) {
     572                /* This is probably a 'dead' trace so obviously we can't query
     573                 * the socket for drop counts, can we? */
     574                return UINT64_MAX;
     575        }
     576       
    526577        if ((FORMAT(trace->format_data)->stats_valid & 2)
    527578                        || (FORMAT(trace->format_data)->stats_valid==0)) {
     
    562613        linuxnative_fin_output,         /* fin_output */
    563614        linuxnative_read_packet,        /* read_packet */
     615        linuxnative_prepare_packet,     /* prepare_packet */
    564616        NULL,                           /* fin_packet */
    565617        linuxnative_write_packet,       /* write_packet */
  • lib/format_pcap.c

    re632f2f rf0fb38f  
    266266}
    267267
     268static int pcap_prepare_packet(libtrace_t *libtrace, libtrace_packet_t *packet,
     269                void *buffer, libtrace_rt_types_t rt_type, uint32_t flags) {
     270       
     271        if (packet->buffer != buffer &&
     272                        packet->buf_control == TRACE_CTRL_PACKET) {
     273                        free(packet->buffer);
     274        }
     275
     276        if ((flags & TRACE_PREP_OWN_BUFFER) == TRACE_PREP_OWN_BUFFER) {
     277                packet->buf_control = TRACE_CTRL_PACKET;
     278        } else
     279                packet->buf_control = TRACE_CTRL_EXTERNAL;
     280       
     281       
     282        packet->buffer = buffer;
     283        packet->header = buffer;
     284        packet->type = rt_type;
     285
     286        /* Assuming header and payload are sequential in the buffer -
     287         * regular pcap often doesn't work like this though, so hopefully
     288         * we're not called by something that is reading genuine pcap! */
     289        packet->payload = (char *)packet->header + sizeof(struct pcap_pkthdr);
     290
     291        if (libtrace->format_data == NULL) {
     292                if (pcap_init_input(libtrace))
     293                        return -1;
     294        }
     295        return 0;
     296}
    268297
    269298static int pcap_read_packet(libtrace_t *libtrace, libtrace_packet_t *packet) {
    270299        int ret = 0;
    271300        int linktype;
    272 
     301        uint32_t flags = 0;
     302       
    273303        assert(libtrace->format_data);
    274304        linktype = pcap_datalink(DATA(libtrace)->input.pcap);
    275305        packet->type = pcap_linktype_to_rt(linktype);
    276 
    277         packet->buf_control = TRACE_CTRL_PACKET;
    278306
    279307        /* If we're using the replacement pcap_next_ex() we need to
     
    287315                        return -1;
    288316                }
     317                packet->header = packet->buffer;
     318                packet->payload = (char *)packet->buffer+sizeof(struct pcap_pkthdr);
    289319                       
    290                 packet->header = packet->buffer;
    291                 packet->payload = (char *)packet->buffer +
    292                                         sizeof(struct pcap_pkthdr);
    293         }
     320        }
     321
     322        flags |= TRACE_PREP_OWN_BUFFER;
    294323       
    295324        for(;;) {
     
    310339                }
    311340
     341                /*
     342                 * pcap is nasty in that the header and payload aren't
     343                 * necessarily located sequentially in memory, but most
     344                 * sensible uses of pcap_prepare_packet will involve a
     345                 * buffer where header and payload are sequential.
     346                 *
     347                 * Basically, don't call pcap_prepare_packet here!
     348                 *
     349                if (pcap_prepare_packet(libtrace, packet, packet->buffer,
     350                                packet->type, flags)) {
     351                        return -1;
     352                }
     353                */
    312354                return ((struct pcap_pkthdr*)packet->header)->len
    313355                        +sizeof(struct pcap_pkthdr);
     
    625667        pcap_fin_output,                /* fin_output */
    626668        pcap_read_packet,               /* read_packet */
     669        pcap_prepare_packet,            /* prepare_packet */
    627670        NULL,                           /* fin_packet */
    628671        pcap_write_packet,              /* write_packet */
     
    664707        pcapint_fin_output,             /* fin_output */
    665708        pcap_read_packet,               /* read_packet */
     709        pcap_prepare_packet,            /* prepare_packet */
    666710        NULL,                           /* fin_packet */
    667711        pcapint_write_packet,           /* write_packet */
  • lib/format_pcapfile.c

    re632f2f rf0fb38f  
    223223}
    224224
     225static int pcapfile_prepare_packet(libtrace_t *libtrace,
     226                libtrace_packet_t *packet, void *buffer,
     227                libtrace_rt_types_t rt_type, uint32_t flags) {
     228
     229        if (packet->buffer != buffer &&
     230                        packet->buf_control == TRACE_CTRL_PACKET) {
     231                free(packet->buffer);
     232        }
     233
     234        if ((flags & TRACE_PREP_OWN_BUFFER) == TRACE_PREP_OWN_BUFFER) {
     235                packet->buf_control = TRACE_CTRL_PACKET;
     236        } else
     237                packet->buf_control = TRACE_CTRL_EXTERNAL;
     238       
     239       
     240        packet->buffer = buffer;
     241        packet->header = buffer;
     242        packet->payload = (char*)packet->buffer
     243                + sizeof(libtrace_pcapfile_pkt_hdr_t);
     244        packet->type = rt_type;
     245
     246        if (libtrace->format_data == NULL) {
     247                if (pcapfile_init_input(libtrace))
     248                        return -1;
     249        }
     250       
     251        return 0;
     252}
     253
    225254static int pcapfile_read_packet(libtrace_t *libtrace, libtrace_packet_t *packet)
    226255{
    227256        int err;
    228 
     257        uint32_t flags = 0;
     258       
    229259        assert(libtrace->format_data);
    230260
     
    234264        if (!packet->buffer || packet->buf_control == TRACE_CTRL_EXTERNAL) {
    235265                packet->buffer = malloc((size_t)LIBTRACE_PACKET_BUFSIZE);
    236                 packet->buf_control = TRACE_CTRL_PACKET;
    237         }
    238 
     266        }
     267
     268        flags |= TRACE_PREP_OWN_BUFFER;
     269       
    239270        err=libtrace_io_read(DATA(libtrace)->file,
    240271                        packet->buffer,
     
    249280                return 0;
    250281        }
    251 
    252         packet->header = packet->buffer;
    253 
    254282
    255283        err=libtrace_io_read(DATA(libtrace)->file,
     
    267295        }
    268296
    269         packet->payload = (char*)packet->buffer
    270                 + sizeof(libtrace_pcapfile_pkt_hdr_t);
     297        if (pcapfile_prepare_packet(libtrace, packet, packet->buffer,
     298                                packet->type, flags)) {
     299                return -1;
     300        }
    271301       
    272302        return sizeof(libtrace_pcapfile_pkt_hdr_t)
     
    544574        pcapfile_fin_output,            /* fin_output */
    545575        pcapfile_read_packet,           /* read_packet */
     576        pcapfile_prepare_packet,        /* prepare_packet */
    546577        NULL,                           /* fin_packet */
    547578        pcapfile_write_packet,          /* write_packet */
  • lib/format_rt.c

    rf3f3558 rf0fb38f  
    188188}
    189189
    190 
    191 static int rt_init_input(libtrace_t *libtrace) {
    192         char *scan;
    193         char *uridata = libtrace->uridata;
     190static void rt_init_format_data(libtrace_t *libtrace) {
    194191        libtrace->format_data = malloc(sizeof(struct rt_format_data_t));
    195192
     
    201198        RT_INFO->buf_current = NULL;
    202199        RT_INFO->buf_filled = 0;
     200        RT_INFO->hostname = NULL;
     201        RT_INFO->port = 0;
     202}
     203
     204static int rt_init_input(libtrace_t *libtrace) {
     205        char *scan;
     206        char *uridata = libtrace->uridata;
     207
     208        rt_init_format_data(libtrace);
    203209       
    204210        if (strlen(uridata) == 0) {
     
    394400                        packet->trace = RT_INFO->dummy_linux;
    395401                        break;
     402                case TRACE_RT_STATUS:
     403                case TRACE_RT_METADATA:
     404                        /* Just use the RT trace! */
     405                        packet->trace = libtrace;
     406                        break;
    396407                case TRACE_RT_DATA_LEGACY_ETH:
    397408                case TRACE_RT_DATA_LEGACY_ATM:
     
    407418        return 0; /* success */
    408419}               
    409 
    410 static void rt_set_payload(libtrace_packet_t *packet) {
    411         dag_record_t *erfptr;
    412        
    413         switch (packet->type) {
    414                 case TRACE_RT_DATA_ERF:
    415                         erfptr = (dag_record_t *)packet->header;
    416                        
    417                         if (erfptr->flags.rxerror == 1) {
    418                                 packet->payload = NULL;
    419                                 break;
    420                         }
    421                         /* else drop into the default case */
    422                 default:
    423                         packet->payload = (char *)packet->buffer +
    424                                 trace_get_framing_length(packet);
    425                         break;
    426         }
    427 }
    428420
    429421static int rt_send_ack(libtrace_t *libtrace,
     
    475467}
    476468
    477        
     469static int rt_prepare_packet(libtrace_t *libtrace, libtrace_packet_t *packet,
     470                void *buffer, libtrace_rt_types_t rt_type, uint32_t flags) {
     471
     472        if (packet->buffer != buffer &&
     473                        packet->buf_control == TRACE_CTRL_PACKET) {
     474                free(packet->buffer);
     475        }
     476
     477        if ((flags & TRACE_PREP_OWN_BUFFER) == TRACE_PREP_OWN_BUFFER) {
     478                packet->buf_control = TRACE_CTRL_PACKET;
     479        } else
     480                packet->buf_control = TRACE_CTRL_EXTERNAL;
     481
     482
     483        packet->buffer = buffer;
     484        packet->header = NULL;
     485        packet->type = rt_type;
     486        packet->payload = buffer;
     487
     488        if (libtrace->format_data == NULL) {
     489                rt_init_format_data(libtrace);
     490        }
     491
     492        return 0;
     493}       
     494
     495static int rt_read_data_packet(libtrace_t *libtrace,
     496                libtrace_packet_t *packet, int blocking) {
     497        uint32_t prep_flags = 0;
     498       
     499        if (rt_read(libtrace, &packet->buffer, (size_t)RT_INFO->rt_hdr.length,
     500                                blocking) != RT_INFO->rt_hdr.length) {
     501                return -1;
     502        }
     503
     504        if (RT_INFO->reliable > 0 && packet->type >= TRACE_RT_DATA_SIMPLE) {
     505                if (rt_send_ack(libtrace, RT_INFO->rt_hdr.sequence) == -1)
     506                                return -1;
     507        }
     508       
     509        if (rt_set_format(libtrace, packet) < 0) {
     510                return -1;
     511        }
     512               
     513        /* Update payload pointers and loss counters correctly */
     514        if (trace_prepare_packet(packet->trace, packet, packet->buffer,
     515                                packet->type, prep_flags)) {
     516                return -1;
     517        }
     518
     519        return 0;
     520}
     521
    478522static int rt_read_packet_versatile(libtrace_t *libtrace,
    479523                libtrace_packet_t *packet,int blocking) {
    480524        rt_header_t *pkt_hdr = NULL;
    481525        void *void_hdr;
     526        libtrace_rt_types_t switch_type;
    482527       
    483528        if (packet->buf_control == TRACE_CTRL_PACKET) {
     
    506551        }
    507552        packet->type = RT_INFO->rt_hdr.type;
    508 
    509553       
    510554        if (packet->type >= TRACE_RT_DATA_SIMPLE) {
    511                 if (rt_read(libtrace,
    512                                         &packet->buffer,
    513                                         (size_t)RT_INFO->rt_hdr.length,
    514                                         blocking) != RT_INFO->rt_hdr.length) {
     555                switch_type = TRACE_RT_DATA_SIMPLE;
     556        } else {
     557                switch_type = packet->type;
     558        }
     559
     560        switch(switch_type) {
     561                case TRACE_RT_DATA_SIMPLE:
     562                case TRACE_RT_DUCK_2_4:
     563                case TRACE_RT_DUCK_2_5:
     564                case TRACE_RT_STATUS:
     565                case TRACE_RT_METADATA:
     566                        if (rt_read_data_packet(libtrace, packet, blocking))
     567                                return -1;
     568                        break;
     569                case TRACE_RT_END_DATA:
     570                case TRACE_RT_KEYCHANGE:
     571                case TRACE_RT_LOSTCONN:
     572                case TRACE_RT_CLIENTDROP:
     573                case TRACE_RT_SERVERSTART:
     574                        /* All these have no payload */
     575                        break;
     576                case TRACE_RT_PAUSE_ACK:
     577                        /* XXX: Add support for this */
     578                        break;
     579                case TRACE_RT_OPTION:
     580                        /* XXX: Add support for this */
     581                        break;
     582                default:
     583                        printf("Bad rt type for client receipt: %d\n",
     584                                        switch_type);
    515585                        return -1;
    516                 }
    517                 packet->header = packet->buffer;
     586        }
     587                               
     588                       
    518589               
    519                 if (RT_INFO->reliable > 0) {
    520                         if (rt_send_ack(libtrace, RT_INFO->rt_hdr.sequence)
    521                                         == -1)
    522                         {
    523                                 return -1;
    524                         }
    525                 }
    526                
    527                        
    528                 if (rt_set_format(libtrace, packet) < 0) {
    529                         return -1;
    530                 }
    531                 rt_set_payload(packet);
    532         } else {
    533                 switch(packet->type) {
    534                         case TRACE_RT_STATUS:
    535                         case TRACE_RT_METADATA:
    536                                 if (rt_read(libtrace, &packet->buffer,
    537                                         (size_t)RT_INFO->rt_hdr.length,
    538                                         blocking) !=
    539                                                 RT_INFO->rt_hdr.length) {
    540                                         return -1;
    541                                 }
    542                                 packet->header = 0;
    543                                 packet->payload = packet->buffer;
    544                                 break;
    545                         case TRACE_RT_DUCK_2_4:
    546                         case TRACE_RT_DUCK_2_5:
    547                                 if (rt_read(libtrace, &packet->buffer,
    548                                         (size_t)RT_INFO->rt_hdr.length,
    549                                         blocking) !=
    550                                                 RT_INFO->rt_hdr.length) {
    551                                         return -1;
    552                                 }
    553                                 if (rt_set_format(libtrace, packet) < 0) {
    554                                         return -1;
    555                                 }
    556                                 packet->header = 0;
    557                                 packet->payload = packet->buffer;
    558                                 break;
    559                         case TRACE_RT_END_DATA:
    560                                 break;
    561                         case TRACE_RT_PAUSE_ACK:
    562                                 /* FIXME: Do something useful */
    563                                 break;
    564                         case TRACE_RT_OPTION:
    565                                 /* FIXME: Do something useful here as well */
    566                                 break;
    567                         case TRACE_RT_KEYCHANGE:
    568                                 break;
    569                         case TRACE_RT_LOSTCONN:
    570                                 break;
    571                         case TRACE_RT_SERVERSTART:
    572                                 break;
    573                         case TRACE_RT_CLIENTDROP:
    574                                 break;
    575                         default:
    576                                 printf("Bad rt type for client receipt: %d\n",
    577                                         packet->type);
    578                                 return -1;
    579                 }
    580         }
    581590        /* Return the number of bytes read from the stream */
    582591        RT_INFO->rt_hdr.type = TRACE_RT_LAST;
     
    711720        NULL,                           /* fin_output */
    712721        rt_read_packet,                 /* read_packet */
     722        rt_prepare_packet,              /* prepare_packet */
    713723        NULL,                           /* fin_packet */
    714724        NULL,                           /* write_packet */
  • lib/format_tsh.c

    rd186e42 rf0fb38f  
    8989}
    9090
     91static int tsh_prepare_packet(libtrace_t *libtrace, libtrace_packet_t *packet,
     92                void *buffer, libtrace_rt_types_t rt_type, uint32_t flags) {
     93        if (packet->buffer != buffer &&
     94                        packet->buf_control == TRACE_CTRL_PACKET) {
     95                free(packet->buffer);
     96        }
     97
     98        if ((flags & TRACE_PREP_OWN_BUFFER) == TRACE_PREP_OWN_BUFFER) {
     99                packet->buf_control = TRACE_CTRL_PACKET;
     100        } else
     101                packet->buf_control = TRACE_CTRL_EXTERNAL;
     102
     103
     104        packet->buffer = buffer;
     105        packet->header = buffer;
     106        packet->type = rt_type;
     107        packet->payload = (char *)packet->buffer + sizeof(tsh_pkt_header_t);
     108
     109        if (libtrace->format_data == NULL) {
     110                if (tsh_init_input(libtrace))
     111                        return -1;
     112        }
     113
     114        return 0;
     115}
     116
    91117static int tsh_read_packet(libtrace_t *libtrace, libtrace_packet_t *packet) {
    92118        int numbytes;
    93119        void *buffer2 = packet->buffer;
     120        uint32_t flags = 0;
    94121
    95122        if (!packet->buffer || packet->buf_control == TRACE_CTRL_EXTERNAL) {
    96123                packet->buffer = malloc((size_t)LIBTRACE_PACKET_BUFSIZE);
    97                 packet->buf_control = TRACE_CTRL_PACKET;
    98124                if (!packet->buffer) {
    99125                        trace_set_err(libtrace, errno,
     
    103129        }
    104130
    105         packet->header = packet->buffer;
     131        flags |= TRACE_PREP_OWN_BUFFER;
    106132        packet->type = TRACE_RT_DATA_TSH;
    107133
     
    122148
    123149        buffer2 = (char*)buffer2 + numbytes;
    124         packet->payload = buffer2;
    125150
    126151        /* Read the IP header */
     
    147172                return -1;
    148173        }
     174       
     175        if (tsh_prepare_packet(libtrace, packet, packet->buffer, packet->type,
     176                                flags)) {
     177                return -1;
     178        }
     179
    149180
    150181        return 80;
     
    205236        NULL,                           /* fin_output */
    206237        tsh_read_packet,                /* read_packet */
     238        tsh_prepare_packet,             /* prepare_packet */
    207239        NULL,                           /* fin_packet */
    208240        NULL,                           /* write_packet */
     
    249281        NULL,                           /* fin_output */
    250282        tsh_read_packet,                /* read_packet */
     283        tsh_prepare_packet,             /* prepare_packet */
    251284        NULL,                           /* fin_packet */
    252285        NULL,                           /* write_packet */
  • lib/libtrace.h.in

    rf3f3558 rf0fb38f  
    304304        TRACE_RT_DATA_LEGACY_ETH=TRACE_RT_DATA_SIMPLE+TRACE_FORMAT_LEGACY_ETH,
    305305        TRACE_RT_DATA_LINUX_NATIVE=TRACE_RT_DATA_SIMPLE+TRACE_FORMAT_LINUX_NATIVE,
     306        TRACE_RT_DATA_BPF       =TRACE_RT_DATA_SIMPLE+TRACE_FORMAT_BPF,
    306307        TRACE_RT_DATA_TSH       =TRACE_RT_DATA_SIMPLE+TRACE_FORMAT_TSH,
    307308
  • lib/libtrace_int.h

    r2faa57e rf0fb38f  
    167167                                                                PRINTF(3,4);
    168168
     169
     170/*
     171 *
     172 * The basic idea of this function is that it will take the data pointed to
     173 * by 'buffer' and treat it as a packet of the same format type as the
     174 * libtrace_t pointed to by 'trace', including the format framing (e.g. an
     175 * erf header for erf and dag formats, a pcap header for pcap formats).
     176 *
     177 * The libtrace packet pointed to by 'packet' will then have its internal
     178 * pointers and values replaced with ones that describe the packet in 'buffer'.
     179 *
     180 * 'rt_type' is used to set packet->type while 'flags' is relatively
     181 * self-explanatory. Definitions of the accepted flags will be provided below.
     182 *
     183 * The primary use of this function is to allow rt_read_packet to nicely
     184 * convert packets from the RT format back to the format that they were
     185 * originally captured with, as RT essentially encapsulates the original trace
     186 * format. We've decided to not make this function available via the API
     187 * because there are a number of issues that can arise if it is not used
     188 * very carefully and there are few situations outside of the RT case where
     189 * you'd want to do something like this anyway.
     190 *
     191 * Returns 0 if successful, -1 if something goes horribly wrong
     192 */
     193int trace_prepare_packet(libtrace_t *trace, libtrace_packet_t *packet,
     194                void *buffer, libtrace_rt_types_t rt_type, uint32_t flags);
     195
     196/* Flags for prepare_packet functions */
     197/*-------------------------------------*/
     198/* If set, the memory pointed to by 'buffer' is malloc()'d and libtrace should
     199 * undertake ownership of that memory. If not set, the memory is treated as
     200 * externally-owned and will not be freed by libtrace when the packet is
     201 * destroyed. */
     202#define TRACE_PREP_OWN_BUFFER   1
     203
     204                                                               
    169205typedef struct libtrace_sll_header_t {
    170206        uint16_t pkttype;               /* packet type */
     
    247283         */
    248284        int (*read_packet)(libtrace_t *libtrace, libtrace_packet_t *packet);
     285        /** prepares a packet for general libtrace usage
     286         * updates internal trace and packet details, such as payload pointers,
     287         * loss counters and packet types.
     288         * Intended (at this stage) only for internal use, particularly by
     289         * RT which needs to decapsulate RT packets */
     290        int (*prepare_packet)(libtrace_t *libtrace, libtrace_packet_t *packet,
     291                        void *buffer, libtrace_rt_types_t rt_type,
     292                        uint32_t flags);
    249293        /** finalise a packet
    250294         * cleanup any resources used by a packet that can't be reused for
  • lib/trace.c

    rf3f3558 rf0fb38f  
    622622DLLEXPORT void trace_destroy_dead(libtrace_t *libtrace) {
    623623        assert(libtrace);
     624        if (libtrace->format_data)
     625                free(libtrace->format_data);
    624626        free(libtrace);
    625627}
     
    761763}
    762764
     765int trace_prepare_packet(libtrace_t *trace, libtrace_packet_t *packet,
     766                void *buffer, libtrace_rt_types_t rt_type, uint32_t flags) {
     767
     768        assert(packet);
     769        assert(trace);
     770       
     771        /* XXX Proper error handling?? */
     772        if (buffer == NULL)
     773                return -1;
     774
     775        if (!(packet->buf_control==TRACE_CTRL_PACKET || packet->buf_control==TRACE_CTRL_EXTERNAL)) {
     776                trace_set_err(trace,TRACE_ERR_BAD_STATE,"Packet passed to trace_read_packet() is invalid\n");
     777                return -1;
     778        }
     779       
     780        packet->trace = trace;
     781       
     782        /* Clear packet cache */
     783        packet->capture_length = -1;
     784        packet->l3_header = NULL;
     785        packet->l3_ethertype = 0;
     786
     787        if (trace->format->prepare_packet) {
     788                return trace->format->prepare_packet(trace, packet,
     789                                buffer, rt_type, flags);
     790        }
     791        trace_set_err(trace, TRACE_ERR_UNSUPPORTED,
     792                        "This format does not support preparing packets\n");
     793        return -1;
     794
     795}
     796
    763797/* Writes a packet to the specified output
    764798 *
     
    15951629}
    15961630
     1631
    15971632uint64_t trace_get_received_packets(libtrace_t *trace)
    15981633{
Note: See TracChangeset for help on using the changeset viewer.