DevINIP.cpp@ 30351

Last change on this file since 30351 was 28800, checked in by vboxsync, 15 years ago
Automated rebranding to Oracle copyright/license strings via filemuncher
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 22.9 KB

Line
1	/* $Id: DevINIP.cpp 28800 2010-04-27 08:22:32Z vboxsync $ */
2	/** @file
3	* DevINIP - Internal Network IP stack device/service.
4	*/
5
6	/*
7	* Copyright (C) 2007-2009 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18
19	/*******************************************************************************
20	* Header Files *
21	*******************************************************************************/
22	#define LOG_GROUP LOG_GROUP_DEV_INIP
23	#include <iprt/cdefs.h> /* include early to allow RT_C_DECLS_BEGIN hack */
24	#include <iprt/mem.h> /* include anything of ours that the lwip headers use. */
25	#include <iprt/semaphore.h>
26	#include <iprt/thread.h>
27	#include <iprt/alloca.h>
28	/* All lwip header files are not C++ safe. So hack around this. */
29	RT_C_DECLS_BEGIN
30	#include "lwip/sys.h"
31	#include "lwip/stats.h"
32	#include "lwip/mem.h"
33	#include "lwip/memp.h"
34	#include "lwip/pbuf.h"
35	#include "lwip/netif.h"
36	#include "ipv4/lwip/ip.h"
37	#include "lwip/udp.h"
38	#include "lwip/tcp.h"
39	#include "lwip/tcpip.h"
40	#include "lwip/sockets.h"
41	#include "netif/etharp.h"
42	RT_C_DECLS_END
43	#include <VBox/pdmdev.h>
44	#include <VBox/pdmnetifs.h>
45	#include <VBox/tm.h>
46	#include <iprt/assert.h>
47	#include <iprt/string.h>
48	#include <iprt/uuid.h>
49
50	#include "../Builtins.h"
51
52
53	/*******************************************************************************
54	* Macros and Defines *
55	*******************************************************************************/
56
57	/** Maximum frame size this device can handle. */
58	#define DEVINIP_MAX_FRAME 1514
59
60
61	/*******************************************************************************
62	* Structures and Typedefs *
63	*******************************************************************************/
64
65	/**
66	* Internal Network IP stack device instance data.
67	*
68	* @implements PDMIBASE
69	* @implements PDMINETWORKDOWN
70	*/
71	typedef struct DEVINTNETIP
72	{
73	/** The base interface for LUN\#0. */
74	PDMIBASE IBase;
75	/** The network port this device provides (LUN\#0). */
76	PDMINETWORKDOWN INetworkDown;
77	/** The base interface of the network driver below us. */
78	PPDMIBASE pDrvBase;
79	/** The connector of the network driver below us. */
80	PPDMINETWORKUP pDrv;
81	/** Pointer to the device instance. */
82	PPDMDEVINSR3 pDevIns;
83	/** MAC adress. */
84	RTMAC MAC;
85	/** Static IP address of the interface. */
86	char *pszIP;
87	/** Netmask of the interface. */
88	char *pszNetmask;
89	/** Gateway for the interface. */
90	char *pszGateway;
91	/** lwIP network interface description. */
92	struct netif IntNetIF;
93	/** lwIP ARP timer. */
94	PTMTIMERR3 ARPTimer;
95	/** lwIP TCP fast timer. */
96	PTMTIMERR3 TCPFastTimer;
97	/** lwIP TCP slow timer. */
98	PTMTIMERR3 TCPSlowTimer;
99	/** lwIP semaphore to coordinate TCPIP init/terminate. */
100	sys_sem_t LWIPTcpInitSem;
101	/** hack: get linking right. remove this eventually, once the device
102	* provides a proper interface to all IP stack functions. */
103	const void *pLinkHack;
104	} DEVINTNETIP, *PDEVINTNETIP;
105
106
107	/*******************************************************************************
108	* Global Variables *
109	*******************************************************************************/
110
111	/**
112	* Pointer to the (only) instance data in this device.
113	*/
114	static PDEVINTNETIP g_pDevINIPData = NULL;
115
116	/*
117	* really ugly hack to avoid linking problems on unix style platforms
118	* using .a libraries for now.
119	*/
120	static const PFNRT g_pDevINILinkHack[] =
121	{
122	(PFNRT)lwip_socket,
123	(PFNRT)lwip_close,
124	(PFNRT)lwip_setsockopt,
125	(PFNRT)lwip_recv,
126	(PFNRT)lwip_send,
127	(PFNRT)lwip_select
128	};
129
130
131	/*******************************************************************************
132	* Internal Functions *
133	*******************************************************************************/
134	static DECLCALLBACK(void) devINIPARPTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer);
135	static DECLCALLBACK(void) devINIPTCPFastTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer);
136	static DECLCALLBACK(void) devINIPTCPSlowTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer);
137	static DECLCALLBACK(err_t) devINIPOutput(struct netif netif, struct pbuf p,
138	struct ip_addr *ipaddr);
139	static DECLCALLBACK(err_t) devINIPOutputRaw(struct netif *netif,
140	struct pbuf *p);
141	static DECLCALLBACK(err_t) devINIPInterface(struct netif *netif);
142
143	/**
144	* ARP cache timeout handling for lwIP.
145	*
146	* @param pDevIns Device instance.
147	* @param pTimer Pointer to timer.
148	*/
149	static DECLCALLBACK(void) devINIPARPTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
150	{
151	PDEVINTNETIP pThis = (PDEVINTNETIP)pvUser;
152	LogFlow(("%s: pDevIns=%p pTimer=%p\n", __FUNCTION__, pDevIns, pTimer));
153	lwip_etharp_tmr();
154	TMTimerSetMillies(pThis->ARPTimer, ARP_TMR_INTERVAL);
155	LogFlow(("%s: return\n", __FUNCTION__));
156	}
157
158	/**
159	* TCP fast timer handling for lwIP.
160	*
161	* @param pDevIns Device instance.
162	* @param pTimer Pointer to timer.
163	*/
164	static DECLCALLBACK(void) devINIPTCPFastTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
165	{
166	PDEVINTNETIP pThis = (PDEVINTNETIP)pvUser;
167	LogFlow(("%s: pDevIns=%p pTimer=%p\n", __FUNCTION__, pDevIns, pTimer));
168	lwip_tcp_fasttmr();
169	TMTimerSetMillies(pThis->TCPFastTimer, TCP_FAST_INTERVAL);
170	LogFlow(("%s: return\n", __FUNCTION__));
171	}
172
173	/**
174	* TCP slow timer handling for lwIP.
175	*
176	* @param pDevIns Device instance.
177	* @param pTimer Pointer to timer.
178	*/
179	static DECLCALLBACK(void) devINIPTCPSlowTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
180	{
181	PDEVINTNETIP pThis = (PDEVINTNETIP)pvUser;
182	LogFlow(("%s: pDevIns=%p pTimer=%p\n", __FUNCTION__, pDevIns, pTimer));
183	lwip_tcp_slowtmr();
184	TMTimerSetMillies(pThis->TCPSlowTimer, TCP_SLOW_INTERVAL);
185	LogFlow(("%s: return\n", __FUNCTION__));
186	}
187
188	/**
189	* Output a TCP/IP packet on the interface. Uses the generic lwIP ARP
190	* code to resolve the address and call the link-level packet function.
191	*
192	* @returns lwIP error code
193	* @param netif Interface on which to send IP packet.
194	* @param p Packet data.
195	* @param ipaddr Destination IP address.
196	*/
197	static DECLCALLBACK(err_t) devINIPOutput(struct netif netif, struct pbuf p,
198	struct ip_addr *ipaddr)
199	{
200	err_t lrc;
201	LogFlow(("%s: netif=%p p=%p ipaddr=%#04x\n", __FUNCTION__, netif, p,
202	ipaddr->addr));
203	lrc = lwip_etharp_output(netif, ipaddr, p);
204	LogFlow(("%s: return %d\n", __FUNCTION__, lrc));
205	return lrc;
206	}
207
208	/**
209	* Output a raw packet on the interface.
210	*
211	* @returns lwIP error code
212	* @param netif Interface on which to send frame.
213	* @param p Frame data.
214	*/
215	static DECLCALLBACK(err_t) devINIPOutputRaw(struct netif *netif,
216	struct pbuf *p)
217	{
218	int rc = VINF_SUCCESS;
219
220	LogFlow(("%s: netif=%p p=%p\n", __FUNCTION__, netif, p));
221	Assert(g_pDevINIPData);
222	Assert(g_pDevINIPData->pDrv);
223
224	/* Silently ignore packets being sent while lwIP isn't set up. */
225	if (g_pDevINIPData)
226	{
227	PPDMSCATTERGATHER pSgBuf;
228	rc = g_pDevINIPData->pDrv->pfnAllocBuf(g_pDevINIPData->pDrv, DEVINIP_MAX_FRAME, NULL /pGso/, &pSgBuf);
229	if (RT_SUCCESS(rc))
230	{
231	#if ETH_PAD_SIZE
232	lwip_pbuf_header(p, -ETH_PAD_SIZE); /* drop the padding word */
233	#endif
234
235	uint8_t pbBuf = pSgBuf ? (uint8_t )pSgBuf->aSegs[0].pvSeg : NULL;
236	size_t cbBuf = 0;
237	for (struct pbuf *q = p; q != NULL; q = q->next)
238	{
239	if (cbBuf + q->len <= DEVINIP_MAX_FRAME)
240	{
241	if (RT_LIKELY(pbBuf))
242	{
243	memcpy(pbBuf, q->payload, q->len);
244	pbBuf += q->len;
245	}
246	cbBuf += q->len;
247	}
248	else
249	{
250	LogRel(("INIP: exceeded frame size\n"));
251	break;
252	}
253	}
254	if (cbBuf)
255	rc = g_pDevINIPData->pDrv->pfnSendBuf(g_pDevINIPData->pDrv, pSgBuf, false);
256	else
257	rc = g_pDevINIPData->pDrv->pfnFreeBuf(g_pDevINIPData->pDrv, pSgBuf);
258
259	#if ETH_PAD_SIZE
260	lwip_pbuf_header(p, ETH_PAD_SIZE); /* reclaim the padding word */
261	#endif
262	}
263	}
264
265	err_t lrc = ERR_OK;
266	if (RT_FAILURE(rc))
267	lrc = ERR_IF;
268	LogFlow(("%s: return %d (vbox: %Rrc)\n", __FUNCTION__, rc, lrc));
269	return lrc;
270	}
271
272	/**
273	* Implements the ethernet interface backend initialization for lwIP.
274	*
275	* @returns lwIP error code
276	* @param netif Interface to configure.
277	*/
278	static DECLCALLBACK(err_t) devINIPInterface(struct netif *netif)
279	{
280	LogFlow(("%s: netif=%p\n", __FUNCTION__, netif));
281	Assert(g_pDevINIPData != NULL);
282	netif->state = g_pDevINIPData;
283	netif->hwaddr_len = sizeof(g_pDevINIPData->MAC);
284	memcpy(netif->hwaddr, &g_pDevINIPData->MAC, sizeof(g_pDevINIPData->MAC));
285	netif->mtu = DEVINIP_MAX_FRAME;
286	netif->flags = NETIF_FLAG_BROADCAST;
287	netif->output = devINIPOutput;
288	netif->linkoutput = devINIPOutputRaw;
289
290	lwip_etharp_init();
291	TMTimerSetMillies(g_pDevINIPData->ARPTimer, ARP_TMR_INTERVAL);
292	LogFlow(("%s: success\n", __FUNCTION__));
293	return ERR_OK;
294	}
295
296	/**
297	* Wait until data can be received.
298	*
299	* @returns VBox status code. VINF_SUCCESS means there is at least one receive descriptor available.
300	* @param pInterface PDM network port interface pointer.
301	* @param cMillies Number of milliseconds to wait. 0 means return immediately.
302	*/
303	static DECLCALLBACK(int) devINIPNetworkDown_WaitInputAvail(PPDMINETWORKDOWN pInterface, RTMSINTERVAL cMillies)
304	{
305	LogFlow(("%s: pInterface=%p\n", __FUNCTION__, pInterface));
306	LogFlow(("%s: return VINF_SUCCESS\n", __FUNCTION__));
307	return VINF_SUCCESS;
308	}
309
310	/**
311	* Receive data and pass it to lwIP for processing.
312	*
313	* @returns VBox status code
314	* @param pInterface PDM network port interface pointer.
315	* @param pvBuf Pointer to frame data.
316	* @param cb Frame size.
317	*/
318	static DECLCALLBACK(int) devINIPNetworkDown_Input(PPDMINETWORKDOWN pInterface,
319	const void *pvBuf, size_t cb)
320	{
321	const uint8_t pbBuf = (const uint8_t )pvBuf;
322	size_t len = cb;
323	const struct eth_hdr *ethhdr;
324	struct pbuf p, q;
325	int rc = VINF_SUCCESS;
326
327	LogFlow(("%s: pInterface=%p pvBuf=%p cb=%lu\n", __FUNCTION__, pInterface,
328	pvBuf, cb));
329	Assert(g_pDevINIPData);
330	Assert(g_pDevINIPData->pDrv);
331
332	/* Silently ignore packets being received while lwIP isn't set up. */
333	if (!g_pDevINIPData)
334	goto out;
335
336	#if ETH_PAD_SIZE
337	len += ETH_PAD_SIZE; /* allow room for Ethernet padding */
338	#endif
339
340	/* We allocate a pbuf chain of pbufs from the pool. */
341	p = lwip_pbuf_alloc(PBUF_RAW, len, PBUF_POOL);
342	if (p != NULL)
343	{
344	#if ETH_PAD_SIZE
345	lwip_pbuf_header(p, -ETH_PAD_SIZE); /* drop the padding word */
346	#endif
347
348	for (q = p; q != NULL; q = q->next)
349	{
350	/* Fill the buffers, and clean out unused buffer space. */
351	memcpy(q->payload, pbBuf, RT_MIN(cb, q->len));
352	pbBuf += RT_MIN(cb, q->len);
353	if (q->len > cb)
354	memset(((uint8_t *)q->payload) + cb, '\0', q->len - cb);
355	cb -= RT_MIN(cb, q->len);
356	}
357
358	ethhdr = (const struct eth_hdr *)p->payload;
359	struct netif *iface = &g_pDevINIPData->IntNetIF;
360	err_t lrc;
361	switch (htons(ethhdr->type))
362	{
363	case ETHTYPE_IP: /* IP packet */
364	lwip_pbuf_header(p, -(ssize_t)sizeof(struct eth_hdr));
365	lrc = iface->input(p, iface);
366	if (lrc)
367	rc = VERR_NET_IO_ERROR;
368	break;
369	case ETHTYPE_ARP: /* ARP packet */
370	lwip_etharp_arp_input(iface, (struct eth_addr *)iface->hwaddr, p);
371	break;
372	default:
373	lwip_pbuf_free(p);
374	}
375	}
376
377	out:
378	LogFlow(("%s: return %Rrc\n", __FUNCTION__, rc));
379	return rc;
380	}
381
382	/**
383	* @interface_method_impl{PDMINETWORKDOWN,pfnXmitPending}
384	*/
385	static DECLCALLBACK(void) devINIPNetworkDown_XmitPending(PPDMINETWORKDOWN pInterface)
386	{
387	NOREF(pInterface);
388	}
389
390
391	/**
392	* Signals the end of lwIP TCPIP initialization.
393	*
394	* @param arg opaque argument, here the pointer to the semaphore.
395	*/
396	static DECLCALLBACK(void) devINIPTcpipInitDone(void *arg)
397	{
398	sys_sem_t sem = (sys_sem_t )arg;
399	lwip_sys_sem_signal(*sem);
400	}
401
402	/* -=-=-=-=- PDMIBASE -=-=-=-=- */
403
404	/**
405	* @interface_method_impl{PDMIBASE,pfnQueryInterface}
406	*/
407	static DECLCALLBACK(void *) devINIPQueryInterface(PPDMIBASE pInterface,
408	const char *pszIID)
409	{
410	PDEVINTNETIP pThis = RT_FROM_MEMBER(pInterface, DEVINTNETIP, IBase);
411	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pThis->IBase);
412	PDMIBASE_RETURN_INTERFACE(pszIID, PDMINETWORKDOWN, &pThis->INetworkDown);
413	return NULL;
414	}
415
416	/* -=-=-=-=- PDMDEVREG -=-=-=-=- */
417
418	/**
419	* Destruct a device instance.
420	*
421	* Most VM resources are freed by the VM. This callback is provided so that any non-VM
422	* resources can be freed correctly.
423	*
424	* @returns VBox status.
425	* @param pDevIns The device instance data.
426	*/
427	static DECLCALLBACK(int) devINIPDestruct(PPDMDEVINS pDevIns)
428	{
429	PDEVINTNETIP pThis = PDMINS_2_DATA(pDevIns, PDEVINTNETIP);
430
431	LogFlow(("%s: pDevIns=%p\n", __FUNCTION__, pDevIns));
432	PDMDEV_CHECK_VERSIONS_RETURN_QUIET(pDevIns);
433
434	if (g_pDevINIPData != NULL)
435	{
436	netif_set_down(&pThis->IntNetIF);
437	netif_remove(&pThis->IntNetIF);
438	tcpip_terminate();
439	lwip_sys_sem_wait(pThis->LWIPTcpInitSem);
440	lwip_sys_sem_free(pThis->LWIPTcpInitSem);
441	}
442
443	if (pThis->pszIP)
444	MMR3HeapFree(pThis->pszIP);
445	if (pThis->pszNetmask)
446	MMR3HeapFree(pThis->pszNetmask);
447	if (pThis->pszGateway)
448	MMR3HeapFree(pThis->pszGateway);
449
450	LogFlow(("%s: success\n", __FUNCTION__));
451	return VINF_SUCCESS;
452	}
453
454
455	/**
456	* @interface_method_impl{PDMDEVREG,pfnConstruct}
457	*/
458	static DECLCALLBACK(int) devINIPConstruct(PPDMDEVINS pDevIns, int iInstance,
459	PCFGMNODE pCfg)
460	{
461	PDEVINTNETIP pThis = PDMINS_2_DATA(pDevIns, PDEVINTNETIP);
462	int rc = VINF_SUCCESS;
463	LogFlow(("%s: pDevIns=%p iInstance=%d pCfg=%p\n", __FUNCTION__,
464	pDevIns, iInstance, pCfg));
465
466	Assert(iInstance == 0);
467	PDMDEV_CHECK_VERSIONS_RETURN(pDevIns);
468
469	/*
470	* Validate the config.
471	*/
472	if (!CFGMR3AreValuesValid(pCfg, "MAC\0IP\0Netmask\0Gateway\0"))
473	{
474	rc = PDMDEV_SET_ERROR(pDevIns, VERR_PDM_DEVINS_UNKNOWN_CFG_VALUES,
475	N_("Unknown Internal Networking IP configuration option"));
476	goto out;
477	}
478
479	/*
480	* Init the static parts.
481	*/
482	pThis->pszIP = NULL;
483	pThis->pszNetmask = NULL;
484	pThis->pszGateway = NULL;
485	/* Pointer to device instance */
486	pThis->pDevIns = pDevIns;
487	/* IBase */
488	pThis->IBase.pfnQueryInterface = devINIPQueryInterface;
489	/* INetworkDown */
490	pThis->INetworkDown.pfnWaitReceiveAvail = devINIPNetworkDown_WaitInputAvail;
491	pThis->INetworkDown.pfnReceive = devINIPNetworkDown_Input;
492	pThis->INetworkDown.pfnXmitPending = devINIPNetworkDown_XmitPending;
493
494	/*
495	* Get the configuration settings.
496	*/
497	rc = CFGMR3QueryBytes(pCfg, "MAC", &pThis->MAC, sizeof(pThis->MAC));
498	if (rc == VERR_CFGM_NOT_BYTES)
499	{
500	char szMAC[64];
501	rc = CFGMR3QueryString(pCfg, "MAC", &szMAC[0], sizeof(szMAC));
502	if (RT_SUCCESS(rc))
503	{
504	char *macStr = &szMAC[0];
505	char pMac = (char )&pThis->MAC;
506	for (uint32_t i = 0; i < 6; i++)
507	{
508	if ( !macStr \|\| !(macStr + 1)
509	\|\| macStr == ':' \|\| (macStr + 1) == ':')
510	{
511	rc = PDMDEV_SET_ERROR(pDevIns,
512	VERR_PDM_DEVINS_UNKNOWN_CFG_VALUES,
513	N_("Configuration error: Invalid \"MAC\" value"));
514	goto out;
515	}
516	char c1 = *macStr++ - '0';
517	if (c1 > 9)
518	c1 -= 7;
519	char c2 = *macStr++ - '0';
520	if (c2 > 9)
521	c2 -= 7;
522	*pMac++ = ((c1 & 0x0f) << 4) \| (c2 & 0x0f);
523	if (i != 5 && *macStr == ':')
524	macStr++;
525	}
526	}
527	}
528	if (RT_FAILURE(rc))
529	{
530	PDMDEV_SET_ERROR(pDevIns, rc,
531	N_("Configuration error: Failed to get the \"MAC\" value"));
532	goto out;
533	}
534	rc = CFGMR3QueryStringAlloc(pCfg, "IP", &pThis->pszIP);
535	if (RT_FAILURE(rc))
536	{
537	PDMDEV_SET_ERROR(pDevIns, rc,
538	N_("Configuration error: Failed to get the \"IP\" value"));
539	goto out;
540	}
541	rc = CFGMR3QueryStringAlloc(pCfg, "Netmask", &pThis->pszNetmask);
542	if (RT_FAILURE(rc))
543	{
544	PDMDEV_SET_ERROR(pDevIns, rc,
545	N_("Configuration error: Failed to get the \"Netmask\" value"));
546	goto out;
547	}
548	rc = CFGMR3QueryStringAlloc(pCfg, "Gateway", &pThis->pszGateway);
549	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
550	rc = VINF_SUCCESS;
551	if (RT_FAILURE(rc))
552	{
553	PDMDEV_SET_ERROR(pDevIns, rc,
554	N_("Configuration error: Failed to get the \"Gateway\" value"));
555	goto out;
556	}
557
558	/*
559	* Attach driver and query the network connector interface.
560	*/
561	rc = PDMDevHlpDriverAttach(pDevIns, 0, &pThis->IBase, &pThis->pDrvBase,
562	"Network Port");
563	if (RT_FAILURE(rc))
564	{
565	pThis->pDrvBase = NULL;
566	pThis->pDrv = NULL;
567	goto out;
568	}
569	else
570	{
571	pThis->pDrv = PDMIBASE_QUERY_INTERFACE(pThis->pDrvBase, PDMINETWORKUP);
572	if (!pThis->pDrv)
573	{
574	AssertMsgFailed(("Failed to obtain the PDMINETWORKUP interface!\n"));
575	rc = VERR_PDM_MISSING_INTERFACE_BELOW;
576	goto out;
577	}
578	}
579
580	struct ip_addr ipaddr, netmask, gw;
581	struct in_addr ip;
582
583	if (!inet_aton(pThis->pszIP, &ip))
584	{
585	rc = PDMDEV_SET_ERROR(pDevIns, VERR_PDM_DEVINS_UNKNOWN_CFG_VALUES,
586	N_("Configuration error: Invalid \"IP\" value"));
587	goto out;
588	}
589	memcpy(&ipaddr, &ip, sizeof(ipaddr));
590	if (!inet_aton(pThis->pszNetmask, &ip))
591	{
592	rc = PDMDEV_SET_ERROR(pDevIns, VERR_PDM_DEVINS_UNKNOWN_CFG_VALUES,
593	N_("Configuration error: Invalid \"Netmask\" value"));
594	goto out;
595	}
596	memcpy(&netmask, &ip, sizeof(netmask));
597	if (pThis->pszGateway)
598	{
599	if (!inet_aton(pThis->pszGateway, &ip))
600	{
601	rc = PDMDEV_SET_ERROR(pDevIns,
602	VERR_PDM_DEVINS_UNKNOWN_CFG_VALUES,
603	N_("Configuration error: Invalid \"Gateway\" value"));
604	goto out;
605	}
606	memcpy(&gw, &ip, sizeof(gw));
607	}
608	else
609	{
610	inet_aton(pThis->pszIP, &ip);
611	memcpy(&gw, &ip, sizeof(gw));
612	}
613
614	/*
615	* Initialize lwIP.
616	*/
617	lwip_stats_init();
618	lwip_sys_init();
619	#if MEM_LIBC_MALLOC == 0
620	lwip_mem_init();
621	#endif
622	lwip_memp_init();
623	lwip_pbuf_init();
624	lwip_netif_init();
625	rc = PDMDevHlpTMTimerCreate(pDevIns, TMCLOCK_VIRTUAL, devINIPARPTimer, pThis,
626	TMTIMER_FLAGS_NO_CRIT_SECT, "lwIP ARP", &pThis->ARPTimer);
627	if (RT_FAILURE(rc))
628	goto out;
629	rc = PDMDevHlpTMTimerCreate(pDevIns, TMCLOCK_VIRTUAL, devINIPTCPFastTimer, pThis,
630	TMTIMER_FLAGS_NO_CRIT_SECT, "lwIP fast TCP", &pThis->TCPFastTimer);
631	if (RT_FAILURE(rc))
632	goto out;
633	TMTimerSetMillies(pThis->TCPFastTimer, TCP_FAST_INTERVAL);
634	rc = PDMDevHlpTMTimerCreate(pDevIns, TMCLOCK_VIRTUAL, devINIPTCPSlowTimer, pThis,
635	TMTIMER_FLAGS_NO_CRIT_SECT, "lwIP slow TCP", &pThis->TCPSlowTimer);
636	if (RT_FAILURE(rc))
637	goto out;
638	TMTimerSetMillies(pThis->TCPFastTimer, TCP_SLOW_INTERVAL);
639	pThis->LWIPTcpInitSem = lwip_sys_sem_new(0);
640	{
641	lwip_tcpip_init(devINIPTcpipInitDone, &pThis->LWIPTcpInitSem);
642	lwip_sys_sem_wait(pThis->LWIPTcpInitSem);
643	}
644
645	/*
646	* Set up global pointer to interface data.
647	*/
648	g_pDevINIPData = pThis;
649
650	struct netif *ret;
651	pThis->IntNetIF.name[0] = 'I';
652	pThis->IntNetIF.name[1] = 'N';
653	ret = netif_add(&pThis->IntNetIF, &ipaddr, &netmask, &gw, NULL,
654	devINIPInterface, lwip_tcpip_input);
655	if (!ret)
656	{
657	rc = VERR_NET_NO_NETWORK;
658	goto out;
659	}
660
661	lwip_netif_set_default(&pThis->IntNetIF);
662	lwip_netif_set_up(&pThis->IntNetIF);
663
664	/* link hack */
665	pThis->pLinkHack = g_pDevINILinkHack;
666
667	out:
668	LogFlow(("%s: return %Rrc\n", __FUNCTION__, rc));
669	return rc;
670	}
671
672
673	/**
674	* Query whether lwIP is initialized or not. Since there is only a single
675	* instance of this device ever for a VM, it can be a global function.
676	*
677	* @returns True if lwIP is initialized.
678	*/
679	bool DevINIPConfigured(void)
680	{
681	return g_pDevINIPData != NULL;
682	}
683
684
685	/**
686	* Internal network IP stack device registration record.
687	*/
688	const PDMDEVREG g_DeviceINIP =
689	{
690	/* u32Version */
691	PDM_DEVREG_VERSION,
692	/* szName */
693	"IntNetIP",
694	/* szRCMod/szR0Mod */
695	"",
696	"",
697	/* pszDescription */
698	"Internal Network IP stack device",
699	/* fFlags */
700	PDM_DEVREG_FLAGS_DEFAULT_BITS,
701	/* fClass. As this is used by the storage devices, it must come earlier. */
702	PDM_DEVREG_CLASS_VMM_DEV,
703	/* cMaxInstances */
704	1,
705	/* cbInstance */
706	sizeof(DEVINTNETIP),
707	/* pfnConstruct */
708	devINIPConstruct,
709	/* pfnDestruct */
710	devINIPDestruct,
711	/* pfnRelocate */
712	NULL,
713	/* pfnIOCtl */
714	NULL,
715	/* pfnPowerOn */
716	NULL,
717	/* pfnReset */
718	NULL,
719	/* pfnSuspend */
720	NULL,
721	/* pfnResume */
722	NULL,
723	/* pfnAttach */
724	NULL,
725	/* pfnDetach */
726	NULL,
727	/* pfnQueryInterface */
728	NULL,
729	/* pfnInitComplete */
730	NULL,
731	/* pfnPowerOff */
732	NULL,
733	/* pfnSoftReset */
734	NULL,
735	/* u32VersionEnd */
736	PDM_DEVREG_VERSION
737	};

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

source: vbox/trunk/src/VBox/Devices/Network/DevINIP.cpp@ 30351

Download in other formats: