source: lib/format_legacy.c @ 32ee9b2

cachetimestampsdeveloprc-4.0.4ringdecrementfixringperformance
Last change on this file since 32ee9b2 was 32ee9b2, checked in by Shane Alcock <salcock@…>, 2 years ago

Add new trace_flush_output() to public API

Can be used to force a libtrace output to dump any buffered output
to disk immediately.

Note that if the file is compressed or the output trace format
requires a trailer, the flushed file will still not be properly
readable afterwards as this will not result in any trailers
being written. You'll still have to close the file for that.

Mainly this is useful for ensuring that output file sizes grow
over time in situations where the amount of output is relatively
small, rather than staying stuck at 0 bytes until we either reach
1MB of output or the file is closed. For instance, you could have
a timer that calls trace_flush_output() every 30 seconds so that
the output file size will grow if any packets were written in the
last 30 seconds.

  • Property mode set to 100644
File size: 19.2 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        NULL,                           /* flush_output */
526        legacyatm_get_link_type,        /* get_link_type */
527        NULL,                           /* get_direction */
528        NULL,                           /* set_direction */
529        legacy_get_erf_timestamp,       /* get_erf_timestamp */
530        NULL,                           /* get_timeval */
531        NULL,                           /* get_timespec */
532        NULL,                           /* get_seconds */
533        NULL,                           /* seek_erf */
534        NULL,                           /* seek_timeval */
535        NULL,                           /* seek_seconds */
536        legacy_get_capture_length,      /* get_capture_length */
537        legacyatm_get_wire_length,      /* get_wire_length */
538        legacyatm_get_framing_length,   /* get_framing_length */
539        NULL,                           /* set_capture_length */
540        NULL,                           /* get_received_packets */
541        NULL,                           /* get_filtered_packets */
542        NULL,                           /* get_dropped_packets */
543        NULL,                           /* get_statistics */
544        NULL,                           /* get_fd */
545        trace_event_trace,              /* trace_event */
546        legacyatm_help,                 /* help */
547        NULL,                           /* next pointer */
548        NON_PARALLEL(false)
549};
550
551static struct libtrace_format_t legacyeth = {
552        "legacyeth",
553        "$Id$",
554        TRACE_FORMAT_LEGACY_ETH,
555        NULL,                           /* probe filename */
556        NULL,                           /* probe magic */
557        erf_init_input,                 /* init_input */       
558        NULL,                           /* config_input */
559        erf_start_input,                /* start_input */
560        NULL,                           /* pause_input */
561        NULL,                           /* init_output */
562        NULL,                           /* config_output */
563        NULL,                           /* start_output */
564        erf_fin_input,                  /* fin_input */
565        NULL,                           /* fin_output */
566        legacy_read_packet,             /* read_packet */
567        legacy_prepare_packet,          /* prepare_packet */
568        NULL,                           /* fin_packet */
569        NULL,                           /* write_packet */
570        NULL,                           /* flush_output */
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_statistics */
589        NULL,                           /* get_fd */
590        trace_event_trace,              /* trace_event */
591        legacyeth_help,                 /* help */
592        NULL,                           /* next pointer */
593        NON_PARALLEL(false)
594};
595
596static struct libtrace_format_t legacypos = {
597        "legacypos",
598        "$Id$",
599        TRACE_FORMAT_LEGACY_POS,
600        NULL,                           /* probe filename */
601        NULL,                           /* probe magic */
602        erf_init_input,                 /* init_input */       
603        NULL,                           /* config_input */
604        erf_start_input,                /* start_input */
605        NULL,                           /* pause_input */
606        NULL,                           /* init_output */
607        NULL,                           /* config_output */
608        NULL,                           /* start_output */
609        erf_fin_input,                  /* fin_input */
610        NULL,                           /* fin_output */
611        legacy_read_packet,             /* read_packet */
612        legacy_prepare_packet,          /* prepare_packet */
613        NULL,                           /* fin_packet */
614        NULL,                           /* write_packet */
615        NULL,                           /* flush_output */
616        legacypos_get_link_type,        /* get_link_type */
617        NULL,                           /* get_direction */
618        NULL,                           /* set_direction */
619        legacy_get_erf_timestamp,       /* get_erf_timestamp */
620        NULL,                           /* get_timeval */
621        NULL,                           /* get_timespec */
622        NULL,                           /* get_seconds */
623        NULL,                           /* seek_erf */
624        NULL,                           /* seek_timeval */
625        NULL,                           /* seek_seconds */
626        legacy_get_capture_length,      /* get_capture_length */
627        legacypos_get_wire_length,      /* get_wire_length */
628        legacypos_get_framing_length,   /* get_framing_length */
629        NULL,                           /* set_capture_length */
630        NULL,                           /* get_received_packets */
631        NULL,                           /* get_filtered_packets */
632        NULL,                           /* get_dropped_packets */
633        NULL,                           /* get_statistics */
634        NULL,                           /* get_fd */
635        trace_event_trace,              /* trace_event */
636        legacypos_help,                 /* help */
637        NULL,                           /* next pointer */
638        NON_PARALLEL(false)
639};
640
641static struct libtrace_format_t legacynzix = {
642        "legacynzix",
643        "$Id$",
644        TRACE_FORMAT_LEGACY_NZIX,
645        NULL,                           /* probe filename */
646        NULL,                           /* probe magic */
647        legacynzix_init_input,          /* init_input */       
648        NULL,                           /* config_input */
649        erf_start_input,                /* start_input */
650        NULL,                           /* pause_input */
651        NULL,                           /* init_output */
652        NULL,                           /* config_output */
653        NULL,                           /* start_output */
654        erf_fin_input,                  /* fin_input */
655        NULL,                           /* fin_output */
656        legacynzix_read_packet,         /* read_packet */
657        legacy_prepare_packet,          /* prepare_packet */
658        NULL,                           /* fin_packet */
659        NULL,                           /* write_packet */
660        NULL,                           /* flush_output */
661        legacynzix_get_link_type,       /* get_link_type */
662        NULL,                           /* get_direction */
663        NULL,                           /* set_direction */
664        NULL,                           /* get_erf_timestamp */
665        legacynzix_get_timeval,         /* get_timeval */
666        NULL,                           /* get_timespec */
667        NULL,                           /* get_seconds */
668        NULL,                           /* seek_erf */
669        NULL,                           /* seek_timeval */
670        NULL,                           /* seek_seconds */
671        legacynzix_get_capture_length,  /* get_capture_length */
672        legacynzix_get_wire_length,     /* get_wire_length */
673        legacynzix_get_framing_length,  /* get_framing_length */
674        NULL,                           /* set_capture_length */
675        NULL,                           /* get_received_packets */
676        NULL,                           /* get_filtered_packets */
677        NULL,                           /* get_dropped_packets */
678        NULL,                           /* get_statistics */
679        NULL,                           /* get_fd */
680        trace_event_trace,              /* trace_event */
681        legacynzix_help,                /* help */
682        NULL,                           /* next pointer */
683        NON_PARALLEL(false)
684};
685       
686void legacy_constructor(void) {
687        register_format(&legacypos);
688        register_format(&legacyeth);
689        register_format(&legacyatm);
690        register_format(&legacynzix);
691}
Note: See TracBrowser for help on using the repository browser.