source: lib/format_erf.c @ f1a1f5e

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

Understand legacy erf formats (as opposed to "legacy dag")
Use libtrace_err properly

  • Property mode set to 100644
File size: 26.8 KB
Line 
1/*
2 * This file is part of libtrace
3 *
4 * Copyright (c) 2004 The University of Waikato, Hamilton, New Zealand.
5 * Authors: Daniel Lawson
6 *          Perry Lorier
7 *         
8 * All rights reserved.
9 *
10 * This code has been developed by the University of Waikato WAND
11 * research group. For further information please see http://www.wand.net.nz/
12 *
13 * libtrace is free software; you can redistribute it and/or modify
14 * it under the terms of the GNU General Public License as published by
15 * the Free Software Foundation; either version 2 of the License, or
16 * (at your option) any later version.
17 *
18 * libtrace is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
21 * GNU General Public License for more details.
22 *
23 * You should have received a copy of the GNU General Public License
24 * along with libtrace; if not, write to the Free Software
25 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
26 *
27 * $Id$
28 *
29 */
30#define _GNU_SOURCE
31
32#include "config.h"
33#include "common.h"
34#include "libtrace.h"
35#include "libtrace_int.h"
36#include "format_helper.h"
37#include "parse_cmd.h"
38
39#ifdef HAVE_INTTYPES_H
40#  include <inttypes.h>
41#else
42#  error "Can't find inttypes.h - this needs to be fixed"
43#endif
44
45#ifdef HAVE_STDDEF_H
46#  include <stddef.h>
47#else
48# error "Can't find stddef.h - do you define ptrdiff_t elsewhere?"
49#endif
50#include <sys/types.h>
51#include <sys/socket.h>
52#include <sys/un.h>
53#include <sys/mman.h>
54#include <sys/stat.h>
55#include <unistd.h>
56#include <assert.h>
57#include <errno.h>
58#include <netdb.h>
59#include <fcntl.h>
60#include <getopt.h>
61#include <stdio.h>
62#include <string.h>
63#include <stdlib.h>
64
65#if HAVE_ZLIB
66#  include <zlib.h>
67#  define LIBTRACE_READ gzread
68#  define LIBTRACE_FDOPEN gzdopen
69#  define LIBTRACE_CLOSE gzclose
70#  define LIBTRACE_WRITE gzwrite
71#else
72#  define LIBTRACE_READ read
73#  define LIBTRACE_FDOPEN open
74#  define LIBTRACE_CLOSE close
75#  define LIBTRACE_WRITE write
76#endif
77
78/* Catch undefined O_LARGEFILE on *BSD etc */
79#ifndef O_LARGEFILE
80#  define O_LARGEFILE 0
81#endif
82
83static struct libtrace_format_t *erf_ptr = 0;
84static struct libtrace_format_t *rtclient_ptr = 0;
85#if HAVE_DAG
86static struct libtrace_format_t *dag_ptr = 0;
87#endif
88static struct libtrace_format_t *legacypos_ptr = 0;
89static struct libtrace_format_t *legacyeth_ptr = 0;
90static struct libtrace_format_t *legacyatm_ptr = 0;
91
92#define CONNINFO libtrace->format_data->conn_info
93#define INPUT libtrace->format_data->input
94#define OUTPUT libtrace->format_data->output
95#if HAVE_DAG
96#define DAG libtrace->format_data->dag
97#endif
98#define OPTIONS libtrace->format_data->options
99struct libtrace_format_data_t {
100        union {
101                struct {
102                        char *hostname;
103                        short port;
104                } rt;
105                char *path;             
106        } conn_info;
107       
108        union {
109                int fd;
110#if HAVE_ZLIB
111                gzFile *file;
112#else   
113                FILE *file;
114#endif
115        } input;
116
117#if HAVE_DAG
118        struct {
119                void *buf; 
120                unsigned bottom;
121                unsigned top;
122                unsigned diff;
123                unsigned curr;
124                unsigned offset;
125        } dag;
126#endif
127};
128
129struct libtrace_format_data_out_t {
130        union {
131                struct {
132                        char *hostname;
133                        short port;
134                } rt;
135                char *path;
136        } conn_info;
137
138        union {
139                struct {
140                        int level;
141                } erf;
142               
143        } options;
144       
145        union {
146                int fd;
147                struct rtserver_t * rtserver;
148#if HAVE_ZLIB
149                gzFile *file;
150#else
151                FILE *file;
152#endif
153        } output;
154};
155
156#ifdef HAVE_DAG
157static int dag_init_input(struct libtrace_t *libtrace) {
158        struct stat buf;
159        libtrace->format_data = (struct libtrace_format_data_t *)
160                malloc(sizeof(struct libtrace_format_data_t));
161
162        CONNINFO.path = libtrace->uridata;
163        if (stat(CONNINFO.path,&buf) == -1) {
164                perror("stat");
165                return 0;
166        } 
167        if (S_ISCHR(buf.st_mode)) {
168                // DEVICE
169                libtrace->sourcetype = DEVICE;
170                if((INPUT.fd = dag_open(CONNINFO.path)) < 0) {
171                        fprintf(stderr,"Cannot open DAG %s: %m\n", 
172                                        CONNINFO.path,errno);
173                        exit(0);
174                }
175                if((DAG.buf = (void *)dag_mmap(INPUT.fd)) == MAP_FAILED) {
176                        fprintf(stderr,"Cannot mmap DAG %s: %m\n", 
177                                        CONNINFO.path,errno);
178                        exit(0);
179                }
180                if(dag_start(INPUT.fd) < 0) {
181                        fprintf(stderr,"Cannot start DAG %s: %m\n", 
182                                        CONNINFO.path,errno);
183                        exit(0);
184                }
185        } else {
186                fprintf(stderr,"%s isn't a valid char device, exiting\n",
187                                CONNINFO.path);
188                return 0;
189        }
190        return 1;
191}
192#endif
193
194/* Dag erf ether packets have a 2 byte padding before the packet
195 * so that the ip header is aligned on a 32 bit boundary.
196 */
197static int erf_get_padding(const struct libtrace_packet_t *packet)
198{
199        switch(trace_get_link_type(packet)) {
200                case TRACE_TYPE_ETH:    return 2;
201                default:                return 0;
202        }
203}
204
205static int erf_get_erf_headersize(const struct libtrace_packet_t *packet)
206{
207        return dag_record_size + erf_get_padding(packet);
208}
209
210
211static int erf_init_input(struct libtrace_t *libtrace) {
212        struct stat buf;
213        struct sockaddr_un unix_sock;
214        libtrace->format_data = (struct libtrace_format_data_t *)
215                malloc(sizeof(struct libtrace_format_data_t));
216
217        CONNINFO.path = libtrace->uridata;
218        if (!strncmp(CONNINFO.path,"-",1)) {
219                // STDIN
220                libtrace->sourcetype = STDIN;
221                INPUT.file = LIBTRACE_FDOPEN(STDIN, "r");
222
223        } else {
224                if (stat(CONNINFO.path,&buf) == -1 ) {
225                        perror("stat");
226                        return 0;
227                }
228                if (S_ISSOCK(buf.st_mode)) {
229                        libtrace->sourcetype = SOCKET;
230                        if ((INPUT.fd = socket(
231                                        AF_UNIX, SOCK_STREAM, 0)) == -1) {
232                                perror("socket");
233                                return 0;
234                        }
235                        unix_sock.sun_family = AF_UNIX;
236                        bzero(unix_sock.sun_path,108);
237                        snprintf(unix_sock.sun_path,
238                                        108,"%s"
239                                        ,CONNINFO.path);
240
241                        if (connect(INPUT.fd, 
242                                        (struct sockaddr *)&unix_sock,
243                                        sizeof(struct sockaddr)) == -1) {
244                                perror("connect (unix)");
245                                return 0;
246                        }
247                } else { 
248
249                        libtrace->sourcetype = TRACE;
250
251                        // we use an FDOPEN call to reopen an FD
252                        // returned from open(), so that we can set
253                        // O_LARGEFILE. This gets around gzopen not
254                        // letting you do this...
255                        INPUT.file = LIBTRACE_FDOPEN(open(
256                                                CONNINFO.path,
257                                                O_LARGEFILE),"r");
258                }
259        }
260        return 1;
261}
262
263static int rtclient_init_input(struct libtrace_t *libtrace) {
264        char *scan;
265        char *uridata = libtrace->uridata;
266        struct hostent *he;
267        struct sockaddr_in remote;
268        libtrace->format_data = (struct libtrace_format_data_t *)
269                malloc(sizeof(struct libtrace_format_data_t));
270
271        libtrace->sourcetype = RT;
272
273        if (strlen(uridata) == 0) {
274                CONNINFO.rt.hostname = 
275                        strdup("localhost");
276                CONNINFO.rt.port = 
277                        COLLECTOR_PORT;
278        } else {
279                if ((scan = strchr(uridata,':')) == NULL) {
280                        CONNINFO.rt.hostname = 
281                                strdup(uridata);
282                        CONNINFO.rt.port =
283                                COLLECTOR_PORT;
284                } else {
285                        CONNINFO.rt.hostname = 
286                                (char *)strndup(uridata,
287                                                (scan - uridata));
288                        CONNINFO.rt.port = 
289                                atoi(++scan);
290                }
291        }
292       
293        if ((he=gethostbyname(CONNINFO.rt.hostname)) == NULL) { 
294                perror("gethostbyname");
295                return 0;
296        } 
297        if ((INPUT.fd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
298                perror("socket");
299                return 0;
300        }
301
302        remote.sin_family = AF_INET;   
303        remote.sin_port = htons(CONNINFO.rt.port);
304        remote.sin_addr = *((struct in_addr *)he->h_addr);
305        bzero(&(remote.sin_zero), 8);
306
307        if (connect(INPUT.fd, (struct sockaddr *)&remote,
308                                sizeof(struct sockaddr)) == -1) {
309                perror("connect (inet)");
310                return 0;
311        }
312        return 1;
313}
314
315static int erf_init_output(struct libtrace_out_t *libtrace) {
316        char *filemode = 0;
317        int fd;
318        libtrace->format_data = (struct libtrace_format_data_out_t *)
319                calloc(1,sizeof(struct libtrace_format_data_out_t));
320
321        OPTIONS.erf.level = 0;
322#if HAVE_ZLIB
323        asprintf(&filemode,"wb%d",OPTIONS.erf.level);
324#else
325        asprintf(&filemode,"w");
326#endif
327
328        if (!strncmp(libtrace->uridata,"-",1)) {
329                // STDOUT
330                OUTPUT.file = LIBTRACE_FDOPEN(dup(1),filemode);
331        }
332        else {
333                // TRACE
334                fd = open(libtrace->uridata, O_CREAT | O_LARGEFILE | O_WRONLY, S_IRUSR | S_IWUSR);
335                if (fd <= 0) {
336                        return 0;
337                }
338                OUTPUT.file = LIBTRACE_FDOPEN(fd,filemode);
339                 
340        }
341        free(filemode); 
342        return 1;
343}
344
345static int erf_config_output(struct libtrace_out_t *libtrace, int argc, char *argv[]) {
346#if HAVE_ZLIB
347        int opt;
348        int level = OPTIONS.erf.level;
349        optind = 1;
350
351
352        while ((opt = getopt(argc, argv, "z:")) != EOF) {
353                switch (opt) {
354                        case 'z':
355                                level = atoi(optarg);
356                                break;
357                        default:
358                                printf("Bad argument to erf: %s\n", optarg);
359                                // maybe spit out some help here
360                                return -1;
361                }
362        }
363        if (level != OPTIONS.erf.level) {
364                if (level > 9 || level < 0) {
365                        // retarded level choice
366                        printf("Compression level must be between 0 and 9 inclusive - you selected %i \n", level);
367                       
368                } else {
369                        OPTIONS.erf.level = level;
370                        return gzsetparams(OUTPUT.file, level, Z_DEFAULT_STRATEGY);
371                }
372        }
373#endif
374        return 0;
375
376}
377
378
379#ifdef HAVE_DAG
380static int dag_fin_input(struct libtrace_t *libtrace) {
381        dag_stop(INPUT.fd);
382}
383#endif
384
385static int erf_fin_input(struct libtrace_t *libtrace) {
386        LIBTRACE_CLOSE(INPUT.file);
387        free(libtrace->format_data);
388        return 0;
389}
390
391static int rtclient_fin_input(struct libtrace_t *libtrace) {
392        close(INPUT.fd);
393        return 0;
394}
395
396static int erf_fin_output(struct libtrace_out_t *libtrace) {
397        LIBTRACE_CLOSE(OUTPUT.file);
398        free(libtrace->format_data);
399
400        return 0;
401}
402 
403
404
405#if HAVE_DAG
406static int dag_read(struct libtrace_t *libtrace, void *buffer, size_t len) {
407        int numbytes;
408        static short lctr = 0;
409        struct dag_record_t *erfptr = 0;
410        int rlen;
411
412        if (buffer == 0)
413                buffer = malloc(len);
414       
415        DAG.bottom = DAG.top;
416        DAG.top = dag_offset(
417                        INPUT.fd,
418                        &(DAG.bottom),
419                        0);
420        DAG.diff = DAG.top -
421                DAG.bottom;
422
423        numbytes=DAG.diff;
424        DAG.offset = 0;
425        return numbytes;
426}
427#endif
428
429#if HAVE_DAG
430static int dag_read_packet(struct libtrace_t *libtrace, struct libtrace_packet_t *packet) {
431        int numbytes;
432        int size;
433        char buf[RP_BUFSIZE];
434        dag_record_t *erfptr;
435        void *buffer = packet->buffer;
436        void *buffer2 = buffer;
437        int rlen;
438       
439        if (DAG.diff == 0) {
440                if ((numbytes = dag_read(libtrace,buf,RP_BUFSIZE)) <= 0) 
441                        return numbytes;
442        }
443
444        //DAG always gives us whole packets
445        erfptr = (dag_record_t *) ((void *)DAG.buf + 
446                        (DAG.bottom + DAG.offset));
447        size = ntohs(erfptr->rlen);
448
449        if ( size  > LIBTRACE_PACKET_BUFSIZE) {
450                assert( size < LIBTRACE_PACKET_BUFSIZE);
451        }
452
453        // have to copy it out of the memory hole at this stage:
454        memcpy(packet->buffer, erfptr, size);
455       
456        packet->status = 0;
457        packet->size = size;
458        DAG.offset += size;
459        DAG.diff -= size;
460
461        assert(DAG.diff >= 0);
462
463        return (size);
464}
465#endif
466
467static int legacy_read_packet(struct libtrace_t *libtrace, struct libtrace_packet_t *packet) {
468        int numbytes;
469        int size;
470        void *buffer = packet->buffer;
471        void *buffer2 = buffer;
472        int rlen;
473
474        if ((numbytes=LIBTRACE_READ(INPUT.file,
475                                        buffer,
476                                        dag_record_size)) == -1) {
477                perror("libtrace_read");
478                return -1;
479        }
480        if (numbytes == 0) {
481                return 0;
482        }
483
484        // legacy - 64byte captures
485        // type is TYPE_LEGACY
486        rlen = 64;
487        size = rlen - dag_record_size;
488        buffer2 = buffer + dag_record_size;
489       
490        if ((numbytes=LIBTRACE_READ(INPUT.file,
491                                        buffer2,
492                                        size)) == -1) {
493                perror("libtrace_read");
494                return -1;
495        }
496        packet->status = 0;
497        packet->size = rlen;
498        return rlen;
499}
500static int erf_read_packet(struct libtrace_t *libtrace, struct libtrace_packet_t *packet) {
501        int numbytes;
502        int size;
503        void *buffer = packet->buffer;
504        void *buffer2 = buffer;
505        int rlen;
506        if ((numbytes=LIBTRACE_READ(INPUT.file,
507                                        buffer,
508                                        dag_record_size)) == -1) {
509                perror("libtrace_read");
510                return -1;
511        }
512        if (numbytes == 0) {
513                return 0;
514        }
515        rlen = ntohs(((dag_record_t *)buffer)->rlen);
516        buffer2 = buffer + dag_record_size;
517        size = rlen - dag_record_size;
518        assert(size < LIBTRACE_PACKET_BUFSIZE);
519        /* If your trace is legacy, or corrupt, then this assert may fire. */
520        /* turns out some older traces have fixed snaplens, which are padded
521         * with 00's if the packet is smaller, so this doesn't work.  Sigh.
522        assert(ntohs(((dag_record_t *)buffer)->rlen) <=
523                        ntohs(((dag_record_t*)buffer)->wlen)+erf_get_erf_headersize(packet));
524        */
525        /* Unknown/corrupt */
526        assert(((dag_record_t *)buffer)->type < 10);
527       
528        // read in the rest of the packet
529        if ((numbytes=LIBTRACE_READ(INPUT.file,
530                                        buffer2,
531                                        size)) != size) {
532                perror("libtrace_read");
533                return -1;
534        }
535        packet->status = 0;
536        packet->size = rlen;
537        return rlen;
538}
539
540static int rtclient_read(struct libtrace_t *libtrace, void *buffer, size_t len) {
541        int numbytes;
542
543        if (buffer == 0)
544                buffer = malloc(len);
545        while(1) {
546#ifndef MSG_NOSIGNAL
547#  define MSG_NOSIGNAL 0
548#endif
549                if ((numbytes = recv(INPUT.fd,
550                                                buffer,
551                                                len,
552                                                MSG_NOSIGNAL)) == -1) {
553                        if (errno == EINTR) {
554                                //ignore EINTR in case
555                                // a caller is using signals
556                                continue;
557                        }
558                        perror("recv");
559                        return -1;
560                }
561                break;
562
563        }
564        return numbytes;
565}
566
567static int rtclient_read_packet(struct libtrace_t *libtrace, struct libtrace_packet_t *packet) {
568        int numbytes = 0;
569        int size = 0;
570        char buf[RP_BUFSIZE];
571        int read_required = 0;
572       
573        void *buffer = 0;
574
575        packet->trace = libtrace;
576        buffer = packet->buffer;
577
578        do {
579                if (tracefifo_out_available(libtrace->fifo) == 0 || read_required) {
580                        if ((numbytes = rtclient_read(
581                                        libtrace,buf,RP_BUFSIZE))<=0) {
582                                return numbytes;
583                        }
584                        tracefifo_write(libtrace->fifo,buf,numbytes);
585                        read_required = 0;
586                }
587                // Read status byte
588                if (tracefifo_out_read(libtrace->fifo,
589                                &packet->status, sizeof(int)) == 0) {
590                        read_required = 1;
591                        continue;
592                }
593                tracefifo_out_update(libtrace->fifo,sizeof(int));
594
595                // read in the ERF header
596                if ((numbytes = tracefifo_out_read(libtrace->fifo, buffer,
597                                                dag_record_size)) == 0) {
598                        tracefifo_out_reset(libtrace->fifo);
599                        read_required = 1;
600                        continue;
601                }
602                size = ntohs(((dag_record_t *)buffer)->rlen);
603               
604                // read in the full packet
605                if ((numbytes = tracefifo_out_read(libtrace->fifo, 
606                                                buffer, size)) == 0) {
607                        tracefifo_out_reset(libtrace->fifo);
608                        read_required = 1;
609                        continue;
610                }
611
612                // got in our whole packet, so...
613                tracefifo_out_update(libtrace->fifo,size);
614
615                tracefifo_ack_update(libtrace->fifo,size + sizeof(int));
616
617                packet->size = numbytes;
618                return numbytes;
619        } while(1);
620}
621
622static int erf_dump_packet(struct libtrace_out_t *libtrace, dag_record_t *erfptr, int pad, void *buffer, size_t size) {
623        int numbytes = 0;
624        if ((numbytes = LIBTRACE_WRITE(OUTPUT.file, erfptr, dag_record_size + pad)) == 0) {
625                perror("libtrace_write");
626                return -1;
627        }
628        if ((numbytes = LIBTRACE_WRITE(OUTPUT.file, buffer, size)) == 0) {
629                perror("libtrace_write");
630                return -1;
631        }
632        return numbytes + pad + dag_record_size;
633}
634               
635static int erf_write_packet(struct libtrace_out_t *libtrace, const struct libtrace_packet_t *packet) {
636        int numbytes = 0;
637        dag_record_t erfhdr;
638        int pad = 0;
639        void *payload = (void *)trace_get_link(packet);
640
641        pad = erf_get_padding(packet);
642        if (packet->trace->format == erf_ptr || 
643#if HAVE_DAG
644                        packet->trace->format == dag_ptr ||
645#endif
646                        packet->trace->format == rtclient_ptr ) {
647                numbytes = erf_dump_packet(libtrace,
648                                (dag_record_t *)packet->buffer,
649                                pad,
650                                payload,
651                                packet->size - 
652                                        (dag_record_size + pad)); 
653        } else {
654                // convert format - build up a new erf header
655                // Timestamp
656                erfhdr.ts = trace_get_erf_timestamp(packet);
657                // Flags. Can't do this
658                memset(&erfhdr.flags,1,1);
659                // Packet length (rlen includes format overhead)
660                erfhdr.rlen = trace_get_capture_length(packet) + erf_get_erf_headersize(packet);
661                // loss counter. Can't do this
662                erfhdr.lctr = 0;
663                // Wire length
664                erfhdr.wlen = trace_get_wire_length(packet);
665               
666                // Write it out
667                numbytes = erf_dump_packet(libtrace,
668                                &erfhdr,
669                                pad,
670                                payload,
671                                erfhdr.rlen);
672        }
673        return numbytes;
674}
675
676
677static void *legacy_get_link(const struct libtrace_packet_t *packet) {
678        return (void *)packet->buffer;
679}
680
681static libtrace_linktype_t legacy_get_link_type(const struct libtrace_packet_t *packet) {
682        return TRACE_TYPE_LEGACY;
683}
684
685static libtrace_linktype_t legacyeth_get_link_type(const struct libtrace_packet_t *packet) {
686        return TRACE_TYPE_LEGACY_ETH;
687}
688
689static libtrace_linktype_t legacyatm_get_link_type(const struct libtrace_packet_t *packet) {
690        return TRACE_TYPE_LEGACY_ATM;
691}
692
693static libtrace_linktype_t legacypos_get_link_type(const struct libtrace_packet_t *packet) {
694        return TRACE_TYPE_LEGACY_POS;
695}
696
697static void *erf_get_link(const struct libtrace_packet_t *packet) {
698        const void *ethptr = 0;
699        dag_record_t *erfptr = 0;
700        erfptr = (dag_record_t *)packet->buffer;
701       
702        if (erfptr->flags.rxerror == 1) {
703                return NULL;
704        }
705        ethptr = ((uint8_t *)packet->buffer +
706                        erf_get_erf_headersize(packet));
707        return (void *)ethptr;
708}
709
710static libtrace_linktype_t erf_get_link_type(const struct libtrace_packet_t *packet) {
711        dag_record_t *erfptr = 0;
712        erfptr = (dag_record_t *)packet->buffer;
713        switch (erfptr->type) {
714                case TYPE_LEGACY:       return TRACE_TYPE_LEGACY;
715                case TYPE_ETH:          return TRACE_TYPE_ETH;
716                case TYPE_ATM:          return TRACE_TYPE_ATM;
717                default: 
718                               fprintf(stderr,"Unknown erf type %02x\n",erfptr->type);
719                               assert(0);
720        }
721        return erfptr->type;
722}
723
724static int8_t erf_get_direction(const struct libtrace_packet_t *packet) {
725        dag_record_t *erfptr = 0;
726        erfptr = (dag_record_t *)packet->buffer;
727        return erfptr->flags.iface;
728}
729
730static int8_t erf_set_direction(const struct libtrace_packet_t *packet, int8_t direction) {
731        dag_record_t *erfptr = 0;
732        erfptr = (dag_record_t *)packet->buffer;
733        erfptr->flags.iface = direction;
734        return erfptr->flags.iface;
735}
736
737static uint64_t erf_get_erf_timestamp(const struct libtrace_packet_t *packet) {
738        dag_record_t *erfptr = 0;
739        erfptr = (dag_record_t *)packet->buffer;
740        return erfptr->ts;
741}
742
743static int legacy_get_capture_length(const struct libtrace_packet_t *packet __attribute__((unused))) {
744        return 64;
745}
746
747static int legacypos_get_wire_length(const struct libtrace_packet_t *packet) {
748        legacy_pos_t *lpos = (legacy_pos_t *)packet->buffer;
749        return ntohs(lpos->wlen);
750}
751
752static int legacyatm_get_wire_length(const struct libtrace_packet_t *packet) {
753        return 53;
754}
755
756static int legacyeth_get_wire_length(const struct libtrace_packet_t *packet) {
757        legacy_ether_t *leth = (legacy_ether_t *)packet->buffer;
758        return ntohs(leth->wlen);
759}
760static int erf_get_capture_length(const struct libtrace_packet_t *packet) {
761        dag_record_t *erfptr = 0;
762        erfptr = (dag_record_t *)packet->buffer;
763        return (ntohs(erfptr->rlen) - erf_get_erf_headersize(packet));
764}
765
766static int erf_get_wire_length(const struct libtrace_packet_t *packet) {
767        dag_record_t *erfptr = 0;
768        erfptr = (dag_record_t *)packet->buffer;
769        return ntohs(erfptr->wlen);
770}
771
772static size_t erf_set_capture_length(struct libtrace_packet_t *packet, size_t size) {
773        dag_record_t *erfptr = 0;
774        assert(packet);
775        if((size + erf_get_erf_headersize(packet)) > packet->size) {
776                // can't make a packet larger
777                return (packet->size - erf_get_erf_headersize(packet));
778        }
779        erfptr = (dag_record_t *)packet->buffer;
780        erfptr->rlen = htons(size + erf_get_erf_headersize(packet));
781        packet->size = size + erf_get_erf_headersize(packet);
782        return size;
783}
784
785static int rtclient_get_fd(const struct libtrace_packet_t *packet) {
786        return packet->trace->format_data->input.fd;
787}
788
789static int erf_get_fd(const struct libtrace_packet_t *packet) {
790        return packet->trace->format_data->input.fd;
791}
792
793#if HAVE_DAG
794static void dag_help() {
795        printf("dag format module: $Revision$\n");
796        printf("Supported input URIs:\n");
797        printf("\tdag:/dev/dagn\n");
798        printf("\n");
799        printf("\te.g.: dag:/dev/dag0\n");
800        printf("\n");
801        printf("Supported output URIs:\n");
802        printf("\tnone\n");
803        printf("\n");
804}
805#endif
806
807static void legacypos_help() {
808        printf("legacypos format module: $Revision$\n");
809        printf("Supported input URIs:\n");
810        printf("\tlegacypos:/path/to/file\t(uncompressed)\n");
811        printf("\tlegacypos:/path/to/file.gz\t(gzip-compressed)\n");
812        printf("\tlegacypos:-\t(stdin, either compressed or not)\n");
813        printf("\n");
814        printf("\te.g.: legacypos:/tmp/trace.gz\n");
815        printf("\n");
816}
817
818static void legacyatm_help() {
819        printf("legacyatm format module: $Revision$\n");
820        printf("Supported input URIs:\n");
821        printf("\tlegacyatm:/path/to/file\t(uncompressed)\n");
822        printf("\tlegacyatm:/path/to/file.gz\t(gzip-compressed)\n");
823        printf("\tlegacyatm:-\t(stdin, either compressed or not)\n");
824        printf("\n");
825        printf("\te.g.: legacyatm:/tmp/trace.gz\n");
826        printf("\n");
827}
828
829static void legacyeth_help() {
830        printf("legacyeth format module: $Revision$\n");
831        printf("Supported input URIs:\n");
832        printf("\tlegacyeth:/path/to/file\t(uncompressed)\n");
833        printf("\tlegacyeth:/path/to/file.gz\t(gzip-compressed)\n");
834        printf("\tlegacyeth:-\t(stdin, either compressed or not)\n");
835        printf("\n");
836        printf("\te.g.: legacyeth:/tmp/trace.gz\n");
837        printf("\n");
838}
839
840static void erf_help() {
841        printf("erf format module: $Revision$\n");
842        printf("Supported input URIs:\n");
843        printf("\terf:/path/to/file\t(uncompressed)\n");
844        printf("\terf:/path/to/file.gz\t(gzip-compressed)\n");
845        printf("\terf:-\t(stdin, either compressed or not)\n");
846        printf("\terf:/path/to/socket\n");
847        printf("\n");
848        printf("\te.g.: erf:/tmp/trace\n");
849        printf("\n");
850        printf("Supported output URIs:\n");
851        printf("\terf:path/to/file\t(uncompressed)\n");
852        printf("\terf:/path/to/file.gz\t(gzip-compressed)\n");
853        printf("\terf:-\t(stdout, either compressed or not)\n");
854        printf("\n");
855        printf("\te.g.: erf:/tmp/trace\n");
856        printf("\n");
857        printf("Supported output options:\n");
858        printf("\t-z\tSpecify the gzip compression, ranging from 0 (uncompressed) to 9 - defaults to 1\n");
859        printf("\n");
860
861       
862}
863
864static void rtclient_help() {
865        printf("rtclient format module\n");
866        printf("Supported input URIs:\n");
867        printf("\trtclient:hostname:port\n");
868        printf("\trtclient:hostname (connects on default port)\n");
869        printf("\n");
870        printf("\te.g.: rtclient:localhost\n");
871        printf("\te.g.: rtclient:localhost:32500\n");
872        printf("\n");
873        printf("Supported output URIs:\n");
874        printf("\trtclient: \t(will output on default port on all available IP addresses) \n");
875        printf("\trtclient:hostname:port\n");
876        printf("\trtclient:port\n");
877        printf("\n");
878        printf("\te.g.: rtclient:32500\n");
879        printf("\te.g.: rtclient:\n");
880        printf("\n");
881
882}
883
884static struct libtrace_format_t legacyatm = {
885        "legacyatm",
886        "$Id$",
887        "legacyatm",
888        erf_init_input,                 /* init_input */       
889        NULL,                           /* init_output */
890        NULL,                           /* config_output */
891        erf_fin_input,                  /* fin_input */
892        NULL,                           /* fin_output */
893        legacy_read_packet,             /* read_packet */
894        NULL,                           /* write_packet */
895        legacy_get_link,                /* get_link */
896        legacyatm_get_link_type,        /* get_link_type */
897        NULL,                           /* get_direction */
898        NULL,                           /* set_direction */
899        erf_get_erf_timestamp,          /* get_erf_timestamp */
900        NULL,                           /* get_timeval */
901        NULL,                           /* get_seconds */
902        legacy_get_capture_length,      /* get_capture_length */
903        legacyatm_get_wire_length,      /* get_wire_length */
904        NULL,                           /* set_capture_length */
905        NULL,                           /* get_fd */
906        trace_event_trace,              /* trace_event */
907        legacyatm_help                  /* help */
908};
909
910static struct libtrace_format_t legacyeth = {
911        "legacyeth",
912        "$Id$",
913        "legacyeth",
914        erf_init_input,                 /* init_input */       
915        NULL,                           /* init_output */
916        NULL,                           /* config_output */
917        erf_fin_input,                  /* fin_input */
918        NULL,                           /* fin_output */
919        legacy_read_packet,             /* read_packet */
920        NULL,                           /* write_packet */
921        legacy_get_link,                /* get_link */
922        legacyeth_get_link_type,        /* get_link_type */
923        NULL,                           /* get_direction */
924        NULL,                           /* set_direction */
925        erf_get_erf_timestamp,          /* get_erf_timestamp */
926        NULL,                           /* get_timeval */
927        NULL,                           /* get_seconds */
928        legacy_get_capture_length,      /* get_capture_length */
929        legacyeth_get_wire_length,      /* get_wire_length */
930        NULL,                           /* set_capture_length */
931        NULL,                           /* get_fd */
932        trace_event_trace,              /* trace_event */
933        legacyeth_help                  /* help */
934};
935
936static struct libtrace_format_t legacypos = {
937        "legacypos",
938        "$Id$",
939        "legacypos",
940        erf_init_input,                 /* init_input */       
941        NULL,                           /* init_output */
942        NULL,                           /* config_output */
943        erf_fin_input,                  /* fin_input */
944        NULL,                           /* fin_output */
945        legacy_read_packet,             /* read_packet */
946        NULL,                           /* write_packet */
947        legacy_get_link,                /* get_link */
948        legacypos_get_link_type,        /* get_link_type */
949        NULL,                           /* get_direction */
950        NULL,                           /* set_direction */
951        erf_get_erf_timestamp,          /* get_erf_timestamp */
952        NULL,                           /* get_timeval */
953        NULL,                           /* get_seconds */
954        legacy_get_capture_length,      /* get_capture_length */
955        legacypos_get_wire_length,      /* get_wire_length */
956        NULL,                           /* set_capture_length */
957        NULL,                           /* get_fd */
958        trace_event_trace,              /* trace_event */
959        legacypos_help                  /* help */
960};
961
962       
963static struct libtrace_format_t erf = {
964        "erf",
965        "$Id$",
966        "erf",
967        erf_init_input,                 /* init_input */       
968        erf_init_output,                /* init_output */
969        erf_config_output,              /* config_output */
970        erf_fin_input,                  /* fin_input */
971        erf_fin_output,                 /* fin_output */
972        erf_read_packet,                /* read_packet */
973        erf_write_packet,               /* write_packet */
974        erf_get_link,                   /* get_link */
975        erf_get_link_type,              /* get_link_type */
976        erf_get_direction,              /* get_direction */
977        erf_set_direction,              /* set_direction */
978        erf_get_erf_timestamp,          /* get_erf_timestamp */
979        NULL,                           /* get_timeval */
980        NULL,                           /* get_seconds */
981        erf_get_capture_length,         /* get_capture_length */
982        erf_get_wire_length,            /* get_wire_length */
983        erf_set_capture_length,         /* set_capture_length */
984        erf_get_fd,                     /* get_fd */
985        trace_event_trace,              /* trace_event */
986        erf_help                        /* help */
987};
988
989#ifdef HAVE_DAG
990static struct libtrace_format_t dag = {
991        "dag",
992        "$Id$",
993        "erf",
994        dag_init_input,                 /* init_input */       
995        NULL,                           /* init_output */
996        NULL,                           /* config_output */
997        dag_fin_input,                  /* fin_input */
998        NULL,                           /* fin_output */
999        dag_read_packet,                /* read_packet */
1000        NULL,                           /* write_packet */
1001        erf_get_link,                   /* get_link */
1002        erf_get_link_type,              /* get_link_type */
1003        erf_get_direction,              /* get_direction */
1004        erf_set_direction,              /* set_direction */
1005        erf_get_erf_timestamp,          /* get_erf_timestamp */
1006        NULL,                           /* get_timeval */
1007        NULL,                           /* get_seconds */
1008        erf_get_capture_length,         /* get_capture_length */
1009        erf_get_wire_length,            /* get_wire_length */
1010        erf_set_capture_length,         /* set_capture_length */
1011        NULL,                           /* get_fd */
1012        trace_event_trace,              /* trace_event */
1013        dag_help                        /* help */
1014};
1015#endif
1016
1017static struct libtrace_format_t rtclient = {
1018        "rtclient",
1019        "$Id$",
1020        "erf",
1021        rtclient_init_input,            /* init_input */       
1022        NULL,                           /* init_output */
1023        NULL,                           /* config_output */
1024        rtclient_fin_input,             /* fin_input */
1025        NULL,                           /* fin_output */
1026        rtclient_read_packet,           /* read_packet */
1027        NULL,                           /* write_packet */
1028        erf_get_link,                   /* get_link */
1029        erf_get_link_type,              /* get_link_type */
1030        erf_get_direction,              /* get_direction */
1031        erf_set_direction,              /* set_direction */
1032        erf_get_erf_timestamp,          /* get_erf_timestamp */
1033        NULL,                           /* get_timeval */
1034        NULL,                           /* get_seconds */
1035        erf_get_capture_length,         /* get_capture_length */
1036        erf_get_wire_length,            /* get_wire_length */
1037        erf_set_capture_length,         /* set_capture_length */
1038        rtclient_get_fd,                /* get_fd */
1039        trace_event_device,             /* trace_event */
1040        rtclient_help                   /* help */
1041};
1042
1043void __attribute__((constructor)) erf_constructor() {
1044        erf_ptr = &erf;
1045        register_format(erf_ptr);
1046#ifdef HAVE_DAG
1047        dag_ptr = &dag;
1048        register_format(dag_ptr);
1049#endif
1050        rtclient_ptr = &rtclient;
1051        register_format(rtclient_ptr);
1052
1053        legacypos_ptr = &legacypos;
1054        register_format(legacypos_ptr);
1055
1056        legacyeth_ptr = &legacyeth;
1057        register_format(legacyeth_ptr);
1058
1059        legacyatm_ptr = &legacyatm;
1060        register_format(legacyatm_ptr);
1061
1062}
Note: See TracBrowser for help on using the repository browser.