slirp_state.h@ 33825

Last change on this file since 33825 was 33825, checked in by vboxsync, 14 years ago
Main,NAT: Managing port-forwarding at runtime. (xTracker/#4835).
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 28.2 KB

Line
1	/** @file
2	* NAT - slirp state/configuration.
3	*/
4
5	/*
6	* Copyright (C) 2006-2010 Oracle Corporation
7	*
8	* This file is part of VirtualBox Open Source Edition (OSE), as
9	* available from http://www.virtualbox.org. This file is free software;
10	* you can redistribute it and/or modify it under the terms of the GNU
11	* General Public License (GPL) as published by the Free Software
12	* Foundation, in version 2 as it comes in the "COPYING" file of the
13	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
14	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
15	*/
16
17	#ifndef ___slirp_state_h
18	#define ___slirp_state_h
19
20	#include <iprt/req.h>
21	#include <iprt/critsect.h>
22
23	#define COUNTERS_INIT
24	#include "counters.h"
25
26	#include "ip_icmp.h"
27	#include "dnsproxy/dnsproxy.h"
28
29
30	/** Where to start DHCP IP number allocation. */
31	#define START_ADDR 15
32
33	/** DHCP Lease time. */
34	#define LEASE_TIME (24 * 3600)
35
36	/*
37	* ARP cache this is naive implementaion of ARP
38	* cache of mapping 4 byte IPv4 address to 6 byte
39	* ethernet one.
40	*/
41	struct arp_cache_entry
42	{
43	uint32_t ip;
44	uint8_t ether[6];
45	LIST_ENTRY(arp_cache_entry) list;
46	};
47	LIST_HEAD(arp_cache_head, arp_cache_entry);
48
49	/** TFTP session entry. */
50	struct tftp_session
51	{
52	int in_use;
53	unsigned char filename[TFTP_FILENAME_MAX];
54
55	struct in_addr client_ip;
56	u_int16_t client_port;
57
58	int timestamp;
59	};
60
61	struct dns_domain_entry
62	{
63	char *dd_pszDomain;
64	LIST_ENTRY(dns_domain_entry) dd_list;
65	};
66	LIST_HEAD(dns_domain_list_head, dns_domain_entry);
67
68	struct dns_entry
69	{
70	struct in_addr de_addr;
71	TAILQ_ENTRY(dns_entry) de_list;
72	};
73	TAILQ_HEAD(dns_list_head, dns_entry);
74	TAILQ_HEAD(if_queue, mbuf);
75
76	struct port_forward_rule
77	{
78	uint16_t proto;
79	uint16_t host_port;
80	uint16_t guest_port;
81	#ifndef VBOX_WITH_NAT_SERVICE
82	struct in_addr guest_addr;
83	#endif
84	struct in_addr bind_ip;
85	uint8_t mac_address[6]; /need ETH_ALEN here /
86	int activated;
87	struct socket *so;
88	LIST_ENTRY(port_forward_rule) list;
89	};
90	LIST_HEAD(port_forward_rule_list, port_forward_rule);
91
92
93
94	/* forward declaration */
95	struct proto_handler;
96
97	/** Main state/configuration structure for slirp NAT. */
98	typedef struct NATState
99	{
100	#define PROFILE_COUNTER(name, dsc) STAMPROFILE Stat ## name
101	#define COUNTING_COUNTER(name, dsc) STAMCOUNTER Stat ## name
102	#include "counters.h"
103	/* Stuff from boot.c */
104	void *pbootp_clients;
105	const char *bootp_filename;
106	/* Stuff from if.c */
107	int if_mtu, if_mru;
108	int if_comp;
109	int if_maxlinkhdr;
110	int if_queued;
111	int if_thresh;
112	/* Stuff from icmp.c */
113	struct icmpstat_t icmpstat;
114	/* Stuff from ip_input.c */
115	struct ipstat_t ipstat;
116	struct ipqhead ipq[IPREASS_NHASH];
117	int maxnipq; /* Administrative limit on # of reass queues*/
118	int maxfragsperpacket; /* Maximum number of IPv4 fragments allowed per packet */
119	int nipq; /* total number of reass queues */
120	uint16_t ip_currid;
121	/* Stuff from mbuf.c */
122	/* Stuff from slirp.c */
123	void *pvUser;
124	uint32_t curtime;
125	uint32_t time_fasttimo;
126	uint32_t last_slowtimo;
127	bool do_slowtimo;
128	bool link_up;
129	struct timeval tt;
130	struct in_addr our_addr;
131	struct in_addr alias_addr;
132	struct in_addr special_addr;
133
134	int tcp_rcvspace;
135	int tcp_sndspace;
136	int socket_rcv;
137	int socket_snd;
138	#ifdef VBOX_WITH_SLIRP_MT
139	PRTREQQUEUE pReqQueue;
140	#endif
141	#ifdef RT_OS_WINDOWS
142	ULONG (WINAPI * pfGetAdaptersAddresses)(ULONG, ULONG, PVOID, PIP_ADAPTER_ADDRESSES, PULONG);
143	#endif
144	struct dns_list_head pDnsList;
145	struct dns_domain_list_head pDomainList;
146	struct in_addr tftp_server;
147	struct in_addr loopback_addr;
148	uint32_t dnsLastUpdate;
149	uint32_t netmask;
150	#ifndef VBOX_WITH_NAT_SERVICE
151	uint8_t client_ethaddr[6];
152	#endif
153	const uint8_t *slirp_ethaddr;
154	char slirp_hostname[33];
155	bool fPassDomain;
156	struct in_addr bindIP;
157	/* Stuff from tcp_input.c */
158	struct socket tcb;
159	#ifdef VBOX_WITH_SLIRP_MT
160	RTCRITSECT tcb_mutex;
161	#endif
162	struct socket *tcp_last_so;
163	tcp_seq tcp_iss;
164	/* Stuff from tcp_timer.c */
165	struct tcpstat_t tcpstat;
166	uint32_t tcp_now;
167	int tcp_reass_qsize;
168	int tcp_reass_maxqlen;
169	int tcp_reass_maxseg;
170	int tcp_reass_overflows;
171	/* Stuff from tftp.c */
172	struct tftp_session tftp_sessions[TFTP_SESSIONS_MAX];
173	const char *tftp_prefix;
174	/* Stuff from udp.c */
175	struct udpstat_t udpstat;
176	struct socket udb;
177	#ifdef VBOX_WITH_SLIRP_MT
178	RTCRITSECT udb_mutex;
179	#endif
180	struct socket *udp_last_so;
181	struct socket icmp_socket;
182	struct icmp_storage icmp_msg_head;
183	# ifndef RT_OS_WINDOWS
184	/* counter of sockets needed for allocation enough room to
185	* process sockets with poll/epoll
186	*
187	* NSOCK_INC/DEC should be injected before every
188	* operation on socket queue (tcb, udb)
189	*/
190	int nsock;
191	# define NSOCK_INC() do {pData->nsock++;} while (0)
192	# define NSOCK_DEC() do {pData->nsock--;} while (0)
193	# define NSOCK_INC_EX(ex) do {ex->pData->nsock++;} while (0)
194	# define NSOCK_DEC_EX(ex) do {ex->pData->nsock--;} while (0)
195	# else
196	# define NSOCK_INC() do {} while (0)
197	# define NSOCK_DEC() do {} while (0)
198	# define NSOCK_INC_EX(ex) do {} while (0)
199	# define NSOCK_DEC_EX(ex) do {} while (0)
200	# endif
201	# ifdef RT_OS_WINDOWS
202	void *pvIcmpBuffer;
203	size_t szIcmpBuffer;
204	/* Accordin MSDN specification IcmpParseReplies
205	* function should be detected in runtime
206	*/
207	long (WINAPI * pfIcmpParseReplies)(void *, long);
208	BOOL (WINAPI * pfIcmpCloseHandle)(HANDLE);
209	HMODULE hmIcmpLibrary;
210	# endif
211	#if defined(RT_OS_WINDOWS)
212	# define VBOX_SOCKET_EVENT (pData->phEvents[VBOX_SOCKET_EVENT_INDEX])
213	HANDLE phEvents[VBOX_EVENT_COUNT];
214	#endif
215	#ifdef zone_mbuf
216	# undef zone_mbuf
217	#endif
218	uma_zone_t zone_mbuf;
219	#ifdef zone_clust
220	# undef zone_clust
221	#endif
222	uma_zone_t zone_clust;
223	#ifdef zone_pack
224	# undef zone_pack
225	#endif
226	uma_zone_t zone_pack;
227	#ifdef zone_jumbop
228	# undef zone_jumbop
229	#endif
230	uma_zone_t zone_jumbop;
231	#ifdef zone_jumbo9
232	# undef zone_jumbo9
233	#endif
234	uma_zone_t zone_jumbo9;
235	#ifdef zone_jumbo16
236	# undef zone_jumbo16
237	#endif
238	uma_zone_t zone_jumbo16;
239	#ifdef zone_ext_refcnt
240	# undef zone_ext_refcnt
241	int nmbclusters; /* limits number of mbuf clusters */
242	int nmbjumbop; /* limits number of page size jumbo clusters */
243	int nmbjumbo9; /* limits number of 9k jumbo clusters */
244	int nmbjumbo16; /* limits number of 16k jumbo clusters */
245	struct mbstat mbstat;
246	#endif
247	uma_zone_t zone_ext_refcnt;
248	bool fUseHostResolver;
249	/* from dnsproxy/dnsproxy.h*/
250	unsigned int authoritative_port;
251	unsigned int authoritative_timeout;
252	unsigned int recursive_port;
253	unsigned int recursive_timeout;
254	unsigned int stats_timeout;
255	unsigned int port;
256
257	unsigned long active_queries;
258	unsigned long all_queries;
259	unsigned long authoritative_queries;
260	unsigned long recursive_queries;
261	unsigned long removed_queries;
262	unsigned long dropped_queries;
263	unsigned long answered_queries;
264	unsigned long dropped_answers;
265	unsigned long late_answers;
266	unsigned long hash_collisions;
267	/dnsproxy/dnsproxy.c/
268	unsigned short queryid;
269	struct sockaddr_in authoritative_addr;
270	struct sockaddr_in recursive_addr;
271	int sock_query;
272	int sock_answer;
273	/* dnsproxy/hash.c */
274	#define HASHSIZE 10
275	#define HASH(id) (id & ((1 << HASHSIZE) - 1))
276	struct request *request_hash[1 << HASHSIZE];
277	/* this field control behaviour of DHCP server */
278	bool fUseDnsProxy;
279
280	LIST_HEAD(RT_NOTHING, libalias) instancehead;
281	int i32AliasMode;
282	struct libalias *proxy_alias;
283	struct libalias *dns_alias;
284	LIST_HEAD(handler_chain, proto_handler) handler_chain;
285	struct port_forward_rule_list port_forward_rule_head;
286	int cRedirectionsActive;
287	int cRedirectionsStored;
288	struct arp_cache_head arp_cache;
289	/libalis modules' handlers/
290	struct proto_handler *ftp_module;
291	struct proto_handler *nbt_module;
292	struct proto_handler *dns_module;
293
294	} NATState;
295
296
297	/** Default IP time to live. */
298	#define ip_defttl IPDEFTTL
299
300	/** Number of permanent buffers in mbuf. */
301	#define mbuf_thresh 30
302
303	/** Use a fixed time before sending keepalive. */
304	#define tcp_keepidle TCPTV_KEEP_IDLE
305
306	/** Use a fixed interval between keepalive. */
307	#define tcp_keepintvl TCPTV_KEEPINTVL
308
309	/** Maximum idle time before timing out a connection. */
310	#define tcp_maxidle (TCPTV_KEEPCNT * tcp_keepintvl)
311
312	/** Default TCP socket options. */
313	#define so_options DO_KEEPALIVE
314
315	/** Default TCP MSS value. */
316	#define tcp_mssdflt TCP_MSS
317
318	/** Default TCP round trip time. */
319	#define tcp_rttdflt (TCPTV_SRTTDFLT / PR_SLOWHZ)
320
321	/** Enable RFC1323 performance enhancements.
322	* @todo check if it really works, it was turned off before. */
323	#define tcp_do_rfc1323 1
324
325	/** TCP receive buffer size. */
326	#define tcp_rcvspace pData->tcp_rcvspace
327
328	/** TCP receive buffer size. */
329	#define tcp_sndspace pData->tcp_sndspace
330
331	/* TCP duplicate ACK retransmit threshold. */
332	#define tcprexmtthresh 3
333
334
335	#define bootp_filename pData->bootp_filename
336
337	#define if_mtu pData->if_mtu
338	#define if_mru pData->if_mru
339	#define if_comp pData->if_comp
340	#define if_maxlinkhdr pData->if_maxlinkhdr
341	#define if_queued pData->if_queued
342	#define if_thresh pData->if_thresh
343
344	#define icmpstat pData->icmpstat
345
346	#define ipstat pData->ipstat
347	#define ipq pData->ipq
348	#define ip_currid pData->ip_currid
349
350	#define mbuf_alloced pData->mbuf_alloced
351	#define mbuf_max pData->mbuf_max
352	#define msize pData->msize
353	#define m_freelist pData->m_freelist
354	#define m_usedlist pData->m_usedlist
355
356	#define curtime pData->curtime
357	#define time_fasttimo pData->time_fasttimo
358	#define last_slowtimo pData->last_slowtimo
359	#define do_slowtimo pData->do_slowtimo
360	#define link_up pData->link_up
361	#define cUsers pData->cUsers
362	#define tt pData->tt
363	#define our_addr pData->our_addr
364	#ifndef VBOX_SLIRP_ALIAS
365	# define alias_addr pData->alias_addr
366	#else
367	# define handler_chain pData->handler_chain
368	#endif
369	#define dns_addr pData->dns_addr
370	#define loopback_addr pData->loopback_addr
371	#define client_ethaddr pData->client_ethaddr
372	#define slirp_hostname pData->slirp_hostname
373
374	#define tcb pData->tcb
375	#define tcp_last_so pData->tcp_last_so
376	#define tcp_iss pData->tcp_iss
377
378	#define tcpstat pData->tcpstat
379	#define tcp_now pData->tcp_now
380
381	#define tftp_sessions pData->tftp_sessions
382	#define tftp_prefix pData->tftp_prefix
383
384	#define udpstat pData->udpstat
385	#define udb pData->udb
386	#define udp_last_so pData->udp_last_so
387
388	#define maxfragsperpacket pData->maxfragsperpacket
389	#define maxnipq pData->maxnipq
390	#define nipq pData->nipq
391
392	#define tcp_reass_qsize pData->tcp_reass_qsize
393	#define tcp_reass_maxqlen pData->tcp_reass_maxqlen
394	#define tcp_reass_maxseg pData->tcp_reass_maxseg
395	#define tcp_reass_overflows pData->tcp_reass_overflows
396
397	#define queue_tcp_label tcb
398	#define queue_udp_label udb
399	#define VBOX_X2(x) x
400	#define VBOX_X(x) VBOX_X2(x)
401
402	#ifdef VBOX_WITH_SLIRP_MT
403
404	# define QSOCKET_LOCK(queue) \
405	do { \
406	int rc; \
407	/* Assert(strcmp(RTThreadSelfName(), "EMT") != 0); */ \
408	rc = RTCritSectEnter(&VBOX_X(queue) ## _mutex); \
409	AssertRC(rc); \
410	} while (0)
411	# define QSOCKET_UNLOCK(queue) \
412	do { \
413	int rc; \
414	rc = RTCritSectLeave(&VBOX_X(queue) ## _mutex); \
415	AssertRC(rc); \
416	} while (0)
417	# define QSOCKET_LOCK_CREATE(queue) \
418	do { \
419	int rc; \
420	rc = RTCritSectInit(&pData->queue ## _mutex); \
421	AssertRC(rc); \
422	} while (0)
423	# define QSOCKET_LOCK_DESTROY(queue) \
424	do { \
425	int rc = RTCritSectDelete(&pData->queue ## _mutex); \
426	AssertRC(rc); \
427	} while (0)
428
429	# define QSOCKET_FOREACH(so, sonext, label) \
430	QSOCKET_LOCK(VBOX_X2(queue_## label ## _label)); \
431	(so) = (VBOX_X(queue_ ## label ## _label)).so_next; \
432	QSOCKET_UNLOCK(VBOX_X2(queue_## label ##_label)); \
433	if ((so) != &(VBOX_X(queue_## label ## _label))) SOCKET_LOCK((so));\
434	for (;;) \
435	{ \
436	if ((so) == &(VBOX_X(queue_## label ## _label))) \
437	{ \
438	break; \
439	} \
440	Log2(("%s:%d Processing so:%R[natsock]\n", __FUNCTION__, __LINE__, (so)));
441
442	# define CONTINUE_NO_UNLOCK(label) goto loop_end_ ## label ## _mt_nounlock
443	# define CONTINUE(label) goto loop_end_ ## label ## _mt
444	/* @todo replace queue parameter with macrodinition */
445	/* _mt_nounlock - user should lock so_next before calling CONTINUE_NO_UNLOCK */
446	# define LOOP_LABEL(label, so, sonext) loop_end_ ## label ## _mt: \
447	(sonext) = (so)->so_next; \
448	SOCKET_UNLOCK(so); \
449	QSOCKET_LOCK(VBOX_X(queue_ ## label ## _label)); \
450	if ((sonext) != &(VBOX_X(queue_## label ## _label))) \
451	{ \
452	SOCKET_LOCK((sonext)); \
453	QSOCKET_UNLOCK(VBOX_X(queue_ ## label ## _label)); \
454	} \
455	else \
456	{ \
457	so = &VBOX_X(queue_ ## label ## _label); \
458	QSOCKET_UNLOCK(VBOX_X(queue_ ## label ## _label)); \
459	break; \
460	} \
461	(so) = (sonext); \
462	continue; \
463	loop_end_ ## label ## _mt_nounlock: \
464	(so) = (sonext)
465
466	# define DO_TCP_OUTPUT(data, sotcb) \
467	do { \
468	PRTREQ pReq; \
469	int rc; \
470	rc = RTReqCallVoid((data)->pReqQueue, &pReq, 0 /cMillies/, \
471	(PFNRT)tcp_output 2, data, sotcb); \
472	if (RT_LIKELY(rc == VERR_TIMEOUT)) \
473	{ \
474	SOCKET_UNLOCK(so); \
475	rc = RTReqWait(pReq, RT_INDEFINITE_WAIT); \
476	AssertReleaseRC(rc); \
477	SOCKET_LOCK(so); \
478	RTReqFree(pReq); \
479	} \
480	else \
481	AssertReleaseRC(rc); \
482	} while(0)
483
484	# define DO_TCP_INPUT(data, mbuf, size, so) \
485	do { \
486	int rc; \
487	rc = RTReqCallEx((data)->pReqQueue, NULL, 0 /cMillies/, \
488	RTREQFLAGS_VOID \| RTREQFLAGS_NO_WAIT, \
489	(PFNRT)tcp_input, 4, data, mbuf, size, so); \
490	AssertReleaseRC(rc); \
491	} while(0)
492
493	# define DO_TCP_CONNECT(data, so) \
494	do { \
495	PRTREQ pReq; \
496	int rc; \
497	rc = RTReqCallVoid((data)->pReqQueue, &pReq, 0 /cMillies/, \
498	(PFNRT)tcp_connect, 2, data, so); \
499	if (RT_LIKELY(rc == VERR_TIMEOUT)) \
500	{ \
501	SOCKET_UNLOCK(so); \
502	rc = RTReqWait(pReq, RT_INDEFINITE_WAIT); \
503	AssertReleaseRC(rc); \
504	SOCKET_LOCK(so); \
505	RTReqFree(pReq); \
506	} \
507	else \
508	AssertReleaseRC(rc); \
509	} while(0)
510
511	# define DO_SOREAD(ret, data, so, ifclose) \
512	do { \
513	PRTREQ pReq; \
514	int rc; \
515	rc = RTReqCallVoid((data)->pReqQueue, &pReq, 0 /cMillies/, \
516	(PFNRT)soread_queue, 4, \
517	data, so, ifclose, &(ret)); \
518	if (RT_LIKELY(rc == VERR_TIMEOUT)) \
519	{ \
520	SOCKET_UNLOCK(so); \
521	rc = RTReqWait(pReq, RT_INDEFINITE_WAIT); \
522	AssertReleaseRC(rc); \
523	SOCKET_LOCK(so); \
524	RTReqFree(pReq); \
525	} \
526	else \
527	AssertReleaseRC(rc); \
528	} while(0)
529
530	# define DO_SOWRITE(ret, data, so) \
531	do { \
532	PRTREQ pReq; \
533	int rc; \
534	rc = RTReqCall((data)->pReqQueue, &pReq, 0 /cMillies/, \
535	(PFNRT)sowrite, 2, data, so); \
536	if (RT_LIKELY(rc == VERR_TIMEOUT)) \
537	{ \
538	SOCKET_UNLOCK(so); \
539	rc = RTReqWait(pReq, RT_INDEFINITE_WAIT); \
540	SOCKET_LOCK(so); \
541	ret = pReq->iStatus; \
542	RTReqFree(pReq); \
543	} \
544	else \
545	AssertReleaseRC(rc); \
546	} while(0)
547
548	# define DO_SORECFROM(data, so) \
549	do { \
550	PRTREQ pReq; \
551	int rc; \
552	rc = RTReqCallVoid((data)->pReqQueue, &pReq, 0 /cMillies /, \
553	(PFNRT)sorecvfrom, 2, data, so); \
554	if (RT_LIKELY(rc == VERR_TIMEOUT)) \
555	{ \
556	SOCKET_UNLOCK(so); \
557	rc = RTReqWait(pReq, RT_INDEFINITE_WAIT); \
558	AssertReleaseRC(rc); \
559	SOCKET_LOCK(so); \
560	RTReqFree(pReq); \
561	} \
562	else \
563	AssertReleaseRC(rc); \
564	} while(0)
565
566	# define DO_UDP_DETACH(data, so, so_next) \
567	do { \
568	PRTREQ pReq; \
569	int rc; \
570	rc = RTReqCallVoid((data)->pReqQueue, &pReq, 0 /* cMillies*/, \
571	(PFNRT)udp_detach, 2, data, so); \
572	if (RT_LIKELY(rc == VERR_TIMEOUT)) \
573	{ \
574	SOCKET_UNLOCK(so); \
575	rc = RTReqWait(pReq, RT_INDEFINITE_WAIT); \
576	AssertReleaseRC(rc); \
577	if ((so_next) != &udb) SOCKET_LOCK((so_next)); \
578	RTReqFree(pReq); \
579	} \
580	else \
581	AssertReleaseRC(rc); \
582	} while(0)
583
584	# define SOLOOKUP(so, label, src, sport, dst, dport) \
585	do { \
586	struct socket *sonxt; \
587	(so) = NULL; \
588	QSOCKET_FOREACH(so, sonxt, label) \
589	/* { */ \
590	if ( so->so_lport == (sport) \
591	&& so->so_laddr.s_addr == (src).s_addr \
592	&& so->so_faddr.s_addr == (dst).s_addr \
593	&& so->so_fport == (dport)) \
594	{ \
595	if (sonxt != &VBOX_X2(queue_ ## label ## _label)) \
596	SOCKET_UNLOCK(sonxt); \
597	break; /so is locked/ \
598	} \
599	LOOP_LABEL(so, sonxt, label); \
600	} \
601	} \
602	} while (0)
603
604	#else /* !VBOX_WITH_SLIRP_MT */
605
606	# define QSOCKET_LOCK(queue) do {} while (0)
607	# define QSOCKET_UNLOCK(queue) do {} while (0)
608	# define QSOCKET_LOCK_CREATE(queue) do {} while (0)
609	# define QSOCKET_LOCK_DESTROY(queue) do {} while (0)
610	# define QSOCKET_FOREACH(so, sonext, label) \
611	for ((so) = VBOX_X2(queue_ ## label ## _label).so_next; \
612	(so) != &(VBOX_X2(queue_ ## label ## _label)); \
613	(so) = (sonext)) \
614	{ \
615	(sonext) = (so)->so_next; \
616	Log2(("%s:%d Processing so:%R[natsock]\n", __FUNCTION__, __LINE__, (so)));
617	# define CONTINUE(label) continue
618	# define CONTINUE_NO_UNLOCK(label) continue
619	# define LOOP_LABEL(label, so, sonext) /* empty*/
620	# define DO_TCP_OUTPUT(data, sotcb) tcp_output((data), (sotcb))
621	# define DO_TCP_INPUT(data, mbuf, size, so) tcp_input((data), (mbuf), (size), (so))
622	# define DO_TCP_CONNECT(data, so) tcp_connect((data), (so))
623	# define DO_SOREAD(ret, data, so, ifclose) \
624	do { \
625	(ret) = soread((data), (so), (ifclose)); \
626	} while(0)
627	# define DO_SOWRITE(ret, data, so) \
628	do { \
629	(ret) = sowrite((data), (so)); \
630	} while(0)
631	# define DO_SORECFROM(data, so) sorecvfrom((data), (so))
632	# define SOLOOKUP(so, label, src, sport, dst, dport) \
633	do { \
634	(so) = solookup(&VBOX_X2(queue_ ## label ## _label), (src), (sport), (dst), (dport)); \
635	} while (0)
636	# define DO_UDP_DETACH(data, so, ignored) udp_detach((data), (so))
637
638	#endif /* !VBOX_WITH_SLIRP_MT */
639
640	#define TCP_OUTPUT(data, sotcb) DO_TCP_OUTPUT((data), (sotcb))
641	#define TCP_INPUT(data, mbuf, size, so) DO_TCP_INPUT((data), (mbuf), (size), (so))
642	#define TCP_CONNECT(data, so) DO_TCP_CONNECT((data), (so))
643	#define SOREAD(ret, data, so, ifclose) DO_SOREAD((ret), (data), (so), (ifclose))
644	#define SOWRITE(ret, data, so) DO_SOWRITE((ret), (data), (so))
645	#define SORECVFROM(data, so) DO_SORECFROM((data), (so))
646	#define UDP_DETACH(data, so, so_next) DO_UDP_DETACH((data), (so), (so_next))
647
648	/* dnsproxy/dnsproxy.c */
649	#define authoritative_port pData->authoritative_port
650	#define authoritative_timeout pData->authoritative_timeout
651	#define recursive_port pData->recursive_port
652	#define recursive_timeout pData->recursive_timeout
653	#define stats_timeout pData->stats_timeout
654	/* dnsproxy/hash.c */
655	#define dns_port pData->port
656	#define request_hash pData->request_hash
657	#define hash_collisions pData->hash_collisions
658	#define active_queries pData->active_queries
659	#define all_queries pData->all_queries
660	#define authoritative_queries pData->authoritative_queries
661	#define recursive_queries pData->recursive_queries
662	#define removed_queries pData->removed_queries
663	#define dropped_queries pData->dropped_queries
664	#define answered_queries pData->answered_queries
665	#define dropped_answers pData->dropped_answers
666	#define late_answers pData->late_answers
667
668	/* dnsproxy/dnsproxy.c */
669	#define queryid pData->queryid
670	#define authoritative_addr pData->authoritative_addr
671	#define recursive_addr pData->recursive_addr
672	#define sock_query pData->sock_query
673	#define sock_answer pData->sock_answer
674
675	#define instancehead pData->instancehead
676
677	#define nmbclusters pData->nmbclusters
678	#define nmbjumbop pData->nmbjumbop
679	#define nmbjumbo9 pData->nmbjumbo9
680	#define nmbjumbo16 pData->nmbjumbo16
681	#define mbstat pData->mbstat
682	#include "ext.h"
683	#undef zone_mbuf
684	#undef zone_clust
685	#undef zone_pack
686	#undef zone_jumbop
687	#undef zone_jumbo9
688	#undef zone_jumbo16
689	#undef zone_ext_refcnt
690	static inline uma_zone_t slirp_zone_pack(PNATState pData)
691	{
692	return pData->zone_pack;
693	}
694	static inline uma_zone_t slirp_zone_jumbop(PNATState pData)
695	{
696	return pData->zone_jumbop;
697	}
698	static inline uma_zone_t slirp_zone_jumbo9(PNATState pData)
699	{
700	return pData->zone_jumbo9;
701	}
702	static inline uma_zone_t slirp_zone_jumbo16(PNATState pData)
703	{
704	return pData->zone_jumbo16;
705	}
706	static inline uma_zone_t slirp_zone_ext_refcnt(PNATState pData)
707	{
708	return pData->zone_ext_refcnt;
709	}
710	static inline uma_zone_t slirp_zone_mbuf(PNATState pData)
711	{
712	return pData->zone_mbuf;
713	}
714	static inline uma_zone_t slirp_zone_clust(PNATState pData)
715	{
716	return pData->zone_clust;
717	}
718	#ifndef VBOX_SLIRP_BSD
719	# define m_adj(m, len) m_adj(pData, (m), (len))
720	#endif
721
722	#endif /* !___slirp_state_h */

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

source: vbox/trunk/src/VBox/Devices/Network/slirp/slirp_state.h@ 33825

Download in other formats: