source: lib/format_erf.c @ 72bfe20

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

trace_event fixed

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