source: lib/format_erf.c @ 641dc7c

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

fixup for bad dag_root detection in configure
tidied up the gzread/read calls through use of a macro
added get_wire_length to the legacy formats

  • Property mode set to 100644
File size: 26.1 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
194static int erf_init_input(struct libtrace_t *libtrace) {
195        struct stat buf;
196        struct sockaddr_un unix_sock;
197        libtrace->format_data = (struct libtrace_format_data_t *)
198                malloc(sizeof(struct libtrace_format_data_t));
199
200        CONNINFO.path = libtrace->uridata;
201        if (!strncmp(CONNINFO.path,"-",1)) {
202                // STDIN
203                libtrace->sourcetype = STDIN;
204                INPUT.file = LIBTRACE_FDOPEN(STDIN, "r");
205
206        } else {
207                if (stat(CONNINFO.path,&buf) == -1 ) {
208                        perror("stat");
209                        return 0;
210                }
211                if (S_ISSOCK(buf.st_mode)) {
212                        libtrace->sourcetype = SOCKET;
213                        if ((INPUT.fd = socket(
214                                        AF_UNIX, SOCK_STREAM, 0)) == -1) {
215                                perror("socket");
216                                return 0;
217                        }
218                        unix_sock.sun_family = AF_UNIX;
219                        bzero(unix_sock.sun_path,108);
220                        snprintf(unix_sock.sun_path,
221                                        108,"%s"
222                                        ,CONNINFO.path);
223
224                        if (connect(INPUT.fd, 
225                                        (struct sockaddr *)&unix_sock,
226                                        sizeof(struct sockaddr)) == -1) {
227                                perror("connect (unix)");
228                                return 0;
229                        }
230                } else { 
231
232                        libtrace->sourcetype = TRACE;
233
234                        // we use an FDOPEN call to reopen an FD
235                        // returned from open(), so that we can set
236                        // O_LARGEFILE. This gets around gzopen not
237                        // letting you do this...
238                        INPUT.file = LIBTRACE_FDOPEN(open(
239                                                CONNINFO.path,
240                                                O_LARGEFILE),"r");
241                }
242        }
243        return 1;
244}
245
246static int rtclient_init_input(struct libtrace_t *libtrace) {
247        char *scan;
248        char *uridata = libtrace->uridata;
249        struct hostent *he;
250        struct sockaddr_in remote;
251        libtrace->format_data = (struct libtrace_format_data_t *)
252                malloc(sizeof(struct libtrace_format_data_t));
253
254        libtrace->sourcetype = RT;
255
256        if (strlen(uridata) == 0) {
257                CONNINFO.rt.hostname = 
258                        strdup("localhost");
259                CONNINFO.rt.port = 
260                        COLLECTOR_PORT;
261        } else {
262                if ((scan = strchr(uridata,':')) == NULL) {
263                        CONNINFO.rt.hostname = 
264                                strdup(uridata);
265                        CONNINFO.rt.port =
266                                COLLECTOR_PORT;
267                } else {
268                        CONNINFO.rt.hostname = 
269                                (char *)strndup(uridata,
270                                                (scan - uridata));
271                        CONNINFO.rt.port = 
272                                atoi(++scan);
273                }
274        }
275       
276        if ((he=gethostbyname(CONNINFO.rt.hostname)) == NULL) { 
277                perror("gethostbyname");
278                return 0;
279        } 
280        if ((INPUT.fd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
281                perror("socket");
282                return 0;
283        }
284
285        remote.sin_family = AF_INET;   
286        remote.sin_port = htons(CONNINFO.rt.port);
287        remote.sin_addr = *((struct in_addr *)he->h_addr);
288        bzero(&(remote.sin_zero), 8);
289
290        if (connect(INPUT.fd, (struct sockaddr *)&remote,
291                                sizeof(struct sockaddr)) == -1) {
292                perror("connect (inet)");
293                return 0;
294        }
295        return 1;
296}
297
298static int erf_init_output(struct libtrace_out_t *libtrace) {
299        char *filemode = 0;
300        int fd;
301        libtrace->format_data = (struct libtrace_format_data_out_t *)
302                calloc(1,sizeof(struct libtrace_format_data_out_t));
303
304        OPTIONS.erf.level = 0;
305#if HAVE_ZLIB
306        asprintf(&filemode,"wb%d",OPTIONS.erf.level);
307#else
308        asprintf(&filemode,"w");
309#endif
310
311        if (!strncmp(libtrace->uridata,"-",1)) {
312                // STDOUT
313                OUTPUT.file = LIBTRACE_FDOPEN(dup(1),filemode);
314        }
315        else {
316                // TRACE
317                fd = open(libtrace->uridata, O_CREAT | O_LARGEFILE | O_WRONLY, S_IRUSR | S_IWUSR);
318                if (fd <= 0) {
319                        return 0;
320                }
321                OUTPUT.file = LIBTRACE_FDOPEN(fd,filemode);
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        LIBTRACE_CLOSE(INPUT.file);
370        free(libtrace->format_data);
371        return 0;
372}
373
374static int rtclient_fin_input(struct libtrace_t *libtrace) {
375        close(INPUT.fd);
376        return 0;
377}
378
379static int erf_fin_output(struct libtrace_out_t *libtrace) {
380        LIBTRACE_CLOSE(OUTPUT.file);
381        free(libtrace->format_data);
382
383        return 0;
384}
385 
386
387
388#if HAVE_DAG
389static int dag_read(struct libtrace_t *libtrace, void *buffer, size_t len) {
390        int numbytes;
391        static short lctr = 0;
392        struct dag_record_t *erfptr = 0;
393        int rlen;
394
395        if (buffer == 0)
396                buffer = malloc(len);
397       
398        DAG.bottom = DAG.top;
399        DAG.top = dag_offset(
400                        INPUT.fd,
401                        &(DAG.bottom),
402                        0);
403        DAG.diff = DAG.top -
404                DAG.bottom;
405
406        numbytes=DAG.diff;
407        DAG.offset = 0;
408        return numbytes;
409}
410#endif
411
412#if HAVE_DAG
413static int dag_read_packet(struct libtrace_t *libtrace, struct libtrace_packet_t *packet) {
414        int numbytes;
415        int size;
416        char buf[RP_BUFSIZE];
417        dag_record_t *erfptr;
418        void *buffer = packet->buffer;
419        void *buffer2 = buffer;
420        int rlen;
421       
422        if (DAG.diff == 0) {
423                if ((numbytes = dag_read(libtrace,buf,RP_BUFSIZE)) <= 0) 
424                        return numbytes;
425        }
426
427        //DAG always gives us whole packets
428        erfptr = (dag_record_t *) ((void *)DAG.buf + 
429                        (DAG.bottom + DAG.offset));
430        size = ntohs(erfptr->rlen);
431
432        if ( size  > LIBTRACE_PACKET_BUFSIZE) {
433                assert( size < LIBTRACE_PACKET_BUFSIZE);
434        }
435
436        // have to copy it out of the memory hole at this stage:
437        memcpy(packet->buffer, erfptr, size);
438       
439        packet->status = 0;
440        packet->size = size;
441        DAG.offset += size;
442        DAG.diff -= size;
443
444        assert(DAG.diff >= 0);
445
446        return (size);
447}
448#endif
449
450static int legacy_read_packet(struct libtrace_t *libtrace, struct libtrace_packet_t *packet) {
451        int numbytes;
452        int size;
453        void *buffer = packet->buffer;
454        void *buffer2 = buffer;
455        dag_record_t *erfptr = (dag_record_t *)buffer;
456        int rlen;
457
458        if ((numbytes=LIBTRACE_READ(INPUT.file,
459                                        buffer,
460                                        dag_record_size)) == -1) {
461                perror("libtrace_read");
462                return -1;
463        }
464        if (numbytes == 0) {
465                return 0;
466        }
467
468        // legacy - 64byte captures
469        // type is TYPE_LEGACY
470        rlen = 64;
471        size = rlen - dag_record_size;
472        buffer2 = buffer + dag_record_size;
473       
474        if ((numbytes=LIBTRACE_READ(INPUT.file,
475                                        buffer2,
476                                        size)) == -1) {
477                perror("libtrace_read");
478                return -1;
479        }
480        packet->status = 0;
481        packet->size = rlen;
482        return rlen;
483}
484static int erf_read_packet(struct libtrace_t *libtrace, struct libtrace_packet_t *packet) {
485        int numbytes;
486        int size;
487        void *buffer = packet->buffer;
488        void *buffer2 = buffer;
489        int rlen;
490        if ((numbytes=LIBTRACE_READ(INPUT.file,
491                                        buffer,
492                                        dag_record_size)) == -1) {
493                perror("libtrace_read");
494                return -1;
495        }
496        if (numbytes == 0) {
497                return 0;
498        }
499        rlen = ntohs(((dag_record_t *)buffer)->rlen);
500        size = rlen - dag_record_size;
501        assert(size < LIBTRACE_PACKET_BUFSIZE);
502        buffer2 = buffer + dag_record_size;
503        /* If your trace is legacy, or corrupt, then this assert may fire. */
504        assert(((dag_record_t *)buffer)->rlen <= 
505                        ((dag_record_t*)buffer)->wlen+sizeof(dag_record_t));
506        /* If it's an unknown type, your trace is legacy */
507        assert(((dag_record_t *)buffer)->type != 0);
508        /* Unknown/corrupt */
509        assert(((dag_record_t *)buffer)->type < 10);
510       
511        // read in the rest of the packet
512        if ((numbytes=LIBTRACE_READ(INPUT.file,
513                                        buffer2,
514                                        size)) == -1) {
515                perror("libtrace_read");
516                return -1;
517        }
518        packet->status = 0;
519        packet->size = rlen;
520        return rlen;
521}
522
523static int rtclient_read(struct libtrace_t *libtrace, void *buffer, size_t len) {
524        int numbytes;
525
526        if (buffer == 0)
527                buffer = malloc(len);
528        while(1) {
529#ifndef MSG_NOSIGNAL
530#  define MSG_NOSIGNAL 0
531#endif
532                if ((numbytes = recv(INPUT.fd,
533                                                buffer,
534                                                len,
535                                                MSG_NOSIGNAL)) == -1) {
536                        if (errno == EINTR) {
537                                //ignore EINTR in case
538                                // a caller is using signals
539                                continue;
540                        }
541                        perror("recv");
542                        return -1;
543                }
544                break;
545
546        }
547        return numbytes;
548}
549
550static int rtclient_read_packet(struct libtrace_t *libtrace, struct libtrace_packet_t *packet) {
551        int numbytes = 0;
552        int size = 0;
553        char buf[RP_BUFSIZE];
554        int read_required = 0;
555       
556        void *buffer = 0;
557
558        packet->trace = libtrace;
559        buffer = packet->buffer;
560
561        do {
562                if (tracefifo_out_available(libtrace->fifo) == 0 || read_required) {
563                        if ((numbytes = rtclient_read(
564                                        libtrace,buf,RP_BUFSIZE))<=0) {
565                                return numbytes;
566                        }
567                        tracefifo_write(libtrace->fifo,buf,numbytes);
568                        read_required = 0;
569                }
570                // Read status byte
571                if (tracefifo_out_read(libtrace->fifo,
572                                &packet->status, sizeof(int)) == 0) {
573                        read_required = 1;
574                        continue;
575                }
576                tracefifo_out_update(libtrace->fifo,sizeof(int));
577
578                // read in the ERF header
579                if ((numbytes = tracefifo_out_read(libtrace->fifo, buffer,
580                                                sizeof(dag_record_t))) == 0) {
581                        tracefifo_out_reset(libtrace->fifo);
582                        read_required = 1;
583                        continue;
584                }
585                size = ntohs(((dag_record_t *)buffer)->rlen);
586               
587                // read in the full packet
588                if ((numbytes = tracefifo_out_read(libtrace->fifo, 
589                                                buffer, size)) == 0) {
590                        tracefifo_out_reset(libtrace->fifo);
591                        read_required = 1;
592                        continue;
593                }
594
595                // got in our whole packet, so...
596                tracefifo_out_update(libtrace->fifo,size);
597
598                tracefifo_ack_update(libtrace->fifo,size + sizeof(int));
599
600                packet->size = numbytes;
601                return numbytes;
602        } while(1);
603}
604
605static int erf_dump_packet(struct libtrace_out_t *libtrace, dag_record_t *erfptr, void *buffer, size_t size) {
606        int numbytes = 0;
607        if ((numbytes = LIBTRACE_WRITE(OUTPUT.file, erfptr, dag_record_size + 2)) == 0) {
608                perror("libtrace_write");
609                return -1;
610        }
611        if ((numbytes = LIBTRACE_WRITE(OUTPUT.file, buffer, size)) == 0) {
612                perror("libtrace_write");
613                return -1;
614        }
615        return numbytes + sizeof(dag_record_t);
616
617}
618               
619static int erf_write_packet(struct libtrace_out_t *libtrace, struct libtrace_packet_t *packet) {
620        int numbytes = 0;
621        dag_record_t erfhdr;
622        void *payload = (void *)trace_get_link(packet);
623
624        if (packet->trace->format == erf_ptr || 
625#if HAVE_DAG
626                        packet->trace->format == dag_ptr ||
627#endif
628                        packet->trace->format == rtclient_ptr ) {
629                numbytes = erf_dump_packet(libtrace,
630                                (dag_record_t *)packet->buffer,
631                                payload,
632                                packet->size - 
633                                        (dag_record_size + 2)); 
634        } else {
635                // convert format - build up a new erf header
636                // Timestamp
637                erfhdr.ts = trace_get_erf_timestamp(packet);
638                // Link type
639                switch(trace_get_link_type(packet)) {
640                case TRACE_TYPE_ETH:
641                        erfhdr.type=TYPE_ETH; break;
642                case TRACE_TYPE_ATM:
643                        erfhdr.type=TYPE_ATM; break;
644                default:
645                        erfhdr.type=0; 
646                }
647                // Flags. Can't do this
648                memset(&erfhdr.flags,1,1);
649                // Packet length
650                erfhdr.rlen = trace_get_capture_length(packet);
651                // loss counter. Can't do this
652                erfhdr.lctr = 0;
653                // Wire length
654                erfhdr.wlen = trace_get_wire_length(packet);
655               
656                // Write it out
657                numbytes = erf_dump_packet(libtrace,
658                                &erfhdr,
659                                payload,
660                                erfhdr.rlen);
661        }
662        return numbytes;
663}
664
665
666static void *legacy_get_link(const struct libtrace_packet_t *packet) {
667        return (void *)packet->buffer;
668}
669
670static libtrace_linktype_t legacy_get_link_type(const struct libtrace_packet_t *packet) {
671        return TRACE_TYPE_LEGACY;
672}
673
674static libtrace_linktype_t legacyeth_get_link_type(const struct libtrace_packet_t *packet) {
675        return TRACE_TYPE_LEGACY_ETH;
676}
677
678static libtrace_linktype_t legacyatm_get_link_type(const struct libtrace_packet_t *packet) {
679        return TRACE_TYPE_LEGACY_ATM;
680}
681
682static libtrace_linktype_t legacypos_get_link_type(const struct libtrace_packet_t *packet) {
683        return TRACE_TYPE_LEGACY_POS;
684}
685
686static void *erf_get_link(const struct libtrace_packet_t *packet) {
687        const void *ethptr = 0;
688        dag_record_t *erfptr = 0;
689        erfptr = (dag_record_t *)packet->buffer;
690       
691        if (erfptr->flags.rxerror == 1) {
692                return NULL;
693        }
694        ethptr = ((uint8_t *)packet->buffer +
695                        dag_record_size + 2);
696        return (void *)ethptr;
697}
698
699static libtrace_linktype_t erf_get_link_type(const struct libtrace_packet_t *packet) {
700        dag_record_t *erfptr = 0;
701        erfptr = (dag_record_t *)packet->buffer;
702        switch (erfptr->type) {
703                case TYPE_ETH: return TRACE_TYPE_ETH;
704                case TYPE_ATM: return TRACE_TYPE_ATM;
705                default: assert(0);
706        }
707        return erfptr->type;
708}
709
710static int8_t erf_get_direction(const struct libtrace_packet_t *packet) {
711        dag_record_t *erfptr = 0;
712        erfptr = (dag_record_t *)packet->buffer;
713        return erfptr->flags.iface;
714}
715
716static int8_t erf_set_direction(const struct libtrace_packet_t *packet, int8_t direction) {
717        dag_record_t *erfptr = 0;
718        erfptr = (dag_record_t *)packet->buffer;
719        erfptr->flags.iface = direction;
720        return erfptr->flags.iface;
721}
722
723static uint64_t erf_get_erf_timestamp(const struct libtrace_packet_t *packet) {
724        dag_record_t *erfptr = 0;
725        erfptr = (dag_record_t *)packet->buffer;
726        return erfptr->ts;
727}
728
729static int legacy_get_capture_length(const struct libtrace_packet_t *packet __attribute__((unused))) {
730        return 64;
731}
732
733static int legacypos_get_wire_length(const struct libtrace_packet_t *packet) {
734        legacy_pos_t *lpos = (legacy_pos_t *)packet->buffer;
735        return ntohs(lpos->wlen);
736}
737
738static int legacyatm_get_wire_length(const struct libtrace_packet_t *packet) {
739        return 53;
740}
741
742static int legacyeth_get_wire_length(const struct libtrace_packet_t *packet) {
743        legacy_ether_t *leth = (legacy_ether_t *)packet->buffer;
744        return ntohs(leth->wlen);
745}
746static int erf_get_capture_length(const struct libtrace_packet_t *packet) {
747        dag_record_t *erfptr = 0;
748        erfptr = (dag_record_t *)packet->buffer;
749        return ntohs(erfptr->rlen);
750}
751
752static int erf_get_wire_length(const struct libtrace_packet_t *packet) {
753        dag_record_t *erfptr = 0;
754        erfptr = (dag_record_t *)packet->buffer;
755        return ntohs(erfptr->wlen);
756}
757
758static size_t erf_set_capture_length(struct libtrace_packet_t *packet, size_t size) {
759        dag_record_t *erfptr = 0;
760        assert(packet);
761        if(size > packet->size) {
762                // can't make a packet larger
763                return packet->size;
764        }
765        erfptr = (dag_record_t *)packet->buffer;
766        erfptr->rlen = ntohs(size + sizeof(dag_record_t));
767        packet->size = size + sizeof(dag_record_t);
768        return packet->size;
769}
770
771static int rtclient_get_fd(const struct libtrace_packet_t *packet) {
772        return packet->trace->format_data->input.fd;
773}
774
775static int erf_get_fd(const struct libtrace_packet_t *packet) {
776        return packet->trace->format_data->input.fd;
777}
778
779#if HAVE_DAG
780static void dag_help() {
781        printf("dag format module: $Revision$\n");
782        printf("Supported input URIs:\n");
783        printf("\tdag:/dev/dagn\n");
784        printf("\n");
785        printf("\te.g.: dag:/dev/dag0\n");
786        printf("\n");
787        printf("Supported output URIs:\n");
788        printf("\tnone\n");
789        printf("\n");
790}
791#endif
792
793static void legacypos_help() {
794        printf("legacypos format module: $Revision$\n");
795        printf("Supported input URIs:\n");
796        printf("\tlegacypos:/path/to/file\t(uncompressed)\n");
797        printf("\tlegacypos:/path/to/file.gz\t(gzip-compressed)\n");
798        printf("\tlegacypos:-\t(stdin, either compressed or not)\n");
799        printf("\n");
800        printf("\te.g.: legacypos:/tmp/trace.gz\n");
801        printf("\n");
802}
803
804static void legacyatm_help() {
805        printf("legacyatm format module: $Revision$\n");
806        printf("Supported input URIs:\n");
807        printf("\tlegacyatm:/path/to/file\t(uncompressed)\n");
808        printf("\tlegacyatm:/path/to/file.gz\t(gzip-compressed)\n");
809        printf("\tlegacyatm:-\t(stdin, either compressed or not)\n");
810        printf("\n");
811        printf("\te.g.: legacyatm:/tmp/trace.gz\n");
812        printf("\n");
813}
814
815static void legacyeth_help() {
816        printf("legacyeth format module: $Revision$\n");
817        printf("Supported input URIs:\n");
818        printf("\tlegacyeth:/path/to/file\t(uncompressed)\n");
819        printf("\tlegacyeth:/path/to/file.gz\t(gzip-compressed)\n");
820        printf("\tlegacyeth:-\t(stdin, either compressed or not)\n");
821        printf("\n");
822        printf("\te.g.: legacyeth:/tmp/trace.gz\n");
823        printf("\n");
824}
825
826static void erf_help() {
827        printf("erf format module: $Revision$\n");
828        printf("Supported input URIs:\n");
829        printf("\terf:/path/to/file\t(uncompressed)\n");
830        printf("\terf:/path/to/file.gz\t(gzip-compressed)\n");
831        printf("\terf:-\t(stdin, either compressed or not)\n");
832        printf("\terf:/path/to/socket\n");
833        printf("\n");
834        printf("\te.g.: erf:/tmp/trace\n");
835        printf("\n");
836        printf("Supported output URIs:\n");
837        printf("\terf:path/to/file\t(uncompressed)\n");
838        printf("\terf:/path/to/file.gz\t(gzip-compressed)\n");
839        printf("\terf:-\t(stdout, either compressed or not)\n");
840        printf("\n");
841        printf("\te.g.: erf:/tmp/trace\n");
842        printf("\n");
843        printf("Supported output options:\n");
844        printf("\t-z\tSpecify the gzip compression, ranging from 0 (uncompressed) to 9 - defaults to 1\n");
845        printf("\n");
846
847       
848}
849
850static void rtclient_help() {
851        printf("rtclient format module\n");
852        printf("Supported input URIs:\n");
853        printf("\trtclient:hostname:port\n");
854        printf("\trtclient:hostname (connects on default port)\n");
855        printf("\n");
856        printf("\te.g.: rtclient:localhost\n");
857        printf("\te.g.: rtclient:localhost:32500\n");
858        printf("\n");
859        printf("Supported output URIs:\n");
860        printf("\trtclient: \t(will output on default port on all available IP addresses) \n");
861        printf("\trtclient:hostname:port\n");
862        printf("\trtclient:port\n");
863        printf("\n");
864        printf("\te.g.: rtclient:32500\n");
865        printf("\te.g.: rtclient:\n");
866        printf("\n");
867
868}
869
870static struct libtrace_format_t legacyatm = {
871        "legacyatm",
872        "$Id$",
873        "legacyatm",
874        erf_init_input,                 /* init_input */       
875        NULL,                           /* init_output */
876        NULL,                           /* config_output */
877        erf_fin_input,                  /* fin_input */
878        NULL,                           /* fin_output */
879        legacy_read_packet,             /* read_packet */
880        NULL,                           /* write_packet */
881        legacy_get_link,                /* get_link */
882        legacyatm_get_link_type,        /* get_link_type */
883        NULL,                           /* get_direction */
884        NULL,                           /* set_direction */
885        erf_get_erf_timestamp,          /* get_erf_timestamp */
886        NULL,                           /* get_timeval */
887        NULL,                           /* get_seconds */
888        legacy_get_capture_length,      /* get_capture_length */
889        legacyatm_get_wire_length,      /* get_wire_length */
890        NULL,                           /* set_capture_length */
891        NULL,                           /* get_fd */
892        trace_event_trace,              /* trace_event */
893        legacyatm_help                  /* help */
894};
895
896static struct libtrace_format_t legacyeth = {
897        "legacyeth",
898        "$Id$",
899        "legacyeth",
900        erf_init_input,                 /* init_input */       
901        NULL,                           /* init_output */
902        NULL,                           /* config_output */
903        erf_fin_input,                  /* fin_input */
904        NULL,                           /* fin_output */
905        legacy_read_packet,             /* read_packet */
906        NULL,                           /* write_packet */
907        legacy_get_link,                /* get_link */
908        legacyeth_get_link_type,        /* get_link_type */
909        NULL,                           /* get_direction */
910        NULL,                           /* set_direction */
911        erf_get_erf_timestamp,          /* get_erf_timestamp */
912        NULL,                           /* get_timeval */
913        NULL,                           /* get_seconds */
914        legacy_get_capture_length,      /* get_capture_length */
915        legacyeth_get_wire_length,      /* get_wire_length */
916        NULL,                           /* set_capture_length */
917        NULL,                           /* get_fd */
918        trace_event_trace,              /* trace_event */
919        legacyeth_help                  /* help */
920};
921
922static struct libtrace_format_t legacypos = {
923        "legacypos",
924        "$Id$",
925        "legacypos",
926        erf_init_input,                 /* init_input */       
927        NULL,                           /* init_output */
928        NULL,                           /* config_output */
929        erf_fin_input,                  /* fin_input */
930        NULL,                           /* fin_output */
931        legacy_read_packet,             /* read_packet */
932        NULL,                           /* write_packet */
933        legacy_get_link,                /* get_link */
934        legacypos_get_link_type,        /* get_link_type */
935        NULL,                           /* get_direction */
936        NULL,                           /* set_direction */
937        erf_get_erf_timestamp,          /* get_erf_timestamp */
938        NULL,                           /* get_timeval */
939        NULL,                           /* get_seconds */
940        legacy_get_capture_length,      /* get_capture_length */
941        legacypos_get_wire_length,      /* get_wire_length */
942        NULL,                           /* set_capture_length */
943        NULL,                           /* get_fd */
944        trace_event_trace,              /* trace_event */
945        legacypos_help                  /* help */
946};
947
948       
949static struct libtrace_format_t erf = {
950        "erf",
951        "$Id$",
952        "erf",
953        erf_init_input,                 /* init_input */       
954        erf_init_output,                /* init_output */
955        erf_config_output,              /* config_output */
956        erf_fin_input,                  /* fin_input */
957        erf_fin_output,                 /* fin_output */
958        erf_read_packet,                /* read_packet */
959        erf_write_packet,               /* write_packet */
960        erf_get_link,                   /* get_link */
961        erf_get_link_type,              /* get_link_type */
962        erf_get_direction,              /* get_direction */
963        erf_set_direction,              /* set_direction */
964        erf_get_erf_timestamp,          /* get_erf_timestamp */
965        NULL,                           /* get_timeval */
966        NULL,                           /* get_seconds */
967        erf_get_capture_length,         /* get_capture_length */
968        erf_get_wire_length,            /* get_wire_length */
969        erf_set_capture_length,         /* set_capture_length */
970        erf_get_fd,                     /* get_fd */
971        trace_event_trace,              /* trace_event */
972        erf_help                        /* help */
973};
974
975#ifdef HAVE_DAG
976static struct libtrace_format_t dag = {
977        "dag",
978        "$Id$",
979        "erf",
980        dag_init_input,                 /* init_input */       
981        NULL,                           /* init_output */
982        NULL,                           /* config_output */
983        dag_fin_input,                  /* fin_input */
984        NULL,                           /* fin_output */
985        dag_read_packet,                /* read_packet */
986        NULL,                           /* write_packet */
987        erf_get_link,                   /* get_link */
988        erf_get_link_type,              /* get_link_type */
989        erf_get_direction,              /* get_direction */
990        erf_set_direction,              /* set_direction */
991        erf_get_erf_timestamp,          /* get_erf_timestamp */
992        NULL,                           /* get_timeval */
993        NULL,                           /* get_seconds */
994        erf_get_capture_length,         /* get_capture_length */
995        erf_get_wire_length,            /* get_wire_length */
996        erf_set_capture_length,         /* set_capture_length */
997        NULL,                           /* get_fd */
998        trace_event_trace,              /* trace_event */
999        dag_help                        /* help */
1000};
1001#endif
1002
1003static struct libtrace_format_t rtclient = {
1004        "rtclient",
1005        "$Id$",
1006        "erf",
1007        rtclient_init_input,            /* init_input */       
1008        NULL,                           /* init_output */
1009        NULL,                           /* config_output */
1010        rtclient_fin_input,             /* fin_input */
1011        NULL,                           /* fin_output */
1012        rtclient_read_packet,           /* read_packet */
1013        NULL,                           /* write_packet */
1014        erf_get_link,                   /* get_link */
1015        erf_get_link_type,              /* get_link_type */
1016        erf_get_direction,              /* get_direction */
1017        erf_set_direction,              /* set_direction */
1018        erf_get_erf_timestamp,          /* get_erf_timestamp */
1019        NULL,                           /* get_timeval */
1020        NULL,                           /* get_seconds */
1021        erf_get_capture_length,         /* get_capture_length */
1022        erf_get_wire_length,            /* get_wire_length */
1023        erf_set_capture_length,         /* set_capture_length */
1024        rtclient_get_fd,                /* get_fd */
1025        trace_event_device,             /* trace_event */
1026        rtclient_help                   /* help */
1027};
1028
1029void __attribute__((constructor)) erf_constructor() {
1030        erf_ptr = &erf;
1031        register_format(erf_ptr);
1032#ifdef HAVE_DAG
1033        dag_ptr = &dag;
1034        register_format(dag_ptr);
1035#endif
1036        rtclient_ptr = &rtclient;
1037        register_format(rtclient_ptr);
1038
1039        legacypos_ptr = &legacypos;
1040        register_format(legacypos_ptr);
1041
1042        legacyeth_ptr = &legacyeth;
1043        register_format(legacyeth_ptr);
1044
1045        legacyatm_ptr = &legacyatm;
1046        register_format(legacyatm_ptr);
1047
1048}
Note: See TracBrowser for help on using the repository browser.