source: lib/format_rt.c @ db03808

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

Rearrange internal structure representations to allow for better use of padding/alignment on 64bit.

  • Property mode set to 100644
File size: 19.5 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        char *pkt_buffer;
80        char *buf_current;
81        size_t buf_filled;
82        int port;
83        int input_fd;
84        int reliable;
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        prep_flags |= TRACE_PREP_DO_NOT_OWN_BUFFER;
500
501        if (rt_read(libtrace, &packet->buffer, (size_t)RT_INFO->rt_hdr.length, 
502                                blocking) != RT_INFO->rt_hdr.length) {
503                return -1;
504        }
505
506        if (RT_INFO->reliable > 0 && packet->type >= TRACE_RT_DATA_SIMPLE) {
507                if (rt_send_ack(libtrace, RT_INFO->rt_hdr.sequence) == -1)
508                                return -1;
509        }
510       
511        if (rt_set_format(libtrace, packet) < 0) {
512                return -1;
513        }
514               
515        /* Update payload pointers and loss counters correctly */
516        if (trace_prepare_packet(packet->trace, packet, packet->buffer,
517                                packet->type, prep_flags)) {
518                return -1;
519        }
520
521        return 0;
522}
523
524static int rt_read_packet_versatile(libtrace_t *libtrace,
525                libtrace_packet_t *packet,int blocking) {
526        rt_header_t *pkt_hdr = NULL;
527        void *void_hdr;
528        libtrace_rt_types_t switch_type;
529       
530        if (packet->buf_control == TRACE_CTRL_PACKET) {
531                packet->buf_control = TRACE_CTRL_EXTERNAL;
532                free(packet->buffer);
533                packet->buffer = NULL;
534        }
535
536        /* RT_LAST means that the next bytes received should be a
537         * rt header - I know it's hax and maybe I'll fix it later on */
538        if (RT_INFO->rt_hdr.type == TRACE_RT_LAST) {
539                void_hdr = (void *)pkt_hdr;
540                /* FIXME: Better error handling required */
541                if (rt_read(libtrace, &void_hdr, 
542                                sizeof(rt_header_t),blocking) !=
543                                sizeof(rt_header_t)) {
544                        return -1;
545                }
546                pkt_hdr = (rt_header_t *)void_hdr;
547               
548                /* Need to salvage these in case the next rt_read overwrites
549                 * the buffer they came from! */
550                RT_INFO->rt_hdr.type = pkt_hdr->type;
551                RT_INFO->rt_hdr.length = pkt_hdr->length;
552                RT_INFO->rt_hdr.sequence = pkt_hdr->sequence;
553        }
554        packet->type = RT_INFO->rt_hdr.type;
555       
556        if (packet->type >= TRACE_RT_DATA_SIMPLE) {
557                switch_type = TRACE_RT_DATA_SIMPLE;
558        } else {
559                switch_type = packet->type;
560        }
561
562        switch(switch_type) {
563                case TRACE_RT_DATA_SIMPLE:
564                case TRACE_RT_DUCK_2_4:
565                case TRACE_RT_DUCK_2_5:
566                case TRACE_RT_STATUS:
567                case TRACE_RT_METADATA:
568                        if (rt_read_data_packet(libtrace, packet, blocking))
569                                return -1;
570                        break;
571                case TRACE_RT_END_DATA:
572                case TRACE_RT_KEYCHANGE:
573                case TRACE_RT_LOSTCONN:
574                case TRACE_RT_CLIENTDROP:
575                case TRACE_RT_SERVERSTART:
576                        /* All these have no payload */
577                        break;
578                case TRACE_RT_PAUSE_ACK:
579                        /* XXX: Add support for this */
580                        break;
581                case TRACE_RT_OPTION:
582                        /* XXX: Add support for this */
583                        break;
584                default:
585                        printf("Bad rt type for client receipt: %d\n",
586                                        switch_type);
587                        return -1;
588        }
589                               
590                       
591               
592        /* Return the number of bytes read from the stream */
593        RT_INFO->rt_hdr.type = TRACE_RT_LAST;
594        return RT_INFO->rt_hdr.length + sizeof(rt_header_t);
595}
596
597static int rt_read_packet(libtrace_t *libtrace,
598                libtrace_packet_t *packet) {
599        return rt_read_packet_versatile(libtrace,packet,1);
600}
601
602
603static int rt_get_capture_length(const libtrace_packet_t *packet) {
604        rt_metadata_t *rt_md_hdr;
605        switch (packet->type) {
606                case TRACE_RT_STATUS:
607                        return sizeof(rt_status_t);
608                case TRACE_RT_HELLO:
609                        return sizeof(rt_hello_t);
610                case TRACE_RT_START:
611                        return 0;
612                case TRACE_RT_ACK:
613                        return sizeof(rt_ack_t);
614                case TRACE_RT_END_DATA:
615                        return 0;
616                case TRACE_RT_CLOSE:
617                        return 0;
618                case TRACE_RT_DENY_CONN:
619                        return sizeof(rt_deny_conn_t);
620                case TRACE_RT_PAUSE:
621                        return 0; 
622                case TRACE_RT_PAUSE_ACK:
623                        return 0;
624                case TRACE_RT_OPTION:
625                        return 0; /* FIXME */
626                case TRACE_RT_KEYCHANGE:
627                        return 0;
628                case TRACE_RT_LOSTCONN:
629                        return 0;
630                case TRACE_RT_SERVERSTART:
631                        return 0;
632                case TRACE_RT_CLIENTDROP:
633                        return 0;
634                case TRACE_RT_METADATA:
635                        /* This is a little trickier to work out */
636                        rt_md_hdr = (rt_metadata_t *)packet->buffer;
637                        return rt_md_hdr->label_len + rt_md_hdr->value_len + 
638                                sizeof(rt_metadata_t);
639                default:
640                        printf("Unknown type: %d\n", packet->type);
641                       
642        }
643        return 0;
644}
645
646static int rt_get_wire_length(UNUSED const libtrace_packet_t *packet) {
647        return 0;
648}
649                       
650static int rt_get_framing_length(UNUSED const libtrace_packet_t *packet) {
651        return 0;
652}
653
654static int rt_get_fd(const libtrace_t *trace) {
655        return ((struct rt_format_data_t *)trace->format_data)->input_fd;
656}
657
658static libtrace_eventobj_t trace_event_rt(libtrace_t *trace,
659                                        libtrace_packet_t *packet) 
660{
661        libtrace_eventobj_t event = {0,0,0.0,0};
662        libtrace_err_t read_err;
663
664        assert(trace);
665        assert(packet);
666       
667        if (trace->format->get_fd) {
668                event.fd = trace->format->get_fd(trace);
669        } else {
670                event.fd = 0;
671        }
672
673        event.size = rt_read_packet_versatile(trace, packet, 0);
674        if (event.size == -1) {
675                read_err = trace_get_err(trace);
676                if (read_err.err_num == EAGAIN) {
677                        event.type = TRACE_EVENT_IOWAIT;
678                }
679                else {
680                        event.type = TRACE_EVENT_PACKET;
681                }
682        } else if (event.size == 0) {
683                if (packet->type == TRACE_RT_END_DATA)
684                        event.type = TRACE_EVENT_TERMINATE;
685                else
686                        event.type = TRACE_EVENT_PACKET;
687               
688        }       
689        else {
690                event.type = TRACE_EVENT_PACKET;
691        }
692
693       
694        return event;
695}
696
697static void rt_help(void) {
698        printf("rt format module\n");
699        printf("Supported input URIs:\n");
700        printf("\trt:hostname:port\n");
701        printf("\trt:hostname (connects on default port)\n");
702        printf("\n");
703        printf("\te.g.: rt:localhost\n");
704        printf("\te.g.: rt:localhost:32500\n");
705        printf("\n");
706
707}
708
709
710static struct libtrace_format_t rt = {
711        "rt",
712        "$Id$",
713        TRACE_FORMAT_RT,
714        NULL,                           /* probe filename */
715        NULL,                           /* probe magic */
716        rt_init_input,                  /* init_input */
717        NULL,                           /* config_input */
718        rt_start_input,                 /* start_input */
719        rt_pause_input,                 /* pause */
720        NULL,                           /* init_output */
721        NULL,                           /* config_output */
722        NULL,                           /* start_output */
723        rt_fin_input,                   /* fin_input */
724        NULL,                           /* fin_output */
725        rt_read_packet,                 /* read_packet */
726        rt_prepare_packet,              /* prepare_packet */
727        NULL,                           /* fin_packet */
728        NULL,                           /* write_packet */
729        NULL,                           /* get_link_type */
730        NULL,                           /* get_direction */
731        NULL,                           /* set_direction */
732        NULL,                           /* get_erf_timestamp */
733        NULL,                           /* get_timeval */
734        NULL,                           /* get_timespec */
735        NULL,                           /* get_seconds */
736        NULL,                           /* seek_erf */
737        NULL,                           /* seek_timeval */
738        NULL,                           /* seek_seconds */
739        rt_get_capture_length,          /* get_capture_length */
740        rt_get_wire_length,                     /* get_wire_length */
741        rt_get_framing_length,          /* get_framing_length */
742        NULL,                           /* set_capture_length */
743        NULL,                           /* get_received_packets */
744        NULL,                           /* get_filtered_packets */
745        NULL,                           /* get_dropped_packets */
746        NULL,                           /* get_captured_packets */
747        rt_get_fd,                      /* get_fd */
748        trace_event_rt,             /* trace_event */
749        rt_help,                        /* help */
750        NULL                            /* next pointer */
751};
752
753void rt_constructor(void) {
754        register_format(&rt);
755}
Note: See TracBrowser for help on using the repository browser.