source: lib/format_legacy.c @ 2c457ec

cachetimestampsdevelopdpdk-ndagetsiliverc-4.0.3rc-4.0.4ringdecrementfixringperformance
Last change on this file since 2c457ec was 2c457ec, checked in by Robert A Zeh <razeh@…>, 3 years ago

Add TRACE_ERR_WANDIO_FAILED for wandio error reporting.

Passing an errcode of 0 to trace_set_err triggers the assertion at
format_helper.c:290, making the error unrecoverable for the calling
code. This happens when the wandio layer encounters an error while
errno is still 0 (for example, an incomplete pcap packet).

To make the error recoverable, pass in TRACE_ERR_WANDIO_FAILED instead
of errno.

  • Property mode set to 100644
File size: 19.1 KB
Line 
1/*
2 *
3 * Copyright (c) 2007-2016 The University of Waikato, Hamilton, New Zealand.
4 * All rights reserved.
5 *
6 * This file is part of libtrace.
7 *
8 * This code has been developed by the University of Waikato WAND
9 * research group. For further information please see http://www.wand.net.nz/
10 *
11 * libtrace is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU Lesser General Public License as published by
13 * the Free Software Foundation; either version 3 of the License, or
14 * (at your option) any later version.
15 *
16 * libtrace is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19 * GNU Lesser General Public License for more details.
20 *
21 * You should have received a copy of the GNU Lesser General Public License
22 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
23 *
24 *
25 */
26#define _GNU_SOURCE
27
28#include "config.h"
29#include "common.h"
30#include "libtrace.h"
31#include "libtrace_int.h"
32#include "format_helper.h"
33#include "wandio.h"
34
35#include <sys/stat.h>
36#include <assert.h>
37#include <errno.h>
38#include <fcntl.h>
39#include <stdio.h>
40#include <string.h>
41#include <stdlib.h>
42#include <regex.h>
43
44#ifdef WIN32
45#  include <io.h>
46#  include <share.h>
47#endif
48
49/* The format module deals with legacy DAG formats from older revisions of the
50 * DAG hardware and software. Aside from a few minor differences, the legacy
51 * formats are very similar so we can deal with them using the same callback
52 * functions for the most part.
53 *
54 * These formats are intended for reading old ERF traces such as the earlier
55 * Auckland traces.
56 *
57 * We definitely do not support writing using these formats - one should
58 * convert packets to regular ERF instead before writing.
59 */
60
61/* Several formats are covered in this source file:
62 *
63 * Legacy Ethernet:     as seen in Auckland VI
64 * Legacy ATM:          as seen in Auckland II and IV
65 * Legacy PoS:          as seen in Leipzig I and II
66 * Legacy NZIX:         as seen in NZIX I
67 */
68
69/* Catch undefined O_LARGEFILE on *BSD etc */
70#ifndef O_LARGEFILE
71#  define O_LARGEFILE 0
72#endif
73
74#ifndef UINT32_MAX
75#  define UINT32_MAX 0xffffffff
76#endif
77
78#define DATA(x) ((struct legacy_format_data_t *)x->format_data)
79
80/* Legacy NZIX timestamps are all relative to the start of the trace, so we
81 * have to remember all sorts of stuff so that we can convert them into a
82 * useful timestamp */
83
84struct legacy_format_data_t {
85        time_t starttime;       /* Time that the trace file was started */
86        uint64_t ts_high;       /* The timestamp of the last packet */
87        uint32_t ts_old;        /* The timestamp of the last packet as
88                                   reported in the NZIX header */
89};
90
91static void legacy_init_format_data(libtrace_t *libtrace) {
92        libtrace->format_data = malloc(sizeof(struct legacy_format_data_t));
93       
94        DATA(libtrace)->ts_high = 0;
95        DATA(libtrace)->ts_old = 0;
96        DATA(libtrace)->starttime = 0;
97}
98
99static int legacyeth_get_framing_length(const libtrace_packet_t *packet UNUSED) 
100{
101        return sizeof(legacy_ether_t);
102}
103
104static int legacypos_get_framing_length(const libtrace_packet_t *packet UNUSED) 
105{
106        return sizeof(legacy_pos_t);
107}
108
109static int legacyatm_get_framing_length(const libtrace_packet_t *packet UNUSED) 
110{
111        return sizeof(legacy_cell_t);
112}
113
114static int legacynzix_get_framing_length(const libtrace_packet_t *packet UNUSED)
115{
116        return sizeof(legacy_nzix_t);
117}
118
119static int erf_init_input(libtrace_t *libtrace) 
120{
121        legacy_init_format_data(libtrace);
122
123        return 0;
124}
125
126/* Takes a trace file name and determines the time that the capture began.
127 *
128 * NZIX only features relative timestamps so the trace file name is the only
129 * indication we have of where the relative timestamping begins from
130 */
131static time_t trtime(char *s) {
132        /* XXX: this function may not be particularly portable to
133         * other platforms, e.g. *BSDs, Windows */
134        struct tm tm;
135        time_t ret;
136
137        if(sscanf(s, "%4u%2u%2u-%2u%2u%2u", &tm.tm_year, &tm.tm_mon,
138                                &tm.tm_mday, &tm.tm_hour, &tm.tm_min,
139                                &tm.tm_sec) != 6) {
140                return (time_t)0;
141        }
142        tm.tm_year = tm.tm_year - 1900;
143        tm.tm_mon --;
144        tm.tm_wday = 0; /* ignored */
145        tm.tm_yday = 0; /* ignored */
146        tm.tm_isdst = -1; /* forces check for summer time */
147       
148        /*
149        if (getenv("TZ") == NULL) {
150                fprintf(stderr, "Failed to get the current TZ");
151                return (time_t)0;
152        }
153        */
154        if (putenv("TZ=Pacific/Auckland")) {
155                perror("putenv");
156                return (time_t)0;
157        }
158        tzset();
159        ret = mktime(&tm);
160
161        return ret;
162}
163       
164
165static int legacynzix_init_input(libtrace_t *libtrace) {
166
167        int retval;
168        char *filename = libtrace->uridata;
169        regex_t reg;
170        regmatch_t match;
171
172
173        legacy_init_format_data(libtrace);     
174       
175        /* Check that the filename appears to contain a suitable timestamp.
176         * Without it, we have no way of determining the actual timestamps
177         * for each packet */
178        if((retval = regcomp(&reg, "[0-9]{8}-[0-9]{6}", REG_EXTENDED)) != 0) {
179                trace_set_err(libtrace, errno, "Failed to compile regex");
180                return -1;
181        }
182        if ((retval = regexec(&reg, filename, 1, &match, 0)) !=0) {
183                trace_set_err(libtrace, errno, "Failed to exec regex");
184                return -1;
185        }
186        DATA(libtrace)->starttime = trtime(&filename[match.rm_so]);
187        return 0;
188}
189
190/* All of the formats can be started in exactly the same way */
191static int erf_start_input(libtrace_t *libtrace)
192{
193        if (libtrace->io)
194                return 0; /* Already open */
195
196        libtrace->io = trace_open_file(libtrace);
197
198        if (libtrace->io)
199                return 0;
200
201        return -1;
202}
203
204static int erf_fin_input(libtrace_t *libtrace) {
205        wandio_destroy(libtrace->io);
206        free(libtrace->format_data);
207        return 0;
208}
209
210static int legacy_prepare_packet(libtrace_t *libtrace, 
211                libtrace_packet_t *packet, void *buffer, 
212                libtrace_rt_types_t rt_type, uint32_t flags) {
213
214        if (packet->buffer != buffer &&
215                        packet->buf_control == TRACE_CTRL_PACKET) {
216                free(packet->buffer);
217        }
218
219        if ((flags & TRACE_PREP_OWN_BUFFER) == TRACE_PREP_OWN_BUFFER) {
220                packet->buf_control = TRACE_CTRL_PACKET;
221        } else
222                packet->buf_control = TRACE_CTRL_EXTERNAL;
223
224
225        packet->buffer = buffer;
226        packet->header = buffer;
227        packet->type = rt_type;
228        packet->payload = (void*)((char*)packet->buffer + 
229                libtrace->format->get_framing_length(packet));
230
231
232        if (libtrace->format_data == NULL) {
233                legacy_init_format_data(libtrace);
234        }
235        return 0;
236}
237
238static int legacy_read_packet(libtrace_t *libtrace, libtrace_packet_t *packet) {
239        int numbytes;
240        void *buffer;
241        uint32_t flags = 0;
242       
243        if (!packet->buffer || packet->buf_control == TRACE_CTRL_EXTERNAL) {
244                packet->buffer=malloc((size_t)LIBTRACE_PACKET_BUFSIZE);
245        }
246        flags |= TRACE_PREP_OWN_BUFFER;
247        buffer = packet->buffer;
248
249        switch(libtrace->format->type) {
250                case TRACE_FORMAT_LEGACY_ATM:
251                        packet->type = TRACE_RT_DATA_LEGACY_ATM;
252                        break;
253                case TRACE_FORMAT_LEGACY_POS:
254                        packet->type = TRACE_RT_DATA_LEGACY_POS;
255                        break;
256                case TRACE_FORMAT_LEGACY_ETH:
257                        packet->type = TRACE_RT_DATA_LEGACY_ETH;
258                        break;
259                default:
260                        assert(0);
261        }
262
263        /* This is going to block until we either get an entire record
264         * or we reach the end of the file */
265        while (1) {
266       
267                if ((numbytes=wandio_read(libtrace->io,
268                                                buffer,
269                                                (size_t)64)) != 64) {
270                        if (numbytes < 0) {
271                                trace_set_err(libtrace,TRACE_ERR_WANDIO_FAILED,"read(%s)",libtrace->uridata);
272                        } else if (numbytes > 0) {
273                               
274                                continue;
275                        }
276                        return numbytes;
277                }
278                break;
279        }
280       
281        if (legacy_prepare_packet(libtrace, packet, packet->buffer, 
282                                packet->type, flags)) {
283                return -1;
284        }
285       
286        return 64;
287       
288}
289
290static int legacynzix_read_packet(libtrace_t *libtrace, libtrace_packet_t *packet) {
291        /* Firstly, I apologize for all the constants being thrown around in
292         * this function, but it does befit the hackish origins of the
293         * NZIX format that I use them. Anyone who wants to clean them up is
294         * welcome to do so */
295        int numbytes;
296        void *buffer;
297        char *data_ptr;
298        uint32_t flags = 0;
299       
300        if (!packet->buffer || packet->buf_control == TRACE_CTRL_EXTERNAL) {
301                packet->buffer=malloc((size_t)LIBTRACE_PACKET_BUFSIZE);
302        }
303        flags |= TRACE_PREP_OWN_BUFFER;
304       
305        buffer = packet->buffer;
306        packet->type = TRACE_RT_DATA_LEGACY_NZIX;
307       
308        while (1) {
309                if ((numbytes = wandio_read(libtrace->io, buffer,
310                                                (size_t)68)) != 68) {
311                        if (numbytes < 0) {
312                                trace_set_err(libtrace,TRACE_ERR_WANDIO_FAILED,"read(%s)",libtrace->uridata);
313                        } else if (numbytes > 0)
314                                continue;
315                        return numbytes;
316                } 
317                /* Packets with a zero length are GPS timestamp packets
318                 * but they aren't inserted at the right time to be
319                 * useful - instead we'll ignore them unless we can think
320                 * of a compelling reason to do otherwise */
321                if (((legacy_nzix_t *)buffer)->len == 0)
322                        continue;
323               
324                break;
325        }
326
327        /* Lets move the padding so that it's in the framing header */
328        data_ptr = ((char *)buffer) + 12;
329        memmove(data_ptr + 2, data_ptr, 26);
330
331        if (legacy_prepare_packet(libtrace, packet, packet->buffer, 
332                                packet->type, flags)) {
333                return -1;
334        }
335        return 68;
336}
337               
338
339static libtrace_linktype_t legacypos_get_link_type(
340                const libtrace_packet_t *packet) {
341        /* POS can be PPP over HDLC (DLT_PPP_SERIAL), or it can be
342         * just straight PPP.  Sigh.
343         *
344         * Ref: RFC 1549
345         *      - Perry Lorier (2008-11-04)
346         */
347       
348        /* It can also be CHDLC, which is different again */
349       
350        /* This check matchs PPP over HDLC, a la RFC 1662 */
351        if (((char *)packet->payload)[0] == '\xFF'
352                && ((char*)packet->payload)[1] == '\x03')
353                return TRACE_TYPE_POS;
354       
355        /* This check matches unicast CHDLC */
356        else if (((char *)packet->payload)[0] == '\x0F' &&
357                ((char*)packet->payload)[1] == '\x00')
358                return TRACE_TYPE_HDLC_POS;
359       
360        /* This check matches broadcast CHDLC */
361        else if (((char *)packet->payload)[0] == '\x8F' &&
362                ((char*)packet->payload)[1] == '\x00')
363                return TRACE_TYPE_HDLC_POS;
364
365        /* Otherwise just assume raw PPP (?) */
366        else 
367                return TRACE_TYPE_PPP;
368}
369
370static libtrace_linktype_t legacyatm_get_link_type(
371                const libtrace_packet_t *packet UNUSED) {
372        return TRACE_TYPE_ATM;
373}
374
375static libtrace_linktype_t legacyeth_get_link_type(const libtrace_packet_t *packet UNUSED) {
376        return TRACE_TYPE_ETH;
377}
378
379static libtrace_linktype_t legacynzix_get_link_type(const libtrace_packet_t *packet UNUSED) {
380        return TRACE_TYPE_ETH;
381}
382
383static int legacy_get_capture_length(const libtrace_packet_t *packet UNUSED) {
384        return 64;
385}
386
387static int legacynzix_get_capture_length(const libtrace_packet_t *packet UNUSED)
388{
389        return 54;
390}
391
392static int legacypos_get_wire_length(const libtrace_packet_t *packet) {
393        legacy_pos_t *lpos = (legacy_pos_t *)packet->header;
394        assert(ntohl(lpos->wlen)>0);
395        return ntohl(lpos->wlen);
396}
397
398static int legacyatm_get_wire_length(const libtrace_packet_t *packet UNUSED) {
399        return 53;
400}
401
402static int legacyeth_get_wire_length(const libtrace_packet_t *packet) {
403        legacy_ether_t *leth = (legacy_ether_t *)packet->header; 
404        return leth->wlen+4; /* +4 for FCS, wirelen is in little endian sigh. */
405}
406
407static int legacynzix_get_wire_length(const libtrace_packet_t *packet) {
408        legacy_nzix_t *lnzix = (legacy_nzix_t *)packet->header;
409        return lnzix->len;
410}
411
412static uint64_t legacy_get_erf_timestamp(const libtrace_packet_t *packet)
413{
414        legacy_ether_t *legacy = (legacy_ether_t*)packet->header;
415        return bswap_le_to_host64(legacy->ts);
416} 
417
418static uint32_t ts_cmp(uint32_t ts_a, uint32_t ts_b) {
419       
420        /* each ts is actually a 30 bit value */
421        ts_a <<= 2;
422        ts_b <<= 2;
423
424
425        if (ts_a > ts_b) 
426                return (ts_a - ts_b);
427        else
428                return (ts_b - ts_a);
429       
430}
431
432static struct timeval legacynzix_get_timeval(const libtrace_packet_t *packet) {
433        uint64_t new_ts = DATA(packet->trace)->ts_high;
434        uint32_t old_ts = DATA(packet->trace)->ts_old;
435        struct timeval tv;
436        uint32_t hdr_ts;
437
438        legacy_nzix_t *legacy = (legacy_nzix_t *)packet->header;
439               
440        hdr_ts = legacy->ts;
441
442        /* Seems we only need 30 bits to represent our timestamp */
443        hdr_ts >>=2;
444       
445        /* Try a sequence number wrap-around comparison */
446        if (ts_cmp(hdr_ts, old_ts) > (UINT32_MAX / 2) )
447                new_ts += (1LL << 30); /* Wraparound */
448        new_ts &= ~((1LL << 30) -1);    /* Mask lower 30 bits */
449        new_ts += hdr_ts;               /* Packet ts is the new 30 bits */
450        DATA(packet->trace)->ts_old = hdr_ts;
451
452        tv.tv_sec = DATA(packet->trace)->starttime + (new_ts / (1000 * 1000));
453        tv.tv_usec = new_ts % (1000 * 1000);
454        DATA(packet->trace)->ts_high = new_ts;
455
456
457        /*dts = tv.tv_sec + (double)tv.tv_usec / 1000 / 1000; */
458        return tv;
459       
460}       
461
462static void legacypos_help(void) {
463        printf("legacypos format module: $Revision: 1753 $\n");
464        printf("Supported input URIs:\n");
465        printf("\tlegacypos:/path/to/file\t(uncompressed)\n");
466        printf("\tlegacypos:/path/to/file.gz\t(gzip-compressed)\n");
467        printf("\tlegacypos:-\t(stdin, either compressed or not)\n");
468        printf("\n");
469        printf("\te.g.: legacypos:/tmp/trace.gz\n");
470        printf("\n");
471}
472
473static void legacyatm_help(void) {
474        printf("legacyatm format module: $Revision: 1753 $\n");
475        printf("Supported input URIs:\n");
476        printf("\tlegacyatm:/path/to/file\t(uncompressed)\n");
477        printf("\tlegacyatm:/path/to/file.gz\t(gzip-compressed)\n");
478        printf("\tlegacyatm:-\t(stdin, either compressed or not)\n");
479        printf("\n");
480        printf("\te.g.: legacyatm:/tmp/trace.gz\n");
481        printf("\n");
482}
483
484static void legacyeth_help(void) {
485        printf("legacyeth format module: $Revision: 1753 $\n");
486        printf("Supported input URIs:\n");
487        printf("\tlegacyeth:/path/to/file\t(uncompressed)\n");
488        printf("\tlegacyeth:/path/to/file.gz\t(gzip-compressed)\n");
489        printf("\tlegacyeth:-\t(stdin, either compressed or not)\n");
490        printf("\n");
491        printf("\te.g.: legacyeth:/tmp/trace.gz\n");
492        printf("\n");
493}
494
495static void legacynzix_help(void) {
496        printf("legacynzix format module: $Revision: 1753 $\n");
497        printf("Supported input URIs:\n");
498        printf("\tlegacynzix:/path/to/file\t(uncompressed)\n");
499        printf("\tlegacynzix:/path/to/file.gz\t(gzip-compressed)\n");
500        printf("\tlegacynzix:-\t(stdin, either compressed or not)\n");
501        printf("\n");
502        printf("\te.g.: legacynzix:/tmp/trace.gz\n");
503        printf("\n");
504}
505
506static struct libtrace_format_t legacyatm = {
507        "legacyatm",
508        "$Id$",
509        TRACE_FORMAT_LEGACY_ATM,
510        NULL,                           /* probe filename */
511        NULL,                           /* probe magic */
512        erf_init_input,                 /* init_input */       
513        NULL,                           /* config_input */
514        erf_start_input,                /* start_input */
515        NULL,                           /* pause_input */
516        NULL,                           /* init_output */
517        NULL,                           /* config_output */
518        NULL,                           /* start_output */
519        erf_fin_input,                  /* fin_input */
520        NULL,                           /* fin_output */
521        legacy_read_packet,             /* read_packet */
522        legacy_prepare_packet,          /* prepare_packet */
523        NULL,                           /* fin_packet */
524        NULL,                           /* write_packet */
525        legacyatm_get_link_type,        /* get_link_type */
526        NULL,                           /* get_direction */
527        NULL,                           /* set_direction */
528        legacy_get_erf_timestamp,       /* get_erf_timestamp */
529        NULL,                           /* get_timeval */
530        NULL,                           /* get_timespec */
531        NULL,                           /* get_seconds */
532        NULL,                           /* seek_erf */
533        NULL,                           /* seek_timeval */
534        NULL,                           /* seek_seconds */
535        legacy_get_capture_length,      /* get_capture_length */
536        legacyatm_get_wire_length,      /* get_wire_length */
537        legacyatm_get_framing_length,   /* get_framing_length */
538        NULL,                           /* set_capture_length */
539        NULL,                           /* get_received_packets */
540        NULL,                           /* get_filtered_packets */
541        NULL,                           /* get_dropped_packets */
542        NULL,                           /* get_statistics */
543        NULL,                           /* get_fd */
544        trace_event_trace,              /* trace_event */
545        legacyatm_help,                 /* help */
546        NULL,                           /* next pointer */
547        NON_PARALLEL(false)
548};
549
550static struct libtrace_format_t legacyeth = {
551        "legacyeth",
552        "$Id$",
553        TRACE_FORMAT_LEGACY_ETH,
554        NULL,                           /* probe filename */
555        NULL,                           /* probe magic */
556        erf_init_input,                 /* init_input */       
557        NULL,                           /* config_input */
558        erf_start_input,                /* start_input */
559        NULL,                           /* pause_input */
560        NULL,                           /* init_output */
561        NULL,                           /* config_output */
562        NULL,                           /* start_output */
563        erf_fin_input,                  /* fin_input */
564        NULL,                           /* fin_output */
565        legacy_read_packet,             /* read_packet */
566        legacy_prepare_packet,          /* prepare_packet */
567        NULL,                           /* fin_packet */
568        NULL,                           /* write_packet */
569        legacyeth_get_link_type,        /* get_link_type */
570        NULL,                           /* get_direction */
571        NULL,                           /* set_direction */
572        legacy_get_erf_timestamp,       /* get_erf_timestamp */
573        NULL,                           /* get_timeval */
574        NULL,                           /* get_timespec */
575        NULL,                           /* get_seconds */
576        NULL,                           /* seek_erf */
577        NULL,                           /* seek_timeval */
578        NULL,                           /* seek_seconds */
579        legacy_get_capture_length,      /* get_capture_length */
580        legacyeth_get_wire_length,      /* get_wire_length */
581        legacyeth_get_framing_length,   /* get_framing_length */
582        NULL,                           /* set_capture_length */
583        NULL,                           /* get_received_packets */
584        NULL,                           /* get_filtered_packets */
585        NULL,                           /* get_dropped_packets */
586        NULL,                           /* get_statistics */
587        NULL,                           /* get_fd */
588        trace_event_trace,              /* trace_event */
589        legacyeth_help,                 /* help */
590        NULL,                           /* next pointer */
591        NON_PARALLEL(false)
592};
593
594static struct libtrace_format_t legacypos = {
595        "legacypos",
596        "$Id$",
597        TRACE_FORMAT_LEGACY_POS,
598        NULL,                           /* probe filename */
599        NULL,                           /* probe magic */
600        erf_init_input,                 /* init_input */       
601        NULL,                           /* config_input */
602        erf_start_input,                /* start_input */
603        NULL,                           /* pause_input */
604        NULL,                           /* init_output */
605        NULL,                           /* config_output */
606        NULL,                           /* start_output */
607        erf_fin_input,                  /* fin_input */
608        NULL,                           /* fin_output */
609        legacy_read_packet,             /* read_packet */
610        legacy_prepare_packet,          /* prepare_packet */
611        NULL,                           /* fin_packet */
612        NULL,                           /* write_packet */
613        legacypos_get_link_type,        /* get_link_type */
614        NULL,                           /* get_direction */
615        NULL,                           /* set_direction */
616        legacy_get_erf_timestamp,       /* get_erf_timestamp */
617        NULL,                           /* get_timeval */
618        NULL,                           /* get_timespec */
619        NULL,                           /* get_seconds */
620        NULL,                           /* seek_erf */
621        NULL,                           /* seek_timeval */
622        NULL,                           /* seek_seconds */
623        legacy_get_capture_length,      /* get_capture_length */
624        legacypos_get_wire_length,      /* get_wire_length */
625        legacypos_get_framing_length,   /* get_framing_length */
626        NULL,                           /* set_capture_length */
627        NULL,                           /* get_received_packets */
628        NULL,                           /* get_filtered_packets */
629        NULL,                           /* get_dropped_packets */
630        NULL,                           /* get_statistics */
631        NULL,                           /* get_fd */
632        trace_event_trace,              /* trace_event */
633        legacypos_help,                 /* help */
634        NULL,                           /* next pointer */
635        NON_PARALLEL(false)
636};
637
638static struct libtrace_format_t legacynzix = {
639        "legacynzix",
640        "$Id$",
641        TRACE_FORMAT_LEGACY_NZIX,
642        NULL,                           /* probe filename */
643        NULL,                           /* probe magic */
644        legacynzix_init_input,          /* init_input */       
645        NULL,                           /* config_input */
646        erf_start_input,                /* start_input */
647        NULL,                           /* pause_input */
648        NULL,                           /* init_output */
649        NULL,                           /* config_output */
650        NULL,                           /* start_output */
651        erf_fin_input,                  /* fin_input */
652        NULL,                           /* fin_output */
653        legacynzix_read_packet,         /* read_packet */
654        legacy_prepare_packet,          /* prepare_packet */
655        NULL,                           /* fin_packet */
656        NULL,                           /* write_packet */
657        legacynzix_get_link_type,       /* get_link_type */
658        NULL,                           /* get_direction */
659        NULL,                           /* set_direction */
660        NULL,                           /* get_erf_timestamp */
661        legacynzix_get_timeval,         /* get_timeval */
662        NULL,                           /* get_timespec */
663        NULL,                           /* get_seconds */
664        NULL,                           /* seek_erf */
665        NULL,                           /* seek_timeval */
666        NULL,                           /* seek_seconds */
667        legacynzix_get_capture_length,  /* get_capture_length */
668        legacynzix_get_wire_length,     /* get_wire_length */
669        legacynzix_get_framing_length,  /* get_framing_length */
670        NULL,                           /* set_capture_length */
671        NULL,                           /* get_received_packets */
672        NULL,                           /* get_filtered_packets */
673        NULL,                           /* get_dropped_packets */
674        NULL,                           /* get_statistics */
675        NULL,                           /* get_fd */
676        trace_event_trace,              /* trace_event */
677        legacynzix_help,                /* help */
678        NULL,                           /* next pointer */
679        NON_PARALLEL(false)
680};
681       
682void legacy_constructor(void) {
683        register_format(&legacypos);
684        register_format(&legacyeth);
685        register_format(&legacyatm);
686        register_format(&legacynzix);
687}
Note: See TracBrowser for help on using the repository browser.