source: lib/format_erf.c @ fe43699

4.0.1-hotfixescachetimestampsdevelopdpdk-ndagetsilivegetfragoffhelplibtrace4ndag_formatpfringrc-4.0.1rc-4.0.2rc-4.0.3rc-4.0.4ringdecrementfixringperformanceringtimestampfixes
Last change on this file since fe43699 was fe43699, checked in by Daniel Lawson <dlawson@…>, 16 years ago

help functions in erf, wag modules.

  • Property mode set to 100644
File size: 20.0 KB
Line 
1/*
2 * This file is part of libtrace
3 *
4 * Copyright (c) 2004 The University of Waikato, Hamilton, New Zealand.
5 * Authors: Daniel Lawson
6 *          Perry Lorier
7 *         
8 * All rights reserved.
9 *
10 * This code has been developed by the University of Waikato WAND
11 * research group. For further information please see http://www.wand.net.nz/
12 *
13 * libtrace is free software; you can redistribute it and/or modify
14 * it under the terms of the GNU General Public License as published by
15 * the Free Software Foundation; either version 2 of the License, or
16 * (at your option) any later version.
17 *
18 * libtrace is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
21 * GNU General Public License for more details.
22 *
23 * You should have received a copy of the GNU General Public License
24 * along with libtrace; if not, write to the Free Software
25 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
26 *
27 * $Id$
28 *
29 */
30
31#include "libtrace.h"
32#include "format.h"
33#include "rtserver.h"
34#include "parse_cmd.h"
35
36#ifdef HAVE_INTTYPES_H
37#  include <inttypes.h>
38#else
39#  error "Can't find inttypes.h - this needs to be fixed"
40#endif
41
42#ifdef HAVE_STDDEF_H
43#  include <stddef.h>
44#else
45# error "Can't find stddef.h - do you define ptrdiff_t elsewhere?"
46#endif
47#include <sys/types.h>
48#include <sys/socket.h>
49#include <sys/un.h>
50#include <sys/mman.h>
51#include <sys/stat.h>
52#include <unistd.h>
53#include <assert.h>
54#include <errno.h>
55#include <netdb.h>
56#include <fcntl.h>
57#include <getopt.h>
58
59/* Catch undefined O_LARGEFILE on *BSD etc */
60#ifndef O_LARGEFILE
61#  define O_LARGEFILE 0
62#endif
63
64#ifdef HAVE_DAG
65static int dag_init_input(struct libtrace_t *libtrace) {
66        struct stat buf;
67        if (stat(libtrace->conn_info.path,&buf) == -1) {
68                perror("stat");
69                return 0;
70        } 
71        if (S_ISCHR(buf.st_mode)) {
72                // DEVICE
73                if((libtrace->input.fd = 
74                                dag_open(libtrace->conn_info.path)) < 0) {
75                        fprintf(stderr,"Cannot open DAG %s: %m\n", 
76                                        libtrace->conn_info.path,errno);
77                        exit(0);
78                }
79                if((libtrace->dag.buf = (void *)
80                                dag_mmap(libtrace->input.fd)) == MAP_FAILED) {
81                        fprintf(stderr,"Cannot mmap DAG %s: %m\n", 
82                                        libtrace->conn_info.path,errno);
83                        exit(0);
84                }
85                if(dag_start(libtrace->input.fd) < 0) {
86                        fprintf(stderr,"Cannot start DAG %s: %m\n", 
87                                        libtrace->conn_info.path,errno);
88                        exit(0);
89                }
90        } else {
91                fprintf(stderr,"%s isn't a valid char device, exiting\n",
92                                libtrace->conn_info.path);
93                return 0;
94        }
95}
96#endif
97
98static int erf_init_input(struct libtrace_t *libtrace) {
99        struct stat buf;
100        struct hostent *he;
101        struct sockaddr_in remote;
102        struct sockaddr_un unix_sock;
103        if (!strncmp(libtrace->conn_info.path,"-",1)) {
104                // STDIN
105#if HAVE_ZLIB
106                libtrace->input.file = gzdopen(STDIN, "r");
107#else   
108                libtrace->input.file = stdin;
109#endif
110
111        } else {
112                if (stat(libtrace->conn_info.path,&buf) == -1 ) {
113                        perror("stat");
114                        return 0;
115                }
116                if (S_ISSOCK(buf.st_mode)) {
117                        // SOCKET
118                        if ((libtrace->input.fd = socket(
119                                        AF_UNIX, SOCK_STREAM, 0)) == -1) {
120                                perror("socket");
121                                return 0;
122                        }
123                        unix_sock.sun_family = AF_UNIX;
124                        bzero(unix_sock.sun_path,108);
125                        snprintf(unix_sock.sun_path,
126                                        108,"%s"
127                                        ,libtrace->conn_info.path);
128
129                        if (connect(libtrace->input.fd, 
130                                        (struct sockaddr *)&unix_sock,
131                                        sizeof(struct sockaddr)) == -1) {
132                                perror("connect (unix)");
133                                return 0;
134                        }
135                } else { 
136                        // TRACE
137#if HAVE_ZLIB
138                        // using gzdopen means we can set O_LARGEFILE
139                        // ourselves. However, this way is messy and
140                        // we lose any error checking on "open"
141                        libtrace->input.file = 
142                                gzdopen(open(
143                                        libtrace->conn_info.path,
144                                        O_LARGEFILE), "r");
145#else
146                        libtrace->input.file = 
147                                fdopen(open(
148                                        libtrace->conn_info.path,
149                                        O_LARGEFILE), "r");
150#endif
151
152                }
153        }
154}
155
156static int rtclient_init_input(struct libtrace_t *libtrace) {
157        char *scan;
158        char *uridata = libtrace->conn_info.path;
159        struct hostent *he;
160        struct sockaddr_in remote;
161
162        if (strlen(uridata) == 0) {
163                libtrace->conn_info.rt.hostname = 
164                        strdup("localhost");
165                libtrace->conn_info.rt.port = 
166                        COLLECTOR_PORT;
167        } else {
168                if ((scan = strchr(uridata,':')) == NULL) {
169                        libtrace->conn_info.rt.hostname = 
170                                strdup(uridata);
171                        libtrace->conn_info.rt.port =
172                                COLLECTOR_PORT;
173                } else {
174                        libtrace->conn_info.rt.hostname = 
175                                (char *)strndup(uridata,
176                                                (scan - uridata));
177                        libtrace->conn_info.rt.port = 
178                                atoi(++scan);
179                }
180        }
181       
182        if ((he=gethostbyname(libtrace->conn_info.rt.hostname)) == NULL) { 
183                perror("gethostbyname");
184                return 0;
185        } 
186        if ((libtrace->input.fd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
187                perror("socket");
188                return 0;
189        }
190
191        remote.sin_family = AF_INET;   
192        remote.sin_port = htons(libtrace->conn_info.rt.port);
193        remote.sin_addr = *((struct in_addr *)he->h_addr);
194        bzero(&(remote.sin_zero), 8);
195
196        if (connect(libtrace->input.fd, (struct sockaddr *)&remote,
197                                sizeof(struct sockaddr)) == -1) {
198                perror("connect (inet)");
199                return 0;
200        }
201}
202
203static int erf_init_output(struct libtrace_out_t *libtrace) {
204        char *filemode = 0;
205
206        libtrace->options.erf.level = 1;
207        asprintf(&filemode,"wb%d",libtrace->options.erf.level);
208
209        if (!strncmp(libtrace->uridata,"-",1)) {
210                // STDOUT
211#if HAVE_ZLIB
212                libtrace->output.file = gzdopen(dup(1), filemode);
213#else
214                libtrace->output.file = stdout;
215#endif
216        }
217        else {
218                // TRACE
219#if HAVE_ZLIB
220                // using gzdopen means we can set O_LARGEFILE
221                // ourselves. However, this way is messy and
222                // we lose any error checking on "open"
223                libtrace->output.file =  gzdopen(open(
224                                        libtrace->uridata,
225                                        O_CREAT | O_LARGEFILE | O_WRONLY, 
226                                        S_IRUSR | S_IWUSR), filemode);
227#else
228                libtrace->output.file =  fdopen(open(
229                                        libtrace->uridata,
230                                        O_CREAT | O_LARGEFILE | O_WRONLY, 
231                                        S_IRUSR | S_IWUSR), "w");
232#endif
233        }
234       
235
236}
237
238static int rtclient_init_output(struct libtrace_out_t *libtrace) {
239        char * uridata = libtrace->uridata;
240        char * scan;
241        // extract conn_info from uridata
242        if (strlen(uridata) == 0) {
243                libtrace->conn_info.rt.hostname = strdup("localhost");
244                libtrace->conn_info.rt.port = COLLECTOR_PORT;
245        }
246        else {
247                if ((scan = strchr(uridata,':')) == NULL) {
248                        libtrace->conn_info.rt.hostname =
249                                strdup(uridata);
250                        libtrace->conn_info.rt.port =
251                                COLLECTOR_PORT;
252                } else {
253                        libtrace->conn_info.rt.hostname =
254                                (char *)strndup(uridata,
255                                                (scan - uridata));
256                        libtrace->conn_info.rt.port =
257                                atoi(++scan);
258                }
259        }
260       
261       
262        libtrace->output.rtserver = rtserver_create(libtrace->conn_info.rt.hostname,
263                                libtrace->conn_info.rt.port);
264        if (!libtrace->output.rtserver)
265                return 0;
266       
267}
268
269static int erf_config_output(struct libtrace_out_t *libtrace, int argc, char *argv[]) {
270        int opt;
271        int level = libtrace->options.erf.level;
272        optind = 1;
273
274        while ((opt = getopt(argc, argv, "z:")) != EOF) {
275                switch (opt) {
276                        case 'z':
277                                level = atoi(optarg);
278                                break;
279                        default:
280                                printf("Bad argument to erf: %s\n", opt);
281                                // maybe spit out some help here
282                                return -1;
283                }
284        }
285        if (level != libtrace->options.erf.level) {
286                if (level > 9 || level < 0) {
287                        // retarded level choice
288                        printf("Compression level must be between 0 and 9 inclusive - you selected %i \n", level);
289                       
290                } else {
291                        libtrace->options.erf.level = level;
292                        return gzsetparams(libtrace->output.file, level, Z_DEFAULT_STRATEGY);
293                }
294        }
295        return 0;
296
297}
298
299static int rtclient_config_output(struct libtrace_out_t *libtrace, int argc, char *argv[]) {
300        return 0;
301}
302
303#ifdef HAVE_DAG
304static int dag_fin_input(struct libtrace_t *libtrace) {
305        dag_stop(libtrace->input.fd);
306}
307#endif
308
309static int erf_fin_input(struct libtrace_t *libtrace) {
310#if HAVE_ZLIB
311        gzclose(libtrace->input.file);
312#else   
313        fclose(libtrace->input.file);   
314#endif
315}
316
317static int rtclient_fin_input(struct libtrace_t *libtrace) {
318        close(libtrace->input.fd);
319}
320
321static int erf_fin_output(struct libtrace_out_t *libtrace) {
322#if HAVE_ZLIB
323        gzclose(libtrace->output.file);
324#else
325        fclose(libtrace->output.file);
326#endif
327}
328 
329
330static int rtclient_fin_output(struct libtrace_out_t *libtrace) {
331        rtserver_destroy(libtrace->output.rtserver);
332}
333
334#if HAVE_DAG
335static int dag_read(struct libtrace_t *libtrace, void *buffer, size_t len) {
336        int numbytes;
337        static short lctr = 0;
338        struct dag_record_t *erfptr = 0;
339        int rlen;
340
341        if (buffer == 0)
342                buffer = malloc(len);
343       
344        libtrace->dag.bottom = libtrace->dag.top;
345        libtrace->dag.top = dag_offset(
346                        libtrace->input.fd,
347                        &(libtrace->dag.bottom),
348                        0);
349        libtrace->dag.diff = libtrace->dag.top -
350                libtrace->dag.bottom;
351
352        numbytes=libtrace->dag.diff;
353        libtrace->dag.offset = 0;
354        return numbytes;
355}
356#endif
357
358#if HAVE_DAG
359static int dag_read_packet(struct libtrace_t *libtrace, struct libtrace_packet_t *packet) {
360        int numbytes;
361        int size;
362        char buf[RP_BUFSIZE];
363        dag_record_t *erfptr;
364        void *buffer = packet->buffer;
365        void *buffer2 = buffer;
366        int rlen;
367       
368        if (libtrace->dag.diff == 0) {
369                if ((numbytes = dag_read(libtrace,buf,RP_BUFSIZE)) <= 0) 
370                        return numbytes;
371        }
372
373        //DAG always gives us whole packets
374        erfptr = (dag_record_t *) ((void *)libtrace->dag.buf + 
375                        (libtrace->dag.bottom + libtrace->dag.offset));
376        size = ntohs(erfptr->rlen);
377
378        if ( size  > LIBTRACE_PACKET_BUFSIZE) {
379                printf("%d\n",size);
380                assert( size < LIBTRACE_PACKET_BUFSIZE);
381        }
382
383        // have to copy it out of the memory hole at this stage:
384        memcpy(packet->buffer, erfptr, size);
385
386        packet->size = size;
387        libtrace->dag.offset += size;
388        libtrace->dag.diff -= size;
389
390        assert(libtrace->dag.diff >= 0);
391
392        return (size);
393}
394#endif
395
396static int erf_read_packet(struct libtrace_t *libtrace, struct libtrace_packet_t *packet) {
397        int numbytes;
398        int size;
399        char buf[RP_BUFSIZE];
400        dag_record_t *erfptr;
401        void *buffer = packet->buffer;
402        void *buffer2 = buffer;
403        int rlen;
404       
405        if ((numbytes=gzread(libtrace->input.file,
406                                        buffer,
407                                        dag_record_size)) == -1) {
408                perror("gzread");
409                return -1;
410        }
411        if (numbytes == 0) {
412                return 0;
413        }
414        rlen = ntohs(((dag_record_t *)buffer)->rlen);
415        size = rlen - dag_record_size;
416        assert(size < LIBTRACE_PACKET_BUFSIZE);
417        buffer2 = buffer + dag_record_size;
418       
419        // read in the rest of the packet
420        if ((numbytes=gzread(libtrace->input.file,
421                                        buffer2,
422                                        size)) == -1) {
423                perror("gzread");
424                return -1;
425        }
426        packet->size = rlen;
427        return rlen;
428}
429
430static int rtclient_read(struct libtrace_t *libtrace, void *buffer, size_t len) {
431        int numbytes;
432        static short lctr = 0;
433        struct dag_record_t *erfptr = 0;
434        int rlen;
435
436        if (buffer == 0)
437                buffer = malloc(len);
438        while(1) {
439#ifndef MSG_NOSIGNAL
440#  define MSG_NOSIGNAL 0
441#endif
442                if ((numbytes = recv(libtrace->input.fd,
443                                                buffer,
444                                                len,
445                                                MSG_NOSIGNAL)) == -1) {
446                        if (errno == EINTR) {
447                                //ignore EINTR in case
448                                // a caller is using signals
449                                continue;
450                        }
451                        perror("recv");
452                        return -1;
453                }
454                break;
455
456        }
457        return numbytes;
458}
459
460static int rtclient_read_packet(struct libtrace_t *libtrace, struct libtrace_packet_t *packet) {
461        int numbytes;
462        int size;
463        char buf[RP_BUFSIZE];
464        dag_record_t *erfptr;
465        int read_required = 0;
466       
467        void *buffer = 0;
468        buffer = packet->buffer;
469
470        do {
471                if (fifo_out_available(libtrace->fifo) == 0 || read_required) {
472                        if ((numbytes = rtclient_read(
473                                                libtrace,buf,RP_BUFSIZE))<=0) {
474                                return numbytes;
475                        }
476                        assert(libtrace->fifo);
477                        fifo_write(libtrace->fifo,buf,numbytes);
478                        read_required = 0;
479                }
480                // Read status byte
481                if (fifo_out_read(libtrace->fifo,
482                                &packet->status, sizeof(int)) == 0) {
483                        read_required = 1;
484                        continue;
485                }
486                fifo_out_update(libtrace->fifo,sizeof(int));
487
488                // read in the ERF header
489                if ((numbytes = fifo_out_read(libtrace->fifo, buffer,
490                                                sizeof(dag_record_t))) == 0) {
491                        fifo_out_reset(libtrace->fifo);
492                        read_required = 1;
493                        continue;
494                }
495                size = ntohs(((dag_record_t *)buffer)->rlen);
496
497                // read in the full packet
498                if ((numbytes = fifo_out_read(libtrace->fifo, 
499                                                buffer, size)) == 0) {
500                        fifo_out_reset(libtrace->fifo);
501                        read_required = 1;
502                        continue;
503                }
504
505                // got in our whole packet, so...
506                fifo_out_update(libtrace->fifo,size);
507
508                fifo_ack_update(libtrace->fifo,size + sizeof(int));
509
510                packet->size = numbytes;
511                return numbytes;
512        } while(1);
513}
514
515static int erf_write_packet(struct libtrace_out_t *libtrace, struct libtrace_packet_t *packet) {
516        int numbytes = 0;
517
518        if ((numbytes = gzwrite(libtrace->output.file, packet->buffer, packet->size)) == 0) {
519                perror("gzwrite");
520                return -1;
521        }
522        return numbytes;
523}
524
525static int rtclient_write_packet(struct libtrace_out_t *libtrace, struct libtrace_packet_t *packet) {
526        int numbytes = 0;
527        int size;
528        int intsize = sizeof(int);
529        char buf[RP_BUFSIZE];
530        void *buffer = &buf[intsize];
531        int write_required = 0;
532       
533        do {
534                if (rtserver_checklisten(libtrace->output.rtserver) < 0)
535                        return -1;
536
537                assert(libtrace->fifo);
538                if (fifo_out_available(libtrace->fifo) == 0 || write_required) {
539                        // Packet added to fifo
540                        if ((numbytes = fifo_write(libtrace->fifo, packet->buffer, packet->size)) == 0) {
541                                // some error with the fifo
542                                perror("fifo_write");
543                                return -1;
544                        }
545                        write_required = 0;
546                }
547
548                // Read from fifo and add protocol header
549                if ((numbytes = fifo_out_read(libtrace->fifo, buffer, sizeof(dag_record_t))) == 0) {
550                        // failure reading in from fifo
551                        fifo_out_reset(libtrace->fifo);
552                        write_required = 1;
553                        continue;
554                }
555                size = ntohs(((dag_record_t *)buffer)->rlen);
556                assert(size < LIBTRACE_PACKET_BUFSIZE);
557                if ((numbytes = fifo_out_read(libtrace->fifo, buffer, size)) == 0) {
558                       // failure reading in from fifo
559                       fifo_out_reset(libtrace->fifo);
560                       write_required = 1;
561                       continue;
562                }
563                // Sort out the protocol header
564                memcpy(buf, &packet->status, intsize);
565
566                if ((numbytes = rtserver_sendclients(libtrace->output.rtserver, buf, size + sizeof(int))) < 0) {
567                        write_required = 0;
568                        continue;
569                }
570
571
572                fifo_out_update(libtrace->fifo, size);
573                fifo_ack_update(libtrace->fifo, size);
574        } while(1);
575}
576
577static void *erf_get_link(const struct libtrace_packet_t *packet) {
578        const void *ethptr = 0;
579        dag_record_t *erfptr = 0;
580        erfptr = (dag_record_t *)packet->buffer;
581       
582        if (erfptr->flags.rxerror == 1) {
583                return NULL;
584        }
585        ethptr = ((uint8_t *)packet->buffer +
586                        dag_record_size + 2);
587        return (void *)ethptr;
588}
589
590static libtrace_linktype_t erf_get_link_type(const struct libtrace_packet_t *packet) {
591        dag_record_t *erfptr = 0;
592        erfptr = (dag_record_t *)packet->buffer;
593        switch (erfptr->type) {
594                case TYPE_ETH: return TRACE_TYPE_ETH;
595                case TYPE_ATM: return TRACE_TYPE_ATM;
596                default: assert(0);
597        }
598        return erfptr->type;
599}
600
601static int8_t erf_get_direction(const struct libtrace_packet_t *packet) {
602        dag_record_t *erfptr = 0;
603        erfptr = (dag_record_t *)packet->buffer;
604        return erfptr->flags.iface;
605}
606
607static int8_t erf_set_direction(const struct libtrace_packet_t *packet, int8_t direction) {
608        dag_record_t *erfptr = 0;
609        erfptr = (dag_record_t *)packet->buffer;
610        erfptr->flags.iface = direction;
611        return erfptr->flags.iface;
612}
613
614static uint64_t erf_get_erf_timestamp(const struct libtrace_packet_t *packet) {
615        dag_record_t *erfptr = 0;
616        erfptr = (dag_record_t *)packet->buffer;
617        return erfptr->ts;
618}
619
620static int erf_get_capture_length(const struct libtrace_packet_t *packet) {
621        dag_record_t *erfptr = 0;
622        erfptr = (dag_record_t *)packet->buffer;
623        return ntohs(erfptr->rlen);
624}
625
626static int erf_get_wire_length(const struct libtrace_packet_t *packet) {
627        dag_record_t *erfptr = 0;
628        erfptr = (dag_record_t *)packet->buffer;
629        return ntohs(erfptr->wlen);
630}
631
632static size_t erf_set_capture_length(struct libtrace_packet_t *packet, const size_t size) {
633        dag_record_t *erfptr = 0;
634        assert(packet);
635        if(size > packet->size) {
636                // can't make a packet larger
637                return packet->size;
638        }
639        erfptr = (dag_record_t *)packet->buffer;
640        erfptr->rlen = ntohs(size + sizeof(dag_record_t));
641        packet->size = size + sizeof(dag_record_t);
642        return packet->size;
643}
644
645static void dag_help() {
646        printf("dag format module: $Revision$\n");
647        printf("Supported input URIs:\n");
648        printf("\tdag:/dev/dagn\n");
649        printf("\n");
650        printf("\te.g.: dag:/dev/dag0\n");
651        printf("\n");
652        printf("Supported output URIs:\n");
653        printf("\tnone\n");
654        printf("\n");
655
656}
657
658static void erf_help() {
659        printf("erf format module: $Revision$\n");
660        printf("Supported input URIs:\n");
661        printf("\terf:/path/to/file\t(uncompressed)\n");
662        printf("\terf:/path/to/file.gz\t(gzip-compressed)\n");
663        printf("\terf:-\t(stdin, either compressed or not)\n")/
664        printf("\terf:/path/to/socket\n");
665        printf("\n");
666        printf("\te.g.: erf:/tmp/trace\n");
667        printf("\n");
668        printf("Supported output URIs:\n");
669        printf("\tnone\n");
670        printf("\n");
671
672}
673
674static void rtclient_help() {
675        printf("rtclient format module\n");
676        printf("Supported input URIs:\n");
677        printf("\trtclient:hostname:port\n");
678        printf("\trtclient:port\n");
679        printf("\n");
680        printf("\te.g.: rtclient:localhost\n");
681        printf("\te.g.: rtclient:localhost:32500\n");
682        printf("\n");
683        printf("Supported output URIs:\n");
684        printf("\trtclient:port\n");
685        printf("\n");
686        printf("\te.g.: rtclient:32500\n");
687        printf("\n");
688
689}
690
691       
692static struct format_t erf = {
693        "erf",
694        "$Id$",
695        erf_init_input,                 /* init_input */       
696        erf_init_output,                /* init_output */
697        erf_config_output,              /* config_output */
698        erf_fin_input,                  /* fin_input */
699        erf_fin_output,                 /* fin_output */
700        NULL,                           /* read */
701        erf_read_packet,                /* read_packet */
702        erf_write_packet,               /* write_packet */
703        erf_get_link,                   /* get_link */
704        erf_get_link_type,              /* get_link_type */
705        erf_get_direction,              /* get_direction */
706        erf_set_direction,              /* set_direction */
707        erf_get_erf_timestamp,          /* get_erf_timestamp */
708        NULL,                           /* get_timeval */
709        NULL,                           /* get_seconds */
710        erf_get_capture_length,         /* get_capture_length */
711        erf_get_wire_length,            /* get_wire_length */
712        erf_set_capture_length,         /* set_capture_length */
713        erf_help                        /* help */
714};
715
716#ifdef HAVE_DAG
717static struct format_t dag = {
718        "dag",
719        "$Id$",
720        dag_init_input,                 /* init_input */       
721        NULL,                           /* init_output */
722        NULL,                           /* config_output */
723        dag_fin_input,                  /* fin_input */
724        NULL,                           /* fin_output */
725        dag_read,                       /* read */
726        dag_read_packet,                /* read_packet */
727        NULL,                           /* write_packet */
728        erf_get_link,                   /* get_link */
729        erf_get_link_type,              /* get_link_type */
730        erf_get_direction,              /* get_direction */
731        erf_set_direction,              /* set_direction */
732        erf_get_erf_timestamp,          /* get_erf_timestamp */
733        NULL,                           /* get_timeval */
734        NULL,                           /* get_seconds */
735        erf_get_capture_length,         /* get_capture_length */
736        erf_get_wire_length,            /* get_wire_length */
737        erf_set_capture_length,         /* set_capture_length */
738        dag_help                        /* help */
739};
740#endif
741
742static struct format_t rtclient = {
743        "rtclient",
744        "$Id$",
745        rtclient_init_input,            /* init_input */       
746        rtclient_init_output,           /* init_output */
747        rtclient_config_output,         /* config_output */
748        rtclient_fin_input,             /* fin_input */
749        rtclient_fin_output,            /* fin_output */
750        rtclient_read,                  /* read */
751        rtclient_read_packet,           /* read_packet */
752        rtclient_write_packet,          /* write_packet */
753        erf_get_link,                   /* get_link */
754        erf_get_link_type,              /* get_link_type */
755        erf_get_direction,              /* get_direction */
756        erf_set_direction,              /* set_direction */
757        erf_get_erf_timestamp,          /* get_erf_timestamp */
758        NULL,                           /* get_timeval */
759        NULL,                           /* get_seconds */
760        erf_get_capture_length,         /* get_capture_length */
761        erf_get_wire_length,            /* get_wire_length */
762        erf_set_capture_length,         /* set_capture_length */
763        rtclient_help                   /* help */
764};
765
766void __attribute__((constructor)) erf_constructor() {
767        register_format(&erf);
768#ifdef HAVE_DAG
769        register_format(&dag);
770#endif
771        register_format(&rtclient);
772}
Note: See TracBrowser for help on using the repository browser.