source: lib/format_legacy.c @ 756b8f9

4.0.1-hotfixescachetimestampsdevelopdpdk-ndagetsilivelibtrace4ndag_formatpfringrc-4.0.1rc-4.0.2rc-4.0.3rc-4.0.4ringdecrementfixringperformanceringtimestampfixes
Last change on this file since 756b8f9 was d8b05b7, checked in by Shane Alcock <salcock@…>, 6 years ago

Make sure our copyright covers recent years

Consistency across all of our source files is also nice.

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