Context Navigation

source: lib/format_rt.c @ 15e9390

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

Last change on this file since 15e9390 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
55	static 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
77	struct 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
93	static 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
190	static 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
204	static 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
233	static 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
253	static 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
271	static 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
289	static 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
368	static 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
421	static 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
469	static 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
495	static 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
524	static 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
597	static int rt_read_packet(libtrace_t *libtrace,
598	libtrace_packet_t *packet) {
599	return rt_read_packet_versatile(libtrace,packet,1);
600	}
601
602
603	static 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
646	static int rt_get_wire_length(UNUSED const libtrace_packet_t *packet) {
647	return 0;
648	}
649
650	static int rt_get_framing_length(UNUSED const libtrace_packet_t *packet) {
651	return 0;
652	}
653
654	static int rt_get_fd(const libtrace_t *trace) {
655	return ((struct rt_format_data_t *)trace->format_data)->input_fd;
656	}
657
658	static 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
697	static 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
710	static 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
753	void rt_constructor(void) {
754	register_format(&rt);
755	}

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

Download in other formats: