source: lib/format_erf.c @ 548a9c2

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

Split erf up into init/start functions
Add "errno" outputs to trace_set_err
Add support for SNAPLEN/FILTER config options

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