source: lib/format_erf.c @ 9c6aa95

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

cleaned up after compiling with -Wall -W

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