Context Navigation

source: lib/format_rt.c @ 7f1b9d4

4.0.1-hotfixescachetimestampsdevelopdpdk-ndagetsilivegetfragoffhelplibtrace4ndag_formatpfringrc-4.0.1rc-4.0.2rc-4.0.3rc-4.0.4ringdecrementfixringperformanceringtimestampfixes

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats: