slirp.c@ 23497

最後變更在這個檔案從23497是 23462,由 vboxsync 提交於 15 年前

NAT: Big changeset:

mbuf_zone has been inroduced.
IPRT timers replaces Slirp's one making poll/WSAWaitForMultipleEvents blocking.
UrgRecv(Thread,Req) introduced for transfering ICMP errors/ARP with highter priority.

屬性 svn:eol-style 設為 native

檔案大小: 66.0 KB

行
1	#include "slirp.h"
2	#ifdef RT_OS_OS2
3	# include <paths.h>
4	#endif
5
6	#include <VBox/err.h>
7	#include <VBox/pdmdrv.h>
8	#include <iprt/assert.h>
9	#include <iprt/file.h>
10	#ifndef RT_OS_WINDOWS
11	# include <sys/ioctl.h>
12	# include <poll.h>
13	#else
14	# include <Winnls.h>
15	# define _WINSOCK2API_
16	# include <IPHlpApi.h>
17	#endif
18	#include <alias.h>
19
20	#if !defined(RT_OS_WINDOWS)
21
22	# define DO_ENGAGE_EVENT1(so, fdset, label) \
23	do { \
24	if( so->so_poll_index != -1 \
25	&& so->s == polls[so->so_poll_index].fd) { \
26	polls[so->so_poll_index].events \|= N_(fdset ## _poll); \
27	break; /* out of this loop */ \
28	} \
29	AssertRelease(poll_index < (nfds)); \
30	AssertRelease(poll_index >= 0 && poll_index < (nfds)); \
31	polls[poll_index].fd = (so)->s; \
32	(so)->so_poll_index = poll_index; \
33	polls[poll_index].events = N_(fdset ## _poll); \
34	polls[poll_index].revents = 0; \
35	poll_index++; \
36	} while(0)
37
38
39	# define DO_ENGAGE_EVENT2(so, fdset1, fdset2, label) \
40	do { \
41	if( so->so_poll_index != -1 \
42	&& so->s == polls[so->so_poll_index].fd) { \
43	polls[so->so_poll_index].events \|= \
44	N_(fdset1 ## _poll) \| N_(fdset1 ## _poll); \
45	break; /* out of this loop */ \
46	} \
47	AssertRelease(poll_index < (nfds)); \
48	polls[poll_index].fd = (so)->s; \
49	(so)->so_poll_index = poll_index; \
50	polls[poll_index].events = \
51	N_(fdset1 ## _poll) \| N_(fdset1 ## _poll); \
52	poll_index++; \
53	} while(0)
54
55	# define DO_POLL_EVENTS(rc, error, so, events, label) do {} while (0)
56
57	# define DO_CHECK_FD_SET(so, events, fdset) ( ((so)->so_poll_index != -1) \
58	&& ((so)->so_poll_index <= ndfs) \
59	&& ((so)->s == polls[so->so_poll_index].fd) \
60	&& (polls[(so)->so_poll_index].revents & N_(fdset ## _poll)))
61	# define DO_UNIX_CHECK_FD_SET(so, events, fdset ) DO_CHECK_FD_SET((so), (events), fdset) /specific for Unix API /
62	# define DO_WIN_CHECK_FD_SET(so, events, fdset ) 0 /* specific for Windows Winsock API */
63
64	# ifndef RT_OS_WINDOWS
65
66	# ifndef RT_OS_LINUX
67	# define readfds_poll (POLLRDNORM)
68	# define writefds_poll (POLLWRNORM)
69	# define xfds_poll (POLLRDBAND\|POLLWRBAND\|POLLPRI)
70	# else
71	# define readfds_poll (POLLIN)
72	# define writefds_poll (POLLOUT)
73	# define xfds_poll (POLLPRI)
74	# endif
75	# define rderr_poll (POLLERR)
76	# define rdhup_poll (POLLHUP)
77	# define nval_poll (POLLNVAL)
78
79	# define ICMP_ENGAGE_EVENT(so, fdset) \
80	do { \
81	if (pData->icmp_socket.s != -1) \
82	DO_ENGAGE_EVENT1((so), fdset, ICMP); \
83	} while (0)
84	# else /* !RT_OS_WINDOWS */
85	# define DO_WIN_CHECK_FD_SET(so, events, fdset ) DO_CHECK_FD_SET((so), (events), fdset)
86	# define ICMP_ENGAGE_EVENT(so, fdset) do {} while(0)
87	#endif /* RT_OS_WINDOWS */
88
89	#else /* defined(RT_OS_WINDOWS) */
90
91	/*
92	* On Windows, we will be notified by IcmpSendEcho2() when the response arrives.
93	* So no call to WSAEventSelect necessary.
94	*/
95	# define ICMP_ENGAGE_EVENT(so, fdset) do {} while(0)
96
97	# define DO_ENGAGE_EVENT1(so, fdset1, label) \
98	do { \
99	rc = WSAEventSelect((so)->s, VBOX_SOCKET_EVENT, FD_ALL_EVENTS); \
100	if (rc == SOCKET_ERROR) \
101	{ \
102	/* This should not happen */ \
103	error = WSAGetLastError(); \
104	LogRel(("WSAEventSelect (" #label ") error %d (so=%x, socket=%s, event=%x)\n", \
105	error, (so), (so)->s, VBOX_SOCKET_EVENT)); \
106	} \
107	} while(0); \
108	CONTINUE(label)
109
110	# define DO_ENGAGE_EVENT2(so, fdset1, fdset2, label) \
111	DO_ENGAGE_EVENT1((so), (fdset1), label)
112
113	# define DO_POLL_EVENTS(rc, error, so, events, label) \
114	(rc) = WSAEnumNetworkEvents((so)->s, VBOX_SOCKET_EVENT, (events)); \
115	if ((rc) == SOCKET_ERROR) \
116	{ \
117	(error) = WSAGetLastError(); \
118	LogRel(("WSAEnumNetworkEvents " #label " error %d\n", (error))); \
119	CONTINUE(label); \
120	}
121
122	# define acceptds_win FD_ACCEPT
123	# define acceptds_win_bit FD_ACCEPT_BIT
124
125	# define readfds_win FD_READ
126	# define readfds_win_bit FD_READ_BIT
127
128	# define writefds_win FD_WRITE
129	# define writefds_win_bit FD_WRITE_BIT
130
131	# define xfds_win FD_OOB
132	# define xfds_win_bit FD_OOB_BIT
133
134	# define DO_CHECK_FD_SET(so, events, fdset) \
135	(((events).lNetworkEvents & fdset ## _win) && ((events).iErrorCode[fdset ## _win_bit] == 0))
136
137	# define DO_WIN_CHECK_FD_SET(so, events, fdset ) DO_CHECK_FD_SET((so), (events), fdset)
138	# define DO_UNIX_CHECK_FD_SET(so, events, fdset ) 1 /specific for Unix API /
139
140	#endif /* defined(RT_OS_WINDOWS) */
141
142	#define TCP_ENGAGE_EVENT1(so, fdset) \
143	DO_ENGAGE_EVENT1((so), fdset, tcp)
144
145	#define TCP_ENGAGE_EVENT2(so, fdset1, fdset2) \
146	DO_ENGAGE_EVENT2((so), fdset1, fdset2, tcp)
147
148	#define UDP_ENGAGE_EVENT(so, fdset) \
149	DO_ENGAGE_EVENT1((so), fdset, udp)
150
151	#define POLL_TCP_EVENTS(rc, error, so, events) \
152	DO_POLL_EVENTS((rc), (error), (so), (events), tcp)
153
154	#define POLL_UDP_EVENTS(rc, error, so, events) \
155	DO_POLL_EVENTS((rc), (error), (so), (events), udp)
156
157	#define CHECK_FD_SET(so, events, set) \
158	(DO_CHECK_FD_SET((so), (events), set))
159
160	#define WIN_CHECK_FD_SET(so, events, set) \
161	(DO_WIN_CHECK_FD_SET((so), (events), set))
162	#define UNIX_CHECK_FD_SET(so, events, set) \
163	(DO_UNIX_CHECK_FD_SET(so, events, set))
164
165	/*
166	* Loging macros
167	*/
168	#if VBOX_WITH_DEBUG_NAT_SOCKETS
169	# if defined(RT_OS_WINDOWS)
170	# define DO_LOG_NAT_SOCK(so, proto, winevent, r_fdset, w_fdset, x_fdset) \
171	do { \
172	LogRel((" " #proto " %R[natsock] %R[natwinnetevents]\n", (so), (winevent))); \
173	} while (0)
174	# else /* RT_OS_WINDOWS */
175	# define DO_LOG_NAT_SOCK(so, proto, winevent, r_fdset, w_fdset, x_fdset) \
176	do { \
177	LogRel((" " #proto " %R[natsock] %s %s %s er: %s, %s, %s\n", (so), \
178	CHECK_FD_SET(so, ign ,r_fdset) ? "READ":"", \
179	CHECK_FD_SET(so, ign, w_fdset) ? "WRITE":"", \
180	CHECK_FD_SET(so, ign, x_fdset) ? "OOB":"", \
181	CHECK_FD_SET(so, ign, rderr) ? "RDERR":"", \
182	CHECK_FD_SET(so, ign, rdhup) ? "RDHUP":"", \
183	CHECK_FD_SET(so, ign, nval) ? "RDNVAL":"")); \
184	} while (0)
185	# endif /* !RT_OS_WINDOWS */
186	#else /* VBOX_WITH_DEBUG_NAT_SOCKETS */
187	# define DO_LOG_NAT_SOCK(so, proto, winevent, r_fdset, w_fdset, x_fdset) do {} while (0)
188	#endif /* !VBOX_WITH_DEBUG_NAT_SOCKETS */
189
190	#define LOG_NAT_SOCK(so, proto, winevent, r_fdset, w_fdset, x_fdset) DO_LOG_NAT_SOCK((so), proto, (winevent), r_fdset, w_fdset, x_fdset)
191
192	static void activate_port_forwarding(PNATState, struct ethhdr *);
193	static uint32_t find_guest_ip(PNATState, const uint8_t *);
194
195	static const uint8_t special_ethaddr[6] =
196	{
197	0x52, 0x54, 0x00, 0x12, 0x35, 0x00
198	};
199
200	static const uint8_t broadcast_ethaddr[6] =
201	{
202	0xff, 0xff, 0xff, 0xff, 0xff, 0xff
203	};
204
205	const uint8_t zerro_ethaddr[6] =
206	{
207	0x0, 0x0, 0x0, 0x0, 0x0, 0x0
208	};
209
210	#ifdef RT_OS_WINDOWS
211	static int get_dns_addr_domain(PNATState pData, bool fVerbose,
212	struct in_addr *pdns_addr,
213	const char **ppszDomain)
214	{
215	/* Get amount of memory required for operation */
216	ULONG flags = GAA_FLAG_INCLUDE_PREFIX; /GAA_FLAG_INCLUDE_ALL_INTERFACES;/ /* all interfaces registered in NDIS */
217	PIP_ADAPTER_ADDRESSES addresses = NULL;
218	PIP_ADAPTER_ADDRESSES addr = NULL;
219	PIP_ADAPTER_DNS_SERVER_ADDRESS dns = NULL;
220	ULONG size = 0;
221	int wlen = 0;
222	char *suffix;
223	struct dns_entry *da = NULL;
224	struct dns_domain_entry *dd = NULL;
225	ULONG ret = ERROR_SUCCESS;
226
227	/* @todo add SKIPing flags to get only required information */
228
229	ret = pData->pfGetAdaptersAddresses(AF_INET, 0, NULL /* reserved */, addresses, &size);
230	if (ret != ERROR_BUFFER_OVERFLOW)
231	{
232	LogRel(("NAT: error %lu occurred on capacity detection operation\n", ret));
233	return -1;
234	}
235
236	if (size == 0)
237	{
238	LogRel(("NAT: Win socket API returns non capacity\n"));
239	return -1;
240	}
241
242	addresses = RTMemAllocZ(size);
243	if (addresses == NULL)
244	{
245	LogRel(("NAT: No memory available \n"));
246	return -1;
247	}
248
249	ret = pData->pfGetAdaptersAddresses(AF_INET, 0, NULL /* reserved */, addresses, &size);
250	if (ret != ERROR_SUCCESS)
251	{
252	LogRel(("NAT: error %lu occurred on fetching adapters info\n", ret));
253	RTMemFree(addresses);
254	return -1;
255	}
256	addr = addresses;
257	while(addr != NULL)
258	{
259	int found;
260	if (addr->OperStatus != IfOperStatusUp)
261	goto next;
262	dns = addr->FirstDnsServerAddress;
263	while (dns != NULL)
264	{
265	struct sockaddr *saddr = dns->Address.lpSockaddr;
266	if (saddr->sa_family != AF_INET)
267	goto next_dns;
268	/* add dns server to list */
269	da = RTMemAllocZ(sizeof(struct dns_entry));
270	if (da == NULL)
271	{
272	LogRel(("NAT: Can't allocate buffer for DNS entry\n"));
273	RTMemFree(addresses);
274	return VERR_NO_MEMORY;
275	}
276	LogRel(("NAT: adding %R[IP4] to DNS server list\n",
277	&((struct sockaddr_in *)saddr)->sin_addr));
278	if (((( struct sockaddr_in *)saddr)->sin_addr.s_addr & htonl(IN_CLASSA_NET)) ==
279	ntohl(INADDR_LOOPBACK & IN_CLASSA_NET)) {
280	da->de_addr.s_addr = htonl(ntohl(special_addr.s_addr) \| CTL_ALIAS);
281	}
282	else
283	{
284	da->de_addr.s_addr = ((struct sockaddr_in *)saddr)->sin_addr.s_addr;
285	}
286	TAILQ_INSERT_HEAD(&pData->dns_list_head, da, de_list);
287
288	if (addr->DnsSuffix == NULL)
289	goto next_dns;
290
291	/uniq/
292	RTUtf16ToUtf8(addr->DnsSuffix, &suffix);
293
294	if (!suffix \|\| strlen(suffix) == 0) {
295	RTStrFree(suffix);
296	goto next_dns;
297	}
298
299	found = 0;
300	LIST_FOREACH(dd, &pData->dns_domain_list_head, dd_list)
301	{
302	if ( dd->dd_pszDomain != NULL
303	&& strcmp(dd->dd_pszDomain, suffix) == 0)
304	{
305	found = 1;
306	RTStrFree(suffix);
307	break;
308	}
309	}
310	if (found == 0)
311	{
312	dd = RTMemAllocZ(sizeof(struct dns_domain_entry));
313	if (dd == NULL)
314	{
315	LogRel(("NAT: not enough memory\n"));
316	RTStrFree(suffix);
317	RTMemFree(addresses);
318	return VERR_NO_MEMORY;
319	}
320	dd->dd_pszDomain = suffix;
321	LogRel(("NAT: adding domain name %s to search list\n", dd->dd_pszDomain));
322	LIST_INSERT_HEAD(&pData->dns_domain_list_head, dd, dd_list);
323	}
324	next_dns:
325	dns = dns->Next;
326	}
327	next:
328	addr = addr->Next;
329	}
330	RTMemFree(addresses);
331	return 0;
332	}
333
334	#else /* !RT_OS_WINDOWS */
335
336	static int RTFileGets(RTFILE File, void pvBuf, size_t cbBufSize, size_t pcbRead)
337	{
338	size_t cbRead;
339	char bTest;
340	int rc = VERR_NO_MEMORY;
341	char pu8Buf = (char )pvBuf;
342	*pcbRead = 0;
343	while( RT_SUCCESS(rc = RTFileRead(File, &bTest, 1, &cbRead))
344	&& (pu8Buf - (char *)pvBuf) < cbBufSize)
345	{
346	if (cbRead == 0)
347	return VERR_EOF;
348	if (bTest == '\r' \|\| bTest == '\n')
349	{
350	*pu8Buf = 0;
351	return VINF_SUCCESS;
352	}
353	*pu8Buf = bTest;
354	pu8Buf++;
355	(*pcbRead)++;
356	}
357	return rc;
358	}
359	static int get_dns_addr_domain(PNATState pData, bool fVerbose,
360	struct in_addr *pdns_addr,
361	const char **ppszDomain)
362	{
363	char buff[512];
364	char buff2[256];
365	RTFILE f;
366	int found = 0;
367	struct in_addr tmp_addr;
368	int rc;
369	size_t bytes;
370
371	#ifdef RT_OS_OS2
372	/* Try various locations. */
373	char *etc = getenv("ETC");
374	if (etc)
375	{
376	RTStrmPrintf(buff, sizeof(buff), "%s/RESOLV2", etc);
377	rc = RTFileOpen(&f, buff, RTFILE_O_READ);
378	}
379	if (RT_FAILURE(rc))
380	{
381	RTStrmPrintf(buff, sizeof(buff), "%s/RESOLV2", _PATH_ETC);
382	rc = RTFileOpen(&f, buff, RTFILE_O_READ);
383	}
384	if (RT_FAILURE(rc))
385	{
386	RTStrmPrintf(buff, sizeof(buff), "%s/resolv.conf", _PATH_ETC);
387	rc = RTFileOpen(&f, buff, RTFILE_O_READ);
388	}
389	#else
390	# ifndef DEBUG_vvl
391	rc = RTFileOpen(&f, "/etc/resolv.conf", RTFILE_O_READ);
392	# else
393	char *home = getenv("HOME");
394	RTStrPrintf(buff, sizeof(buff), "%s/resolv.conf", home);
395	rc = RTFileOpen(&f, buff, RTFILE_O_READ);
396	if (RT_SUCCESS(rc))
397	{
398	Log(("NAT: DNS we're using %s\n", buff));
399	}
400	else
401	{
402	rc = RTFileOpen(&f, "/etc/resolv.conf", RTFILE_O_READ);
403	Log(("NAT: DNS we're using %s\n", buff));
404	}
405	# endif
406	#endif
407	if (RT_FAILURE(rc))
408	return -1;
409
410	if (ppszDomain)
411	*ppszDomain = NULL;
412	Log(("nat: DNS Servers:\n"));
413	while ( RT_SUCCESS(rc = RTFileGets(f, buff, 512, &bytes))
414	&& rc != VERR_EOF)
415	{
416	struct dns_entry *da = NULL;
417	if (sscanf(buff, "nameserver%*[ \t]%256s", buff2) == 1)
418	{
419	if (!inet_aton(buff2, &tmp_addr))
420	continue;
421	/localhost mask /
422	da = RTMemAllocZ(sizeof (struct dns_entry));
423	if (da == NULL)
424	{
425	LogRel(("can't alloc memory for DNS entry\n"));
426	return -1;
427	}
428	/check /
429	da->de_addr.s_addr = tmp_addr.s_addr;
430	if ((da->de_addr.s_addr & htonl(IN_CLASSA_NET)) == ntohl(INADDR_LOOPBACK & IN_CLASSA_NET)) {
431	da->de_addr.s_addr = htonl(ntohl(special_addr.s_addr) \| CTL_ALIAS);
432	}
433	TAILQ_INSERT_HEAD(&pData->dns_list_head, da, de_list);
434	found++;
435	}
436	if ((!strncmp(buff, "domain", 6) \|\| !strncmp(buff, "search", 6)))
437	{
438	char *tok;
439	char *saveptr;
440	struct dns_domain_entry *dd = NULL;
441	int found = 0;
442	tok = strtok_r(&buff[6], " \t\n", &saveptr);
443	LIST_FOREACH(dd, &pData->dns_domain_list_head, dd_list)
444	{
445	if( tok != NULL
446	&& strcmp(tok, dd->dd_pszDomain) == 0)
447	{
448	found = 1;
449	break;
450	}
451	}
452	if (tok != NULL && found == 0) {
453	dd = RTMemAllocZ(sizeof(struct dns_domain_entry));
454	if (dd == NULL)
455	{
456	LogRel(("NAT: not enought memory to add domain list\n"));
457	return VERR_NO_MEMORY;
458	}
459	dd->dd_pszDomain = RTStrDup(tok);
460	LogRel(("NAT: adding domain name %s to search list\n", dd->dd_pszDomain));
461	LIST_INSERT_HEAD(&pData->dns_domain_list_head, dd, dd_list);
462	}
463	}
464	}
465	RTFileClose(f);
466	if (!found)
467	return -1;
468	return 0;
469	}
470
471	#endif
472
473	static int slirp_init_dns_list(PNATState pData)
474	{
475	TAILQ_INIT(&pData->dns_list_head);
476	LIST_INIT(&pData->dns_domain_list_head);
477	return get_dns_addr_domain(pData, true, NULL, NULL);
478	}
479
480	static void slirp_release_dns_list(PNATState pData)
481	{
482	struct dns_entry *de = NULL;
483	struct dns_domain_entry *dd = NULL;
484	while(!TAILQ_EMPTY(&pData->dns_list_head)) {
485	de = TAILQ_FIRST(&pData->dns_list_head);
486	TAILQ_REMOVE(&pData->dns_list_head, de, de_list);
487	RTMemFree(de);
488	}
489	while(!LIST_EMPTY(&pData->dns_domain_list_head)) {
490	dd = LIST_FIRST(&pData->dns_domain_list_head);
491	LIST_REMOVE(dd, dd_list);
492	if (dd->dd_pszDomain != NULL)
493	RTStrFree(dd->dd_pszDomain);
494	RTMemFree(dd);
495	}
496	}
497
498	int get_dns_addr(PNATState pData, struct in_addr *pdns_addr)
499	{
500	return get_dns_addr_domain(pData, false, pdns_addr, NULL);
501	}
502
503	#ifndef VBOX_WITH_NAT_SERVICE
504	int slirp_init(PNATState ppData, const char pszNetAddr, uint32_t u32Netmask,
505	bool fPassDomain, bool fUseHostResolver, void *pvUser)
506	#else
507	int slirp_init(PNATState *ppData, uint32_t u32NetAddr, uint32_t u32Netmask,
508	bool fPassDomain, void *pvUser)
509	#endif
510	{
511	int fNATfailed = 0;
512	int rc;
513	PNATState pData = RTMemAllocZ(sizeof(NATState));
514	*ppData = pData;
515	if (!pData)
516	return VERR_NO_MEMORY;
517	if (u32Netmask & 0x1f)
518	/* CTL is x.x.x.15, bootp passes up to 16 IPs (15..31) */
519	return VERR_INVALID_PARAMETER;
520	pData->fPassDomain = !fUseHostResolver ? fPassDomain : false;
521	pData->use_host_resolver = fUseHostResolver;
522	pData->pvUser = pvUser;
523	pData->netmask = u32Netmask;
524
525	/* sockets & TCP defaults */
526	pData->socket_rcv = 64 * _1K;
527	pData->socket_snd = 64 * _1K;
528	tcp_sndspace = 64 * _1K;
529	tcp_rcvspace = 64 * _1K;
530
531	#ifdef RT_OS_WINDOWS
532	{
533	WSADATA Data;
534	WSAStartup(MAKEWORD(2, 0), &Data);
535	}
536	pData->phEvents[VBOX_SOCKET_EVENT_INDEX] = CreateEvent(NULL, FALSE, FALSE, NULL);
537	#endif
538	#ifdef VBOX_WITH_SLIRP_MT
539	QSOCKET_LOCK_CREATE(tcb);
540	QSOCKET_LOCK_CREATE(udb);
541	rc = RTReqCreateQueue(&pData->pReqQueue);
542	AssertReleaseRC(rc);
543	#endif
544
545	link_up = 1;
546
547	rc = bootp_dhcp_init(pData);
548	if (rc != 0)
549	{
550	LogRel(("NAT: DHCP server initialization was failed\n"));
551	return VINF_NAT_DNS;
552	}
553	debug_init();
554	if_init(pData);
555	ip_init(pData);
556	icmp_init(pData);
557
558	/* Initialise mbufs after setting the MTU */
559	#ifndef VBOX_WITH_SLIRP_BSD_MBUF
560	m_init(pData);
561	#else
562	mbuf_init(pData);
563	#endif
564
565	#ifndef VBOX_WITH_NAT_SERVICE
566	inet_aton(pszNetAddr, &special_addr);
567	#else
568	special_addr.s_addr = u32NetAddr;
569	#endif
570	pData->slirp_ethaddr = &special_ethaddr[0];
571	alias_addr.s_addr = special_addr.s_addr \| htonl(CTL_ALIAS);
572	/* @todo: add ability to configure this staff */
573
574	/* set default addresses */
575	inet_aton("127.0.0.1", &loopback_addr);
576	if (!pData->use_host_resolver)
577	{
578	if (slirp_init_dns_list(pData) < 0)
579	fNATfailed = 1;
580
581	dnsproxy_init(pData);
582	}
583
584	getouraddr(pData);
585	{
586	int flags = 0;
587	struct in_addr proxy_addr;
588	pData->proxy_alias = LibAliasInit(pData, NULL);
589	if (pData->proxy_alias == NULL)
590	{
591	LogRel(("NAT: LibAlias default rule wasn't initialized\n"));
592	AssertMsgFailed(("NAT: LibAlias default rule wasn't initialized\n"));
593	}
594	flags = LibAliasSetMode(pData->proxy_alias, 0, 0);
595	#ifndef NO_FW_PUNCH
596	flags \|= PKT_ALIAS_PUNCH_FW;
597	#endif
598	flags \|= PKT_ALIAS_LOG; /* set logging */
599	flags = LibAliasSetMode(pData->proxy_alias, flags, ~0);
600	proxy_addr.s_addr = htonl(ntohl(special_addr.s_addr) \| CTL_ALIAS);
601	LibAliasSetAddress(pData->proxy_alias, proxy_addr);
602	ftp_alias_load(pData);
603	nbt_alias_load(pData);
604	if (pData->use_host_resolver)
605	dns_alias_load(pData);
606	}
607	return fNATfailed ? VINF_NAT_DNS : VINF_SUCCESS;
608	}
609
610	/**
611	* Register statistics.
612	*/
613	void slirp_register_statistics(PNATState pData, PPDMDRVINS pDrvIns)
614	{
615	#ifdef VBOX_WITH_STATISTICS
616	# define PROFILE_COUNTER(name, dsc) REGISTER_COUNTER(name, pData, STAMTYPE_PROFILE, STAMUNIT_TICKS_PER_CALL, dsc)
617	# define COUNTING_COUNTER(name, dsc) REGISTER_COUNTER(name, pData, STAMTYPE_COUNTER, STAMUNIT_COUNT, dsc)
618	# include "counters.h"
619	# undef COUNTER
620	/** @todo register statistics for the variables dumped by:
621	* ipstats(pData); tcpstats(pData); udpstats(pData); icmpstats(pData);
622	* mbufstats(pData); sockstats(pData); */
623	#endif /* VBOX_WITH_STATISTICS */
624	}
625
626	/**
627	* Deregister statistics.
628	*/
629	void slirp_deregister_statistics(PNATState pData, PPDMDRVINS pDrvIns)
630	{
631	#ifdef VBOX_WITH_STATISTICS
632	# define PROFILE_COUNTER(name, dsc) DEREGISTER_COUNTER(name, pData)
633	# define COUNTING_COUNTER(name, dsc) DEREGISTER_COUNTER(name, pData)
634	# include "counters.h"
635	#endif /* VBOX_WITH_STATISTICS */
636	}
637
638	/**
639	* Marks the link as up, making it possible to establish new connections.
640	*/
641	void slirp_link_up(PNATState pData)
642	{
643	link_up = 1;
644	}
645
646	/**
647	* Marks the link as down and cleans up the current connections.
648	*/
649	void slirp_link_down(PNATState pData)
650	{
651	struct socket *so;
652
653	while ((so = tcb.so_next) != &tcb)
654	{
655	if (so->so_state & SS_NOFDREF \|\| so->s == -1)
656	sofree(pData, so);
657	else
658	tcp_drop(pData, sototcpcb(so), 0);
659	}
660
661	while ((so = udb.so_next) != &udb)
662	udp_detach(pData, so);
663
664	link_up = 0;
665	}
666
667	/**
668	* Terminates the slirp component.
669	*/
670	void slirp_term(PNATState pData)
671	{
672	#ifdef RT_OS_WINDOWS
673	pData->pfIcmpCloseHandle(pData->icmp_socket.sh);
674	FreeLibrary(pData->hmIcmpLibrary);
675	RTMemFree(pData->pvIcmpBuffer);
676	#else
677	closesocket(pData->icmp_socket.s);
678	#endif
679
680	slirp_link_down(pData);
681	slirp_release_dns_list(pData);
682	ftp_alias_unload(pData);
683	nbt_alias_unload(pData);
684	if (pData->use_host_resolver)
685	dns_alias_unload(pData);
686	while(!LIST_EMPTY(&instancehead))
687	{
688	struct libalias *la = LIST_FIRST(&instancehead);
689	/* libalias do all clean up */
690	LibAliasUninit(la);
691	}
692	while(!LIST_EMPTY(&pData->arp_cache))
693	{
694	struct arp_cache_entry *ac = LIST_FIRST(&pData->arp_cache);
695	LIST_REMOVE(ac, list);
696	RTMemFree(ac);
697	}
698	bootp_dhcp_fini(pData);
699	m_fini(pData);
700	#ifdef RT_OS_WINDOWS
701	WSACleanup();
702	#endif
703	#ifdef LOG_ENABLED
704	Log(("\n"
705	"NAT statistics\n"
706	"--------------\n"
707	"\n"));
708	ipstats(pData);
709	tcpstats(pData);
710	udpstats(pData);
711	icmpstats(pData);
712	mbufstats(pData);
713	sockstats(pData);
714	Log(("\n"
715	"\n"
716	"\n"));
717	#endif
718	RTMemFree(pData);
719	}
720
721
722	#define CONN_CANFSEND(so) (((so)->so_state & (SS_FCANTSENDMORE\|SS_ISFCONNECTED)) == SS_ISFCONNECTED)
723	#define CONN_CANFRCV(so) (((so)->so_state & (SS_FCANTRCVMORE\|SS_ISFCONNECTED)) == SS_ISFCONNECTED)
724
725	/*
726	* curtime kept to an accuracy of 1ms
727	*/
728	static void updtime(PNATState pData)
729	{
730	#ifdef RT_OS_WINDOWS
731	struct _timeb tb;
732
733	_ftime(&tb);
734	curtime = (u_int)tb.time * (u_int)1000;
735	curtime += (u_int)tb.millitm;
736	#else
737	gettimeofday(&tt, 0);
738
739	curtime = (u_int)tt.tv_sec * (u_int)1000;
740	curtime += (u_int)tt.tv_usec / (u_int)1000;
741
742	if ((tt.tv_usec % 1000) >= 500)
743	curtime++;
744	#endif
745	}
746
747	#ifdef RT_OS_WINDOWS
748	void slirp_select_fill(PNATState pData, int *pnfds)
749	#else /* RT_OS_WINDOWS */
750	void slirp_select_fill(PNATState pData, int pnfds, struct pollfd polls)
751	#endif /* !RT_OS_WINDOWS */
752	{
753	struct socket so, so_next;
754	int nfds;
755	#if defined(RT_OS_WINDOWS)
756	int rc;
757	int error;
758	#else
759	int poll_index = 0;
760	#endif
761	int i;
762
763	STAM_PROFILE_START(&pData->StatFill, a);
764
765	nfds = *pnfds;
766
767	/*
768	* First, TCP sockets
769	*/
770	do_slowtimo = 0;
771	if (!link_up)
772	goto done;
773
774	/*
775	* *_slowtimo needs calling if there are IP fragments
776	* in the fragment queue, or there are TCP connections active
777	*/
778	/* XXX:
779	* triggering of fragment expiration should be the same but use new macroses
780	*/
781	do_slowtimo = (tcb.so_next != &tcb);
782	if (!do_slowtimo)
783	{
784	for (i = 0; i < IPREASS_NHASH; i++)
785	{
786	if (!TAILQ_EMPTY(&ipq[i]))
787	{
788	do_slowtimo = 1;
789	slirp_arm_slow_timer(pData->pvUser);
790	break;
791	}
792	}
793	}
794	ICMP_ENGAGE_EVENT(&pData->icmp_socket, readfds);
795
796	STAM_COUNTER_RESET(&pData->StatTCP);
797	STAM_COUNTER_RESET(&pData->StatTCPHot);
798
799	QSOCKET_FOREACH(so, so_next, tcp)
800	/* { */
801	#if !defined(RT_OS_WINDOWS)
802	so->so_poll_index = -1;
803	#endif
804	if (pData->fmbuf_water_line == 1)
805	{
806	if (mbuf_alloced < pData->mbuf_water_line_limit/2)
807	{
808	pData->fmbuf_water_warn_sent = 0;
809	pData->fmbuf_water_line = 0;
810	}
811	#ifndef RT_OS_WINDOWS
812	poll_index = 0;
813	#endif
814	goto done;
815	}
816	STAM_COUNTER_INC(&pData->StatTCP);
817
818	/*
819	* See if we need a tcp_fasttimo
820	*/
821	if ( time_fasttimo == 0
822	&& so->so_tcpcb != NULL
823	&& so->so_tcpcb->t_flags & TF_DELACK)
824	{
825	time_fasttimo = curtime; /* Flag when we want a fasttimo */
826	slirp_arm_fast_timer(pData->pvUser);
827	}
828
829	/*
830	* NOFDREF can include still connecting to local-host,
831	* newly socreated() sockets etc. Don't want to select these.
832	*/
833	if (so->so_state & SS_NOFDREF \|\| so->s == -1)
834	CONTINUE(tcp);
835
836	/*
837	* Set for reading sockets which are accepting
838	*/
839	if (so->so_state & SS_FACCEPTCONN)
840	{
841	STAM_COUNTER_INC(&pData->StatTCPHot);
842	TCP_ENGAGE_EVENT1(so, readfds);
843	CONTINUE(tcp);
844	}
845
846	/*
847	* Set for writing sockets which are connecting
848	*/
849	if (so->so_state & SS_ISFCONNECTING)
850	{
851	Log2(("connecting %R[natsock] engaged\n",so));
852	STAM_COUNTER_INC(&pData->StatTCPHot);
853	TCP_ENGAGE_EVENT1(so, writefds);
854	}
855
856	/*
857	* Set for writing if we are connected, can send more, and
858	* we have something to send
859	*/
860	if (CONN_CANFSEND(so) && so->so_rcv.sb_cc)
861	{
862	STAM_COUNTER_INC(&pData->StatTCPHot);
863	TCP_ENGAGE_EVENT1(so, writefds);
864	}
865
866	/*
867	* Set for reading (and urgent data) if we are connected, can
868	* receive more, and we have room for it XXX /2 ?
869	*/
870	if (CONN_CANFRCV(so) && (so->so_snd.sb_cc < (so->so_snd.sb_datalen/2)))
871	{
872	STAM_COUNTER_INC(&pData->StatTCPHot);
873	TCP_ENGAGE_EVENT2(so, readfds, xfds);
874	}
875	LOOP_LABEL(tcp, so, so_next);
876	}
877
878	/*
879	* UDP sockets
880	*/
881	STAM_COUNTER_RESET(&pData->StatUDP);
882	STAM_COUNTER_RESET(&pData->StatUDPHot);
883
884	QSOCKET_FOREACH(so, so_next, udp)
885	/* { */
886
887	if (pData->fmbuf_water_line == 1)
888	{
889	if (mbuf_alloced < pData->mbuf_water_line_limit/2)
890	{
891	pData->fmbuf_water_line = 0;
892	pData->fmbuf_water_warn_sent = 0;
893	}
894	#ifndef RT_OS_WINDOWS
895	poll_index = 0;
896	#endif
897	goto done;
898	}
899	STAM_COUNTER_INC(&pData->StatUDP);
900	#if !defined(RT_OS_WINDOWS)
901	so->so_poll_index = -1;
902	#endif
903
904	/*
905	* See if it's timed out
906	*/
907	if (so->so_expire)
908	{
909	if (so->so_expire <= curtime)
910	{
911	Log2(("NAT: %R[natsock] expired\n", so));
912	if (so->so_timeout != NULL)
913	{
914	so->so_timeout(pData, so, so->so_timeout_arg);
915	}
916	#ifdef VBOX_WITH_SLIRP_MT
917	/* we need so_next for continue our cycle*/
918	so_next = so->so_next;
919	#endif
920	UDP_DETACH(pData, so, so_next);
921	CONTINUE_NO_UNLOCK(udp);
922	}
923	else
924	{
925	do_slowtimo = 1; /* Let socket expire */
926	slirp_arm_slow_timer(pData->pvUser);
927	}
928	}
929
930	/*
931	* When UDP packets are received from over the link, they're
932	* sendto()'d straight away, so no need for setting for writing
933	* Limit the number of packets queued by this session to 4.
934	* Note that even though we try and limit this to 4 packets,
935	* the session could have more queued if the packets needed
936	* to be fragmented.
937	*
938	* (XXX <= 4 ?)
939	*/
940	if ((so->so_state & SS_ISFCONNECTED) && so->so_queued <= 4)
941	{
942	STAM_COUNTER_INC(&pData->StatUDPHot);
943	UDP_ENGAGE_EVENT(so, readfds);
944	}
945	LOOP_LABEL(udp, so, so_next);
946	}
947	done:
948
949	#if defined(RT_OS_WINDOWS)
950	*pnfds = VBOX_EVENT_COUNT;
951	#else /* RT_OS_WINDOWS */
952	AssertRelease(poll_index <= *pnfds);
953	*pnfds = poll_index;
954	#endif /* !RT_OS_WINDOWS */
955
956	STAM_PROFILE_STOP(&pData->StatFill, a);
957	}
958
959	#if defined(RT_OS_WINDOWS)
960	void slirp_select_poll(PNATState pData, int fTimeout, int fIcmp)
961	#else /* RT_OS_WINDOWS */
962	void slirp_select_poll(PNATState pData, struct pollfd *polls, int ndfs)
963	#endif /* !RT_OS_WINDOWS */
964	{
965	struct socket so, so_next;
966	int ret;
967	#if defined(RT_OS_WINDOWS)
968	WSANETWORKEVENTS NetworkEvents;
969	int rc;
970	int error;
971	#else
972	int poll_index = 0;
973	#endif
974
975	STAM_PROFILE_START(&pData->StatPoll, a);
976
977	/* Update time */
978	updtime(pData);
979
980	/*
981	* See if anything has timed out
982	*/
983	if (link_up)
984	{
985	if (time_fasttimo && ((curtime - time_fasttimo) >= 2))
986	{
987	STAM_PROFILE_START(&pData->StatFastTimer, a);
988	tcp_fasttimo(pData);
989	time_fasttimo = 0;
990	STAM_PROFILE_STOP(&pData->StatFastTimer, a);
991	}
992	if (do_slowtimo && ((curtime - last_slowtimo) >= 499))
993	{
994	STAM_PROFILE_START(&pData->StatSlowTimer, a);
995	ip_slowtimo(pData);
996	tcp_slowtimo(pData);
997	last_slowtimo = curtime;
998	STAM_PROFILE_STOP(&pData->StatSlowTimer, a);
999	}
1000	}
1001	#if defined(RT_OS_WINDOWS)
1002	if (fTimeout)
1003	return; /* only timer update */
1004	#endif
1005
1006	/*
1007	* Check sockets
1008	*/
1009	if (!link_up)
1010	goto done;
1011	#if defined(RT_OS_WINDOWS)
1012	/*XXX: before renaming please make see define
1013	* fIcmp in slirp_state.h
1014	*/
1015	if (fIcmp)
1016	sorecvfrom(pData, &pData->icmp_socket);
1017	#else
1018	if ( (pData->icmp_socket.s != -1)
1019	&& CHECK_FD_SET(&pData->icmp_socket, ignored, readfds))
1020	sorecvfrom(pData, &pData->icmp_socket);
1021	#endif
1022	/*
1023	* Check TCP sockets
1024	*/
1025	QSOCKET_FOREACH(so, so_next, tcp)
1026	/* { */
1027	if (pData->fmbuf_water_line == 1)
1028	{
1029	if (mbuf_alloced < pData->mbuf_water_line_limit/2)
1030	{
1031	pData->fmbuf_water_line = 0;
1032	pData->fmbuf_water_warn_sent = 0;
1033	}
1034	goto done;
1035	}
1036
1037	#ifdef VBOX_WITH_SLIRP_MT
1038	if ( so->so_state & SS_NOFDREF
1039	&& so->so_deleted == 1)
1040	{
1041	struct socket son, sop = NULL;
1042	QSOCKET_LOCK(tcb);
1043	if (so->so_next != NULL)
1044	{
1045	if (so->so_next != &tcb)
1046	SOCKET_LOCK(so->so_next);
1047	son = so->so_next;
1048	}
1049	if ( so->so_prev != &tcb
1050	&& so->so_prev != NULL)
1051	{
1052	SOCKET_LOCK(so->so_prev);
1053	sop = so->so_prev;
1054	}
1055	QSOCKET_UNLOCK(tcb);
1056	remque(pData, so);
1057	NSOCK_DEC();
1058	SOCKET_UNLOCK(so);
1059	SOCKET_LOCK_DESTROY(so);
1060	RTMemFree(so);
1061	so_next = son;
1062	if (sop != NULL)
1063	SOCKET_UNLOCK(sop);
1064	CONTINUE_NO_UNLOCK(tcp);
1065	}
1066	#endif
1067	/*
1068	* FD_ISSET is meaningless on these sockets
1069	* (and they can crash the program)
1070	*/
1071	if (so->so_state & SS_NOFDREF \|\| so->s == -1)
1072	CONTINUE(tcp);
1073
1074	POLL_TCP_EVENTS(rc, error, so, &NetworkEvents);
1075
1076	LOG_NAT_SOCK(so, TCP, &NetworkEvents, readfds, writefds, xfds);
1077
1078
1079	/*
1080	* Check for URG data
1081	* This will soread as well, so no need to
1082	* test for readfds below if this succeeds
1083	*/
1084
1085	/* out-of-band data */
1086	if (CHECK_FD_SET(so, NetworkEvents, xfds))
1087	{
1088	sorecvoob(pData, so);
1089	}
1090
1091	/*
1092	* Check sockets for reading
1093	*/
1094	else if ( CHECK_FD_SET(so, NetworkEvents, readfds)
1095	\|\| WIN_CHECK_FD_SET(so, NetworkEvents, acceptds))
1096	{
1097	/*
1098	* Check for incoming connections
1099	*/
1100	if (so->so_state & SS_FACCEPTCONN)
1101	{
1102	TCP_CONNECT(pData, so);
1103	#if defined(RT_OS_WINDOWS)
1104	if (!(NetworkEvents.lNetworkEvents & FD_CLOSE))
1105	#endif
1106	CONTINUE(tcp);
1107	}
1108
1109	ret = soread(pData, so);
1110	/* Output it if we read something */
1111	if (RT_LIKELY(ret > 0))
1112	TCP_OUTPUT(pData, sototcpcb(so));
1113	}
1114
1115	#if defined(RT_OS_WINDOWS)
1116	/*
1117	* Check for FD_CLOSE events.
1118	* in some cases once FD_CLOSE engaged on socket it could be flashed latter (for some reasons)
1119	*/
1120	if ( (NetworkEvents.lNetworkEvents & FD_CLOSE)
1121	\|\| (so->so_close == 1))
1122	{
1123	so->so_close = 1; /* mark it */
1124	/*
1125	* drain the socket
1126	*/
1127	for (;;)
1128	{
1129	ret = soread(pData, so);
1130	if (ret > 0)
1131	TCP_OUTPUT(pData, sototcpcb(so));
1132	else
1133	break;
1134	}
1135	CONTINUE(tcp);
1136	}
1137	#endif
1138
1139	/*
1140	* Check sockets for writing
1141	*/
1142	if (CHECK_FD_SET(so, NetworkEvents, writefds))
1143	{
1144	/*
1145	* Check for non-blocking, still-connecting sockets
1146	*/
1147	if (so->so_state & SS_ISFCONNECTING)
1148	{
1149	Log2(("connecting %R[natsock] catched\n", so));
1150	/* Connected */
1151	so->so_state &= ~SS_ISFCONNECTING;
1152
1153	/*
1154	* This should be probably guarded by PROBE_CONN too. Anyway,
1155	* we disable it on OS/2 because the below send call returns
1156	* EFAULT which causes the opened TCP socket to close right
1157	* after it has been opened and connected.
1158	*/
1159	#ifndef RT_OS_OS2
1160	ret = send(so->s, (const char *)&ret, 0, 0);
1161	if (ret < 0)
1162	{
1163	/* XXXXX Must fix, zero bytes is a NOP */
1164	if ( errno == EAGAIN
1165	\|\| errno == EWOULDBLOCK
1166	\|\| errno == EINPROGRESS
1167	\|\| errno == ENOTCONN)
1168	CONTINUE(tcp);
1169
1170	/* else failed */
1171	so->so_state = SS_NOFDREF;
1172	}
1173	/* else so->so_state &= ~SS_ISFCONNECTING; */
1174	#endif
1175
1176	/*
1177	* Continue tcp_input
1178	*/
1179	TCP_INPUT(pData, (struct mbuf *)NULL, sizeof(struct ip), so);
1180	/* continue; */
1181	}
1182	else
1183	SOWRITE(ret, pData, so);
1184	/*
1185	* XXX If we wrote something (a lot), there could be the need
1186	* for a window update. In the worst case, the remote will send
1187	* a window probe to get things going again.
1188	*/
1189	}
1190
1191	/*
1192	* Probe a still-connecting, non-blocking socket
1193	* to check if it's still alive
1194	*/
1195	#ifdef PROBE_CONN
1196	if (so->so_state & SS_ISFCONNECTING)
1197	{
1198	ret = recv(so->s, (char *)&ret, 0, 0);
1199
1200	if (ret < 0)
1201	{
1202	/* XXX */
1203	if ( errno == EAGAIN
1204	\|\| errno == EWOULDBLOCK
1205	\|\| errno == EINPROGRESS
1206	\|\| errno == ENOTCONN)
1207	{
1208	CONTINUE(tcp); /* Still connecting, continue */
1209	}
1210
1211	/* else failed */
1212	so->so_state = SS_NOFDREF;
1213
1214	/* tcp_input will take care of it */
1215	}
1216	else
1217	{
1218	ret = send(so->s, &ret, 0, 0);
1219	if (ret < 0)
1220	{
1221	/* XXX */
1222	if ( errno == EAGAIN
1223	\|\| errno == EWOULDBLOCK
1224	\|\| errno == EINPROGRESS
1225	\|\| errno == ENOTCONN)
1226	{
1227	CONTINUE(tcp);
1228	}
1229	/* else failed */
1230	so->so_state = SS_NOFDREF;
1231	}
1232	else
1233	so->so_state &= ~SS_ISFCONNECTING;
1234
1235	}
1236	TCP_INPUT((struct mbuf *)NULL, sizeof(struct ip),so);
1237	} /* SS_ISFCONNECTING */
1238	#endif
1239	#ifndef RT_OS_WINDOWS
1240	if ( UNIX_CHECK_FD_SET(so, NetworkEvents, rdhup)
1241	\|\| UNIX_CHECK_FD_SET(so, NetworkEvents, rderr))
1242	{
1243	int err;
1244	int inq, outq;
1245	int status;
1246	socklen_t optlen = sizeof(int);
1247	inq = outq = 0;
1248	status = getsockopt(so->s, SOL_SOCKET, SO_ERROR, &err, &optlen);
1249	if (status != 0)
1250	Log(("NAT: can't get error status from %R[natsock]\n", so));
1251	#ifndef RT_OS_SOLARIS
1252	status = ioctl(so->s, FIONREAD, &inq); /* tcp(7) recommends SIOCINQ which is Linux specific */
1253	if (status != 0 \|\| status != EINVAL)
1254	{
1255	/* EINVAL returned if socket in listen state tcp(7)*/
1256	Log(("NAT: can't get depth of IN queue status from %R[natsock]\n", so));
1257	}
1258	status = ioctl(so->s, TIOCOUTQ, &outq); /* SIOCOUTQ see previous comment */
1259	if (status != 0)
1260	Log(("NAT: can't get depth of OUT queue from %R[natsock]\n", so));
1261	#else
1262	/*
1263	* Solaris has bit different ioctl commands and its handlings
1264	* hint: streamio(7) I_NREAD
1265	*/
1266	#endif
1267	if ( so->so_state & SS_ISFCONNECTING
1268	\|\| UNIX_CHECK_FD_SET(so, NetworkEvents, readfds))
1269	{
1270	/**
1271	* Check if we need here take care about gracefull connection
1272	* @todo try with proxy server
1273	*/
1274	if (UNIX_CHECK_FD_SET(so, NetworkEvents, readfds))
1275	{
1276	/*
1277	* Never meet inq != 0 or outq != 0, anyway let it stay for a while
1278	* in case it happens we'll able to detect it.
1279	* Give TCP/IP stack wait or expire the socket.
1280	*/
1281	Log(("NAT: %R[natsock] err(%d:%s) s(in:%d,out:%d)happens on read I/O, "
1282	"other side close connection \n", so, err, strerror(err), inq, outq));
1283	CONTINUE(tcp);
1284	}
1285	goto tcp_input_close;
1286	}
1287	if ( !UNIX_CHECK_FD_SET(so, NetworkEvents, readfds)
1288	&& !UNIX_CHECK_FD_SET(so, NetworkEvents, writefds)
1289	&& !UNIX_CHECK_FD_SET(so, NetworkEvents, xfds))
1290	{
1291	Log(("NAT: system expires the socket %R[natsock] err(%d:%s) s(in:%d,out:%d) happens on non-I/O. ",
1292	so, err, strerror(err), inq, outq));
1293	goto tcp_input_close;
1294	}
1295	Log(("NAT: %R[natsock] we've met(%d:%s) s(in:%d, out:%d) unhandled combination hup (%d) "
1296	"rederr(%d) on (r:%d, w:%d, x:%d)\n",
1297	so, err, strerror(err),
1298	inq, outq,
1299	UNIX_CHECK_FD_SET(so, ign, rdhup),
1300	UNIX_CHECK_FD_SET(so, ign, rderr),
1301	UNIX_CHECK_FD_SET(so, ign, readfds),
1302	UNIX_CHECK_FD_SET(so, ign, writefds),
1303	UNIX_CHECK_FD_SET(so, ign, xfds)));
1304	/*
1305	* Give OS's TCP/IP stack a chance to resolve an issue or expire the socket.
1306	*/
1307	CONTINUE(tcp);
1308	tcp_input_close:
1309	so->so_state = SS_NOFDREF; /cause connection valid tcp connection termination and socket closing /
1310	TCP_INPUT(pData, (struct mbuf *)NULL, sizeof(struct ip), so);
1311	CONTINUE(tcp);
1312	}
1313	#endif
1314	LOOP_LABEL(tcp, so, so_next);
1315	}
1316
1317	/*
1318	* Now UDP sockets.
1319	* Incoming packets are sent straight away, they're not buffered.
1320	* Incoming UDP data isn't buffered either.
1321	*/
1322	QSOCKET_FOREACH(so, so_next, udp)
1323	/* { */
1324	if (pData->fmbuf_water_line == 1)
1325	{
1326	if (mbuf_alloced < pData->mbuf_water_line_limit/2)
1327	{
1328	pData->fmbuf_water_line = 0;
1329	pData->fmbuf_water_warn_sent = 0;
1330	}
1331	goto done;
1332	}
1333	#ifdef VBOX_WITH_SLIRP_MT
1334	if ( so->so_state & SS_NOFDREF
1335	&& so->so_deleted == 1)
1336	{
1337	struct socket son, sop = NULL;
1338	QSOCKET_LOCK(udb);
1339	if (so->so_next != NULL)
1340	{
1341	if (so->so_next != &udb)
1342	SOCKET_LOCK(so->so_next);
1343	son = so->so_next;
1344	}
1345	if ( so->so_prev != &udb
1346	&& so->so_prev != NULL)
1347	{
1348	SOCKET_LOCK(so->so_prev);
1349	sop = so->so_prev;
1350	}
1351	QSOCKET_UNLOCK(udb);
1352	remque(pData, so);
1353	NSOCK_DEC();
1354	SOCKET_UNLOCK(so);
1355	SOCKET_LOCK_DESTROY(so);
1356	RTMemFree(so);
1357	so_next = son;
1358	if (sop != NULL)
1359	SOCKET_UNLOCK(sop);
1360	CONTINUE_NO_UNLOCK(udp);
1361	}
1362	#endif
1363	POLL_UDP_EVENTS(rc, error, so, &NetworkEvents);
1364
1365	LOG_NAT_SOCK(so, UDP, &NetworkEvents, readfds, writefds, xfds);
1366
1367	if (so->s != -1 && CHECK_FD_SET(so, NetworkEvents, readfds))
1368	{
1369	SORECVFROM(pData, so);
1370	}
1371	LOOP_LABEL(udp, so, so_next);
1372	}
1373
1374	done:
1375	#if 0
1376	/*
1377	* See if we can start outputting
1378	*/
1379	if (if_queued && link_up)
1380	if_start(pData);
1381	#endif
1382
1383	STAM_PROFILE_STOP(&pData->StatPoll, a);
1384	}
1385
1386
1387	struct arphdr
1388	{
1389	unsigned short ar_hrd; /* format of hardware address */
1390	unsigned short ar_pro; /* format of protocol address */
1391	unsigned char ar_hln; /* length of hardware address */
1392	unsigned char ar_pln; /* length of protocol address */
1393	unsigned short ar_op; /* ARP opcode (command) */
1394
1395	/*
1396	* Ethernet looks like this : This bit is variable sized however...
1397	*/
1398	unsigned char ar_sha[ETH_ALEN]; /* sender hardware address */
1399	unsigned char ar_sip[4]; /* sender IP address */
1400	unsigned char ar_tha[ETH_ALEN]; /* target hardware address */
1401	unsigned char ar_tip[4]; /* target IP address */
1402	};
1403	AssertCompileSize(struct arphdr, 28);
1404
1405	static void arp_input(PNATState pData, struct mbuf *m)
1406	{
1407	struct ethhdr *eh;
1408	struct ethhdr *reh;
1409	struct arphdr *ah;
1410	struct arphdr *rah;
1411	int ar_op;
1412	struct ex_list *ex_ptr;
1413	uint32_t htip;
1414	uint32_t tip;
1415	struct mbuf *mr;
1416	eh = mtod(m, struct ethhdr *);
1417	ah = (struct arphdr *)&eh[1];
1418	htip = ntohl((uint32_t)ah->ar_tip);
1419	tip = (uint32_t)ah->ar_tip;
1420
1421
1422	ar_op = ntohs(ah->ar_op);
1423	switch(ar_op)
1424	{
1425	case ARPOP_REQUEST:
1426	#ifndef VBOX_WITH_SLIRP_BSD_MBUF
1427	mr = m_get(pData);
1428
1429	reh = mtod(mr, struct ethhdr *);
1430	memcpy(reh->h_source, eh->h_source, ETH_ALEN); /* XXX: if_encap will swap src and dst*/
1431	Log4(("NAT: arp:%R[ether]->%R[ether]\n",
1432	reh->h_source, reh->h_dest));
1433	Log4(("NAT: arp: %R[IP4]\n", &tip));
1434
1435	mr->m_data += if_maxlinkhdr;
1436	mr->m_len = sizeof(struct arphdr);
1437	rah = mtod(mr, struct arphdr *);
1438	#else
1439	mr = m_getcl(pData, M_NOWAIT, MT_HEADER, M_PKTHDR);
1440	reh = mtod(mr, struct ethhdr *);
1441	mr->m_data += ETH_HLEN;
1442	rah = mtod(mr, struct arphdr *);
1443	mr->m_len = sizeof(struct arphdr);
1444	Assert(mr);
1445	memcpy(reh->h_source, eh->h_source, ETH_ALEN); /* XXX: if_encap will swap src and dst*/
1446	#endif
1447	#ifdef VBOX_WITH_NAT_SERVICE
1448	if (tip == special_addr.s_addr) goto arp_ok;
1449	#endif
1450	if ((htip & pData->netmask) == ntohl(special_addr.s_addr))
1451	{
1452	if ( CTL_CHECK(htip, CTL_DNS)
1453	\|\| CTL_CHECK(htip, CTL_ALIAS)
1454	\|\| CTL_CHECK(htip, CTL_TFTP))
1455	goto arp_ok;
1456	for (ex_ptr = exec_list; ex_ptr; ex_ptr = ex_ptr->ex_next)
1457	{
1458	if ((htip & ~pData->netmask) == ex_ptr->ex_addr)
1459	{
1460	goto arp_ok;
1461	}
1462	}
1463	m_free(pData, m);
1464	m_free(pData, mr);
1465	return;
1466	arp_ok:
1467	rah->ar_hrd = htons(1);
1468	rah->ar_pro = htons(ETH_P_IP);
1469	rah->ar_hln = ETH_ALEN;
1470	rah->ar_pln = 4;
1471	rah->ar_op = htons(ARPOP_REPLY);
1472	memcpy(rah->ar_sha, special_ethaddr, ETH_ALEN);
1473
1474	switch (htip & ~pData->netmask)
1475	{
1476	case CTL_DNS:
1477	case CTL_ALIAS:
1478	rah->ar_sha[5] = (uint8_t)(htip & ~pData->netmask);
1479	break;
1480	default:;
1481	}
1482
1483	memcpy(rah->ar_sip, ah->ar_tip, 4);
1484	memcpy(rah->ar_tha, ah->ar_sha, ETH_ALEN);
1485	memcpy(rah->ar_tip, ah->ar_sip, 4);
1486	if_encap(pData, ETH_P_ARP, mr, ETH_ENCAP_URG);
1487	m_free(pData, m);
1488	}
1489	/Gratuitous ARP/
1490	if ( (uint32_t )ah->ar_sip == (uint32_t )ah->ar_tip
1491	&& memcmp(ah->ar_tha, broadcast_ethaddr, ETH_ALEN) == 0
1492	&& memcmp(eh->h_dest, broadcast_ethaddr, ETH_ALEN) == 0)
1493	{
1494	/* we've received anounce about address asignment
1495	* Let's do ARP cache update
1496	*/
1497	if (slirp_arp_cache_update(pData, (uint32_t )ah->ar_tip, &eh->h_dest[0]) == 0)
1498	{
1499	m_free(pData, mr);
1500	m_free(pData, m);
1501	break;
1502	}
1503	slirp_arp_cache_add(pData, (uint32_t )ah->ar_tip, &eh->h_dest[0]);
1504	/* good opportunity to activate port-forwarding on address (self)asignment*/
1505	activate_port_forwarding(pData, eh);
1506	}
1507	break;
1508	case ARPOP_REPLY:
1509	{
1510	if (slirp_arp_cache_update(pData, (uint32_t )ah->ar_sip, &ah->ar_sha[0]) == 0)
1511	{
1512	m_free(pData, m);
1513	break;
1514	}
1515	slirp_arp_cache_add(pData, (uint32_t )ah->ar_sip, ah->ar_sha);
1516	/after/save restore we need up port forwarding again/
1517	if (pData->port_forwarding_activated == 0)
1518	activate_port_forwarding(pData, eh);
1519	m_free(pData, m);
1520	}
1521	break;
1522	default:
1523	break;
1524	}
1525	}
1526
1527	#ifdef VBOX_WITH_SLIRP_BSD_MBUF
1528	void slirp_input(PNATState pData, const uint8_t *pkt, int pkt_len)
1529	#else
1530	void slirp_input(PNATState pData, void *pvArg)
1531	#endif
1532	{
1533	struct mbuf *m;
1534	int proto;
1535	static bool fWarnedIpv6;
1536	#ifdef VBOX_WITH_SLIRP_BSD_MBUF
1537	struct ethhdr eh = (struct ethhdr)pkt;
1538	int size = 0;
1539	#else
1540	struct ethhdr *eh;
1541	#endif
1542
1543	#ifndef VBOX_WITH_SLIRP_BSD_MBUF
1544	m = (struct mbuf *)pvArg;
1545	if (m->m_len < ETH_HLEN)
1546	{
1547	LogRel(("NAT: packet having size %d has been ingnored\n", m->m_len));
1548	m_free(pData, m);
1549	return;
1550	}
1551	eh = mtod(m, struct ethhdr *);
1552	proto = ntohs(eh->h_proto);
1553	#else
1554	Log2(("NAT: slirp_input %d\n", pkt_len));
1555	if (pkt_len < ETH_HLEN)
1556	{
1557	LogRel(("NAT: packet having size %d has been ingnored\n", pkt_len));
1558	return;
1559	}
1560	Log4(("NAT: in:%R[ether]->%R[ether]\n", &eh->h_source, &eh->h_dest));
1561
1562	if (memcmp(eh->h_source, special_ethaddr, ETH_ALEN) == 0)
1563	{
1564	/* @todo vasily: add ether logging routine in debug.c */
1565	Log(("NAT: packet was addressed to other MAC\n"));
1566	RTMemFree((void *)pkt);
1567	return;
1568	}
1569
1570	if (pkt_len < MSIZE)
1571	{
1572	size = MCLBYTES;
1573	}
1574	else if (pkt_len < MCLBYTES)
1575	{
1576	size = MCLBYTES;
1577	}
1578	else if(pkt_len < MJUM9BYTES)
1579	{
1580	size = MJUM9BYTES;
1581	}
1582	else if (pkt_len < MJUM16BYTES)
1583	{
1584	size = MJUM16BYTES;
1585	}
1586	else
1587	{
1588	AssertMsgFailed(("Unsupported size"));
1589	}
1590	m = m_getjcl(pData, M_NOWAIT, MT_HEADER, M_PKTHDR, size);
1591	if (!m)
1592	{
1593	LogRel(("NAT: can't allocate new mbuf\n"));
1594	RTMemFree((void *)pkt);
1595	return;
1596	}
1597
1598	m->m_len = pkt_len ;
1599	memcpy(m->m_data, pkt, pkt_len);
1600	proto = ntohs((uint16_t )(pkt + 12));
1601	#endif
1602	/* Note: we add to align the IP header */
1603
1604
1605	if (pData->port_forwarding_activated == 0)
1606	activate_port_forwarding(pData, mtod(m, struct ethhdr *));
1607
1608	switch(proto)
1609	{
1610	case ETH_P_ARP:
1611	arp_input(pData, m);
1612	break;
1613	case ETH_P_IP:
1614	/* Update time. Important if the network is very quiet, as otherwise
1615	* the first outgoing connection gets an incorrect timestamp. */
1616	updtime(pData);
1617	m_adj(m, ETH_HLEN);
1618	#ifdef VBOX_WITH_SLIRP_BSD_MBUF
1619	M_ASSERTPKTHDR(m);
1620	m->m_pkthdr.header = mtod(m, void *);
1621	#endif
1622	#if 1
1623	if ( pData->fmbuf_water_line
1624	&& pData->fmbuf_water_warn_sent == 0
1625	&& (curtime - pData->tsmbuf_water_warn_sent) > 500)
1626	{
1627	icmp_error(pData, m, ICMP_SOURCEQUENCH, 0, 0, "Out of resources!!!");
1628	pData->fmbuf_water_warn_sent = 1;
1629	pData->tsmbuf_water_warn_sent = curtime;
1630	}
1631	#endif
1632	ip_input(pData, m);
1633	break;
1634	case ETH_P_IPV6:
1635	m_free(pData, m);
1636	if (!fWarnedIpv6)
1637	{
1638	LogRel(("NAT: IPv6 not supported\n"));
1639	fWarnedIpv6 = true;
1640	}
1641	break;
1642	default:
1643	Log(("NAT: Unsupported protocol %x\n", proto));
1644	m_free(pData, m);
1645	break;
1646	}
1647	#ifdef VBOX_WITH_SLIRP_BSD_MBUF
1648	RTMemFree((void *)pkt);
1649	#endif
1650	}
1651
1652	/* output the IP packet to the ethernet device */
1653	void if_encap(PNATState pData, uint16_t eth_proto, struct mbuf *m, int flags)
1654	{
1655	struct ethhdr *eh;
1656	uint8_t *buf = NULL;
1657	size_t mlen = 0;
1658	STAM_PROFILE_START(&pData->StatIF_encap, a);
1659
1660	#ifndef VBOX_WITH_SLIRP_BSD_MBUF
1661	m->m_data -= if_maxlinkhdr;
1662	m->m_len += ETH_HLEN;
1663	eh = mtod(m, struct ethhdr *);
1664
1665	if(MBUF_HEAD(m) != m->m_data)
1666	{
1667	LogRel(("NAT: ethernet detects corruption of the packet"));
1668	AssertMsgFailed(("!!Ethernet frame corrupted!!"));
1669	}
1670	#else
1671	M_ASSERTPKTHDR(m);
1672	m->m_data -= ETH_HLEN;
1673	m->m_len += ETH_HLEN;
1674	eh = mtod(m, struct ethhdr *);
1675	#endif
1676
1677	if (memcmp(eh->h_source, special_ethaddr, ETH_ALEN) != 0)
1678	{
1679	memcpy(eh->h_dest, eh->h_source, ETH_ALEN);
1680	memcpy(eh->h_source, special_ethaddr, ETH_ALEN);
1681	Assert(memcmp(eh->h_dest, special_ethaddr, ETH_ALEN) != 0);
1682	if (memcmp(eh->h_dest, zerro_ethaddr, ETH_ALEN) == 0)
1683	{
1684	/* don't do anything */
1685	goto done;
1686	}
1687	}
1688	#ifndef VBOX_WITH_SLIRP_BSD_MBUF
1689	mlen = m->m_len;
1690	#else
1691	mlen = m_length(m, NULL);
1692	buf = RTMemAlloc(mlen);
1693	if (buf == NULL)
1694	{
1695	LogRel(("NAT: Can't alloc memory for outgoing buffer\n"));
1696	goto done;
1697	}
1698	#endif
1699	eh->h_proto = htons(eth_proto);
1700	#ifdef VBOX_WITH_SLIRP_BSD_MBUF
1701	m_copydata(m, 0, mlen, (char *)buf);
1702	#else
1703	if (flags & ETH_ENCAP_URG)
1704	slirp_urg_output(pData->pvUser, m, mtod(m, char *), mlen);
1705	else
1706	slirp_output(pData->pvUser, m, mtod(m, char *), mlen);
1707	#endif
1708	done:
1709	STAM_PROFILE_STOP(&pData->StatIF_encap, a);
1710	#ifdef VBOX_WITH_SLIRP_BSD_MBUF
1711	m_free(pData, m);
1712	#endif
1713	}
1714
1715	/**
1716	* Still we're using dhcp server leasing to map ether to IP
1717	* @todo see rt_lookup_in_cache
1718	*/
1719	static uint32_t find_guest_ip(PNATState pData, const uint8_t *eth_addr)
1720	{
1721	uint32_t ip = INADDR_ANY;
1722	if (eth_addr == NULL)
1723	goto done;
1724	if (memcmp(eth_addr, zerro_ethaddr, ETH_ALEN) == 0
1725	\|\| memcmp(eth_addr, broadcast_ethaddr, ETH_ALEN) == 0)
1726	goto done;
1727	if(slirp_arp_lookup_ip_by_ether(pData, eth_addr, &ip) == 0)
1728	goto done;
1729	bootp_cache_lookup_ip_by_ether(pData, eth_addr, &ip);
1730	done:
1731	return ip;
1732	}
1733
1734	/**
1735	* We need check if we've activated port forwarding
1736	* for specific machine ... that of course relates to
1737	* service mode
1738	* @todo finish this for service case
1739	*/
1740	static void activate_port_forwarding(PNATState pData, struct ethhdr *ethdr)
1741	{
1742	struct port_forward_rule *rule = NULL;
1743
1744	pData->port_forwarding_activated = 1;
1745	/* check mac here */
1746	LIST_FOREACH(rule, &pData->port_forward_rule_head, list)
1747	{
1748	struct socket *so;
1749	struct alias_link *link;
1750	struct libalias *lib;
1751	int flags;
1752	struct sockaddr sa;
1753	struct sockaddr_in *psin;
1754	socklen_t socketlen;
1755	struct in_addr alias;
1756	int rc;
1757	uint32_t guest_addr; /* need to understand if we already give address to guest */
1758
1759	if (rule->activated)
1760	continue; /already activated /
1761	#ifdef VBOX_WITH_NAT_SERVICE
1762	if (memcmp(rule->mac_address, ethdr->h_source, ETH_ALEN) != 0)
1763	continue; /not right mac, @todo: it'd be better do the list port forwarding per mac /
1764	guest_addr = find_guest_ip(pData, ethdr->h_source);
1765	#else
1766	#if 0
1767	if (memcmp(client_ethaddr, ethdr->h_source, ETH_ALEN) != 0)
1768	continue;
1769	#endif
1770	guest_addr = find_guest_ip(pData, ethdr->h_source);
1771	#endif
1772	if (guest_addr == INADDR_ANY)
1773	{
1774	/* the address wasn't granted */
1775	pData->port_forwarding_activated = 0;
1776	return;
1777	}
1778	#if defined(DEBUG_vvl) && !defined(VBOX_WITH_NAT_SERVICE)
1779	Assert(rule->guest_addr.s_addr == guest_addr);
1780	#endif
1781
1782	LogRel(("NAT: set redirect %s hp:%d gp:%d\n", (rule->proto == IPPROTO_UDP?"UDP":"TCP"),
1783	rule->host_port, rule->guest_port));
1784	if (rule->proto == IPPROTO_UDP)
1785	{
1786	so = udp_listen(pData, rule->bind_ip.s_addr, htons(rule->host_port), guest_addr,
1787	htons(rule->guest_port), 0);
1788	}
1789	else
1790	{
1791	so = solisten(pData, rule->bind_ip.s_addr, htons(rule->host_port), guest_addr,
1792	htons(rule->guest_port), 0);
1793	}
1794	if (so == NULL)
1795	{
1796	LogRel(("NAT: failed redirect %s hp:%d gp:%d\n", (rule->proto == IPPROTO_UDP?"UDP":"TCP"),
1797	rule->host_port, rule->guest_port));
1798	goto remove_port_forwarding;
1799	}
1800
1801	psin = (struct sockaddr_in *)&sa;
1802	psin->sin_family = AF_INET;
1803	psin->sin_port = 0;
1804	psin->sin_addr.s_addr = INADDR_ANY;
1805	socketlen = sizeof(struct sockaddr);
1806
1807	rc = getsockname(so->s, &sa, &socketlen);
1808	if (rc < 0 \|\| sa.sa_family != AF_INET)
1809	{
1810	LogRel(("NAT: failed redirect %s hp:%d gp:%d\n", (rule->proto == IPPROTO_UDP?"UDP":"TCP"),
1811	rule->host_port, rule->guest_port));
1812	goto remove_port_forwarding;
1813	}
1814
1815	psin = (struct sockaddr_in *)&sa;
1816
1817	lib = LibAliasInit(pData, NULL);
1818	flags = LibAliasSetMode(lib, 0, 0);
1819	flags \|= PKT_ALIAS_LOG; /* set logging */
1820	flags \|= PKT_ALIAS_REVERSE; /* set logging */
1821	flags = LibAliasSetMode(lib, flags, ~0);
1822
1823	alias.s_addr = htonl(ntohl(guest_addr) \| CTL_ALIAS);
1824	link = LibAliasRedirectPort(lib, psin->sin_addr, htons(rule->host_port),
1825	alias, htons(rule->guest_port),
1826	special_addr, -1, /* not very clear for now*/
1827	rule->proto);
1828	if (link == NULL)
1829	{
1830	LogRel(("NAT: failed redirect %s hp:%d gp:%d\n", (rule->proto == IPPROTO_UDP?"UDP":"TCP"),
1831	rule->host_port, rule->guest_port));
1832	goto remove_port_forwarding;
1833	}
1834	so->so_la = lib;
1835	rule->activated = 1;
1836	continue;
1837	remove_port_forwarding:
1838	LIST_REMOVE(rule, list);
1839	RTMemFree(rule);
1840	}
1841	}
1842
1843	/**
1844	* Changes in 3.1 instead of opening new socket do the following:
1845	* gain more information:
1846	* 1. bind IP
1847	* 2. host port
1848	* 3. guest port
1849	* 4. proto
1850	* 5. guest MAC address
1851	* the guest's MAC address is rather important for service, but we easily
1852	* could get it from VM configuration in DrvNAT or Service, the idea is activating
1853	* corresponding port-forwarding
1854	*/
1855	int slirp_redir(PNATState pData, int is_udp, struct in_addr host_addr, int host_port,
1856	struct in_addr guest_addr, int guest_port, const uint8_t *ethaddr)
1857	{
1858	struct port_forward_rule *rule = NULL;
1859	Assert(memcmp(ethaddr, zerro_ethaddr, ETH_ALEN) == 0);
1860	rule = RTMemAllocZ(sizeof(struct port_forward_rule));
1861	if (rule == NULL)
1862	return 1;
1863	rule->proto = (is_udp ? IPPROTO_UDP : IPPROTO_TCP);
1864	rule->host_port = host_port;
1865	rule->guest_port = guest_port;
1866	#ifndef VBOX_WITH_NAT_SERVICE
1867	rule->guest_addr.s_addr = guest_addr.s_addr;
1868	#endif
1869	rule->bind_ip.s_addr = host_addr.s_addr;
1870	memcpy(rule->mac_address, ethaddr, ETH_ALEN);
1871	/* @todo add mac address */
1872	LIST_INSERT_HEAD(&pData->port_forward_rule_head, rule, list);
1873	return 0;
1874	}
1875
1876	int slirp_add_exec(PNATState pData, int do_pty, const char *args, int addr_low_byte,
1877	int guest_port)
1878	{
1879	return add_exec(&exec_list, do_pty, (char *)args,
1880	addr_low_byte, htons(guest_port));
1881	}
1882
1883	void slirp_set_ethaddr(PNATState pData, const uint8_t *ethaddr)
1884	{
1885	#ifndef VBOX_WITH_NAT_SERVICE
1886	memcpy(client_ethaddr, ethaddr, ETH_ALEN);
1887	#endif
1888	}
1889
1890	#if defined(RT_OS_WINDOWS)
1891	HANDLE *slirp_get_events(PNATState pData)
1892	{
1893	return pData->phEvents;
1894	}
1895	void slirp_register_external_event(PNATState pData, HANDLE hEvent, int index)
1896	{
1897	pData->phEvents[index] = hEvent;
1898	}
1899	#endif
1900
1901	unsigned int slirp_get_timeout_ms(PNATState pData)
1902	{
1903	if (link_up)
1904	{
1905	if (time_fasttimo)
1906	return 2;
1907	if (do_slowtimo)
1908	return 500; /* see PR_SLOWHZ */
1909	}
1910	return 0;
1911	}
1912
1913	#ifndef RT_OS_WINDOWS
1914	int slirp_get_nsock(PNATState pData)
1915	{
1916	return pData->nsock;
1917	}
1918	#endif
1919
1920	/*
1921	* this function called from NAT thread
1922	*/
1923	void slirp_post_sent(PNATState pData, void *pvArg)
1924	{
1925	struct socket *so = 0;
1926	struct tcpcb *tp = 0;
1927	struct mbuf m = (struct mbuf )pvArg;
1928	m_free(pData, m);
1929	}
1930	#ifdef VBOX_WITH_SLIRP_MT
1931	void slirp_process_queue(PNATState pData)
1932	{
1933	RTReqProcess(pData->pReqQueue, RT_INDEFINITE_WAIT);
1934	}
1935	void *slirp_get_queue(PNATState pData)
1936	{
1937	return pData->pReqQueue;
1938	}
1939	#endif
1940
1941	void slirp_set_dhcp_TFTP_prefix(PNATState pData, const char *tftpPrefix)
1942	{
1943	Log2(("tftp_prefix:%s\n", tftpPrefix));
1944	tftp_prefix = tftpPrefix;
1945	}
1946
1947	void slirp_set_dhcp_TFTP_bootfile(PNATState pData, const char *bootFile)
1948	{
1949	Log2(("bootFile:%s\n", bootFile));
1950	bootp_filename = bootFile;
1951	}
1952
1953	void slirp_set_dhcp_next_server(PNATState pData, const char *next_server)
1954	{
1955	Log2(("next_server:%s\n", next_server));
1956	if (next_server == NULL)
1957	pData->tftp_server.s_addr = htonl(ntohl(special_addr.s_addr) \| CTL_TFTP);
1958	else
1959	inet_aton(next_server, &pData->tftp_server);
1960	}
1961
1962	int slirp_set_binding_address(PNATState pData, char *addr)
1963	{
1964	if (addr == NULL \|\| (inet_aton(addr, &pData->bindIP) == 0))
1965	{
1966	pData->bindIP.s_addr = INADDR_ANY;
1967	return 1;
1968	}
1969	return 0;
1970	}
1971
1972	void slirp_set_dhcp_dns_proxy(PNATState pData, bool fDNSProxy)
1973	{
1974	if (!pData->use_host_resolver)
1975	{
1976	Log2(("NAT: DNS proxy switched %s\n", (fDNSProxy ? "on" : "off")));
1977	pData->use_dns_proxy = fDNSProxy;
1978	}
1979	else
1980	{
1981	LogRel(("NAT: Host Resolver conflicts with DNS proxy, the last one was forcely ignored\n"));
1982	}
1983	}
1984
1985	#define CHECK_ARG(name, val, lim_min, lim_max) \
1986	do { \
1987	if ((val) < (lim_min) \|\| (val) > (lim_max)) \
1988	{ \
1989	LogRel(("NAT: (" #name ":%d) has been ignored, " \
1990	"because out of range (%d, %d)\n", (val), (lim_min), (lim_max))); \
1991	return; \
1992	} \
1993	else \
1994	{ \
1995	LogRel(("NAT: (" #name ":%d)\n", (val))); \
1996	} \
1997	} while (0)
1998
1999	/* don't allow user set less 8kB and more than 1M values */
2000	#define _8K_1M_CHECK_ARG(name, val) CHECK_ARG(name, (val), 8, 1024)
2001	void slirp_set_rcvbuf(PNATState pData, int kilobytes)
2002	{
2003	_8K_1M_CHECK_ARG("SOCKET_RCVBUF", kilobytes);
2004	pData->socket_rcv = kilobytes;
2005	}
2006	void slirp_set_sndbuf(PNATState pData, int kilobytes)
2007	{
2008	_8K_1M_CHECK_ARG("SOCKET_SNDBUF", kilobytes);
2009	pData->socket_snd = kilobytes * _1K;
2010	}
2011	void slirp_set_tcp_rcvspace(PNATState pData, int kilobytes)
2012	{
2013	_8K_1M_CHECK_ARG("TCP_RCVSPACE", kilobytes);
2014	tcp_rcvspace = kilobytes * _1K;
2015	}
2016	void slirp_set_tcp_sndspace(PNATState pData, int kilobytes)
2017	{
2018	_8K_1M_CHECK_ARG("TCP_SNDSPACE", kilobytes);
2019	tcp_sndspace = kilobytes * _1K;
2020	}
2021
2022	/*
2023	* Looking for Ether by ip in ARP-cache
2024	* Note: it´s responsible of caller to allocate buffer for result
2025	* @returns 0 - if found, 1 - otherwise
2026	*/
2027	int slirp_arp_lookup_ether_by_ip(PNATState pData, uint32_t ip, uint8_t *ether)
2028	{
2029	struct arp_cache_entry *ac = NULL;
2030	int rc = 1;
2031	if (ether == NULL)
2032	return rc;
2033
2034	if (LIST_EMPTY(&pData->arp_cache))
2035	return rc;
2036
2037	LIST_FOREACH(ac, &pData->arp_cache, list)
2038	{
2039	if (ac->ip == ip)
2040	{
2041	memcpy(ether, ac->ether, ETH_ALEN);
2042	rc = 0;
2043	return rc;
2044	}
2045	}
2046	return rc;
2047	}
2048
2049	/*
2050	* Looking for IP by Ether in ARP-cache
2051	* Note: it´s responsible of caller to allocate buffer for result
2052	* @returns 0 - if found, 1 - otherwise
2053	*/
2054	int slirp_arp_lookup_ip_by_ether(PNATState pData, const uint8_t ether, uint32_t ip)
2055	{
2056	struct arp_cache_entry *ac = NULL;
2057	int rc = 1;
2058	*ip = INADDR_ANY;
2059	if (LIST_EMPTY(&pData->arp_cache))
2060	return rc;
2061	LIST_FOREACH(ac, &pData->arp_cache, list)
2062	{
2063	if (memcmp(ether, ac->ether, ETH_ALEN))
2064	{
2065	*ip = ac->ip;
2066	rc = 0;
2067	return rc;
2068	}
2069	}
2070	return rc;
2071	}
2072
2073	void slirp_arp_who_has(PNATState pData, uint32_t dst)
2074	{
2075	struct mbuf *m;
2076	struct ethhdr *ehdr;
2077	struct arphdr *ahdr;
2078
2079	#ifndef VBOX_WITH_SLIRP_BSD_MBUF
2080	m = m_get(pData);
2081	#else
2082	m = m_getcl(pData, M_NOWAIT, MT_HEADER, M_PKTHDR);
2083	#endif
2084	if (m == NULL)
2085	{
2086	LogRel(("NAT: Can't alloc mbuf for ARP request\n"));
2087	return;
2088	}
2089	ehdr = mtod(m, struct ethhdr *);
2090	memset(ehdr->h_source, 0xff, ETH_ALEN);
2091	ahdr = (struct arphdr *)&ehdr[1];
2092	ahdr->ar_hrd = htons(1);
2093	ahdr->ar_pro = htons(ETH_P_IP);
2094	ahdr->ar_hln = ETH_ALEN;
2095	ahdr->ar_pln = 4;
2096	ahdr->ar_op = htons(ARPOP_REQUEST);
2097	memcpy(ahdr->ar_sha, special_ethaddr, ETH_ALEN);
2098	(uint32_t )ahdr->ar_sip = htonl(ntohl(special_addr.s_addr) \| CTL_ALIAS);
2099	memset(ahdr->ar_tha, 0xff, ETH_ALEN); /broadcast/
2100	(uint32_t )ahdr->ar_tip = dst;
2101	#ifndef VBOX_WITH_SLIRP_BSD_MBUF
2102	m->m_data += if_maxlinkhdr;
2103	m->m_len = sizeof(struct arphdr);
2104	#else
2105	/* warn!!! should falls in mbuf minimal size */
2106	m->m_len = sizeof(struct arphdr) + ETH_HLEN;
2107	#endif
2108	if_encap(pData, ETH_P_ARP, m, ETH_ENCAP_URG);
2109	Log(("NAT: ARP request sent\n"));
2110	}
2111
2112	/* updates the arp cache
2113	* @returns 0 - if has found and updated
2114	* 1 - if hasn't found.
2115	*/
2116	int slirp_arp_cache_update(PNATState pData, uint32_t dst, const uint8_t *mac)
2117	{
2118	struct arp_cache_entry *ac;
2119	LIST_FOREACH(ac, &pData->arp_cache, list)
2120	{
2121	if (memcmp(ac->ether, mac, ETH_ALEN) == 0)
2122	{
2123	ac->ip = dst;
2124	return 0;
2125	}
2126	}
2127	return 1;
2128	}
2129
2130	void slirp_arp_cache_add(PNATState pData, uint32_t ip, const uint8_t *ether)
2131	{
2132	struct arp_cache_entry *ac = NULL;
2133	ac = RTMemAllocZ(sizeof(struct arp_cache_entry));
2134	if (ac == NULL)
2135	{
2136	LogRel(("NAT: Can't allocate arp cache entry\n"));
2137	return;
2138	}
2139	ac->ip = ip;
2140	memcpy(ac->ether, ether, ETH_ALEN);
2141	LIST_INSERT_HEAD(&pData->arp_cache, ac, list);
2142	}
2143
2144	#ifdef VBOX_WITH_SLIRP_BSD_MBUF
2145	void slirp_set_mtu(PNATState pData, int mtu)
2146	{
2147	if (mtu < 20 \|\| mtu >= 16000)
2148	{
2149	LogRel(("NAT: mtu(%d) is out of range (20;16000] mtu forcely assigned to 1500\n", mtu));
2150	mtu = 1500;
2151	}
2152	if_mtu =
2153	if_mru = mtu;
2154	}
2155	#endif
2156	void slirp_set_dhcp_mtu(PNATState, int);

注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

source: vbox/trunk/src/VBox/Devices/Network/slirp/slirp.c@ 23497

以其他格式下載: