source: lib/format_rt.c @ f0fb38f

4.0.1-hotfixescachetimestampsdevelopdpdk-ndagetsilivegetfragoffhelplibtrace4ndag_formatpfringrc-4.0.1rc-4.0.2rc-4.0.3rc-4.0.4ringdecrementfixringperformanceringtimestampfixes
Last change on this file since f0fb38f was f0fb38f, checked in by Shane Alcock <salcock@…>, 14 years ago
  • Added prepare_packet functions to all formats, primarily to support translating RT packets into the appropriate format. These functions are all used internally as well, as most formats still need to "prepare" packets that have been read by setting pointers, updating loss counters etc.
  • Also added a trace_prepare_packet function, but this is not made available externally at this stage
  • Added init_format_data functions to some formats to initialise format data structures in cases where the init_trace function does more than just that
  • Refactored rt packet reading code to use the new trace_prepare_packet functionality - also did a lot of tidying of the code
  • Added missing RT type for BPF format
  • Property mode set to 100644
File size: 19.4 KB
Line 
1/*
2 * This file is part of libtrace
3 *
4 * Copyright (c) 2007,2008 The University of Waikato, Hamilton, New Zealand.
5 * Authors: Daniel Lawson
6 *          Perry Lorier
7 *          Shane Alcock
8 *
9 * All rights reserved.
10 *
11 * This code has been developed by the University of Waikato WAND
12 * research group. For further information please see http://www.wand.net.nz/
13 *
14 * libtrace is free software; you can redistribute it and/or modify
15 * it under the terms of the GNU General Public License as published by
16 * the Free Software Foundation; either version 2 of the License, or
17 * (at your option) any later version.
18 *
19 * libtrace is distributed in the hope that it will be useful,
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
22 * GNU General Public License for more details.
23 *
24 * You should have received a copy of the GNU General Public License
25 * along with libtrace; if not, write to the Free Software
26 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
27 *
28 * $Id$
29 *
30 */
31
32#define _GNU_SOURCE
33
34#include "config.h"
35#include "common.h"
36#include "libtrace.h"
37#include "libtrace_int.h"
38#include "format_helper.h"
39#include "rt_protocol.h"
40
41#include <sys/stat.h>
42#include <assert.h>
43#include <errno.h>
44#include <fcntl.h>
45#include <stdio.h>
46#include <string.h>
47#include <stdlib.h>
48
49#ifndef WIN32
50# include <netdb.h>
51#endif
52
53#define RT_INFO ((struct rt_format_data_t*)libtrace->format_data)
54
55static const char *rt_deny_reason(enum rt_conn_denied_t reason) 
56{
57        const char *string = 0;
58
59        switch(reason) {
60                case RT_DENY_WRAPPER:
61                        string = "Rejected by TCP Wrappers";
62                        break;
63                case RT_DENY_FULL:
64                        string = "Max connections reached on server";
65                        break;
66                case RT_DENY_AUTH:
67                        string = "Authentication failed";
68                        break;
69                default:
70                        string = "Unknown reason";
71        }
72
73        return string;
74}
75
76
77struct rt_format_data_t {
78        char *hostname;
79        int port;
80        int input_fd;
81        int reliable;
82        char *pkt_buffer;
83        char *buf_current;
84        size_t buf_filled;
85        rt_header_t rt_hdr;
86       
87        libtrace_t *dummy_duck;
88        libtrace_t *dummy_erf;
89        libtrace_t *dummy_pcap;
90        libtrace_t *dummy_linux;
91};
92
93static int rt_connect(libtrace_t *libtrace) {
94        struct hostent *he;
95        struct sockaddr_in remote;
96        rt_header_t connect_msg;
97        rt_deny_conn_t deny_hdr;       
98        rt_hello_t hello_opts;
99        uint8_t reason;
100       
101        if ((he=gethostbyname(RT_INFO->hostname)) == NULL) {
102                trace_set_err(libtrace, TRACE_ERR_INIT_FAILED,
103                                "Failed to convert hostname %s to address",
104                                RT_INFO->hostname);
105                return -1;
106        }
107        if ((RT_INFO->input_fd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
108                trace_set_err(libtrace, TRACE_ERR_INIT_FAILED,
109                                "Could not create socket");
110                return -1;
111        }
112
113        memset(&remote,0, sizeof(remote));
114        remote.sin_family = AF_INET;
115        remote.sin_port = htons(RT_INFO->port);
116        remote.sin_addr = *((struct in_addr *)he->h_addr);
117
118        if (connect(RT_INFO->input_fd, (struct sockaddr *)&remote,
119                                (socklen_t)sizeof(struct sockaddr)) == -1) {
120                trace_set_err(libtrace, TRACE_ERR_INIT_FAILED,
121                                "Could not connect to host %s on port %d",
122                                RT_INFO->hostname, RT_INFO->port);
123                return -1;
124        }
125
126       
127#if 0
128        oldflags = fcntl(RT_INFO->input_fd, F_GETFL, 0);
129        if (oldflags == -1) {
130                trace_set_err(libtrace, errno,
131                                "Could not get fd flags from fd %d\n",
132                                RT_INFO->input_fd);
133                return -1;
134        }
135        oldflags |= O_NONBLOCK;
136        if (fcntl(RT_INFO->input_fd, F_SETFL, oldflags) == -1) {
137                trace_set_err(libtrace, errno,
138                                "Could not set fd flags for fd %d\n",
139                                RT_INFO->input_fd);
140                return -1;
141        }
142#endif
143       
144       
145        /* We are connected, now receive message from server */
146       
147        if (recv(RT_INFO->input_fd, (void*)&connect_msg, sizeof(rt_header_t), 0) != sizeof(rt_header_t) ) {
148                trace_set_err(libtrace, TRACE_ERR_INIT_FAILED,
149                                "Could not receive connection message from %s",
150                                RT_INFO->hostname);
151                return -1;
152        }
153       
154        switch (connect_msg.type) {
155                case TRACE_RT_DENY_CONN:
156                       
157                        if (recv(RT_INFO->input_fd, (void*)&deny_hdr, 
158                                                sizeof(rt_deny_conn_t),
159                                                0) != sizeof(rt_deny_conn_t)) {
160                                reason = 0;
161                        }       
162                        reason = deny_hdr.reason;
163                        trace_set_err(libtrace, TRACE_ERR_INIT_FAILED,
164                                "Connection attempt is denied: %s",
165                                rt_deny_reason(reason));       
166                        return -1;
167                case TRACE_RT_HELLO:
168                        /* do something with options */
169                        if (recv(RT_INFO->input_fd, (void*)&hello_opts, 
170                                                sizeof(rt_hello_t), 0)
171                                        != sizeof(rt_hello_t)) {
172                                trace_set_err(libtrace, TRACE_ERR_INIT_FAILED,
173                                        "Failed to receive TRACE_RT_HELLO options");
174                                return -1;
175                        }
176                        RT_INFO->reliable = hello_opts.reliable;
177                       
178                        return 0;
179                default:
180                        trace_set_err(libtrace, TRACE_ERR_INIT_FAILED,
181                                        "Unknown message type received: %d",
182                                        connect_msg.type);
183                        return -1;
184        }
185        trace_set_err(libtrace, TRACE_ERR_INIT_FAILED,
186                        "Somehow you managed to reach this unreachable code");
187        return -1;
188}
189
190static void rt_init_format_data(libtrace_t *libtrace) {
191        libtrace->format_data = malloc(sizeof(struct rt_format_data_t));
192
193        RT_INFO->dummy_duck = NULL;
194        RT_INFO->dummy_erf = NULL;
195        RT_INFO->dummy_pcap = NULL;
196        RT_INFO->dummy_linux = NULL;
197        RT_INFO->pkt_buffer = NULL;
198        RT_INFO->buf_current = NULL;
199        RT_INFO->buf_filled = 0;
200        RT_INFO->hostname = NULL;
201        RT_INFO->port = 0;
202}
203
204static int rt_init_input(libtrace_t *libtrace) {
205        char *scan;
206        char *uridata = libtrace->uridata;
207
208        rt_init_format_data(libtrace);
209       
210        if (strlen(uridata) == 0) {
211                RT_INFO->hostname =
212                        strdup("localhost");
213                RT_INFO->port =
214                        COLLECTOR_PORT;
215        } else {
216                if ((scan = strchr(uridata,':')) == NULL) {
217                        RT_INFO->hostname =
218                                strdup(uridata);
219                        RT_INFO->port =
220                                COLLECTOR_PORT;
221                } else {
222                        RT_INFO->hostname =
223                                (char *)strndup(uridata,
224                                                (size_t)(scan - uridata));
225                        RT_INFO->port =
226                                atoi(++scan);
227                }
228        }
229
230        return 0;
231}
232       
233static int rt_start_input(libtrace_t *libtrace) {
234        rt_header_t start_msg;
235
236        start_msg.type = TRACE_RT_START;
237        start_msg.length = 0; 
238
239        if (rt_connect(libtrace) == -1)
240                return -1;
241       
242        /* Need to send start message to server */
243        if (send(RT_INFO->input_fd, (void*)&start_msg, sizeof(rt_header_t) +
244                                start_msg.length, 0) != sizeof(rt_header_t)) {
245                printf("Failed to send start message to server\n");
246                return -1;
247        }
248        RT_INFO->rt_hdr.type = TRACE_RT_LAST;
249
250        return 0;
251}
252
253static int rt_pause_input(libtrace_t *libtrace) {
254        rt_header_t close_msg;
255
256        close_msg.type = TRACE_RT_CLOSE;
257        close_msg.length = 0; 
258       
259        /* Send a close message to the server */
260        if (send(RT_INFO->input_fd, (void*)&close_msg, sizeof(rt_header_t) + 
261                                close_msg.length, 0) != (int)sizeof(rt_header_t)
262                                + close_msg.length) {
263                printf("Failed to send close message to server\n");
264       
265        }
266
267        close(RT_INFO->input_fd);
268        return 0;
269}
270
271static int rt_fin_input(libtrace_t *libtrace) {
272        if (RT_INFO->dummy_duck)
273                trace_destroy_dead(RT_INFO->dummy_duck);
274
275        if (RT_INFO->dummy_erf) 
276                trace_destroy_dead(RT_INFO->dummy_erf);
277               
278        if (RT_INFO->dummy_pcap)
279                trace_destroy_dead(RT_INFO->dummy_pcap);
280
281        if (RT_INFO->dummy_linux)
282                trace_destroy_dead(RT_INFO->dummy_linux);
283        free(libtrace->format_data);
284        return 0;
285}
286
287#define RT_BUF_SIZE 4000U
288
289static int rt_read(libtrace_t *libtrace, void **buffer, size_t len, int block) 
290{
291        int numbytes;
292       
293        assert(len <= RT_BUF_SIZE);
294       
295        if (!RT_INFO->pkt_buffer) {
296                RT_INFO->pkt_buffer = (char*)malloc((size_t)RT_BUF_SIZE);
297                RT_INFO->buf_current = RT_INFO->pkt_buffer;
298                RT_INFO->buf_filled = 0;
299        }
300
301#ifndef MSG_DONTWAIT
302#define MSG_DONTWAIT 0
303#endif
304
305        if (block)
306                block=0;
307        else
308                block=MSG_DONTWAIT;
309
310       
311        if (len > RT_INFO->buf_filled) {
312                memcpy(RT_INFO->pkt_buffer, RT_INFO->buf_current, 
313                                RT_INFO->buf_filled);
314                RT_INFO->buf_current = RT_INFO->pkt_buffer;
315#ifndef MSG_NOSIGNAL
316#  define MSG_NOSIGNAL 0
317#endif
318                while (len > RT_INFO->buf_filled) {
319                        if ((numbytes = recv(RT_INFO->input_fd,
320                                                RT_INFO->buf_current + 
321                                                RT_INFO->buf_filled,
322                                                RT_BUF_SIZE-RT_INFO->buf_filled,
323                                                MSG_NOSIGNAL|block)) <= 0) {
324                                if (numbytes == 0) {
325                                        trace_set_err(libtrace, TRACE_ERR_BAD_PACKET, 
326                                                        "No data received");
327                                        return -1;
328                                }
329                               
330                                if (errno == EINTR) {
331                                        /* ignore EINTR in case
332                                         * a caller is using signals
333                                         */
334                                        continue;
335                                }
336                                if (errno == EAGAIN) {
337                                        trace_set_err(libtrace,
338                                                        EAGAIN,
339                                                        "EAGAIN");
340                                        return -1;
341                                }
342                               
343                                perror("recv");
344                                trace_set_err(libtrace, errno,
345                                                "Failed to read data into rt recv buffer");
346                                return -1;
347                        }
348                        /*
349                        buf_ptr = RT_INFO->pkt_buffer;
350                        for (i = 0; i < RT_BUF_SIZE ; i++) {
351                                       
352                                printf("%02x", (unsigned char)*buf_ptr);
353                                buf_ptr ++;
354                        }
355                        printf("\n");
356                        */
357                        RT_INFO->buf_filled+=numbytes;
358                }
359
360        }
361        *buffer = RT_INFO->buf_current;
362        RT_INFO->buf_current += len;
363        RT_INFO->buf_filled -= len;
364        return len;
365}
366
367
368static int rt_set_format(libtrace_t *libtrace, libtrace_packet_t *packet) 
369{
370
371        /* Try to minimize the number of corrupt packets that slip through
372         * while making it easy to identify new pcap DLTs */
373        if (packet->type > TRACE_RT_DATA_DLT && 
374                        packet->type < TRACE_RT_DATA_DLT_END) {
375                if (!RT_INFO->dummy_pcap) {
376                        RT_INFO->dummy_pcap = trace_create_dead("pcap:-");
377                }
378                packet->trace = RT_INFO->dummy_pcap;
379                return 0;       
380        }
381
382        switch (packet->type) {
383                case TRACE_RT_DUCK_2_4:
384                case TRACE_RT_DUCK_2_5:
385                        if (!RT_INFO->dummy_duck) {
386                                RT_INFO->dummy_duck = trace_create_dead("duck:dummy");
387                        }
388                        packet->trace = RT_INFO->dummy_duck;
389                        break;
390                case TRACE_RT_DATA_ERF:
391                        if (!RT_INFO->dummy_erf) {
392                                RT_INFO->dummy_erf = trace_create_dead("erf:-");
393                        }
394                        packet->trace = RT_INFO->dummy_erf;
395                        break;
396                case TRACE_RT_DATA_LINUX_NATIVE:
397                        if (!RT_INFO->dummy_linux) {
398                                RT_INFO->dummy_linux = trace_create_dead("int:");
399                        }
400                        packet->trace = RT_INFO->dummy_linux;
401                        break;
402                case TRACE_RT_STATUS:
403                case TRACE_RT_METADATA:
404                        /* Just use the RT trace! */
405                        packet->trace = libtrace;
406                        break;
407                case TRACE_RT_DATA_LEGACY_ETH:
408                case TRACE_RT_DATA_LEGACY_ATM:
409                case TRACE_RT_DATA_LEGACY_POS:
410                        printf("Sending legacy over RT is currently not supported\n");
411                        trace_set_err(libtrace, TRACE_ERR_BAD_PACKET, "Legacy packet cannot be sent over rt");
412                        return -1;
413                default:
414                        printf("Unrecognised format: %u\n", packet->type);
415                        trace_set_err(libtrace, TRACE_ERR_BAD_PACKET, "Unrecognised packet format");
416                        return -1;
417        }
418        return 0; /* success */
419}               
420
421static int rt_send_ack(libtrace_t *libtrace, 
422                uint32_t seqno)  {
423       
424        static char *ack_buffer = 0;
425        char *buf_ptr;
426        int numbytes = 0;
427        size_t to_write = 0;
428        rt_header_t *hdr;
429        rt_ack_t *ack_hdr;
430       
431        if (!ack_buffer) {
432                ack_buffer = (char*)malloc(sizeof(rt_header_t) 
433                                                        + sizeof(rt_ack_t));
434        }
435       
436        hdr = (rt_header_t *) ack_buffer;
437        ack_hdr = (rt_ack_t *) (ack_buffer + sizeof(rt_header_t));
438       
439        hdr->type = TRACE_RT_ACK;
440        hdr->length = sizeof(rt_ack_t);
441
442        ack_hdr->sequence = seqno;
443       
444        to_write = hdr->length + sizeof(rt_header_t);
445        buf_ptr = ack_buffer;
446
447        while (to_write > 0) {
448                numbytes = send(RT_INFO->input_fd, buf_ptr, to_write, 0); 
449                if (numbytes == -1) {
450                        if (errno == EINTR || errno == EAGAIN) {
451                                continue;
452                        }
453                        else {
454                                printf("Error sending ack\n");
455                                perror("send");
456                                trace_set_err(libtrace, TRACE_ERR_BAD_PACKET, 
457                                                "Error sending ack");
458                                return -1;
459                        }
460                }
461                to_write = to_write - numbytes;
462                buf_ptr = buf_ptr + to_write;
463               
464        }
465
466        return 1;
467}
468
469static int rt_prepare_packet(libtrace_t *libtrace, libtrace_packet_t *packet,
470                void *buffer, libtrace_rt_types_t rt_type, uint32_t flags) {
471
472        if (packet->buffer != buffer &&
473                        packet->buf_control == TRACE_CTRL_PACKET) {
474                free(packet->buffer);
475        }
476
477        if ((flags & TRACE_PREP_OWN_BUFFER) == TRACE_PREP_OWN_BUFFER) {
478                packet->buf_control = TRACE_CTRL_PACKET;
479        } else
480                packet->buf_control = TRACE_CTRL_EXTERNAL;
481
482
483        packet->buffer = buffer;
484        packet->header = NULL;
485        packet->type = rt_type;
486        packet->payload = buffer;
487
488        if (libtrace->format_data == NULL) {
489                rt_init_format_data(libtrace);
490        }
491
492        return 0;
493}       
494
495static int rt_read_data_packet(libtrace_t *libtrace,
496                libtrace_packet_t *packet, int blocking) {
497        uint32_t prep_flags = 0;
498       
499        if (rt_read(libtrace, &packet->buffer, (size_t)RT_INFO->rt_hdr.length, 
500                                blocking) != RT_INFO->rt_hdr.length) {
501                return -1;
502        }
503
504        if (RT_INFO->reliable > 0 && packet->type >= TRACE_RT_DATA_SIMPLE) {
505                if (rt_send_ack(libtrace, RT_INFO->rt_hdr.sequence) == -1)
506                                return -1;
507        }
508       
509        if (rt_set_format(libtrace, packet) < 0) {
510                return -1;
511        }
512               
513        /* Update payload pointers and loss counters correctly */
514        if (trace_prepare_packet(packet->trace, packet, packet->buffer,
515                                packet->type, prep_flags)) {
516                return -1;
517        }
518
519        return 0;
520}
521
522static int rt_read_packet_versatile(libtrace_t *libtrace,
523                libtrace_packet_t *packet,int blocking) {
524        rt_header_t *pkt_hdr = NULL;
525        void *void_hdr;
526        libtrace_rt_types_t switch_type;
527       
528        if (packet->buf_control == TRACE_CTRL_PACKET) {
529                packet->buf_control = TRACE_CTRL_EXTERNAL;
530                free(packet->buffer);
531                packet->buffer = NULL;
532        }
533
534        /* RT_LAST means that the next bytes received should be a
535         * rt header - I know it's hax and maybe I'll fix it later on */
536        if (RT_INFO->rt_hdr.type == TRACE_RT_LAST) {
537                void_hdr = (void *)pkt_hdr;
538                /* FIXME: Better error handling required */
539                if (rt_read(libtrace, &void_hdr, 
540                                sizeof(rt_header_t),blocking) !=
541                                sizeof(rt_header_t)) {
542                        return -1;
543                }
544                pkt_hdr = (rt_header_t *)void_hdr;
545               
546                /* Need to salvage these in case the next rt_read overwrites
547                 * the buffer they came from! */
548                RT_INFO->rt_hdr.type = pkt_hdr->type;
549                RT_INFO->rt_hdr.length = pkt_hdr->length;
550                RT_INFO->rt_hdr.sequence = pkt_hdr->sequence;
551        }
552        packet->type = RT_INFO->rt_hdr.type;
553       
554        if (packet->type >= TRACE_RT_DATA_SIMPLE) {
555                switch_type = TRACE_RT_DATA_SIMPLE;
556        } else {
557                switch_type = packet->type;
558        }
559
560        switch(switch_type) {
561                case TRACE_RT_DATA_SIMPLE:
562                case TRACE_RT_DUCK_2_4:
563                case TRACE_RT_DUCK_2_5:
564                case TRACE_RT_STATUS:
565                case TRACE_RT_METADATA:
566                        if (rt_read_data_packet(libtrace, packet, blocking))
567                                return -1;
568                        break;
569                case TRACE_RT_END_DATA:
570                case TRACE_RT_KEYCHANGE:
571                case TRACE_RT_LOSTCONN:
572                case TRACE_RT_CLIENTDROP:
573                case TRACE_RT_SERVERSTART:
574                        /* All these have no payload */
575                        break;
576                case TRACE_RT_PAUSE_ACK:
577                        /* XXX: Add support for this */
578                        break;
579                case TRACE_RT_OPTION:
580                        /* XXX: Add support for this */
581                        break;
582                default:
583                        printf("Bad rt type for client receipt: %d\n",
584                                        switch_type);
585                        return -1;
586        }
587                               
588                       
589               
590        /* Return the number of bytes read from the stream */
591        RT_INFO->rt_hdr.type = TRACE_RT_LAST;
592        return RT_INFO->rt_hdr.length + sizeof(rt_header_t);
593}
594
595static int rt_read_packet(libtrace_t *libtrace,
596                libtrace_packet_t *packet) {
597        return rt_read_packet_versatile(libtrace,packet,1);
598}
599
600
601static int rt_get_capture_length(const libtrace_packet_t *packet) {
602        rt_metadata_t *rt_md_hdr;
603        switch (packet->type) {
604                case TRACE_RT_STATUS:
605                        return sizeof(rt_status_t);
606                case TRACE_RT_HELLO:
607                        return sizeof(rt_hello_t);
608                case TRACE_RT_START:
609                        return 0;
610                case TRACE_RT_ACK:
611                        return sizeof(rt_ack_t);
612                case TRACE_RT_END_DATA:
613                        return 0;
614                case TRACE_RT_CLOSE:
615                        return 0;
616                case TRACE_RT_DENY_CONN:
617                        return sizeof(rt_deny_conn_t);
618                case TRACE_RT_PAUSE:
619                        return 0; 
620                case TRACE_RT_PAUSE_ACK:
621                        return 0;
622                case TRACE_RT_OPTION:
623                        return 0; /* FIXME */
624                case TRACE_RT_KEYCHANGE:
625                        return 0;
626                case TRACE_RT_LOSTCONN:
627                        return 0;
628                case TRACE_RT_SERVERSTART:
629                        return 0;
630                case TRACE_RT_CLIENTDROP:
631                        return 0;
632                case TRACE_RT_METADATA:
633                        /* This is a little trickier to work out */
634                        rt_md_hdr = (rt_metadata_t *)packet->buffer;
635                        return rt_md_hdr->label_len + rt_md_hdr->value_len + 
636                                sizeof(rt_metadata_t);
637                default:
638                        printf("Unknown type: %d\n", packet->type);
639                       
640        }
641        return 0;
642}
643
644static int rt_get_wire_length(UNUSED const libtrace_packet_t *packet) {
645        return 0;
646}
647                       
648static int rt_get_framing_length(UNUSED const libtrace_packet_t *packet) {
649        return 0;
650}
651
652static int rt_get_fd(const libtrace_t *trace) {
653        return ((struct rt_format_data_t *)trace->format_data)->input_fd;
654}
655
656static libtrace_eventobj_t trace_event_rt(libtrace_t *trace,
657                                        libtrace_packet_t *packet) 
658{
659        libtrace_eventobj_t event = {0,0,0.0,0};
660        libtrace_err_t read_err;
661
662        assert(trace);
663        assert(packet);
664       
665        if (trace->format->get_fd) {
666                event.fd = trace->format->get_fd(trace);
667        } else {
668                event.fd = 0;
669        }
670
671        event.size = rt_read_packet_versatile(trace, packet, 0);
672        if (event.size == -1) {
673                read_err = trace_get_err(trace);
674                if (read_err.err_num == EAGAIN) {
675                        event.type = TRACE_EVENT_IOWAIT;
676                }
677                else {
678                        event.type = TRACE_EVENT_PACKET;
679                }
680        } else if (event.size == 0) {
681                if (packet->type == TRACE_RT_END_DATA)
682                        event.type = TRACE_EVENT_TERMINATE;
683                else
684                        event.type = TRACE_EVENT_PACKET;
685               
686        }       
687        else {
688                event.type = TRACE_EVENT_PACKET;
689        }
690
691       
692        return event;
693}
694
695static void rt_help(void) {
696        printf("rt format module\n");
697        printf("Supported input URIs:\n");
698        printf("\trt:hostname:port\n");
699        printf("\trt:hostname (connects on default port)\n");
700        printf("\n");
701        printf("\te.g.: rt:localhost\n");
702        printf("\te.g.: rt:localhost:32500\n");
703        printf("\n");
704
705}
706
707
708static struct libtrace_format_t rt = {
709        "rt",
710        "$Id$",
711        TRACE_FORMAT_RT,
712        rt_init_input,                  /* init_input */
713        NULL,                           /* config_input */
714        rt_start_input,                 /* start_input */
715        rt_pause_input,                 /* pause */
716        NULL,                           /* init_output */
717        NULL,                           /* config_output */
718        NULL,                           /* start_output */
719        rt_fin_input,                   /* fin_input */
720        NULL,                           /* fin_output */
721        rt_read_packet,                 /* read_packet */
722        rt_prepare_packet,              /* prepare_packet */
723        NULL,                           /* fin_packet */
724        NULL,                           /* write_packet */
725        NULL,                           /* get_link_type */
726        NULL,                           /* get_direction */
727        NULL,                           /* set_direction */
728        NULL,                           /* get_erf_timestamp */
729        NULL,                           /* get_timeval */
730        NULL,                           /* get_seconds */
731        NULL,                           /* seek_erf */
732        NULL,                           /* seek_timeval */
733        NULL,                           /* seek_seconds */
734        rt_get_capture_length,          /* get_capture_length */
735        rt_get_wire_length,                     /* get_wire_length */
736        rt_get_framing_length,          /* get_framing_length */
737        NULL,                           /* set_capture_length */
738        NULL,                           /* get_received_packets */
739        NULL,                           /* get_filtered_packets */
740        NULL,                           /* get_dropped_packets */
741        NULL,                           /* get_captured_packets */
742        rt_get_fd,                      /* get_fd */
743        trace_event_rt,             /* trace_event */
744        rt_help,                        /* help */
745        NULL                            /* next pointer */
746};
747
748void rt_constructor(void) {
749        register_format(&rt);
750}
Note: See TracBrowser for help on using the repository browser.