source: lib/format_erf.c @ 3d4d52d

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

Abstract away opening up traces into a single trace_open_trace that's more
simple and reliable.

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