DrvTAP.cpp@ 75478

Last change on this file since 75478 was 73097, checked in by vboxsync, 6 years ago
*: Made RT_UOFFSETOF, RT_OFFSETOF, RT_UOFFSETOF_ADD and RT_OFFSETOF_ADD work like builtin_offsetof() and require compile time resolvable requests, adding RT_UOFFSETOF_DYN for the dynamic questions that can only be answered at runtime.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 37.2 KB

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

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

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

Download in other formats: