source: lib/format_legacy.c @ a3041a4

4.0.1-hotfixescachetimestampsdevelopdpdk-ndagetsilivegetfragoffhelplibtrace4ndag_formatpfringrc-4.0.1rc-4.0.2rc-4.0.3rc-4.0.4ringdecrementfixringperformanceringtimestampfixes
Last change on this file since a3041a4 was a3041a4, checked in by Shane Alcock <salcock@…>, 10 years ago
  • Fixed "unused but set" warnings that new gcc now likes to report
  • Property mode set to 100644
File size: 19.0 KB
Line 
1/*
2 * This file is part of libtrace
3 *
4 * Copyright (c) 2007,2008,2009,2010 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        getenv("TZ");
157        if (putenv("TZ=Pacific/Auckland")) {
158                perror("putenv");
159                return (time_t)0;
160        }
161        tzset();
162        ret = mktime(&tm);
163
164        return ret;
165}
166       
167
168static int legacynzix_init_input(libtrace_t *libtrace) {
169
170        int retval;
171        char *filename = libtrace->uridata;
172        regex_t reg;
173        regmatch_t match;
174
175
176        legacy_init_format_data(libtrace);     
177       
178        /* Check that the filename appears to contain a suitable timestamp.
179         * Without it, we have no way of determining the actual timestamps
180         * for each packet */
181        if((retval = regcomp(&reg, "[0-9]{8}-[0-9]{6}", REG_EXTENDED)) != 0) {
182                trace_set_err(libtrace, errno, "Failed to compile regex");
183                return -1;
184        }
185        if ((retval = regexec(&reg, filename, 1, &match, 0)) !=0) {
186                trace_set_err(libtrace, errno, "Failed to exec regex");
187                return -1;
188        }
189        DATA(libtrace)->starttime = trtime(&filename[match.rm_so]);
190        return 0;
191}
192
193/* All of the formats can be started in exactly the same way */
194static int erf_start_input(libtrace_t *libtrace)
195{
196        if (libtrace->io)
197                return 0; /* Already open */
198
199        libtrace->io = trace_open_file(libtrace);
200
201        if (libtrace->io)
202                return 0;
203
204        return -1;
205}
206
207static int erf_fin_input(libtrace_t *libtrace) {
208        wandio_destroy(libtrace->io);
209        free(libtrace->format_data);
210        return 0;
211}
212
213static int legacy_prepare_packet(libtrace_t *libtrace, 
214                libtrace_packet_t *packet, void *buffer, 
215                libtrace_rt_types_t rt_type, uint32_t flags) {
216
217        if (packet->buffer != buffer &&
218                        packet->buf_control == TRACE_CTRL_PACKET) {
219                free(packet->buffer);
220        }
221
222        if ((flags & TRACE_PREP_OWN_BUFFER) == TRACE_PREP_OWN_BUFFER) {
223                packet->buf_control = TRACE_CTRL_PACKET;
224        } else
225                packet->buf_control = TRACE_CTRL_EXTERNAL;
226
227
228        packet->buffer = buffer;
229        packet->header = buffer;
230        packet->type = rt_type;
231        packet->payload = (void*)((char*)packet->buffer + 
232                libtrace->format->get_framing_length(packet));
233
234
235        if (libtrace->format_data == NULL) {
236                legacy_init_format_data(libtrace);
237        }
238        return 0;
239}
240
241static int legacy_read_packet(libtrace_t *libtrace, libtrace_packet_t *packet) {
242        int numbytes;
243        void *buffer;
244        uint32_t flags = 0;
245       
246        if (!packet->buffer || packet->buf_control == TRACE_CTRL_EXTERNAL) {
247                packet->buffer=malloc((size_t)LIBTRACE_PACKET_BUFSIZE);
248        }
249        flags |= TRACE_PREP_OWN_BUFFER;
250        buffer = packet->buffer;
251
252        switch(libtrace->format->type) {
253                case TRACE_FORMAT_LEGACY_ATM:
254                        packet->type = TRACE_RT_DATA_LEGACY_ATM;
255                        break;
256                case TRACE_FORMAT_LEGACY_POS:
257                        packet->type = TRACE_RT_DATA_LEGACY_POS;
258                        break;
259                case TRACE_FORMAT_LEGACY_ETH:
260                        packet->type = TRACE_RT_DATA_LEGACY_ETH;
261                        break;
262                default:
263                        assert(0);
264        }
265
266        /* This is going to block until we either get an entire record
267         * or we reach the end of the file */
268        while (1) {
269       
270                if ((numbytes=wandio_read(libtrace->io,
271                                                buffer,
272                                                (size_t)64)) != 64) {
273                        if (numbytes < 0) {
274                                trace_set_err(libtrace,errno,"read(%s)",libtrace->uridata);
275                        } else if (numbytes > 0) {
276                               
277                                continue;
278                        }
279                        return numbytes;
280                }
281                break;
282        }
283       
284        if (legacy_prepare_packet(libtrace, packet, packet->buffer, 
285                                packet->type, flags)) {
286                return -1;
287        }
288       
289        return 64;
290       
291}
292
293static int legacynzix_read_packet(libtrace_t *libtrace, libtrace_packet_t *packet) {
294        /* Firstly, I apologize for all the constants being thrown around in
295         * this function, but it does befit the hackish origins of the
296         * NZIX format that I use them. Anyone who wants to clean them up is
297         * welcome to do so */
298        int numbytes;
299        void *buffer;
300        char *data_ptr;
301        uint32_t flags = 0;
302       
303        if (!packet->buffer || packet->buf_control == TRACE_CTRL_EXTERNAL) {
304                packet->buffer=malloc((size_t)LIBTRACE_PACKET_BUFSIZE);
305        }
306        flags |= TRACE_PREP_OWN_BUFFER;
307       
308        buffer = packet->buffer;
309        packet->type = TRACE_RT_DATA_LEGACY_NZIX;
310       
311        while (1) {
312                if ((numbytes = wandio_read(libtrace->io, buffer,
313                                                (size_t)68)) != 68) {
314                        if (numbytes < 0) {
315                                trace_set_err(libtrace,errno,"read(%s)",libtrace->uridata);
316                        } else if (numbytes > 0)
317                                continue;
318                        return numbytes;
319                } 
320                /* Packets with a zero length are GPS timestamp packets
321                 * but they aren't inserted at the right time to be
322                 * useful - instead we'll ignore them unless we can think
323                 * of a compelling reason to do otherwise */
324                if (((legacy_nzix_t *)buffer)->len == 0)
325                        continue;
326               
327                break;
328        }
329
330        /* Lets move the padding so that it's in the framing header */
331        data_ptr = ((char *)buffer) + 12;
332        memmove(data_ptr + 2, data_ptr, 26);
333
334        if (legacy_prepare_packet(libtrace, packet, packet->buffer, 
335                                packet->type, flags)) {
336                return -1;
337        }
338        return 68;
339}
340               
341
342static libtrace_linktype_t legacypos_get_link_type(
343                const libtrace_packet_t *packet) {
344        /* POS can be PPP over HDLC (DLT_PPP_SERIAL), or it can be
345         * just straight PPP.  Sigh.
346         *
347         * Ref: RFC 1549
348         *      - Perry Lorier (2008-11-04)
349         */
350       
351        /* It can also be CHDLC, which is different again */
352       
353        /* This check matchs PPP over HDLC, a la RFC 1662 */
354        if (((char *)packet->payload)[0] == '\xFF'
355                && ((char*)packet->payload)[1] == '\x03')
356                return TRACE_TYPE_POS;
357       
358        /* This check matches unicast CHDLC */
359        else if (((char *)packet->payload)[0] == '\x0F' &&
360                ((char*)packet->payload)[1] == '\x00')
361                return TRACE_TYPE_HDLC_POS;
362       
363        /* This check matches broadcast CHDLC */
364        else if (((char *)packet->payload)[0] == '\x8F' &&
365                ((char*)packet->payload)[1] == '\x00')
366                return TRACE_TYPE_HDLC_POS;
367
368        /* Otherwise just assume raw PPP (?) */
369        else 
370                return TRACE_TYPE_PPP;
371}
372
373static libtrace_linktype_t legacyatm_get_link_type(
374                const libtrace_packet_t *packet UNUSED) {
375        return TRACE_TYPE_ATM;
376}
377
378static libtrace_linktype_t legacyeth_get_link_type(const libtrace_packet_t *packet UNUSED) {
379        return TRACE_TYPE_ETH;
380}
381
382static libtrace_linktype_t legacynzix_get_link_type(const libtrace_packet_t *packet UNUSED) {
383        return TRACE_TYPE_ETH;
384}
385
386static int legacy_get_capture_length(const libtrace_packet_t *packet UNUSED) {
387        return 64;
388}
389
390static int legacynzix_get_capture_length(const libtrace_packet_t *packet UNUSED)
391{
392        return 54;
393}
394
395static int legacypos_get_wire_length(const libtrace_packet_t *packet) {
396        legacy_pos_t *lpos = (legacy_pos_t *)packet->header;
397        assert(ntohl(lpos->wlen)>0);
398        return ntohl(lpos->wlen);
399}
400
401static int legacyatm_get_wire_length(const libtrace_packet_t *packet UNUSED) {
402        return 53;
403}
404
405static int legacyeth_get_wire_length(const libtrace_packet_t *packet) {
406        legacy_ether_t *leth = (legacy_ether_t *)packet->header; 
407        return leth->wlen+4; /* +4 for FCS, wirelen is in little endian sigh. */
408}
409
410static int legacynzix_get_wire_length(const libtrace_packet_t *packet) {
411        legacy_nzix_t *lnzix = (legacy_nzix_t *)packet->header;
412        return lnzix->len;
413}
414
415static uint64_t legacy_get_erf_timestamp(const libtrace_packet_t *packet)
416{
417        legacy_ether_t *legacy = (legacy_ether_t*)packet->header;
418        return legacy->ts;
419} 
420
421static uint32_t ts_cmp(uint32_t ts_a, uint32_t ts_b) {
422       
423        /* each ts is actually a 30 bit value */
424        ts_a <<= 2;
425        ts_b <<= 2;
426
427
428        if (ts_a > ts_b) 
429                return (ts_a - ts_b);
430        else
431                return (ts_b - ts_a);
432       
433}
434
435static struct timeval legacynzix_get_timeval(const libtrace_packet_t *packet) {
436        uint64_t new_ts = DATA(packet->trace)->ts_high;
437        uint32_t old_ts = DATA(packet->trace)->ts_old;
438        struct timeval tv;
439        uint32_t hdr_ts;
440
441        legacy_nzix_t *legacy = (legacy_nzix_t *)packet->header;
442               
443        hdr_ts = legacy->ts;
444
445        /* Seems we only need 30 bits to represent our timestamp */
446        hdr_ts >>=2;
447       
448        /* Try a sequence number wrap-around comparison */
449        if (ts_cmp(hdr_ts, old_ts) > (UINT32_MAX / 2) )
450                new_ts += (1LL << 30); /* Wraparound */
451        new_ts &= ~((1LL << 30) -1);    /* Mask lower 30 bits */
452        new_ts += hdr_ts;               /* Packet ts is the new 30 bits */
453        DATA(packet->trace)->ts_old = hdr_ts;
454
455        tv.tv_sec = DATA(packet->trace)->starttime + (new_ts / (1000 * 1000));
456        tv.tv_usec = new_ts % (1000 * 1000);
457        DATA(packet->trace)->ts_high = new_ts;
458
459
460        /*dts = tv.tv_sec + (double)tv.tv_usec / 1000 / 1000; */
461        return tv;
462       
463}       
464
465static void legacypos_help(void) {
466        printf("legacypos format module: $Revision$\n");
467        printf("Supported input URIs:\n");
468        printf("\tlegacypos:/path/to/file\t(uncompressed)\n");
469        printf("\tlegacypos:/path/to/file.gz\t(gzip-compressed)\n");
470        printf("\tlegacypos:-\t(stdin, either compressed or not)\n");
471        printf("\n");
472        printf("\te.g.: legacypos:/tmp/trace.gz\n");
473        printf("\n");
474}
475
476static void legacyatm_help(void) {
477        printf("legacyatm format module: $Revision$\n");
478        printf("Supported input URIs:\n");
479        printf("\tlegacyatm:/path/to/file\t(uncompressed)\n");
480        printf("\tlegacyatm:/path/to/file.gz\t(gzip-compressed)\n");
481        printf("\tlegacyatm:-\t(stdin, either compressed or not)\n");
482        printf("\n");
483        printf("\te.g.: legacyatm:/tmp/trace.gz\n");
484        printf("\n");
485}
486
487static void legacyeth_help(void) {
488        printf("legacyeth format module: $Revision$\n");
489        printf("Supported input URIs:\n");
490        printf("\tlegacyeth:/path/to/file\t(uncompressed)\n");
491        printf("\tlegacyeth:/path/to/file.gz\t(gzip-compressed)\n");
492        printf("\tlegacyeth:-\t(stdin, either compressed or not)\n");
493        printf("\n");
494        printf("\te.g.: legacyeth:/tmp/trace.gz\n");
495        printf("\n");
496}
497
498static void legacynzix_help(void) {
499        printf("legacynzix format module: $Revision$\n");
500        printf("Supported input URIs:\n");
501        printf("\tlegacynzix:/path/to/file\t(uncompressed)\n");
502        printf("\tlegacynzix:/path/to/file.gz\t(gzip-compressed)\n");
503        printf("\tlegacynzix:-\t(stdin, either compressed or not)\n");
504        printf("\n");
505        printf("\te.g.: legacynzix:/tmp/trace.gz\n");
506        printf("\n");
507}
508
509static struct libtrace_format_t legacyatm = {
510        "legacyatm",
511        "$Id$",
512        TRACE_FORMAT_LEGACY_ATM,
513        NULL,                           /* probe filename */
514        NULL,                           /* probe magic */
515        erf_init_input,                 /* init_input */       
516        NULL,                           /* config_input */
517        erf_start_input,                /* start_input */
518        NULL,                           /* pause_input */
519        NULL,                           /* init_output */
520        NULL,                           /* config_output */
521        NULL,                           /* start_output */
522        erf_fin_input,                  /* fin_input */
523        NULL,                           /* fin_output */
524        legacy_read_packet,             /* read_packet */
525        legacy_prepare_packet,          /* prepare_packet */
526        NULL,                           /* fin_packet */
527        NULL,                           /* write_packet */
528        legacyatm_get_link_type,        /* get_link_type */
529        NULL,                           /* get_direction */
530        NULL,                           /* set_direction */
531        legacy_get_erf_timestamp,       /* get_erf_timestamp */
532        NULL,                           /* get_timeval */
533        NULL,                           /* get_timespec */
534        NULL,                           /* get_seconds */
535        NULL,                           /* seek_erf */
536        NULL,                           /* seek_timeval */
537        NULL,                           /* seek_seconds */
538        legacy_get_capture_length,      /* get_capture_length */
539        legacyatm_get_wire_length,      /* get_wire_length */
540        legacyatm_get_framing_length,   /* get_framing_length */
541        NULL,                           /* set_capture_length */
542        NULL,                           /* get_received_packets */
543        NULL,                           /* get_filtered_packets */
544        NULL,                           /* get_dropped_packets */
545        NULL,                           /* get_captured_packets */
546        NULL,                           /* get_fd */
547        trace_event_trace,              /* trace_event */
548        legacyatm_help,                 /* help */
549        NULL                            /* next pointer */
550};
551
552static struct libtrace_format_t legacyeth = {
553        "legacyeth",
554        "$Id$",
555        TRACE_FORMAT_LEGACY_ETH,
556        NULL,                           /* probe filename */
557        NULL,                           /* probe magic */
558        erf_init_input,                 /* init_input */       
559        NULL,                           /* config_input */
560        erf_start_input,                /* start_input */
561        NULL,                           /* pause_input */
562        NULL,                           /* init_output */
563        NULL,                           /* config_output */
564        NULL,                           /* start_output */
565        erf_fin_input,                  /* fin_input */
566        NULL,                           /* fin_output */
567        legacy_read_packet,             /* read_packet */
568        legacy_prepare_packet,          /* prepare_packet */
569        NULL,                           /* fin_packet */
570        NULL,                           /* write_packet */
571        legacyeth_get_link_type,        /* get_link_type */
572        NULL,                           /* get_direction */
573        NULL,                           /* set_direction */
574        legacy_get_erf_timestamp,       /* get_erf_timestamp */
575        NULL,                           /* get_timeval */
576        NULL,                           /* get_timespec */
577        NULL,                           /* get_seconds */
578        NULL,                           /* seek_erf */
579        NULL,                           /* seek_timeval */
580        NULL,                           /* seek_seconds */
581        legacy_get_capture_length,      /* get_capture_length */
582        legacyeth_get_wire_length,      /* get_wire_length */
583        legacyeth_get_framing_length,   /* get_framing_length */
584        NULL,                           /* set_capture_length */
585        NULL,                           /* get_received_packets */
586        NULL,                           /* get_filtered_packets */
587        NULL,                           /* get_dropped_packets */
588        NULL,                           /* get_captured_packets */
589        NULL,                           /* get_fd */
590        trace_event_trace,              /* trace_event */
591        legacyeth_help,                 /* help */
592        NULL                            /* next pointer */
593};
594
595static struct libtrace_format_t legacypos = {
596        "legacypos",
597        "$Id$",
598        TRACE_FORMAT_LEGACY_POS,
599        NULL,                           /* probe filename */
600        NULL,                           /* probe magic */
601        erf_init_input,                 /* init_input */       
602        NULL,                           /* config_input */
603        erf_start_input,                /* start_input */
604        NULL,                           /* pause_input */
605        NULL,                           /* init_output */
606        NULL,                           /* config_output */
607        NULL,                           /* start_output */
608        erf_fin_input,                  /* fin_input */
609        NULL,                           /* fin_output */
610        legacy_read_packet,             /* read_packet */
611        legacy_prepare_packet,          /* prepare_packet */
612        NULL,                           /* fin_packet */
613        NULL,                           /* write_packet */
614        legacypos_get_link_type,        /* get_link_type */
615        NULL,                           /* get_direction */
616        NULL,                           /* set_direction */
617        legacy_get_erf_timestamp,       /* get_erf_timestamp */
618        NULL,                           /* get_timeval */
619        NULL,                           /* get_timespec */
620        NULL,                           /* get_seconds */
621        NULL,                           /* seek_erf */
622        NULL,                           /* seek_timeval */
623        NULL,                           /* seek_seconds */
624        legacy_get_capture_length,      /* get_capture_length */
625        legacypos_get_wire_length,      /* get_wire_length */
626        legacypos_get_framing_length,   /* get_framing_length */
627        NULL,                           /* set_capture_length */
628        NULL,                           /* get_received_packets */
629        NULL,                           /* get_filtered_packets */
630        NULL,                           /* get_dropped_packets */
631        NULL,                           /* get_captured_packets */
632        NULL,                           /* get_fd */
633        trace_event_trace,              /* trace_event */
634        legacypos_help,                 /* help */
635        NULL,                           /* next pointer */
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_captured_packets */
675        NULL,                           /* get_fd */
676        trace_event_trace,              /* trace_event */
677        legacynzix_help,                /* help */
678        NULL,                           /* next pointer */
679};
680       
681void legacy_constructor(void) {
682        register_format(&legacypos);
683        register_format(&legacyeth);
684        register_format(&legacyatm);
685        register_format(&legacynzix);
686}
Note: See TracBrowser for help on using the repository browser.