DrvTAP.cpp@ 105381

Last change on this file since 105381 was 98103, checked in by vboxsync, 23 months ago
Copyright year updates by scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 37.6 KB

Line
1	/* $Id: DrvTAP.cpp 98103 2023-01-17 14:15:46Z vboxsync $ */
2	/** @file
3	* DrvTAP - Universal TAP network transport driver.
4	*/
5
6	/*
7	* Copyright (C) 2006-2023 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* SPDX-License-Identifier: GPL-3.0-only
26	*/
27
28
29	/*********************************************************************************************************************************
30	* Header Files *
31	*********************************************************************************************************************************/
32	#define LOG_GROUP LOG_GROUP_DRV_TUN
33	#include <VBox/log.h>
34	#include <VBox/vmm/pdmdrv.h>
35	#include <VBox/vmm/pdmnetifs.h>
36	#include <VBox/vmm/pdmnetinline.h>
37
38	#include <iprt/asm.h>
39	#include <iprt/assert.h>
40	#include <iprt/ctype.h>
41	#include <iprt/file.h>
42	#include <iprt/mem.h>
43	#include <iprt/path.h>
44	#include <iprt/pipe.h>
45	#include <iprt/semaphore.h>
46	#include <iprt/string.h>
47	#include <iprt/thread.h>
48	#include <iprt/uuid.h>
49	#ifdef RT_OS_SOLARIS
50	# include <iprt/process.h>
51	# include <iprt/env.h>
52	#endif
53
54	#include <sys/ioctl.h>
55	#include <sys/poll.h>
56	#ifdef RT_OS_SOLARIS
57	# include <sys/stat.h>
58	# include <sys/ethernet.h>
59	# include <sys/sockio.h>
60	# include <netinet/in.h>
61	# include <netinet/in_systm.h>
62	# include <netinet/ip.h>
63	# include <netinet/ip_icmp.h>
64	# include <netinet/udp.h>
65	# include <netinet/tcp.h>
66	# include <net/if.h>
67	# include <stropts.h>
68	# include <fcntl.h>
69	# include <stdlib.h>
70	# include <stdio.h>
71	#else
72	# include <sys/fcntl.h>
73	#endif
74	#include <errno.h>
75	#include <unistd.h>
76
77	#include "VBoxDD.h"
78
79
80	/*********************************************************************************************************************************
81	* Structures and Typedefs *
82	*********************************************************************************************************************************/
83	/**
84	* TAP driver instance data.
85	*
86	* @implements PDMINETWORKUP
87	*/
88	typedef struct DRVTAP
89	{
90	/** The network interface. */
91	PDMINETWORKUP INetworkUp;
92	/** The network interface. */
93	PPDMINETWORKDOWN pIAboveNet;
94	/** Pointer to the driver instance. */
95	PPDMDRVINS pDrvIns;
96	/** TAP device file handle. */
97	RTFILE hFileDevice;
98	/** The configured TAP device name. */
99	char *pszDeviceName;
100	#ifdef RT_OS_SOLARIS
101	/** IP device file handle (/dev/udp). */
102	int iIPFileDes;
103	/** Whether device name is obtained from setup application. */
104	bool fStatic;
105	#endif
106	/** TAP setup application. */
107	char *pszSetupApplication;
108	/** TAP terminate application. */
109	char *pszTerminateApplication;
110	/** The write end of the control pipe. */
111	RTPIPE hPipeWrite;
112	/** The read end of the control pipe. */
113	RTPIPE hPipeRead;
114	/** Reader thread. */
115	PPDMTHREAD pThread;
116
117	/** @todo The transmit thread. */
118	/** Transmit lock used by drvTAPNetworkUp_BeginXmit. */
119	RTCRITSECT XmitLock;
120
121	#ifdef VBOX_WITH_STATISTICS
122	/** Number of sent packets. */
123	STAMCOUNTER StatPktSent;
124	/** Number of sent bytes. */
125	STAMCOUNTER StatPktSentBytes;
126	/** Number of received packets. */
127	STAMCOUNTER StatPktRecv;
128	/** Number of received bytes. */
129	STAMCOUNTER StatPktRecvBytes;
130	/** Profiling packet transmit runs. */
131	STAMPROFILE StatTransmit;
132	/** Profiling packet receive runs. */
133	STAMPROFILEADV StatReceive;
134	#endif /* VBOX_WITH_STATISTICS */
135
136	#ifdef LOG_ENABLED
137	/** The nano ts of the last transfer. */
138	uint64_t u64LastTransferTS;
139	/** The nano ts of the last receive. */
140	uint64_t u64LastReceiveTS;
141	#endif
142	} DRVTAP, *PDRVTAP;
143
144
145	/** Converts a pointer to TAP::INetworkUp to a PRDVTAP. */
146	#define PDMINETWORKUP_2_DRVTAP(pInterface) ( (PDRVTAP)((uintptr_t)pInterface - RT_UOFFSETOF(DRVTAP, INetworkUp)) )
147
148
149	/*********************************************************************************************************************************
150	* Internal Functions *
151	*********************************************************************************************************************************/
152	#ifdef RT_OS_SOLARIS
153	static int SolarisTAPAttach(PDRVTAP pThis);
154	#endif
155
156
157
158	/**
159	* @interface_method_impl{PDMINETWORKUP,pfnBeginXmit}
160	*/
161	static DECLCALLBACK(int) drvTAPNetworkUp_BeginXmit(PPDMINETWORKUP pInterface, bool fOnWorkerThread)
162	{
163	RT_NOREF(fOnWorkerThread);
164	PDRVTAP pThis = PDMINETWORKUP_2_DRVTAP(pInterface);
165	int rc = RTCritSectTryEnter(&pThis->XmitLock);
166	if (RT_FAILURE(rc))
167	{
168	/** @todo XMIT thread */
169	rc = VERR_TRY_AGAIN;
170	}
171	return rc;
172	}
173
174
175	/**
176	* @interface_method_impl{PDMINETWORKUP,pfnAllocBuf}
177	*/
178	static DECLCALLBACK(int) drvTAPNetworkUp_AllocBuf(PPDMINETWORKUP pInterface, size_t cbMin,
179	PCPDMNETWORKGSO pGso, PPPDMSCATTERGATHER ppSgBuf)
180	{
181	RT_NOREF(pInterface);
182	#ifdef VBOX_STRICT
183	PDRVTAP pThis = PDMINETWORKUP_2_DRVTAP(pInterface);
184	Assert(RTCritSectIsOwner(&pThis->XmitLock));
185	#endif
186
187	/*
188	* Allocate a scatter / gather buffer descriptor that is immediately
189	* followed by the buffer space of its single segment. The GSO context
190	* comes after that again.
191	*/
192	PPDMSCATTERGATHER pSgBuf = (PPDMSCATTERGATHER)RTMemAlloc( RT_ALIGN_Z(sizeof(*pSgBuf), 16)
193	+ RT_ALIGN_Z(cbMin, 16)
194	+ (pGso ? RT_ALIGN_Z(sizeof(*pGso), 16) : 0));
195	if (!pSgBuf)
196	return VERR_NO_MEMORY;
197
198	/*
199	* Initialize the S/G buffer and return.
200	*/
201	pSgBuf->fFlags = PDMSCATTERGATHER_FLAGS_MAGIC \| PDMSCATTERGATHER_FLAGS_OWNER_1;
202	pSgBuf->cbUsed = 0;
203	pSgBuf->cbAvailable = RT_ALIGN_Z(cbMin, 16);
204	pSgBuf->pvAllocator = NULL;
205	if (!pGso)
206	pSgBuf->pvUser = NULL;
207	else
208	{
209	pSgBuf->pvUser = (uint8_t *)(pSgBuf + 1) + pSgBuf->cbAvailable;
210	(PPDMNETWORKGSO)pSgBuf->pvUser = pGso;
211	}
212	pSgBuf->cSegs = 1;
213	pSgBuf->aSegs[0].cbSeg = pSgBuf->cbAvailable;
214	pSgBuf->aSegs[0].pvSeg = pSgBuf + 1;
215
216	#if 0 /* poison */
217	memset(pSgBuf->aSegs[0].pvSeg, 'F', pSgBuf->aSegs[0].cbSeg);
218	#endif
219	*ppSgBuf = pSgBuf;
220	return VINF_SUCCESS;
221	}
222
223
224	/**
225	* @interface_method_impl{PDMINETWORKUP,pfnFreeBuf}
226	*/
227	static DECLCALLBACK(int) drvTAPNetworkUp_FreeBuf(PPDMINETWORKUP pInterface, PPDMSCATTERGATHER pSgBuf)
228	{
229	RT_NOREF(pInterface);
230	#ifdef VBOX_STRICT
231	PDRVTAP pThis = PDMINETWORKUP_2_DRVTAP(pInterface);
232	Assert(RTCritSectIsOwner(&pThis->XmitLock));
233	#endif
234
235	if (pSgBuf)
236	{
237	Assert((pSgBuf->fFlags & PDMSCATTERGATHER_FLAGS_MAGIC_MASK) == PDMSCATTERGATHER_FLAGS_MAGIC);
238	pSgBuf->fFlags = 0;
239	RTMemFree(pSgBuf);
240	}
241	return VINF_SUCCESS;
242	}
243
244
245	/**
246	* @interface_method_impl{PDMINETWORKUP,pfnSendBuf}
247	*/
248	static DECLCALLBACK(int) drvTAPNetworkUp_SendBuf(PPDMINETWORKUP pInterface, PPDMSCATTERGATHER pSgBuf, bool fOnWorkerThread)
249	{
250	RT_NOREF(fOnWorkerThread);
251	PDRVTAP pThis = PDMINETWORKUP_2_DRVTAP(pInterface);
252	STAM_COUNTER_INC(&pThis->StatPktSent);
253	STAM_COUNTER_ADD(&pThis->StatPktSentBytes, pSgBuf->cbUsed);
254	STAM_PROFILE_START(&pThis->StatTransmit, a);
255
256	AssertPtr(pSgBuf);
257	Assert((pSgBuf->fFlags & PDMSCATTERGATHER_FLAGS_MAGIC_MASK) == PDMSCATTERGATHER_FLAGS_MAGIC);
258	Assert(RTCritSectIsOwner(&pThis->XmitLock));
259
260	int rc;
261	if (!pSgBuf->pvUser)
262	{
263	#ifdef LOG_ENABLED
264	uint64_t u64Now = RTTimeProgramNanoTS();
265	LogFlow(("drvTAPSend: %-4d bytes at %llu ns deltas: r=%llu t=%llu\n",
266	pSgBuf->cbUsed, u64Now, u64Now - pThis->u64LastReceiveTS, u64Now - pThis->u64LastTransferTS));
267	pThis->u64LastTransferTS = u64Now;
268	#endif
269	Log2(("drvTAPSend: pSgBuf->aSegs[0].pvSeg=%p pSgBuf->cbUsed=%#x\n"
270	"%.*Rhxd\n",
271	pSgBuf->aSegs[0].pvSeg, pSgBuf->cbUsed, pSgBuf->cbUsed, pSgBuf->aSegs[0].pvSeg));
272
273	rc = RTFileWrite(pThis->hFileDevice, pSgBuf->aSegs[0].pvSeg, pSgBuf->cbUsed, NULL);
274	}
275	else
276	{
277	uint8_t abHdrScratch[256];
278	uint8_t const pbFrame = (uint8_t const )pSgBuf->aSegs[0].pvSeg;
279	PCPDMNETWORKGSO pGso = (PCPDMNETWORKGSO)pSgBuf->pvUser;
280	uint32_t const cSegs = PDMNetGsoCalcSegmentCount(pGso, pSgBuf->cbUsed); Assert(cSegs > 1);
281	rc = VINF_SUCCESS;
282	for (size_t iSeg = 0; iSeg < cSegs; iSeg++)
283	{
284	uint32_t cbSegFrame;
285	void pvSegFrame = PDMNetGsoCarveSegmentQD(pGso, (uint8_t )pbFrame, pSgBuf->cbUsed, abHdrScratch,
286	iSeg, cSegs, &cbSegFrame);
287	rc = RTFileWrite(pThis->hFileDevice, pvSegFrame, cbSegFrame, NULL);
288	if (RT_FAILURE(rc))
289	break;
290	}
291	}
292
293	pSgBuf->fFlags = 0;
294	RTMemFree(pSgBuf);
295
296	STAM_PROFILE_STOP(&pThis->StatTransmit, a);
297	AssertRC(rc);
298	if (RT_FAILURE(rc))
299	rc = rc == VERR_NO_MEMORY ? VERR_NET_NO_BUFFER_SPACE : VERR_NET_DOWN;
300	return rc;
301	}
302
303
304	/**
305	* @interface_method_impl{PDMINETWORKUP,pfnEndXmit}
306	*/
307	static DECLCALLBACK(void) drvTAPNetworkUp_EndXmit(PPDMINETWORKUP pInterface)
308	{
309	PDRVTAP pThis = PDMINETWORKUP_2_DRVTAP(pInterface);
310	RTCritSectLeave(&pThis->XmitLock);
311	}
312
313
314	/**
315	* @interface_method_impl{PDMINETWORKUP,pfnSetPromiscuousMode}
316	*/
317	static DECLCALLBACK(void) drvTAPNetworkUp_SetPromiscuousMode(PPDMINETWORKUP pInterface, bool fPromiscuous)
318	{
319	RT_NOREF(pInterface, fPromiscuous);
320	LogFlow(("drvTAPNetworkUp_SetPromiscuousMode: fPromiscuous=%d\n", fPromiscuous));
321	/* nothing to do */
322	}
323
324
325	/**
326	* Notification on link status changes.
327	*
328	* @param pInterface Pointer to the interface structure containing the called function pointer.
329	* @param enmLinkState The new link state.
330	* @thread EMT
331	*/
332	static DECLCALLBACK(void) drvTAPNetworkUp_NotifyLinkChanged(PPDMINETWORKUP pInterface, PDMNETWORKLINKSTATE enmLinkState)
333	{
334	RT_NOREF(pInterface, enmLinkState);
335	LogFlow(("drvTAPNetworkUp_NotifyLinkChanged: enmLinkState=%d\n", enmLinkState));
336	/** @todo take action on link down and up. Stop the polling and such like. */
337	}
338
339
340	/**
341	* Asynchronous I/O thread for handling receive.
342	*
343	* @returns VINF_SUCCESS (ignored).
344	* @param Thread Thread handle.
345	* @param pvUser Pointer to a DRVTAP structure.
346	*/
347	static DECLCALLBACK(int) drvTAPAsyncIoThread(PPDMDRVINS pDrvIns, PPDMTHREAD pThread)
348	{
349	PDRVTAP pThis = PDMINS_2_DATA(pDrvIns, PDRVTAP);
350	LogFlow(("drvTAPAsyncIoThread: pThis=%p\n", pThis));
351
352	if (pThread->enmState == PDMTHREADSTATE_INITIALIZING)
353	return VINF_SUCCESS;
354
355	STAM_PROFILE_ADV_START(&pThis->StatReceive, a);
356
357	/*
358	* Polling loop.
359	*/
360	while (pThread->enmState == PDMTHREADSTATE_RUNNING)
361	{
362	/*
363	* Wait for something to become available.
364	*/
365	struct pollfd aFDs[2];
366	aFDs[0].fd = RTFileToNative(pThis->hFileDevice);
367	aFDs[0].events = POLLIN \| POLLPRI;
368	aFDs[0].revents = 0;
369	aFDs[1].fd = RTPipeToNative(pThis->hPipeRead);
370	aFDs[1].events = POLLIN \| POLLPRI \| POLLERR \| POLLHUP;
371	aFDs[1].revents = 0;
372	STAM_PROFILE_ADV_STOP(&pThis->StatReceive, a);
373	errno=0;
374	int rc = poll(&aFDs[0], RT_ELEMENTS(aFDs), -1 /* infinite */);
375
376	/* this might have changed in the meantime */
377	if (pThread->enmState != PDMTHREADSTATE_RUNNING)
378	break;
379
380	STAM_PROFILE_ADV_START(&pThis->StatReceive, a);
381	if ( rc > 0
382	&& (aFDs[0].revents & (POLLIN \| POLLPRI))
383	&& !aFDs[1].revents)
384	{
385	/*
386	* Read the frame.
387	*/
388	char achBuf[16384];
389	size_t cbRead = 0;
390	/** @note At least on Linux we will never receive more than one network packet
391	* after poll() returned successfully. I don't know why but a second
392	* RTFileRead() operation will return with VERR_TRY_AGAIN in any case. */
393	rc = RTFileRead(pThis->hFileDevice, achBuf, sizeof(achBuf), &cbRead);
394	if (RT_SUCCESS(rc))
395	{
396	/*
397	* Wait for the device to have space for this frame.
398	* Most guests use frame-sized receive buffers, hence non-zero cbMax
399	* automatically means there is enough room for entire frame. Some
400	* guests (eg. Solaris) use large chains of small receive buffers
401	* (each 128 or so bytes large). We will still start receiving as soon
402	* as cbMax is non-zero because:
403	* - it would be quite expensive for pfnCanReceive to accurately
404	* determine free receive buffer space
405	* - if we were waiting for enough free buffers, there is a risk
406	* of deadlocking because the guest could be waiting for a receive
407	* overflow error to allocate more receive buffers
408	*/
409	STAM_PROFILE_ADV_STOP(&pThis->StatReceive, a);
410	int rc1 = pThis->pIAboveNet->pfnWaitReceiveAvail(pThis->pIAboveNet, RT_INDEFINITE_WAIT);
411	STAM_PROFILE_ADV_START(&pThis->StatReceive, a);
412
413	/*
414	* A return code != VINF_SUCCESS means that we were woken up during a VM
415	* state transition. Drop the packet and wait for the next one.
416	*/
417	if (RT_FAILURE(rc1))
418	continue;
419
420	/*
421	* Pass the data up.
422	*/
423	#ifdef LOG_ENABLED
424	uint64_t u64Now = RTTimeProgramNanoTS();
425	LogFlow(("drvTAPAsyncIoThread: %-4d bytes at %llu ns deltas: r=%llu t=%llu\n",
426	cbRead, u64Now, u64Now - pThis->u64LastReceiveTS, u64Now - pThis->u64LastTransferTS));
427	pThis->u64LastReceiveTS = u64Now;
428	#endif
429	Log2(("drvTAPAsyncIoThread: cbRead=%#x\n" "%.*Rhxd\n", cbRead, cbRead, achBuf));
430	STAM_COUNTER_INC(&pThis->StatPktRecv);
431	STAM_COUNTER_ADD(&pThis->StatPktRecvBytes, cbRead);
432	rc1 = pThis->pIAboveNet->pfnReceive(pThis->pIAboveNet, achBuf, cbRead);
433	AssertRC(rc1);
434	}
435	else
436	{
437	LogFlow(("drvTAPAsyncIoThread: RTFileRead -> %Rrc\n", rc));
438	if (rc == VERR_INVALID_HANDLE)
439	break;
440	RTThreadYield();
441	}
442	}
443	else if ( rc > 0
444	&& aFDs[1].revents)
445	{
446	LogFlow(("drvTAPAsyncIoThread: Control message: enmState=%d revents=%#x\n", pThread->enmState, aFDs[1].revents));
447	if (aFDs[1].revents & (POLLHUP \| POLLERR \| POLLNVAL))
448	break;
449
450	/* drain the pipe */
451	char ch;
452	size_t cbRead;
453	RTPipeRead(pThis->hPipeRead, &ch, 1, &cbRead);
454	}
455	else
456	{
457	/*
458	* poll() failed for some reason. Yield to avoid eating too much CPU.
459	*
460	* EINTR errors have been seen frequently. They should be harmless, even
461	* if they are not supposed to occur in our setup.
462	*/
463	if (errno == EINTR)
464	Log(("rc=%d revents=%#x,%#x errno=%p %s\n", rc, aFDs[0].revents, aFDs[1].revents, errno, strerror(errno)));
465	else
466	AssertMsgFailed(("rc=%d revents=%#x,%#x errno=%p %s\n", rc, aFDs[0].revents, aFDs[1].revents, errno, strerror(errno)));
467	RTThreadYield();
468	}
469	}
470
471
472	LogFlow(("drvTAPAsyncIoThread: returns %Rrc\n", VINF_SUCCESS));
473	STAM_PROFILE_ADV_STOP(&pThis->StatReceive, a);
474	return VINF_SUCCESS;
475	}
476
477
478	/**
479	* Unblock the send thread so it can respond to a state change.
480	*
481	* @returns VBox status code.
482	* @param pDevIns The pcnet device instance.
483	* @param pThread The send thread.
484	*/
485	static DECLCALLBACK(int) drvTapAsyncIoWakeup(PPDMDRVINS pDrvIns, PPDMTHREAD pThread)
486	{
487	RT_NOREF(pThread);
488	PDRVTAP pThis = PDMINS_2_DATA(pDrvIns, PDRVTAP);
489
490	size_t cbIgnored;
491	int rc = RTPipeWrite(pThis->hPipeWrite, "", 1, &cbIgnored);
492	AssertRC(rc);
493
494	return VINF_SUCCESS;
495	}
496
497
498	#if defined(RT_OS_SOLARIS)
499	/**
500	* Calls OS-specific TAP setup application/script.
501	*
502	* @returns VBox error code.
503	* @param pThis The instance data.
504	*/
505	static int drvTAPSetupApplication(PDRVTAP pThis)
506	{
507	char szCommand[4096];
508
509	RTStrPrintf(szCommand, sizeof(szCommand), "%s %s", pThis->pszSetupApplication,
510	pThis->fStatic ? pThis->pszDeviceName : "");
511
512	/* Pipe open the setup application. */
513	Log2(("Starting TAP setup application: %s\n", szCommand));
514	FILE* pfSetupHandle = popen(szCommand, "r");
515	if (pfSetupHandle == 0)
516	{
517	LogRel(("TAP#%d: Failed to run TAP setup application: %s\n", pThis->pDrvIns->iInstance,
518	pThis->pszSetupApplication, strerror(errno)));
519	return VERR_HOSTIF_INIT_FAILED;
520	}
521	if (!pThis->fStatic)
522	{
523	/* Obtain device name from setup application. */
524	char acBuffer[64];
525	size_t cBufSize;
526	fgets(acBuffer, sizeof(acBuffer), pfSetupHandle);
527	cBufSize = strlen(acBuffer);
528	/* The script must return the name of the interface followed by a carriage return as the
529	first line of its output. We need a null-terminated string. */
530	if ((cBufSize < 2) \|\| (acBuffer[cBufSize - 1] != '\n'))
531	{
532	pclose(pfSetupHandle);
533	LogRel(("The TAP interface setup script did not return the name of a TAP device.\n"));
534	return VERR_HOSTIF_INIT_FAILED;
535	}
536	/* Overwrite the terminating newline character. */
537	acBuffer[cBufSize - 1] = 0;
538	RTStrAPrintf(&pThis->pszDeviceName, "%s", acBuffer);
539	}
540	int rc = pclose(pfSetupHandle);
541	if (!WIFEXITED(rc))
542	{
543	LogRel(("The TAP interface setup script terminated abnormally.\n"));
544	return VERR_HOSTIF_INIT_FAILED;
545	}
546	if (WEXITSTATUS(rc) != 0)
547	{
548	LogRel(("The TAP interface setup script returned a non-zero exit code.\n"));
549	return VERR_HOSTIF_INIT_FAILED;
550	}
551	return VINF_SUCCESS;
552	}
553
554
555	/**
556	* Calls OS-specific TAP terminate application/script.
557	*
558	* @returns VBox error code.
559	* @param pThis The instance data.
560	*/
561	static int drvTAPTerminateApplication(PDRVTAP pThis)
562	{
563	char *pszArgs[3];
564	pszArgs[0] = pThis->pszTerminateApplication;
565	pszArgs[1] = pThis->pszDeviceName;
566	pszArgs[2] = NULL;
567
568	Log2(("Starting TAP terminate application: %s %s\n", pThis->pszTerminateApplication, pThis->pszDeviceName));
569	RTPROCESS pid = NIL_RTPROCESS;
570	int rc = RTProcCreate(pszArgs[0], pszArgs, RTENV_DEFAULT, 0, &pid);
571	if (RT_SUCCESS(rc))
572	{
573	RTPROCSTATUS Status;
574	rc = RTProcWait(pid, 0, &Status);
575	if (RT_SUCCESS(rc))
576	{
577	if ( Status.iStatus == 0
578	&& Status.enmReason == RTPROCEXITREASON_NORMAL)
579	return VINF_SUCCESS;
580
581	LogRel(("TAP#%d: Error running TAP terminate application: %s\n", pThis->pDrvIns->iInstance, pThis->pszTerminateApplication));
582	}
583	else
584	LogRel(("TAP#%d: RTProcWait failed for: %s\n", pThis->pDrvIns->iInstance, pThis->pszTerminateApplication));
585	}
586	else
587	{
588	/* Bad. RTProcCreate() failed! */
589	LogRel(("TAP#%d: Failed to fork() process for running TAP terminate application: %s\n", pThis->pDrvIns->iInstance,
590	pThis->pszTerminateApplication, strerror(errno)));
591	}
592	return VERR_HOSTIF_TERM_FAILED;
593	}
594
595	#endif /* RT_OS_SOLARIS */
596
597
598	#ifdef RT_OS_SOLARIS
599	/** From net/if_tun.h, installed by Universal TUN/TAP driver */
600	# define TUNNEWPPA (('T'<<16) \| 0x0001)
601	/** Whether to enable ARP for TAP. */
602	# define VBOX_SOLARIS_TAP_ARP 1
603
604	/**
605	* Creates/Attaches TAP device to IP.
606	*
607	* @returns VBox error code.
608	* @param pThis The instance data.
609	*/
610	static DECLCALLBACK(int) SolarisTAPAttach(PDRVTAP pThis)
611	{
612	LogFlow(("SolarisTapAttach: pThis=%p\n", pThis));
613
614
615	int IPFileDes = open("/dev/udp", O_RDWR, 0);
616	if (IPFileDes < 0)
617	return PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_PDM_HIF_OPEN_FAILED, RT_SRC_POS,
618	N_("Failed to open /dev/udp. errno=%d"), errno);
619
620	int TapFileDes = open("/dev/tap", O_RDWR, 0);
621	if (TapFileDes < 0)
622	return PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_PDM_HIF_OPEN_FAILED, RT_SRC_POS,
623	N_("Failed to open /dev/tap for TAP. errno=%d"), errno);
624
625	/* Use the PPA from the ifname if possible (e.g "tap2", then use 2 as PPA) */
626	int iPPA = -1;
627	if (pThis->pszDeviceName)
628	{
629	size_t cch = strlen(pThis->pszDeviceName);
630	if (cch > 1 && RT_C_IS_DIGIT(pThis->pszDeviceName[cch - 1]) != 0)
631	iPPA = pThis->pszDeviceName[cch - 1] - '0';
632	}
633
634	struct strioctl ioIF;
635	ioIF.ic_cmd = TUNNEWPPA;
636	ioIF.ic_len = sizeof(iPPA);
637	ioIF.ic_dp = (char *)(&iPPA);
638	ioIF.ic_timout = 0;
639	iPPA = ioctl(TapFileDes, I_STR, &ioIF);
640	if (iPPA < 0)
641	{
642	close(TapFileDes);
643	return PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_HOSTIF_IOCTL, RT_SRC_POS,
644	N_("Failed to get new interface. errno=%d"), errno);
645	}
646
647	int InterfaceFD = open("/dev/tap", O_RDWR, 0);
648	if (!InterfaceFD)
649	return PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_PDM_HIF_OPEN_FAILED, RT_SRC_POS,
650	N_("Failed to open interface /dev/tap. errno=%d"), errno);
651
652	if (ioctl(InterfaceFD, I_PUSH, "ip") == -1)
653	{
654	close(InterfaceFD);
655	return PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_HOSTIF_IOCTL, RT_SRC_POS,
656	N_("Failed to push IP. errno=%d"), errno);
657	}
658
659	struct lifreq ifReq;
660	memset(&ifReq, 0, sizeof(ifReq));
661	if (ioctl(InterfaceFD, SIOCGLIFFLAGS, &ifReq) == -1)
662	LogRel(("TAP#%d: Failed to get interface flags.\n", pThis->pDrvIns->iInstance));
663
664	ifReq.lifr_ppa = iPPA;
665	RTStrCopy(ifReq.lifr_name, sizeof(ifReq.lifr_name), pThis->pszDeviceName);
666
667	if (ioctl(InterfaceFD, SIOCSLIFNAME, &ifReq) == -1)
668	LogRel(("TAP#%d: Failed to set PPA. errno=%d\n", pThis->pDrvIns->iInstance, errno));
669
670	if (ioctl(InterfaceFD, SIOCGLIFFLAGS, &ifReq) == -1)
671	LogRel(("TAP#%d: Failed to get interface flags after setting PPA. errno=%d\n", pThis->pDrvIns->iInstance, errno));
672
673	# ifdef VBOX_SOLARIS_TAP_ARP
674	/* Interface */
675	if (ioctl(InterfaceFD, I_PUSH, "arp") == -1)
676	LogRel(("TAP#%d: Failed to push ARP to Interface FD. errno=%d\n", pThis->pDrvIns->iInstance, errno));
677
678	/* IP */
679	if (ioctl(IPFileDes, I_POP, NULL) == -1)
680	LogRel(("TAP#%d: Failed I_POP from IP FD. errno=%d\n", pThis->pDrvIns->iInstance, errno));
681
682	if (ioctl(IPFileDes, I_PUSH, "arp") == -1)
683	LogRel(("TAP#%d: Failed to push ARP to IP FD. errno=%d\n", pThis->pDrvIns->iInstance, errno));
684
685	/* ARP */
686	int ARPFileDes = open("/dev/tap", O_RDWR, 0);
687	if (ARPFileDes < 0)
688	LogRel(("TAP#%d: Failed to open for /dev/tap for ARP. errno=%d", pThis->pDrvIns->iInstance, errno));
689
690	if (ioctl(ARPFileDes, I_PUSH, "arp") == -1)
691	LogRel(("TAP#%d: Failed to push ARP to ARP FD. errno=%d\n", pThis->pDrvIns->iInstance, errno));
692
693	ioIF.ic_cmd = SIOCSLIFNAME;
694	ioIF.ic_timout = 0;
695	ioIF.ic_len = sizeof(ifReq);
696	ioIF.ic_dp = (char *)&ifReq;
697	if (ioctl(ARPFileDes, I_STR, &ioIF) == -1)
698	LogRel(("TAP#%d: Failed to set interface name to ARP.\n", pThis->pDrvIns->iInstance));
699	# endif
700
701	/* We must use I_LINK and not I_PLINK as I_PLINK makes the link persistent.
702	* Then we would not be able unlink the interface if we reuse it.
703	* Even 'unplumb' won't work after that.
704	*/
705	int IPMuxID = ioctl(IPFileDes, I_LINK, InterfaceFD);
706	if (IPMuxID == -1)
707	{
708	close(InterfaceFD);
709	# ifdef VBOX_SOLARIS_TAP_ARP
710	close(ARPFileDes);
711	# endif
712	LogRel(("TAP#%d: Cannot link TAP device to IP.\n", pThis->pDrvIns->iInstance));
713	return PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_HOSTIF_IOCTL, RT_SRC_POS,
714	N_("Failed to link TAP device to IP. Check TAP interface name. errno=%d"), errno);
715	}
716
717	# ifdef VBOX_SOLARIS_TAP_ARP
718	int ARPMuxID = ioctl(IPFileDes, I_LINK, ARPFileDes);
719	if (ARPMuxID == -1)
720	LogRel(("TAP#%d: Failed to link TAP device to ARP\n", pThis->pDrvIns->iInstance));
721
722	close(ARPFileDes);
723	# endif
724	close(InterfaceFD);
725
726	/* Reuse ifReq */
727	memset(&ifReq, 0, sizeof(ifReq));
728	RTStrCopy(ifReq.lifr_name, sizeof(ifReq.lifr_name), pThis->pszDeviceName);
729	ifReq.lifr_ip_muxid = IPMuxID;
730	# ifdef VBOX_SOLARIS_TAP_ARP
731	ifReq.lifr_arp_muxid = ARPMuxID;
732	# endif
733
734	if (ioctl(IPFileDes, SIOCSLIFMUXID, &ifReq) == -1)
735	{
736	# ifdef VBOX_SOLARIS_TAP_ARP
737	ioctl(IPFileDes, I_PUNLINK, ARPMuxID);
738	# endif
739	ioctl(IPFileDes, I_PUNLINK, IPMuxID);
740	close(IPFileDes);
741	LogRel(("TAP#%d: Failed to set Mux ID.\n", pThis->pDrvIns->iInstance));
742	return PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_HOSTIF_IOCTL, RT_SRC_POS,
743	N_("Failed to set Mux ID. Check TAP interface name. errno=%d"), errno);
744	}
745
746	int rc = RTFileFromNative(&pThis->hFileDevice, TapFileDes);
747	AssertLogRelRC(rc);
748	if (RT_FAILURE(rc))
749	{
750	close(IPFileDes);
751	close(TapFileDes);
752	}
753	pThis->iIPFileDes = IPFileDes;
754
755	return VINF_SUCCESS;
756	}
757
758	#endif /* RT_OS_SOLARIS */
759
760	/* -=-=-=-=- PDMIBASE -=-=-=-=- */
761
762	/**
763	* @interface_method_impl{PDMIBASE,pfnQueryInterface}
764	*/
765	static DECLCALLBACK(void ) drvTAPQueryInterface(PPDMIBASE pInterface, const char pszIID)
766	{
767	PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
768	PDRVTAP pThis = PDMINS_2_DATA(pDrvIns, PDRVTAP);
769
770	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pDrvIns->IBase);
771	PDMIBASE_RETURN_INTERFACE(pszIID, PDMINETWORKUP, &pThis->INetworkUp);
772	return NULL;
773	}
774
775	/* -=-=-=-=- PDMDRVREG -=-=-=-=- */
776
777	/**
778	* Destruct a driver instance.
779	*
780	* Most VM resources are freed by the VM. This callback is provided so that any non-VM
781	* resources can be freed correctly.
782	*
783	* @param pDrvIns The driver instance data.
784	*/
785	static DECLCALLBACK(void) drvTAPDestruct(PPDMDRVINS pDrvIns)
786	{
787	LogFlow(("drvTAPDestruct\n"));
788	PDRVTAP pThis = PDMINS_2_DATA(pDrvIns, PDRVTAP);
789	PDMDRV_CHECK_VERSIONS_RETURN_VOID(pDrvIns);
790
791	/*
792	* Terminate the control pipe.
793	*/
794	int rc;
795	if (pThis->hPipeWrite != NIL_RTPIPE)
796	{
797	rc = RTPipeClose(pThis->hPipeWrite); AssertRC(rc);
798	pThis->hPipeWrite = NIL_RTPIPE;
799	}
800	if (pThis->hPipeRead != NIL_RTPIPE)
801	{
802	rc = RTPipeClose(pThis->hPipeRead); AssertRC(rc);
803	pThis->hPipeRead = NIL_RTPIPE;
804	}
805
806	#ifdef RT_OS_SOLARIS
807	/** @todo r=bird: This does need checking against ConsoleImpl2.cpp if used on non-solaris systems. */
808	if (pThis->hFileDevice != NIL_RTFILE)
809	{
810	int rc = RTFileClose(pThis->hFileDevice); AssertRC(rc);
811	pThis->hFileDevice = NIL_RTFILE;
812	}
813
814	/*
815	* Call TerminateApplication after closing the device otherwise
816	* TerminateApplication would not be able to unplumb it.
817	*/
818	if (pThis->pszTerminateApplication)
819	drvTAPTerminateApplication(pThis);
820
821	#endif /* RT_OS_SOLARIS */
822
823	#ifdef RT_OS_SOLARIS
824	if (!pThis->fStatic)
825	RTStrFree(pThis->pszDeviceName); /* allocated by drvTAPSetupApplication */
826	else
827	PDMDrvHlpMMHeapFree(pDrvIns, pThis->pszDeviceName);
828	#else
829	PDMDrvHlpMMHeapFree(pDrvIns, pThis->pszDeviceName);
830	#endif
831	pThis->pszDeviceName = NULL;
832	PDMDrvHlpMMHeapFree(pDrvIns, pThis->pszSetupApplication);
833	pThis->pszSetupApplication = NULL;
834	PDMDrvHlpMMHeapFree(pDrvIns, pThis->pszTerminateApplication);
835	pThis->pszTerminateApplication = NULL;
836
837	/*
838	* Kill the xmit lock.
839	*/
840	if (RTCritSectIsInitialized(&pThis->XmitLock))
841	RTCritSectDelete(&pThis->XmitLock);
842
843	#ifdef VBOX_WITH_STATISTICS
844	/*
845	* Deregister statistics.
846	*/
847	PDMDrvHlpSTAMDeregister(pDrvIns, &pThis->StatPktSent);
848	PDMDrvHlpSTAMDeregister(pDrvIns, &pThis->StatPktSentBytes);
849	PDMDrvHlpSTAMDeregister(pDrvIns, &pThis->StatPktRecv);
850	PDMDrvHlpSTAMDeregister(pDrvIns, &pThis->StatPktRecvBytes);
851	PDMDrvHlpSTAMDeregister(pDrvIns, &pThis->StatTransmit);
852	PDMDrvHlpSTAMDeregister(pDrvIns, &pThis->StatReceive);
853	#endif /* VBOX_WITH_STATISTICS */
854	}
855
856
857	/**
858	* Construct a TAP network transport driver instance.
859	*
860	* @copydoc FNPDMDRVCONSTRUCT
861	*/
862	static DECLCALLBACK(int) drvTAPConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags)
863	{
864	RT_NOREF(fFlags);
865	PDMDRV_CHECK_VERSIONS_RETURN(pDrvIns);
866	PDRVTAP pThis = PDMINS_2_DATA(pDrvIns, PDRVTAP);
867	PCPDMDRVHLPR3 pHlp = pDrvIns->pHlpR3;
868
869	/*
870	* Init the static parts.
871	*/
872	pThis->pDrvIns = pDrvIns;
873	pThis->hFileDevice = NIL_RTFILE;
874	pThis->hPipeWrite = NIL_RTPIPE;
875	pThis->hPipeRead = NIL_RTPIPE;
876	pThis->pszDeviceName = NULL;
877	#ifdef RT_OS_SOLARIS
878	pThis->iIPFileDes = -1;
879	pThis->fStatic = true;
880	#endif
881	pThis->pszSetupApplication = NULL;
882	pThis->pszTerminateApplication = NULL;
883
884	/* IBase */
885	pDrvIns->IBase.pfnQueryInterface = drvTAPQueryInterface;
886	/* INetwork */
887	pThis->INetworkUp.pfnBeginXmit = drvTAPNetworkUp_BeginXmit;
888	pThis->INetworkUp.pfnAllocBuf = drvTAPNetworkUp_AllocBuf;
889	pThis->INetworkUp.pfnFreeBuf = drvTAPNetworkUp_FreeBuf;
890	pThis->INetworkUp.pfnSendBuf = drvTAPNetworkUp_SendBuf;
891	pThis->INetworkUp.pfnEndXmit = drvTAPNetworkUp_EndXmit;
892	pThis->INetworkUp.pfnSetPromiscuousMode = drvTAPNetworkUp_SetPromiscuousMode;
893	pThis->INetworkUp.pfnNotifyLinkChanged = drvTAPNetworkUp_NotifyLinkChanged;
894
895	#ifdef VBOX_WITH_STATISTICS
896	/*
897	* Statistics.
898	*/
899	PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatPktSent, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES, "Number of sent packets.", "/Drivers/TAP%d/Packets/Sent", pDrvIns->iInstance);
900	PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatPktSentBytes, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_BYTES, "Number of sent bytes.", "/Drivers/TAP%d/Bytes/Sent", pDrvIns->iInstance);
901	PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatPktRecv, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES, "Number of received packets.", "/Drivers/TAP%d/Packets/Received", pDrvIns->iInstance);
902	PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatPktRecvBytes, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_BYTES, "Number of received bytes.", "/Drivers/TAP%d/Bytes/Received", pDrvIns->iInstance);
903	PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatTransmit, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling packet transmit runs.", "/Drivers/TAP%d/Transmit", pDrvIns->iInstance);
904	PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatReceive, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling packet receive runs.", "/Drivers/TAP%d/Receive", pDrvIns->iInstance);
905	#endif /* VBOX_WITH_STATISTICS */
906
907	/*
908	* Validate the config.
909	*/
910	PDMDRV_VALIDATE_CONFIG_RETURN(pDrvIns, "Device"
911	"\|FileHandle"
912	"\|TAPSetupApplication"
913	"\|TAPTerminateApplication"
914	"\|MAC",
915	"");
916
917	/*
918	* Check that no-one is attached to us.
919	*/
920	AssertMsgReturn(PDMDrvHlpNoAttach(pDrvIns) == VERR_PDM_NO_ATTACHED_DRIVER,
921	("Configuration error: Not possible to attach anything to this driver!\n"),
922	VERR_PDM_DRVINS_NO_ATTACH);
923
924	/*
925	* Query the network port interface.
926	*/
927	pThis->pIAboveNet = PDMIBASE_QUERY_INTERFACE(pDrvIns->pUpBase, PDMINETWORKDOWN);
928	if (!pThis->pIAboveNet)
929	return PDMDRV_SET_ERROR(pDrvIns, VERR_PDM_MISSING_INTERFACE_ABOVE,
930	N_("Configuration error: The above device/driver didn't export the network port interface"));
931
932	/*
933	* Read the configuration.
934	*/
935	int rc;
936	#if defined(RT_OS_SOLARIS) /** @todo Other platforms' TAP code should be moved here from ConsoleImpl. */
937	rc = pHlp->pfnCFGMQueryStringAlloc(pCfg, "TAPSetupApplication", &pThis->pszSetupApplication);
938	if (RT_SUCCESS(rc))
939	{
940	if (!RTPathExists(pThis->pszSetupApplication))
941	return PDMDrvHlpVMSetError(pDrvIns, VERR_HOSTIF_INIT_FAILED, RT_SRC_POS,
942	N_("Invalid TAP setup program path: %s"), pThis->pszSetupApplication);
943	}
944	else if (rc != VERR_CFGM_VALUE_NOT_FOUND)
945	return PDMDRV_SET_ERROR(pDrvIns, rc, N_("Configuration error: failed to query \"TAPTerminateApplication\""));
946
947	rc = pHlp->pfnCFGMQueryStringAlloc(pCfg, "TAPTerminateApplication", &pThis->pszTerminateApplication);
948	if (RT_SUCCESS(rc))
949	{
950	if (!RTPathExists(pThis->pszTerminateApplication))
951	return PDMDrvHlpVMSetError(pDrvIns, VERR_HOSTIF_INIT_FAILED, RT_SRC_POS,
952	N_("Invalid TAP terminate program path: %s"), pThis->pszTerminateApplication);
953	}
954	else if (rc != VERR_CFGM_VALUE_NOT_FOUND)
955	return PDMDRV_SET_ERROR(pDrvIns, rc, N_("Configuration error: failed to query \"TAPTerminateApplication\""));
956
957	rc = pHlp->pfnCFGMQueryStringAlloc(pCfg, "Device", &pThis->pszDeviceName);
958	if (RT_FAILURE(rc))
959	pThis->fStatic = false;
960
961	/* Obtain the device name from the setup application (if none was specified). */
962	if (pThis->pszSetupApplication)
963	{
964	rc = drvTAPSetupApplication(pThis);
965	if (RT_FAILURE(rc))
966	return PDMDrvHlpVMSetError(pDrvIns, VERR_HOSTIF_INIT_FAILED, RT_SRC_POS,
967	N_("Error running TAP setup application. rc=%d"), rc);
968	}
969
970	/*
971	* Do the setup.
972	*/
973	rc = SolarisTAPAttach(pThis);
974	if (RT_FAILURE(rc))
975	return rc;
976
977	#else /* !RT_OS_SOLARIS */
978
979	uint64_t u64File;
980	rc = pHlp->pfnCFGMQueryU64(pCfg, "FileHandle", &u64File);
981	if (RT_FAILURE(rc))
982	return PDMDRV_SET_ERROR(pDrvIns, rc,
983	N_("Configuration error: Query for \"FileHandle\" 32-bit signed integer failed"));
984	pThis->hFileDevice = (RTFILE)(uintptr_t)u64File;
985	if (!RTFileIsValid(pThis->hFileDevice))
986	return PDMDrvHlpVMSetError(pDrvIns, VERR_INVALID_HANDLE, RT_SRC_POS,
987	N_("The TAP file handle %RTfile is not valid"), pThis->hFileDevice);
988	#endif /* !RT_OS_SOLARIS */
989
990	/*
991	* Create the transmit lock.
992	*/
993	rc = RTCritSectInit(&pThis->XmitLock);
994	AssertRCReturn(rc, rc);
995
996	/*
997	* Make sure the descriptor is non-blocking and valid.
998	*
999	* We should actually query if it's a TAP device, but I haven't
1000	* found any way to do that.
1001	*/
1002	if (fcntl(RTFileToNative(pThis->hFileDevice), F_SETFL, O_NONBLOCK) == -1)
1003	return PDMDrvHlpVMSetError(pDrvIns, VERR_HOSTIF_IOCTL, RT_SRC_POS,
1004	N_("Configuration error: Failed to configure /dev/net/tun. errno=%d"), errno);
1005	/** @todo determine device name. This can be done by reading the link /proc/<pid>/fd/<fd> */
1006	Log(("drvTAPContruct: %d (from fd)\n", (intptr_t)pThis->hFileDevice));
1007	rc = VINF_SUCCESS;
1008
1009	/*
1010	* Create the control pipe.
1011	*/
1012	rc = RTPipeCreate(&pThis->hPipeRead, &pThis->hPipeWrite, 0 /fFlags/);
1013	AssertRCReturn(rc, rc);
1014
1015	/*
1016	* Create the async I/O thread.
1017	*/
1018	rc = PDMDrvHlpThreadCreate(pDrvIns, &pThis->pThread, pThis, drvTAPAsyncIoThread, drvTapAsyncIoWakeup, 128 * _1K, RTTHREADTYPE_IO, "TAP");
1019	AssertRCReturn(rc, rc);
1020
1021	return rc;
1022	}
1023
1024
1025	/**
1026	* TAP network transport driver registration record.
1027	*/
1028	const PDMDRVREG g_DrvHostInterface =
1029	{
1030	/* u32Version */
1031	PDM_DRVREG_VERSION,
1032	/* szName */
1033	"HostInterface",
1034	/* szRCMod */
1035	"",
1036	/* szR0Mod */
1037	"",
1038	/* pszDescription */
1039	"TAP Network Transport Driver",
1040	/* fFlags */
1041	PDM_DRVREG_FLAGS_HOST_BITS_DEFAULT,
1042	/* fClass. */
1043	PDM_DRVREG_CLASS_NETWORK,
1044	/* cMaxInstances */
1045	~0U,
1046	/* cbInstance */
1047	sizeof(DRVTAP),
1048	/* pfnConstruct */
1049	drvTAPConstruct,
1050	/* pfnDestruct */
1051	drvTAPDestruct,
1052	/* pfnRelocate */
1053	NULL,
1054	/* pfnIOCtl */
1055	NULL,
1056	/* pfnPowerOn */
1057	NULL,
1058	/* pfnReset */
1059	NULL,
1060	/* pfnSuspend */
1061	NULL, /** @todo Do power on, suspend and resume handlers! */
1062	/* pfnResume */
1063	NULL,
1064	/* pfnAttach */
1065	NULL,
1066	/* pfnDetach */
1067	NULL,
1068	/* pfnPowerOff */
1069	NULL,
1070	/* pfnSoftReset */
1071	NULL,
1072	/* u32EndVersion */
1073	PDM_DRVREG_VERSION
1074	};
1075

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

source: vbox/trunk/src/VBox/Devices/Network/DrvTAP.cpp@ 105381

Download in other formats: