DevINIP.cpp@ 69250

Last change on this file since 69250 was 63562, checked in by vboxsync, 8 years ago
scm: cleaning up todos
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 24.4 KB

Line
1	/* $Id: DevINIP.cpp 63562 2016-08-16 14:04:03Z vboxsync $ */
2	/** @file
3	* DevINIP - Internal Network IP stack device/service.
4	*/
5
6	/*
7	* Copyright (C) 2007-2016 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 "lwip/api.h"
37	#include "lwip/tcp_impl.h"
38	# if LWIP_IPV6
39	# include "ipv6/lwip/ethip6.h"
40	# endif
41	#include "lwip/udp.h"
42	#include "lwip/tcp.h"
43	#include "lwip/tcpip.h"
44	#include "lwip/sockets.h"
45	#include "netif/etharp.h"
46	RT_C_DECLS_END
47	#include <VBox/vmm/pdmdev.h>
48	#include <VBox/vmm/pdmnetifs.h>
49	#include <VBox/vmm/tm.h>
50	#include <iprt/assert.h>
51	#include <iprt/string.h>
52	#include <iprt/uuid.h>
53
54	#include "VBoxDD.h"
55	#include "VBoxLwipCore.h"
56
57
58	/*********************************************************************************************************************************
59	* Macros and Defines *
60	*********************************************************************************************************************************/
61
62	/** Maximum frame size this device can handle. */
63	#define DEVINIP_MAX_FRAME 1514
64
65
66	/*********************************************************************************************************************************
67	* Structures and Typedefs *
68	*********************************************************************************************************************************/
69
70	/**
71	* Internal Network IP stack device instance data.
72	*
73	* @implements PDMIBASE
74	* @implements PDMINETWORKDOWN
75	*/
76	typedef struct DEVINTNETIP
77	{
78	/** The base interface for LUN\#0. */
79	PDMIBASE IBase;
80	/** The network port this device provides (LUN\#0). */
81	PDMINETWORKDOWN INetworkDown;
82	/** The network configuration port this device provides (LUN\#0). */
83	PDMINETWORKCONFIG INetworkConfig;
84	/** The base interface of the network driver below us. */
85	PPDMIBASE pDrvBase;
86	/** The connector of the network driver below us. */
87	PPDMINETWORKUP pDrv;
88	/** Pointer to the device instance. */
89	PPDMDEVINSR3 pDevIns;
90	/** MAC address. */
91	RTMAC MAC;
92	/** Static IP address of the interface. */
93	char *pszIP;
94	/** Netmask of the interface. */
95	char *pszNetmask;
96	/** Gateway for the interface. */
97	char *pszGateway;
98	/** lwIP network interface description. */
99	struct netif IntNetIF;
100	/** lwIP ARP timer. */
101	PTMTIMERR3 ARPTimer;
102	/** lwIP TCP fast timer. */
103	PTMTIMERR3 TCPFastTimer;
104	/** lwIP TCP slow timer. */
105	PTMTIMERR3 TCPSlowTimer;
106	/** lwIP semaphore to coordinate TCPIP init/terminate. */
107	sys_sem_t LWIPTcpInitSem;
108	/** hack: get linking right. remove this eventually, once the device
109	* provides a proper interface to all IP stack functions. */
110	const void *pLinkHack;
111	/** Flag whether the link is up. */
112	bool fLnkUp;
113	/**
114	* In callback we're getting status of interface adding operation (TCPIP thread),
115	* but we need inform constructing routine whether it was success or not(EMT thread).
116	*/
117	int rcInitialization;
118	} DEVINTNETIP, *PDEVINTNETIP;
119
120
121	/*********************************************************************************************************************************
122	* Global Variables *
123	*********************************************************************************************************************************/
124
125	/**
126	* Pointer to the (only) instance data in this device.
127	*/
128	static PDEVINTNETIP g_pDevINIPData = NULL;
129
130	/*
131	* really ugly hack to avoid linking problems on unix style platforms
132	* using .a libraries for now.
133	*/
134	static const PFNRT g_pDevINILinkHack[] =
135	{
136	(PFNRT)lwip_socket,
137	(PFNRT)lwip_close,
138	(PFNRT)lwip_setsockopt,
139	(PFNRT)lwip_recv,
140	(PFNRT)lwip_send,
141	(PFNRT)lwip_select
142	};
143
144
145	#if 0 /* unused */
146	/**
147	* Output a TCP/IP packet on the interface. Uses the generic lwIP ARP
148	* code to resolve the address and call the link-level packet function.
149	*
150	* @returns lwIP error code
151	* @param netif Interface on which to send IP packet.
152	* @param p Packet data.
153	* @param ipaddr Destination IP address.
154	*/
155	static err_t devINIPOutput(struct netif netif, struct pbuf p, struct ip_addr *ipaddr)
156	{
157	err_t lrc;
158	LogFlow(("%s: netif=%p p=%p ipaddr=%#04x\n", __FUNCTION__, netif, p,
159	ipaddr->addr));
160
161	lrc = lwip_etharp_output(netif, p, ipaddr);
162
163	LogFlow(("%s: return %d\n", __FUNCTION__, lrc));
164	return lrc;
165	}
166	#endif
167
168	/**
169	* Output a raw packet on the interface.
170	*
171	* @returns lwIP error code
172	* @param netif Interface on which to send frame.
173	* @param p Frame data.
174	*/
175	static err_t devINIPOutputRaw(struct netif netif, struct pbuf p)
176	{
177	NOREF(netif);
178	int rc = VINF_SUCCESS;
179
180	LogFlow(("%s: netif=%p p=%p\n", __FUNCTION__, netif, p));
181	Assert(g_pDevINIPData);
182	Assert(g_pDevINIPData->pDrv);
183
184	/* Silently ignore packets being sent while lwIP isn't set up. */
185	if (g_pDevINIPData)
186	{
187	PPDMSCATTERGATHER pSgBuf;
188
189	rc = g_pDevINIPData->pDrv->pfnBeginXmit(g_pDevINIPData->pDrv, true /* fOnWorkerThread */);
190	if (RT_FAILURE(rc))
191	return ERR_IF;
192
193	rc = g_pDevINIPData->pDrv->pfnAllocBuf(g_pDevINIPData->pDrv, DEVINIP_MAX_FRAME, NULL /pGso/, &pSgBuf);
194	if (RT_SUCCESS(rc))
195	{
196	#if ETH_PAD_SIZE
197	lwip_pbuf_header(p, -ETH_PAD_SIZE); /* drop the padding word */
198	#endif
199
200	uint8_t pbBuf = pSgBuf ? (uint8_t )pSgBuf->aSegs[0].pvSeg : NULL;
201	size_t cbBuf = 0;
202	for (struct pbuf *q = p; q != NULL; q = q->next)
203	{
204	if (cbBuf + q->len <= DEVINIP_MAX_FRAME)
205	{
206	if (RT_LIKELY(pbBuf))
207	{
208	memcpy(pbBuf, q->payload, q->len);
209	pbBuf += q->len;
210	}
211	cbBuf += q->len;
212	}
213	else
214	{
215	LogRel(("INIP: exceeded frame size\n"));
216	break;
217	}
218	}
219	if (cbBuf)
220	{
221	pSgBuf->cbUsed = cbBuf;
222	rc = g_pDevINIPData->pDrv->pfnSendBuf(g_pDevINIPData->pDrv, pSgBuf, true /* fOnWorkerThread */);
223	}
224	else
225	rc = g_pDevINIPData->pDrv->pfnFreeBuf(g_pDevINIPData->pDrv, pSgBuf);
226
227	#if ETH_PAD_SIZE
228	lwip_pbuf_header(p, ETH_PAD_SIZE); /* reclaim the padding word */
229	#endif
230	}
231
232	g_pDevINIPData->pDrv->pfnEndXmit(g_pDevINIPData->pDrv);
233	}
234
235	err_t lrc = ERR_OK;
236	if (RT_FAILURE(rc))
237	lrc = ERR_IF;
238	LogFlow(("%s: return %d (vbox: %Rrc)\n", __FUNCTION__, rc, lrc));
239	return lrc;
240	}
241
242	/**
243	* Implements the ethernet interface backend initialization for lwIP.
244	*
245	* @returns lwIP error code
246	* @param netif Interface to configure.
247	*/
248	static err_t devINIPInterface(struct netif *netif)
249	{
250	LogFlow(("%s: netif=%p\n", __FUNCTION__, netif));
251	Assert(g_pDevINIPData != NULL);
252	netif->state = g_pDevINIPData;
253	netif->hwaddr_len = sizeof(g_pDevINIPData->MAC);
254	memcpy(netif->hwaddr, &g_pDevINIPData->MAC, sizeof(g_pDevINIPData->MAC));
255	netif->mtu = DEVINIP_MAX_FRAME;
256	netif->flags = NETIF_FLAG_BROADCAST;
257	netif->flags \|= NETIF_FLAG_ETHARP;
258	netif->flags \|= NETIF_FLAG_ETHERNET;
259
260	#if LWIP_IPV6
261	netif_create_ip6_linklocal_address(netif, 0);
262	netif_ip6_addr_set_state(netif, 0, IP6_ADDR_VALID);
263	netif->output_ip6 = ethip6_output;
264	netif->ip6_autoconfig_enabled=1;
265	LogFunc(("netif: ipv6:%RTnaipv6\n", &netif->ip6_addr[0].addr[0]));
266	#endif
267
268	netif->output = lwip_etharp_output;
269	netif->linkoutput = devINIPOutputRaw;
270
271	LogFlow(("%s: success\n", __FUNCTION__));
272	return ERR_OK;
273	}
274
275	/**
276	* Parses CFGM parameters related to network connection
277	*/
278	static DECLCALLBACK(int) devINIPNetworkConfiguration(PPDMDEVINS pDevIns, PDEVINTNETIP pThis, PCFGMNODE pCfg)
279	{
280	int rc = VINF_SUCCESS;
281	rc = CFGMR3QueryStringAlloc(pCfg, "IP", &pThis->pszIP);
282	if (RT_FAILURE(rc))
283	{
284	PDMDEV_SET_ERROR(pDevIns, rc,
285	N_("Configuration error: Failed to get the \"IP\" value"));
286	/** @todo perhaps we should panic if IPv4 address isn't specify, with assumtion that
287	* ISCSI target specified in IPv6 form.
288	*/
289	return rc;
290	}
291
292	rc = CFGMR3QueryStringAlloc(pCfg, "Netmask", &pThis->pszNetmask);
293	if (RT_FAILURE(rc))
294	{
295	PDMDEV_SET_ERROR(pDevIns, rc,
296	N_("Configuration error: Failed to get the \"Netmask\" value"));
297	return rc;
298	}
299	rc = CFGMR3QueryStringAlloc(pCfg, "Gateway", &pThis->pszGateway);
300	if ( RT_FAILURE(rc)
301	&& rc != VERR_CFGM_VALUE_NOT_FOUND)
302	{
303	PDMDEV_SET_ERROR(pDevIns, rc,
304	N_("Configuration error: Failed to get the \"Gateway\" value"));
305	return rc;
306	}
307	return VINF_SUCCESS;
308	}
309
310	/**
311	* Wait until data can be received.
312	*
313	* @returns VBox status code. VINF_SUCCESS means there is at least one receive descriptor available.
314	* @param pInterface PDM network port interface pointer.
315	* @param cMillies Number of milliseconds to wait. 0 means return immediately.
316	*/
317	static DECLCALLBACK(int) devINIPNetworkDown_WaitInputAvail(PPDMINETWORKDOWN pInterface, RTMSINTERVAL cMillies)
318	{
319	RT_NOREF(pInterface, cMillies);
320	LogFlow(("%s: pInterface=%p\n", __FUNCTION__, pInterface));
321	LogFlow(("%s: return VINF_SUCCESS\n", __FUNCTION__));
322	return VINF_SUCCESS;
323	}
324
325	/**
326	* Receive data and pass it to lwIP for processing.
327	*
328	* @returns VBox status code
329	* @param pInterface PDM network port interface pointer.
330	* @param pvBuf Pointer to frame data.
331	* @param cb Frame size.
332	*/
333	static DECLCALLBACK(int) devINIPNetworkDown_Input(PPDMINETWORKDOWN pInterface, const void *pvBuf, size_t cb)
334	{
335	RT_NOREF(pInterface);
336	const uint8_t pbBuf = (const uint8_t )pvBuf;
337	size_t len = cb;
338	const struct eth_hdr *ethhdr;
339	struct pbuf p, q;
340
341	LogFlow(("%s: pInterface=%p pvBuf=%p cb=%lu\n", __FUNCTION__, pInterface, pvBuf, cb));
342	Assert(g_pDevINIPData);
343	Assert(g_pDevINIPData->pDrv);
344
345	/* Silently ignore packets being received while lwIP isn't set up. */
346	if (!g_pDevINIPData)
347	{
348	LogFlow(("%s: return %Rrc (no global)\n", __FUNCTION__, VINF_SUCCESS));
349	return VINF_SUCCESS;
350	}
351
352	#if ETH_PAD_SIZE
353	len += ETH_PAD_SIZE; /* allow room for Ethernet padding */
354	#endif
355
356	/* We allocate a pbuf chain of pbufs from the pool. */
357	Assert((u16_t)len == len);
358	p = lwip_pbuf_alloc(PBUF_RAW, (u16_t)len, PBUF_POOL);
359	if (p != NULL)
360	{
361	#if ETH_PAD_SIZE
362	lwip_pbuf_header(p, -ETH_PAD_SIZE); /* drop the padding word */
363	#endif
364
365	for (q = p; q != NULL; q = q->next)
366	{
367	/* Fill the buffers, and clean out unused buffer space. */
368	memcpy(q->payload, pbBuf, RT_MIN(cb, q->len));
369	pbBuf += RT_MIN(cb, q->len);
370	if (q->len > cb)
371	memset(((uint8_t *)q->payload) + cb, '\0', q->len - cb);
372	cb -= RT_MIN(cb, q->len);
373	}
374
375	ethhdr = (const struct eth_hdr *)p->payload;
376	struct netif *iface = &g_pDevINIPData->IntNetIF;
377
378	/* We've setup flags NETIF_FLAG_ETHARP and NETIF_FLAG_ETHERNET
379	so this should be thread-safe. */
380	tcpip_input(p,iface);
381	}
382
383	LogFlow(("%s: return %Rrc\n", __FUNCTION__, VINF_SUCCESS));
384	return VINF_SUCCESS;
385	}
386
387	/**
388	* @interface_method_impl{PDMINETWORKDOWN,pfnXmitPending}
389	*/
390	static DECLCALLBACK(void) devINIPNetworkDown_XmitPending(PPDMINETWORKDOWN pInterface)
391	{
392	NOREF(pInterface);
393	}
394
395
396	/**
397	* Signals the end of lwIP TCPIP initialization.
398	*
399	* @note: TCPIP thread, corresponding EMT waiting on semaphore.
400	* @param arg opaque argument, here the pointer to the PDEVINTNETIP.
401	*/
402	static DECLCALLBACK(void) devINIPTcpipInitDone(void *arg)
403	{
404	PDEVINTNETIP pThis = (PDEVINTNETIP)arg;
405	AssertPtrReturnVoid(arg);
406
407	pThis->rcInitialization = VINF_SUCCESS;
408	{
409	struct netif *ret;
410	struct ip_addr ipaddr, netmask, gw;
411	struct in_addr ip;
412
413	if (!inet_aton(pThis->pszIP, &ip))
414	{
415	pThis->rcInitialization = VERR_PDM_DEVINS_UNKNOWN_CFG_VALUES;
416	PDMDEV_SET_ERROR(pThis->pDevIns,
417	pThis->rcInitialization,
418	N_("Configuration error: Invalid \"IP\" value"));
419	goto done;
420	}
421	memcpy(&ipaddr, &ip, sizeof(ipaddr));
422
423	if (!inet_aton(pThis->pszNetmask, &ip))
424	{
425	pThis->rcInitialization = VERR_PDM_DEVINS_UNKNOWN_CFG_VALUES;
426	PDMDEV_SET_ERROR(pThis->pDevIns,
427	pThis->rcInitialization,
428	N_("Configuration error: Invalid \"Netmask\" value"));
429	goto done;
430	}
431	memcpy(&netmask, &ip, sizeof(netmask));
432
433	if (pThis->pszGateway)
434	{
435	if (!inet_aton(pThis->pszGateway, &ip))
436	{
437	pThis->rcInitialization = VERR_PDM_DEVINS_UNKNOWN_CFG_VALUES;
438	PDMDEV_SET_ERROR(pThis->pDevIns,
439	pThis->rcInitialization,
440	N_("Configuration error: Invalid \"Gateway\" value"));
441	goto done;
442	}
443
444	}
445	else
446	{
447	inet_aton(pThis->pszIP, &ip);
448	}
449	memcpy(&gw, &ip, sizeof(gw));
450
451	pThis->IntNetIF.name[0] = 'I';
452	pThis->IntNetIF.name[1] = 'N';
453
454	ret = netif_add(&pThis->IntNetIF, &ipaddr, &netmask, &gw, NULL,
455	devINIPInterface, lwip_tcpip_input);
456
457	if (!ret)
458	{
459
460	pThis->rcInitialization = VERR_NET_NO_NETWORK;
461	PDMDEV_SET_ERROR(pThis->pDevIns,
462	pThis->rcInitialization,
463	N_("netif_add failed"));
464	goto done;
465	}
466
467	lwip_netif_set_default(&pThis->IntNetIF);
468	lwip_netif_set_up(&pThis->IntNetIF);
469	}
470	done:
471	return;
472	}
473
474
475	/**
476	* This callback is for finitializing our activity on TCPIP thread.
477	* XXX: We do it only for new LWIP, old LWIP will stay broken for now.
478	*/
479	static DECLCALLBACK(void) devINIPTcpipFiniDone(void *arg)
480	{
481	PDEVINTNETIP pThis = (PDEVINTNETIP)arg;
482	AssertPtrReturnVoid(arg);
483
484	netif_set_link_down(&pThis->IntNetIF);
485	netif_set_down(&pThis->IntNetIF);
486	netif_remove(&pThis->IntNetIF);
487	}
488
489
490	/**
491	* Gets the current Media Access Control (MAC) address.
492	*
493	* @returns VBox status code.
494	* @param pInterface Pointer to the interface structure containing the called function pointer.
495	* @param pMac Where to store the MAC address.
496	* @thread EMT
497	*/
498	static DECLCALLBACK(int) devINIPGetMac(PPDMINETWORKCONFIG pInterface, PRTMAC pMac)
499	{
500	PDEVINTNETIP pThis = RT_FROM_MEMBER(pInterface, DEVINTNETIP, INetworkConfig);
501	memcpy(pMac, pThis->MAC.au8, sizeof(RTMAC));
502	return VINF_SUCCESS;
503	}
504
505	/**
506	* Gets the new link state.
507	*
508	* @returns The current link state.
509	* @param pInterface Pointer to the interface structure containing the called function pointer.
510	* @thread EMT
511	*/
512	static DECLCALLBACK(PDMNETWORKLINKSTATE) devINIPGetLinkState(PPDMINETWORKCONFIG pInterface)
513	{
514	PDEVINTNETIP pThis = RT_FROM_MEMBER(pInterface, DEVINTNETIP, INetworkConfig);
515	if (pThis->fLnkUp)
516	return PDMNETWORKLINKSTATE_UP;
517	return PDMNETWORKLINKSTATE_DOWN;
518	}
519
520
521	/**
522	* Sets the new link state.
523	*
524	* @returns VBox status code.
525	* @param pInterface Pointer to the interface structure containing the called function pointer.
526	* @param enmState The new link state
527	*/
528	static DECLCALLBACK(int) devINIPSetLinkState(PPDMINETWORKCONFIG pInterface, PDMNETWORKLINKSTATE enmState)
529	{
530	PDEVINTNETIP pThis = RT_FROM_MEMBER(pInterface, DEVINTNETIP, INetworkConfig);
531	bool fNewUp = enmState == PDMNETWORKLINKSTATE_UP;
532
533	if (fNewUp != pThis->fLnkUp)
534	{
535	if (fNewUp)
536	{
537	LogFlowFunc(("Link is up\n"));
538	pThis->fLnkUp = true;
539	}
540	else
541	{
542	LogFlowFunc(("Link is down\n"));
543	pThis->fLnkUp = false;
544	}
545	if (pThis->pDrv)
546	pThis->pDrv->pfnNotifyLinkChanged(pThis->pDrv, enmState);
547	}
548	return VINF_SUCCESS;
549	}
550
551	/* -=-=-=-=- PDMIBASE -=-=-=-=- */
552
553	/**
554	* @interface_method_impl{PDMIBASE,pfnQueryInterface}
555	*/
556	static DECLCALLBACK(void *) devINIPQueryInterface(PPDMIBASE pInterface,
557	const char *pszIID)
558	{
559	PDEVINTNETIP pThis = RT_FROM_MEMBER(pInterface, DEVINTNETIP, IBase);
560	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pThis->IBase);
561	PDMIBASE_RETURN_INTERFACE(pszIID, PDMINETWORKDOWN, &pThis->INetworkDown);
562	PDMIBASE_RETURN_INTERFACE(pszIID, PDMINETWORKCONFIG, &pThis->INetworkConfig);
563	return NULL;
564	}
565
566	/* -=-=-=-=- PDMDEVREG -=-=-=-=- */
567
568	/**
569	* Destruct a device instance.
570	*
571	* Most VM resources are freed by the VM. This callback is provided so that any non-VM
572	* resources can be freed correctly.
573	*
574	* @returns VBox status code.
575	* @param pDevIns The device instance data.
576	*/
577	static DECLCALLBACK(int) devINIPDestruct(PPDMDEVINS pDevIns)
578	{
579	PDEVINTNETIP pThis = PDMINS_2_DATA(pDevIns, PDEVINTNETIP);
580
581	LogFlow(("%s: pDevIns=%p\n", __FUNCTION__, pDevIns));
582	PDMDEV_CHECK_VERSIONS_RETURN_QUIET(pDevIns);
583
584	if (g_pDevINIPData != NULL)
585	vboxLwipCoreFinalize(devINIPTcpipFiniDone, pThis);
586
587	MMR3HeapFree(pThis->pszIP);
588	pThis->pszIP = NULL;
589	MMR3HeapFree(pThis->pszNetmask);
590	pThis->pszNetmask = NULL;
591	MMR3HeapFree(pThis->pszGateway);
592	pThis->pszGateway = NULL;
593
594	LogFlow(("%s: success\n", __FUNCTION__));
595	return VINF_SUCCESS;
596	}
597
598
599	/**
600	* @interface_method_impl{PDMDEVREG,pfnConstruct}
601	*/
602	static DECLCALLBACK(int) devINIPConstruct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfg)
603	{
604	RT_NOREF(iInstance);
605	PDEVINTNETIP pThis = PDMINS_2_DATA(pDevIns, PDEVINTNETIP);
606
607	LogFlow(("%s: pDevIns=%p iInstance=%d pCfg=%p\n", __FUNCTION__,
608	pDevIns, iInstance, pCfg));
609
610	Assert(iInstance == 0);
611	PDMDEV_CHECK_VERSIONS_RETURN(pDevIns);
612
613	/*
614	* Validate the config.
615	*/
616	if (!CFGMR3AreValuesValid(pCfg, "MAC\0IP\0"
617	"IPv6\0"
618	"Netmask\0Gateway\0"))
619	return PDMDEV_SET_ERROR(pDevIns, VERR_PDM_DEVINS_UNKNOWN_CFG_VALUES,
620	N_("Unknown Internal Networking IP configuration option"));
621
622	/*
623	* Init the static parts.
624	*/
625	pThis->pszIP = NULL;
626	pThis->pszNetmask = NULL;
627	pThis->pszGateway = NULL;
628	/* Pointer to device instance */
629	pThis->pDevIns = pDevIns;
630	/* IBase */
631	pThis->IBase.pfnQueryInterface = devINIPQueryInterface;
632	/* INetworkDown */
633	pThis->INetworkDown.pfnWaitReceiveAvail = devINIPNetworkDown_WaitInputAvail;
634	pThis->INetworkDown.pfnReceive = devINIPNetworkDown_Input;
635	pThis->INetworkDown.pfnXmitPending = devINIPNetworkDown_XmitPending;
636	/* INetworkConfig */
637	pThis->INetworkConfig.pfnGetMac = devINIPGetMac;
638	pThis->INetworkConfig.pfnGetLinkState = devINIPGetLinkState;
639	pThis->INetworkConfig.pfnSetLinkState = devINIPSetLinkState;
640
641	/*
642	* Get the configuration settings.
643	*/
644	int rc = CFGMR3QueryBytes(pCfg, "MAC", &pThis->MAC, sizeof(pThis->MAC));
645	if (rc == VERR_CFGM_NOT_BYTES)
646	{
647	char szMAC[64];
648	rc = CFGMR3QueryString(pCfg, "MAC", &szMAC[0], sizeof(szMAC));
649	if (RT_SUCCESS(rc))
650	{
651	char *macStr = &szMAC[0];
652	char pMac = (char )&pThis->MAC;
653	for (uint32_t i = 0; i < 6; i++)
654	{
655	if ( !macStr \|\| !(macStr + 1)
656	\|\| macStr == ':' \|\| (macStr + 1) == ':')
657	return PDMDEV_SET_ERROR(pDevIns,
658	VERR_PDM_DEVINS_UNKNOWN_CFG_VALUES,
659	N_("Configuration error: Invalid \"MAC\" value"));
660	char c1 = *macStr++ - '0';
661	if (c1 > 9)
662	c1 -= 7;
663	char c2 = *macStr++ - '0';
664	if (c2 > 9)
665	c2 -= 7;
666	*pMac++ = ((c1 & 0x0f) << 4) \| (c2 & 0x0f);
667	if (i != 5 && *macStr == ':')
668	macStr++;
669	}
670	}
671	}
672	if (RT_FAILURE(rc))
673	return PDMDEV_SET_ERROR(pDevIns, rc,
674	N_("Configuration error: Failed to get the \"MAC\" value"));
675	rc = devINIPNetworkConfiguration(pDevIns, pThis, pCfg);
676	AssertLogRelRCReturn(rc, rc);
677
678	/*
679	* Attach driver and query the network connector interface.
680	*/
681	rc = PDMDevHlpDriverAttach(pDevIns, 0, &pThis->IBase, &pThis->pDrvBase, "Network Port");
682	if (RT_FAILURE(rc))
683	{
684	pThis->pDrvBase = NULL;
685	pThis->pDrv = NULL;
686	return PDMDEV_SET_ERROR(pDevIns, rc, N_("Error attaching device below us"));
687	}
688	pThis->pDrv = PDMIBASE_QUERY_INTERFACE(pThis->pDrvBase, PDMINETWORKUP);
689	AssertMsgReturn(pThis->pDrv, ("Failed to obtain the PDMINETWORKUP interface!\n"), VERR_PDM_MISSING_INTERFACE_BELOW);
690
691
692	/*
693	* Set up global pointer to interface data.
694	*/
695	g_pDevINIPData = pThis;
696
697
698	/* link hack */
699	pThis->pLinkHack = g_pDevINILinkHack;
700
701	/*
702	* Initialize lwIP.
703	*/
704	vboxLwipCoreInitialize(devINIPTcpipInitDone, pThis);
705
706	/* this rc could be updated in devINIPTcpInitDone thread */
707	AssertRCReturn(pThis->rcInitialization, pThis->rcInitialization);
708
709
710	LogFlow(("%s: return %Rrc\n", __FUNCTION__, rc));
711	return rc;
712	}
713
714
715	/**
716	* Query whether lwIP is initialized or not. Since there is only a single
717	* instance of this device ever for a VM, it can be a global function.
718	*
719	* @returns True if lwIP is initialized.
720	*/
721	bool DevINIPConfigured(void)
722	{
723	return g_pDevINIPData != NULL;
724	}
725
726
727	/**
728	* Internal network IP stack device registration record.
729	*/
730	const PDMDEVREG g_DeviceINIP =
731	{
732	/* u32Version */
733	PDM_DEVREG_VERSION,
734	/* szName */
735	"IntNetIP",
736	/* szRCMod/szR0Mod */
737	"",
738	"",
739	/* pszDescription */
740	"Internal Network IP stack device",
741	/* fFlags */
742	PDM_DEVREG_FLAGS_DEFAULT_BITS,
743	/* fClass. As this is used by the storage devices, it must come earlier. */
744	PDM_DEVREG_CLASS_VMM_DEV,
745	/* cMaxInstances */
746	1,
747	/* cbInstance */
748	sizeof(DEVINTNETIP),
749	/* pfnConstruct */
750	devINIPConstruct,
751	/* pfnDestruct */
752	devINIPDestruct,
753	/* pfnRelocate */
754	NULL,
755	/* pfnMemSetup */
756	NULL,
757	/* pfnPowerOn */
758	NULL,
759	/* pfnReset */
760	NULL,
761	/* pfnSuspend */
762	NULL,
763	/* pfnResume */
764	NULL,
765	/* pfnAttach */
766	NULL,
767	/* pfnDetach */
768	NULL,
769	/* pfnQueryInterface */
770	NULL,
771	/* pfnInitComplete */
772	NULL,
773	/* pfnPowerOff */
774	NULL,
775	/* pfnSoftReset */
776	NULL,
777	/* u32VersionEnd */
778	PDM_DEVREG_VERSION
779	};

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

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

Download in other formats: