source: lib/format_erf.c @ ab4cb04

4.0.1-hotfixescachetimestampsdevelopdpdk-ndagetsilivegetfragoffhelplibtrace4ndag_formatpfringrc-4.0.1rc-4.0.2rc-4.0.3rc-4.0.4ringdecrementfixringperformanceringtimestampfixes
Last change on this file since ab4cb04 was ab4cb04, checked in by Perry Lorier <perry@…>, 16 years ago

Cleanup struct libtrace_Format_data_t

  • Property mode set to 100644
File size: 22.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#define _GNU_SOURCE
31
32#include "config.h"
33#include "common.h"
34#include "libtrace.h"
35#include "libtrace_int.h"
36#include "format_helper.h"
37#include "parse_cmd.h"
38
39#ifdef HAVE_INTTYPES_H
40#  include <inttypes.h>
41#else
42#  error "Can't find inttypes.h - this needs to be fixed"
43#endif
44
45#ifdef HAVE_STDDEF_H
46#  include <stddef.h>
47#else
48# error "Can't find stddef.h - do you define ptrdiff_t elsewhere?"
49#endif
50#include <sys/types.h>
51#include <sys/socket.h>
52#include <sys/un.h>
53#include <sys/mman.h>
54#include <sys/stat.h>
55#include <unistd.h>
56#include <assert.h>
57#include <errno.h>
58#include <netdb.h>
59#include <fcntl.h>
60#include <getopt.h>
61#include <stdio.h>
62#include <string.h>
63#include <stdlib.h>
64
65
66#define COLLECTOR_PORT 3435
67
68static struct libtrace_format_t erf;
69static struct libtrace_format_t rtclient;
70#if HAVE_DAG
71static struct libtrace_format_t dag;
72#endif
73
74#define DATA(x) ((struct libtrace_format_data_t *)x->format_data)
75#define DATAOUT(x) ((struct libtrace_format_data_out_t *)x->format_data)
76#define CONNINFO DATA(libtrace)->conn_info
77#define INPUT DATA(libtrace)->input
78#define OUTPUT DATAOUT(libtrace)->output
79#if HAVE_DAG
80#define DAG DATA(libtrace)->dag
81#endif
82#define OPTIONS DATAOUT(libtrace)->options
83struct libtrace_format_data_t {
84        union {
85                struct {
86                        char *hostname;
87                        short port;
88                } rt;
89        } conn_info;
90       
91        union {
92                int fd;
93                LIBTRACE_FILE file;
94        } input;
95
96#if HAVE_DAG
97        struct {
98                void *buf; 
99                unsigned bottom;
100                unsigned top;
101                unsigned diff;
102                unsigned curr;
103                unsigned offset;
104        } dag;
105#endif
106};
107
108struct libtrace_format_data_out_t {
109        union {
110                struct {
111                        char *hostname;
112                        short port;
113                } rt;
114                char *path;
115        } conn_info;
116
117
118
119        union {
120                struct {
121                        int level;
122                        int fileflag;
123                } erf;
124               
125        } options;
126       
127        union {
128                int fd;
129                struct rtserver_t * rtserver;
130#if HAVE_ZLIB
131                gzFile *file;
132#else
133                int file;
134#endif
135        } output;
136};
137
138/** Structure holding status information for a packet */
139typedef struct libtrace_packet_status {
140        uint8_t type;
141        uint8_t reserved;
142        uint16_t message;
143} libtrace_packet_status_t;
144
145
146#ifdef HAVE_DAG
147static int dag_init_input(struct libtrace_t *libtrace) {
148        libtrace->format_data = (struct libtrace_format_data_t *)
149                malloc(sizeof(struct libtrace_format_data_t));
150}
151
152static int dag_start_input(struct libtrace_t *libtrace) {
153        struct stat buf;
154        if (stat(libtrace->uridata, &buf) == -1) {
155                trace_set_err(libtrace,errno,"stat(%s)",libtrace->uridata);
156                return 0;
157        } 
158        if (S_ISCHR(buf.st_mode)) {
159                /* DEVICE */
160                if((INPUT.fd = dag_open(libtrace->uridata)) < 0) {
161                        trace_set_err(libtrace,errno,"Cannot open DAG %s",
162                                        libtrace->uridata);
163                        return 0;
164                }
165                if((DAG.buf = (void *)dag_mmap(INPUT.fd)) == MAP_FAILED) {
166                        trace_set_err(libtrace,errno,"Cannot mmap DAG %s",
167                                        libtrace->uridata);
168                        return 0;
169                }
170                if(dag_start(INPUT.fd) < 0) {
171                        trace_set_err(libtrace,errno,"Cannot start DAG %s",
172                                        libtrace->uridata);
173                        return 0;
174                }
175        } else {
176                trace_set_err(libtrace,errno,"Not a valid dag device: %s",
177                                libtrace->uridata);
178                return 0;
179        }
180        return 1;
181}
182#endif
183
184/* Dag erf ether packets have a 2 byte padding before the packet
185 * so that the ip header is aligned on a 32 bit boundary.
186 */
187static int erf_get_padding(const struct libtrace_packet_t *packet)
188{
189        switch(trace_get_link_type(packet)) {
190                case TRACE_TYPE_ETH:    return 2;
191                default:                return 0;
192        }
193}
194
195static int erf_get_framing_length(const struct libtrace_packet_t *packet)
196{
197        return dag_record_size + erf_get_padding(packet);
198}
199
200
201static int erf_init_input(struct libtrace_t *libtrace) 
202{
203        libtrace->format_data = (struct libtrace_format_data_t *)
204                malloc(sizeof(struct libtrace_format_data_t));
205
206}
207
208static int erf_start_input(struct libtrace_t *libtrace)
209{
210        INPUT.file = trace_open_file(libtrace);
211
212        if (!INPUT.file)
213                return -1;
214
215        return 0;
216}
217
218static int rtclient_init_input(struct libtrace_t *libtrace) {
219        char *scan;
220        libtrace->format_data = (struct libtrace_format_data_t *)
221                malloc(sizeof(struct libtrace_format_data_t));
222
223
224        if (strlen(libtrace->uridata) == 0) {
225                CONNINFO.rt.hostname = 
226                        strdup("localhost");
227                CONNINFO.rt.port = 
228                        COLLECTOR_PORT;
229        } else {
230                if ((scan = strchr(libtrace->uridata,':')) == NULL) {
231                        CONNINFO.rt.hostname = 
232                                strdup(libtrace->uridata);
233                        CONNINFO.rt.port =
234                                COLLECTOR_PORT;
235                } else {
236                        CONNINFO.rt.hostname = 
237                                (char *)strndup(libtrace->uridata,
238                                                (scan - libtrace->uridata));
239                        CONNINFO.rt.port = 
240                                atoi(++scan);
241                }
242        }
243       
244}
245
246static int rtclient_start_input(libtrace_t *libtrace)
247{
248        struct hostent *he;
249        struct sockaddr_in remote;
250        if ((he=gethostbyname(CONNINFO.rt.hostname)) == NULL) { 
251                trace_set_err(libtrace,errno,"failed to resolve %s",
252                                CONNINFO.rt.hostname);
253                return -1;
254        } 
255        if ((INPUT.fd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
256                trace_set_err(libtrace,errno,"socket(AF_INET,SOCK_STREAM)");
257                return -1;
258        }
259
260        remote.sin_family = AF_INET;   
261        remote.sin_port = htons(CONNINFO.rt.port);
262        remote.sin_addr = *((struct in_addr *)he->h_addr);
263        bzero(&(remote.sin_zero), 8);
264
265        if (connect(INPUT.fd, (struct sockaddr *)&remote,
266                                sizeof(struct sockaddr)) == -1) {
267                trace_set_err(libtrace,errno,"connect(%s)",
268                                CONNINFO.rt.hostname);
269                return 0;
270        }
271        return -1;
272}
273
274static int erf_init_output(struct libtrace_out_t *libtrace) {
275        libtrace->format_data = (struct libtrace_format_data_out_t *)
276                calloc(1,sizeof(struct libtrace_format_data_out_t));
277
278        OPTIONS.erf.level = 0;
279        OPTIONS.erf.fileflag = O_CREAT | O_LARGEFILE | O_WRONLY;
280        OUTPUT.file = 0;
281
282        return 0;
283}
284
285static int erf_config_output(struct libtrace_out_t *libtrace, trace_option_t option, void *value) {
286
287        switch (option) {
288                case TRACE_OPTION_OUTPUT_COMPRESS:
289                        OPTIONS.erf.level = *(int*)value;
290                        return 0;
291                case TRACE_OPTION_OUTPUT_FILEFLAGS:
292                        OPTIONS.erf.fileflag = *(int*)value;
293                        return 0;
294                default:
295                        /* Unknown option */
296                        trace_set_err_out(libtrace,TRACE_ERR_UNKNOWN_OPTION,
297                                        "Unknown option");
298                        return -1;
299        }
300}
301
302
303#ifdef HAVE_DAG
304static int dag_fin_input(struct libtrace_t *libtrace) {
305        dag_stop(INPUT.fd);
306        free(libtrace->format_data);
307}
308#endif
309
310static int rtclient_fin_input(struct libtrace_t *libtrace) {
311        free(CONNINFO.rt.hostname);
312        close(INPUT.fd);
313        free(libtrace->format_data);
314        return 0;
315}
316
317static int erf_fin_input(struct libtrace_t *libtrace) {
318        LIBTRACE_CLOSE(INPUT.file);
319        free(libtrace->format_data);
320        return 0;
321}
322
323static int erf_fin_output(struct libtrace_out_t *libtrace) {
324        LIBTRACE_CLOSE(OUTPUT.file);
325        free(libtrace->format_data);
326        return 0;
327}
328 
329#if HAVE_DAG
330static int dag_read(struct libtrace_t *libtrace, int block_flag) {
331        int numbytes;
332        static short lctr = 0;
333        struct dag_record_t *erfptr = 0;
334        int rlen;
335
336        if (DAG.diff != 0) 
337                return DAG.diff;
338
339        DAG.bottom = DAG.top;
340        DAG.top = dag_offset(
341                        INPUT.fd,
342                        &(DAG.bottom),
343                        block_flag);
344        DAG.diff = DAG.top -
345                DAG.bottom;
346
347        numbytes=DAG.diff;
348        DAG.offset = 0;
349        return numbytes;
350}
351#endif
352
353#if HAVE_DAG
354static int dag_read_packet(struct libtrace_t *libtrace, struct libtrace_packet_t *packet) {
355        int numbytes;
356        int size;
357        dag_record_t *erfptr;
358        void *buffer = packet->buffer;
359        void *buffer2 = buffer;
360        int rlen;
361
362        if (packet->buf_control == TRACE_CTRL_PACKET) {
363                packet->buf_control = TRACE_CTRL_EXTERNAL;
364                free(packet->buffer);
365                packet->buffer = 0;
366        }
367       
368        packet->type = RT_DATA_ERF;
369       
370        if ((numbytes = dag_read(libtrace,0)) <= 0) 
371                return numbytes;
372
373        /*DAG always gives us whole packets */
374        erfptr = (dag_record_t *) ((void *)DAG.buf + 
375                        (DAG.bottom + DAG.offset));
376        size = ntohs(erfptr->rlen);
377
378        if ( size  > LIBTRACE_PACKET_BUFSIZE) {
379                assert( size < LIBTRACE_PACKET_BUFSIZE);
380        }
381       
382        packet->buffer = erfptr;
383        packet->header = erfptr;
384        if (((dag_record_t *)packet->buffer)->flags.rxerror == 1) {
385                packet->payload = NULL;
386        } else {
387                packet->payload = packet->buffer + erf_get_framing_length(packet);
388        }
389
390        DAG.offset += size;
391        DAG.diff -= size;
392
393        assert(DAG.diff >= 0);
394
395        return (size);
396}
397#endif
398
399static int erf_read_packet(struct libtrace_t *libtrace, struct libtrace_packet_t *packet) {
400        int numbytes;
401        int size;
402        void *buffer2 = packet->buffer;
403        int rlen;
404
405        if (!packet->buffer || packet->buf_control == TRACE_CTRL_EXTERNAL) {
406                packet->buffer = malloc(LIBTRACE_PACKET_BUFSIZE);
407                packet->buf_control = TRACE_CTRL_PACKET;
408        }
409
410        packet->header = packet->buffer;
411        packet->type = RT_DATA_ERF;
412
413        if ((numbytes=LIBTRACE_READ(INPUT.file,
414                                        packet->buffer,
415                                        dag_record_size)) == -1) {
416                trace_set_err(libtrace,errno,"read(%s)",
417                                libtrace->uridata);
418                return -1;
419        }
420        if (numbytes == 0) {
421                return 0;
422        }
423
424        rlen = ntohs(((dag_record_t *)packet->buffer)->rlen);
425        buffer2 = (char*)packet->buffer + dag_record_size;
426        size = rlen - dag_record_size;
427        assert(size < LIBTRACE_PACKET_BUFSIZE);
428
429       
430        /* Unknown/corrupt */
431        assert(((dag_record_t *)packet->buffer)->type < 10);
432       
433        /* read in the rest of the packet */
434        if ((numbytes=LIBTRACE_READ(INPUT.file,
435                                        buffer2,
436                                        size)) != size) {
437                trace_set_err(libtrace,errno, "read(%s)", libtrace->uridata);
438                return -1;
439        }
440        if (((dag_record_t *)packet->buffer)->flags.rxerror == 1) {
441                packet->payload = NULL;
442        } else {
443                packet->payload = (char*)packet->buffer + erf_get_framing_length(packet);
444        }
445        return rlen;
446}
447
448static int rtclient_read(struct libtrace_t *libtrace, void *buffer, size_t len) {
449        int numbytes;
450
451        while(1) {
452#ifndef MSG_NOSIGNAL
453#  define MSG_NOSIGNAL 0
454#endif
455                if ((numbytes = recv(INPUT.fd,
456                                                buffer,
457                                                len,
458                                                MSG_NOSIGNAL)) == -1) {
459                        if (errno == EINTR) {
460                                /*ignore EINTR in case
461                                 *a caller is using signals
462                                 */
463                                continue;
464                        }
465                        trace_set_err(libtrace,errno,"recv(%s)",
466                                        libtrace->uridata);
467                        return -1;
468                }
469                break;
470
471        }
472        return numbytes;
473}
474
475static int rtclient_read_packet(struct libtrace_t *libtrace, struct libtrace_packet_t *packet) {
476        int numbytes = 0;
477        char buf[RP_BUFSIZE];
478        int read_required = 0;
479       
480        void *buffer = 0;
481
482        if (packet->buf_control == TRACE_CTRL_EXTERNAL || !packet->buffer) {
483                packet->buf_control = TRACE_CTRL_PACKET;
484                packet->buffer = malloc(LIBTRACE_PACKET_BUFSIZE);
485        }
486
487        buffer = packet->buffer;
488        packet->header = packet->buffer;
489       
490        packet->type = RT_DATA_ERF;
491
492       
493        do {
494                struct libtrace_packet_status status;
495                int size;
496                if (tracefifo_out_available(libtrace->fifo) == 0 
497                                || read_required) {
498                        if ((numbytes = rtclient_read(
499                                        libtrace,buf,RP_BUFSIZE))<=0) {
500                                return numbytes;
501                        }
502                        tracefifo_write(libtrace->fifo,buf,numbytes);
503                        read_required = 0;
504                }
505                /* Read status byte */
506                if (tracefifo_out_read(libtrace->fifo,
507                                &status, sizeof(uint32_t)) == 0) {
508                        read_required = 1;
509                        continue;
510                }
511                tracefifo_out_update(libtrace->fifo,sizeof(uint32_t));
512                /* Read in packet size */
513                if (tracefifo_out_read(libtrace->fifo,
514                                &size, sizeof(uint32_t)) == 0) {
515                        tracefifo_out_reset(libtrace->fifo);
516                        read_required = 1;
517                        continue;
518                }
519                tracefifo_out_update(libtrace->fifo, sizeof(uint32_t));
520               
521                if (status.type == 2 /* RT_MSG */) {
522                        /* Need to skip this packet as it is a message packet */
523                        tracefifo_out_update(libtrace->fifo, size);
524                        tracefifo_ack_update(libtrace->fifo, size + 
525                                        sizeof(uint32_t) + 
526                                        sizeof(libtrace_packet_status_t));
527                        continue;
528                }
529               
530                /* read in the full packet */
531                if ((numbytes = tracefifo_out_read(libtrace->fifo, 
532                                                buffer, size)) == 0) {
533                        tracefifo_out_reset(libtrace->fifo);
534                        read_required = 1;
535                        continue;
536                }
537
538                /* got in our whole packet, so... */
539                tracefifo_out_update(libtrace->fifo,size);
540
541                tracefifo_ack_update(libtrace->fifo,size + 
542                                sizeof(uint32_t) + 
543                                sizeof(libtrace_packet_status_t));
544
545                if (((dag_record_t *)buffer)->flags.rxerror == 1) {
546                        packet->payload = NULL;
547                } else {
548                        packet->payload = (char*)packet->buffer + erf_get_framing_length(packet);
549                }
550                return numbytes;
551        } while(1);
552}
553
554static int erf_dump_packet(libtrace_out_t *libtrace,
555                dag_record_t *erfptr, int pad, void *buffer, size_t size) {
556        int numbytes = 0;
557        assert(size>=0 && size<=65536);
558        /* FIXME: Shouldn't this return != dag_record_size+pad on error? */
559        if ((numbytes = LIBTRACE_WRITE(OUTPUT.file, erfptr, dag_record_size + pad)) == 0) {
560                trace_set_err_out(libtrace,errno,
561                                "write(%s)",libtrace->uridata);
562                return -1;
563        }
564
565        if ((numbytes=LIBTRACE_WRITE(OUTPUT.file, buffer, size)) == 0) {
566                trace_set_err_out(libtrace,errno,
567                                "write(%s)",libtrace->uridata);
568                return -1;
569        }
570
571        return numbytes + pad + dag_record_size;
572}
573
574static int erf_start_output(libtrace_out_t *libtrace)
575{
576        OUTPUT.file = trace_open_file_out(libtrace,
577                        OPTIONS.erf.level,
578                        OPTIONS.erf.fileflag);
579        if (!OUTPUT.file) {
580                return -1;
581        }
582        return 0;
583}
584               
585static int erf_write_packet(libtrace_out_t *libtrace, 
586                const libtrace_packet_t *packet) 
587{
588        int numbytes = 0;
589        int pad = 0;
590        dag_record_t *dag_hdr = (dag_record_t *)packet->header;
591        void *payload = packet->payload;
592
593        assert(OUTPUT.file);
594
595        pad = erf_get_padding(packet);
596
597        /* If we've had an rxerror, we have no payload to write - fix rlen to
598         * be the correct length */
599        if (payload == NULL) {
600                dag_hdr->rlen = htons(dag_record_size + pad);
601        } 
602       
603        if (libtrace->format == &erf 
604#if HAVE_DAG
605                        || libtrace->format == &dag
606#endif
607                        ) {
608                numbytes = erf_dump_packet(libtrace,
609                                (dag_record_t *)packet->buffer,
610                                pad,
611                                payload,
612                                trace_get_capture_length(packet)
613                                );
614        } else {
615                dag_record_t erfhdr;
616                /* convert format - build up a new erf header */
617                /* Timestamp */
618                erfhdr.ts = trace_get_erf_timestamp(packet);
619                erfhdr.type = libtrace_to_erf_type(trace_get_link_type(packet));
620                /* Flags. Can't do this */
621                memset(&erfhdr.flags,1,sizeof(erfhdr.flags));
622                /* Packet length (rlen includes format overhead) */
623                erfhdr.rlen = trace_get_capture_length(packet) 
624                        + erf_get_framing_length(packet);
625                /* loss counter. Can't do this */
626                erfhdr.lctr = 0;
627                /* Wire length */
628                erfhdr.wlen = trace_get_wire_length(packet);
629
630                /* Write it out */
631                numbytes = erf_dump_packet(libtrace,
632                                &erfhdr,
633                                pad,
634                                payload,
635                                trace_get_capture_length(packet));
636        }
637        return numbytes;
638}
639
640static libtrace_linktype_t erf_get_link_type(const struct libtrace_packet_t *packet) {
641        dag_record_t *erfptr = 0;
642        erfptr = (dag_record_t *)packet->header;
643        return erf_type_to_libtrace(erfptr->type);
644}
645
646static int8_t erf_get_direction(const struct libtrace_packet_t *packet) {
647        dag_record_t *erfptr = 0;
648        erfptr = (dag_record_t *)packet->header;
649        return erfptr->flags.iface;
650}
651
652static int8_t erf_set_direction(const struct libtrace_packet_t *packet, int8_t direction) {
653        dag_record_t *erfptr = 0;
654        erfptr = (dag_record_t *)packet->header;
655        erfptr->flags.iface = direction;
656        return erfptr->flags.iface;
657}
658
659static uint64_t erf_get_erf_timestamp(const struct libtrace_packet_t *packet) {
660        dag_record_t *erfptr = 0;
661        erfptr = (dag_record_t *)packet->header;
662        return erfptr->ts;
663}
664
665static int erf_get_capture_length(const struct libtrace_packet_t *packet) {
666        dag_record_t *erfptr = 0;
667        erfptr = (dag_record_t *)packet->header;
668        return (ntohs(erfptr->rlen) - erf_get_framing_length(packet));
669}
670
671static int erf_get_wire_length(const struct libtrace_packet_t *packet) {
672        dag_record_t *erfptr = 0;
673        erfptr = (dag_record_t *)packet->header;
674        return ntohs(erfptr->wlen);
675}
676
677static size_t erf_set_capture_length(struct libtrace_packet_t *packet, size_t size) {
678        dag_record_t *erfptr = 0;
679        assert(packet);
680        if(size  > trace_get_capture_length(packet)) {
681                /* can't make a packet larger */
682                return trace_get_capture_length(packet);
683        }
684        erfptr = (dag_record_t *)packet->header;
685        erfptr->rlen = htons(size + erf_get_framing_length(packet));
686        printf("Set length: %i\n", trace_get_capture_length(packet));
687        return trace_get_capture_length(packet);
688}
689
690static int rtclient_get_fd(const libtrace_t *libtrace) {
691        return INPUT.fd;
692}
693
694static int erf_get_fd(const libtrace_t *libtrace) {
695        return INPUT.fd;
696}
697
698#ifdef HAVE_DAG
699struct libtrace_eventobj_t trace_event_dag(struct libtrace_t *trace, struct libtrace_packet_t *packet) {
700        struct libtrace_eventobj_t event = {0,0,0.0,0};
701        int dag_fd;
702        int data;
703
704        if (trace->format->get_fd) {
705                dag_fd = trace->format->get_fd(trace);
706        } else {
707                dag_fd = 0;
708        }
709       
710        data = dag_read(trace, DAGF_NONBLOCK);
711
712        if (data > 0) {
713                event.size = trace_read_packet(trace,packet);
714                event.type = TRACE_EVENT_PACKET;
715                return event;
716        }
717        event.type = TRACE_EVENT_SLEEP;
718        event.seconds = 0.0001;
719        return event;
720}
721#endif
722
723#if HAVE_DAG
724static void dag_help() {
725        printf("dag format module: $Revision$\n");
726        printf("Supported input URIs:\n");
727        printf("\tdag:/dev/dagn\n");
728        printf("\n");
729        printf("\te.g.: dag:/dev/dag0\n");
730        printf("\n");
731        printf("Supported output URIs:\n");
732        printf("\tnone\n");
733        printf("\n");
734}
735#endif
736
737static void erf_help() {
738        printf("erf format module: $Revision$\n");
739        printf("Supported input URIs:\n");
740        printf("\terf:/path/to/file\t(uncompressed)\n");
741        printf("\terf:/path/to/file.gz\t(gzip-compressed)\n");
742        printf("\terf:-\t(stdin, either compressed or not)\n");
743        printf("\terf:/path/to/socket\n");
744        printf("\n");
745        printf("\te.g.: erf:/tmp/trace\n");
746        printf("\n");
747        printf("Supported output URIs:\n");
748        printf("\terf:path/to/file\t(uncompressed)\n");
749        printf("\terf:/path/to/file.gz\t(gzip-compressed)\n");
750        printf("\terf:-\t(stdout, either compressed or not)\n");
751        printf("\n");
752        printf("\te.g.: erf:/tmp/trace\n");
753        printf("\n");
754        printf("Supported output options:\n");
755        printf("\t-z\tSpecify the gzip compression, ranging from 0 (uncompressed) to 9 - defaults to 1\n");
756        printf("\n");
757
758       
759}
760
761static void rtclient_help() {
762        printf("rtclient format module: $Revision$\n");
763        printf("DEPRECATED - use rt module instead\n");
764        printf("Supported input URIs:\n");
765        printf("\trtclient:host:port\n");
766        printf("\n");
767        printf("\te.g.:rtclient:localhost:3435\n");
768        printf("\n");
769        printf("Supported output URIs:\n");
770        printf("\tnone\n");
771        printf("\n");
772}       
773
774static struct libtrace_format_t erf = {
775        "erf",
776        "$Id$",
777        TRACE_FORMAT_ERF,
778        erf_init_input,                 /* init_input */       
779        NULL,                           /* config_input */
780        erf_start_input,                /* start_input */
781        NULL,                           /* pause_input */
782        erf_init_output,                /* init_output */
783        erf_config_output,              /* config_output */
784        erf_start_output,               /* start_output */
785        erf_fin_input,                  /* fin_input */
786        erf_fin_output,                 /* fin_output */
787        erf_read_packet,                /* read_packet */
788        erf_write_packet,               /* write_packet */
789        erf_get_link_type,              /* get_link_type */
790        erf_get_direction,              /* get_direction */
791        erf_set_direction,              /* set_direction */
792        erf_get_erf_timestamp,          /* get_erf_timestamp */
793        NULL,                           /* get_timeval */
794        NULL,                           /* get_seconds */
795        NULL,                           /* seek_erf */
796        NULL,                           /* seek_timeval */
797        NULL,                           /* seek_seconds */
798        erf_get_capture_length,         /* get_capture_length */
799        erf_get_wire_length,            /* get_wire_length */
800        erf_get_framing_length,         /* get_framing_length */
801        erf_set_capture_length,         /* set_capture_length */
802        erf_get_fd,                     /* get_fd */
803        trace_event_trace,              /* trace_event */
804        erf_help                        /* help */
805};
806
807#ifdef HAVE_DAG
808static struct libtrace_format_t dag = {
809        "dag",
810        "$Id$",
811        TRACE_FORMAT_ERF,
812        dag_init_input,                 /* init_input */       
813        NULL,                           /* config_input */
814        dag_start_input,                /* start_input */
815        NULL,                           /* pause_input */
816        NULL,                           /* init_output */
817        NULL,                           /* config_output */
818        NULL,                           /* start_output */
819        dag_fin_input,                  /* fin_input */
820        NULL,                           /* fin_output */
821        dag_read_packet,                /* read_packet */
822        NULL,                           /* write_packet */
823        erf_get_link_type,              /* get_link_type */
824        erf_get_direction,              /* get_direction */
825        erf_set_direction,              /* set_direction */
826        erf_get_erf_timestamp,          /* get_erf_timestamp */
827        NULL,                           /* get_timeval */
828        NULL,                           /* get_seconds */
829        NULL,                           /* seek_erf */
830        NULL,                           /* seek_timeval */
831        NULL,                           /* seek_seconds */
832        erf_get_capture_length,         /* get_capture_length */
833        erf_get_wire_length,            /* get_wire_length */
834        erf_get_framing_length,         /* get_framing_length */
835        erf_set_capture_length,         /* set_capture_length */
836        NULL,                           /* get_fd */
837        trace_event_dag,                /* trace_event */
838        dag_help                        /* help */
839};
840#endif
841
842static struct libtrace_format_t rtclient = {
843        "rtclient",
844        "$Id$",
845        TRACE_FORMAT_ERF,
846        rtclient_init_input,            /* init_input */       
847        NULL,                           /* config_input */
848        rtclient_start_input,           /* start_input */
849        NULL,                           /* pause_input */
850        NULL,                           /* init_output */
851        NULL,                           /* config_output */
852        NULL,                           /* start_output */
853        rtclient_fin_input,             /* fin_input */
854        NULL,                           /* fin_output */
855        rtclient_read_packet,           /* read_packet */
856        NULL,                           /* write_packet */
857        erf_get_link_type,              /* get_link_type */
858        erf_get_direction,              /* get_direction */
859        erf_set_direction,              /* set_direction */
860        erf_get_erf_timestamp,          /* get_erf_timestamp */
861        NULL,                           /* get_timeval */
862        NULL,                           /* get_seconds */
863        NULL,                           /* seek_erf */
864        NULL,                           /* seek_timeval */
865        NULL,                           /* seek_seconds */
866        erf_get_capture_length,         /* get_capture_length */
867        erf_get_wire_length,            /* get_wire_length */
868        erf_get_framing_length,         /* get_framing_length */
869        erf_set_capture_length,         /* set_capture_length */
870        rtclient_get_fd,                /* get_fd */
871        trace_event_device,             /* trace_event */
872        rtclient_help                   /* help */
873};
874
875void __attribute__((constructor)) erf_constructor() {
876        register_format(&rtclient);
877        register_format(&erf);
878#ifdef HAVE_DAG
879        register_format(&dag);
880#endif
881}
Note: See TracBrowser for help on using the repository browser.