source: lib/format_erf.c @ 5fb2251

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

Cleanups
Changed fifo to use a more portable MIN() to get rid of some more warnings

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