source: lib/format_erf.c @ 0f7f688

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

Added checks in the erf handler to make sure you don't read corrupt/legacy
traces as a non legacy format.

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