DrvTCP.cpp@ 69922

Last change on this file since 69922 was 69419, checked in by vboxsync, 7 years ago
Serial/DrvTcp: scm updates
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 21.4 KB

Line
1	/* $Id: DrvTCP.cpp 69419 2017-10-27 10:09:47Z vboxsync $ */
2	/** @file
3	* TCP socket driver implementing the IStream interface.
4	*/
5
6	/*
7	* Contributed by Alexey Eromenko (derived from DrvNamedPipe).
8	*
9	* Copyright (C) 2006-2017 Oracle Corporation
10	*
11	* This file is part of VirtualBox Open Source Edition (OSE), as
12	* available from http://www.virtualbox.org. This file is free software;
13	* you can redistribute it and/or modify it under the terms of the GNU
14	* General Public License (GPL) as published by the Free Software
15	* Foundation, in version 2 as it comes in the "COPYING" file of the
16	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
17	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
18	*/
19
20
21	/*********************************************************************************************************************************
22	* Header Files *
23	*********************************************************************************************************************************/
24	#define LOG_GROUP LOG_GROUP_DRV_TCP
25	#include <VBox/vmm/pdmdrv.h>
26	#include <iprt/assert.h>
27	#include <iprt/file.h>
28	#include <iprt/stream.h>
29	#include <iprt/alloc.h>
30	#include <iprt/pipe.h>
31	#include <iprt/poll.h>
32	#include <iprt/string.h>
33	#include <iprt/semaphore.h>
34	#include <iprt/socket.h>
35	#include <iprt/tcp.h>
36	#include <iprt/uuid.h>
37	#include <stdlib.h>
38
39	#include "VBoxDD.h"
40
41
42	/*********************************************************************************************************************************
43	* Defined Constants And Macros *
44	*********************************************************************************************************************************/
45
46	#define DRVTCP_POLLSET_ID_SOCKET 0
47	#define DRVTCP_POLLSET_ID_WAKEUP 1
48
49	#define DRVTCP_WAKEUP_REASON_EXTERNAL 0
50	#define DRVTCP_WAKEUP_REASON_NEW_CONNECTION 1
51
52
53	/*********************************************************************************************************************************
54	* Structures and Typedefs *
55	*********************************************************************************************************************************/
56	/**
57	* TCP driver instance data.
58	*
59	* @implements PDMISTREAM
60	*/
61	typedef struct DRVTCP
62	{
63	/** The stream interface. */
64	PDMISTREAM IStream;
65	/** Pointer to the driver instance. */
66	PPDMDRVINS pDrvIns;
67	/** Pointer to the TCP server address:port or port only. (Freed by MM) */
68	char *pszLocation;
69	/** Flag whether VirtualBox represents the server or client side. */
70	bool fIsServer;
71
72	/** Handle of the TCP server for incoming connections. */
73	PRTTCPSERVER hTcpServ;
74	/** Socket handle of the TCP socket connection. */
75	RTSOCKET hTcpSock;
76
77	/** Poll set used to wait for I/O events. */
78	RTPOLLSET hPollSet;
79	/** Reading end of the wakeup pipe. */
80	RTPIPE hPipeWakeR;
81	/** Writing end of the wakeup pipe. */
82	RTPIPE hPipeWakeW;
83	/** Flag whether the socket is in the pollset. */
84	bool fTcpSockInPollSet;
85	/** Flag whether the send buffer is full nad it is required to wait for more
86	* space until there is room again. */
87	bool fXmitBufFull;
88
89	/** Thread for listening for new connections. */
90	RTTHREAD ListenThread;
91	/** Flag to signal listening thread to shut down. */
92	bool volatile fShutdown;
93	} DRVTCP, *PDRVTCP;
94
95
96	/*********************************************************************************************************************************
97	* Internal Functions *
98	*********************************************************************************************************************************/
99
100
101	/**
102	* Kicks any possibly polling thread to get informed about changes.
103	*
104	* @returns VBOx status code.
105	* @param pThis The TCP driver instance.
106	* @param bReason The reason code to handle.
107	*/
108	static int drvTcpPollerKick(PDRVTCP pThis, uint8_t bReason)
109	{
110	size_t cbWritten = 0;
111	return RTPipeWrite(pThis->hPipeWakeW, &bReason, 1, &cbWritten);
112	}
113
114
115	/** @interface_method_impl{PDMISTREAM,pfnPoll} */
116	static DECLCALLBACK(int) drvTcpPoll(PPDMISTREAM pInterface, uint32_t fEvts, uint32_t *pfEvts, RTMSINTERVAL cMillies)
117	{
118	int rc = VINF_SUCCESS;
119	PDRVTCP pThis = RT_FROM_MEMBER(pInterface, DRVTCP, IStream);
120
121	if (pThis->hTcpSock != NIL_RTSOCKET)
122	{
123	if (!pThis->fTcpSockInPollSet)
124	{
125	rc = RTPollSetAddSocket(pThis->hPollSet, pThis->hTcpSock,
126	fEvts, DRVTCP_POLLSET_ID_SOCKET);
127	if (RT_SUCCESS(rc))
128	{
129	pThis->fTcpSockInPollSet = true;
130	pThis->fXmitBufFull = false;
131	}
132	}
133	else
134	{
135	/*
136	* Just return if the send buffer wasn't full till now and
137	* the caller wants to check whether writing is possible with
138	* the event set.
139	*
140	* On Windows the write event is only posted after a send operation returned
141	* WSAEWOULDBLOCK. So without this we would block in the poll call below waiting
142	* for an event which would never happen if the buffer has space left.
143	*/
144	if ( (fEvts & RTPOLL_EVT_WRITE)
145	&& !pThis->fXmitBufFull)
146	{
147	*pfEvts = RTPOLL_EVT_WRITE;
148	return VINF_SUCCESS;
149	}
150
151	/* Always include error event. */
152	fEvts \|= RTPOLL_EVT_ERROR;
153	rc = RTPollSetEventsChange(pThis->hPollSet, DRVTCP_POLLSET_ID_SOCKET, fEvts);
154	AssertRC(rc);
155	}
156	}
157
158	if (RT_SUCCESS(rc))
159	{
160	while (RT_SUCCESS(rc))
161	{
162	uint32_t fEvtsRecv = 0;
163	uint32_t idHnd = 0;
164
165	rc = RTPoll(pThis->hPollSet, cMillies, &fEvtsRecv, &idHnd);
166	if (RT_SUCCESS(rc))
167	{
168	if (idHnd == DRVTCP_POLLSET_ID_WAKEUP)
169	{
170	/* We got woken up, drain the pipe and return. */
171	uint8_t bReason;
172	size_t cbRead = 0;
173	rc = RTPipeRead(pThis->hPipeWakeR, &bReason, 1, &cbRead);
174	AssertRC(rc);
175
176	if (bReason == DRVTCP_WAKEUP_REASON_EXTERNAL)
177	rc = VERR_INTERRUPTED;
178	else if (bReason == DRVTCP_WAKEUP_REASON_NEW_CONNECTION)
179	{
180	Assert(!pThis->fTcpSockInPollSet);
181	rc = RTPollSetAddSocket(pThis->hPollSet, pThis->hTcpSock,
182	fEvts, DRVTCP_POLLSET_ID_SOCKET);
183	if (RT_SUCCESS(rc))
184	pThis->fTcpSockInPollSet = true;
185	}
186	else
187	AssertMsgFailed(("Unknown wakeup reason in pipe %u\n", bReason));
188	}
189	else
190	{
191	Assert(idHnd == DRVTCP_POLLSET_ID_SOCKET);
192
193	/* On error we close the socket here. */
194	if (fEvtsRecv & RTPOLL_EVT_ERROR)
195	{
196	rc = RTPollSetRemove(pThis->hPollSet, DRVTCP_POLLSET_ID_SOCKET);
197	AssertRC(rc);
198
199	if (pThis->fIsServer)
200	RTTcpServerDisconnectClient2(pThis->hTcpSock);
201	else
202	RTSocketClose(pThis->hTcpSock);
203	pThis->hTcpSock = NIL_RTSOCKET;
204	pThis->fTcpSockInPollSet = false;
205	/* Continue with polling. */
206	}
207	else
208	{
209	if (fEvtsRecv & RTPOLL_EVT_WRITE)
210	pThis->fXmitBufFull = false;
211	*pfEvts = fEvtsRecv;
212	break;
213	}
214	}
215	}
216	}
217	}
218
219	return rc;
220	}
221
222
223	/** @interface_method_impl{PDMISTREAM,pfnPollInterrupt} */
224	static DECLCALLBACK(int) drvTcpPollInterrupt(PPDMISTREAM pInterface)
225	{
226	PDRVTCP pThis = RT_FROM_MEMBER(pInterface, DRVTCP, IStream);
227	return drvTcpPollerKick(pThis, DRVTCP_WAKEUP_REASON_EXTERNAL);
228	}
229
230
231	/** @interface_method_impl{PDMISTREAM,pfnRead} */
232	static DECLCALLBACK(int) drvTcpRead(PPDMISTREAM pInterface, void pvBuf, size_t pcbRead)
233	{
234	int rc = VINF_SUCCESS;
235	PDRVTCP pThis = RT_FROM_MEMBER(pInterface, DRVTCP, IStream);
236	LogFlow(("%s: pvBuf=%p pcbRead=%#x (%s)\n", __FUNCTION__, pvBuf, pcbRead, pThis->pszLocation));
237
238	Assert(pvBuf);
239
240	if (pThis->hTcpSock != NIL_RTSOCKET)
241	{
242	size_t cbRead;
243	size_t cbBuf = *pcbRead;
244	rc = RTSocketReadNB(pThis->hTcpSock, pvBuf, cbBuf, &cbRead);
245	if (RT_SUCCESS(rc))
246	{
247	if (!cbRead && rc != VINF_TRY_AGAIN)
248	{
249	rc = RTPollSetRemove(pThis->hPollSet, DRVTCP_POLLSET_ID_SOCKET);
250	AssertRC(rc);
251
252	if (pThis->fIsServer)
253	RTTcpServerDisconnectClient2(pThis->hTcpSock);
254	else
255	RTSocketClose(pThis->hTcpSock);
256	pThis->hTcpSock = NIL_RTSOCKET;
257	pThis->fTcpSockInPollSet = false;
258	rc = VINF_SUCCESS;
259	}
260	*pcbRead = cbRead;
261	}
262	}
263	else
264	{
265	RTThreadSleep(100);
266	*pcbRead = 0;
267	}
268
269	LogFlow(("%s: pcbRead=%zu returns %Rrc\n", __FUNCTION__, pcbRead, rc));
270	return rc;
271	}
272
273
274	/** @interface_method_impl{PDMISTREAM,pfnWrite} */
275	static DECLCALLBACK(int) drvTcpWrite(PPDMISTREAM pInterface, const void pvBuf, size_t pcbWrite)
276	{
277	int rc = VINF_SUCCESS;
278	PDRVTCP pThis = RT_FROM_MEMBER(pInterface, DRVTCP, IStream);
279	LogFlow(("%s: pvBuf=%p pcbWrite=%#x (%s)\n", __FUNCTION__, pvBuf, pcbWrite, pThis->pszLocation));
280
281	Assert(pvBuf);
282	if (pThis->hTcpSock != NIL_RTSOCKET)
283	{
284	size_t cbBuf = *pcbWrite;
285	rc = RTSocketWriteNB(pThis->hTcpSock, pvBuf, cbBuf, pcbWrite);
286	if (rc == VINF_TRY_AGAIN)
287	{
288	Assert(*pcbWrite == 0);
289	pThis->fXmitBufFull = true;
290	rc = VERR_TIMEOUT;
291	}
292	}
293	else
294	*pcbWrite = 0;
295
296	LogFlow(("%s: returns %Rrc pcbWrite=%zu\n", __FUNCTION__, rc, pcbWrite));
297	return rc;
298	}
299
300
301	/**
302	* @interface_method_impl{PDMIBASE,pfnQueryInterface}
303	*/
304	static DECLCALLBACK(void ) drvTCPQueryInterface(PPDMIBASE pInterface, const char pszIID)
305	{
306	PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
307	PDRVTCP pThis = PDMINS_2_DATA(pDrvIns, PDRVTCP);
308	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pDrvIns->IBase);
309	PDMIBASE_RETURN_INTERFACE(pszIID, PDMISTREAM, &pThis->IStream);
310	return NULL;
311	}
312
313
314	/* -=-=-=-=- listen thread -=-=-=-=- */
315
316	/**
317	* Receive thread loop.
318	*
319	* @returns VINF_SUCCESS
320	* @param hThreadSelf Thread handle to this thread.
321	* @param pvUser User argument.
322	*/
323	static DECLCALLBACK(int) drvTCPListenLoop(RTTHREAD hThreadSelf, void *pvUser)
324	{
325	RT_NOREF(hThreadSelf);
326	PDRVTCP pThis = (PDRVTCP)pvUser;
327
328	while (RT_LIKELY(!pThis->fShutdown))
329	{
330	RTSOCKET hTcpSockNew = NIL_RTSOCKET;
331	int rc = RTTcpServerListen2(pThis->hTcpServ, &hTcpSockNew);
332	if (RT_SUCCESS(rc))
333	{
334	if (pThis->hTcpSock != NIL_RTSOCKET)
335	{
336	LogRel(("DrvTCP%d: only single connection supported\n", pThis->pDrvIns->iInstance));
337	RTTcpServerDisconnectClient2(hTcpSockNew);
338	}
339	else
340	{
341	pThis->hTcpSock = hTcpSockNew;
342	/* Inform the poller about the new socket. */
343	drvTcpPollerKick(pThis, DRVTCP_WAKEUP_REASON_NEW_CONNECTION);
344	}
345	}
346	}
347
348	return VINF_SUCCESS;
349	}
350
351	/* -=-=-=-=- PDMDRVREG -=-=-=-=- */
352
353	/**
354	* Common worker for drvTCPPowerOff and drvTCPDestructor.
355	*
356	* @param pThis The instance data.
357	*/
358	static void drvTCPShutdownListener(PDRVTCP pThis)
359	{
360	/*
361	* Signal shutdown of the listener thread.
362	*/
363	pThis->fShutdown = true;
364	if ( pThis->fIsServer
365	&& pThis->hTcpServ != NULL)
366	{
367	int rc = RTTcpServerShutdown(pThis->hTcpServ);
368	AssertRC(rc);
369	pThis->hTcpServ = NULL;
370	}
371	}
372
373
374	/**
375	* Power off a TCP socket stream driver instance.
376	*
377	* This does most of the destruction work, to avoid ordering dependencies.
378	*
379	* @param pDrvIns The driver instance data.
380	*/
381	static DECLCALLBACK(void) drvTCPPowerOff(PPDMDRVINS pDrvIns)
382	{
383	PDRVTCP pThis = PDMINS_2_DATA(pDrvIns, PDRVTCP);
384	LogFlow(("%s: %s\n", __FUNCTION__, pThis->pszLocation));
385
386	drvTCPShutdownListener(pThis);
387	}
388
389
390	/**
391	* Destruct a TCP socket stream driver instance.
392	*
393	* Most VM resources are freed by the VM. This callback is provided so that
394	* any non-VM resources can be freed correctly.
395	*
396	* @param pDrvIns The driver instance data.
397	*/
398	static DECLCALLBACK(void) drvTCPDestruct(PPDMDRVINS pDrvIns)
399	{
400	PDRVTCP pThis = PDMINS_2_DATA(pDrvIns, PDRVTCP);
401	LogFlow(("%s: %s\n", __FUNCTION__, pThis->pszLocation));
402	PDMDRV_CHECK_VERSIONS_RETURN_VOID(pDrvIns);
403
404	drvTCPShutdownListener(pThis);
405
406	/*
407	* While the thread exits, clean up as much as we can.
408	*/
409	if (pThis->hTcpSock != NIL_RTSOCKET)
410	{
411	int rc = RTPollSetRemove(pThis->hPollSet, DRVTCP_POLLSET_ID_SOCKET);
412	AssertRC(rc);
413
414	rc = RTSocketShutdown(pThis->hTcpSock, true /* fRead /, true / fWrite */);
415	AssertRC(rc);
416
417	rc = RTSocketClose(pThis->hTcpSock);
418	AssertRC(rc); RT_NOREF(rc);
419
420	pThis->hTcpSock = NIL_RTSOCKET;
421	}
422
423	if (pThis->hPipeWakeR != NIL_RTPIPE)
424	{
425	int rc = RTPipeClose(pThis->hPipeWakeR);
426	AssertRC(rc);
427
428	pThis->hPipeWakeR = NIL_RTPIPE;
429	}
430
431	if (pThis->hPipeWakeW != NIL_RTPIPE)
432	{
433	int rc = RTPipeClose(pThis->hPipeWakeW);
434	AssertRC(rc);
435
436	pThis->hPipeWakeW = NIL_RTPIPE;
437	}
438
439	if (pThis->hPollSet != NIL_RTPOLLSET)
440	{
441	int rc = RTPollSetDestroy(pThis->hPollSet);
442	AssertRC(rc);
443
444	pThis->hPollSet = NIL_RTPOLLSET;
445	}
446
447	MMR3HeapFree(pThis->pszLocation);
448	pThis->pszLocation = NULL;
449
450	/*
451	* Wait for the thread.
452	*/
453	if (pThis->ListenThread != NIL_RTTHREAD)
454	{
455	int rc = RTThreadWait(pThis->ListenThread, 30000, NULL);
456	if (RT_SUCCESS(rc))
457	pThis->ListenThread = NIL_RTTHREAD;
458	else
459	LogRel(("DrvTCP%d: listen thread did not terminate (%Rrc)\n", pDrvIns->iInstance, rc));
460	}
461	}
462
463
464	/**
465	* Construct a TCP socket stream driver instance.
466	*
467	* @copydoc FNPDMDRVCONSTRUCT
468	*/
469	static DECLCALLBACK(int) drvTCPConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags)
470	{
471	RT_NOREF(fFlags);
472	PDMDRV_CHECK_VERSIONS_RETURN(pDrvIns);
473	PDRVTCP pThis = PDMINS_2_DATA(pDrvIns, PDRVTCP);
474
475	/*
476	* Init the static parts.
477	*/
478	pThis->pDrvIns = pDrvIns;
479	pThis->pszLocation = NULL;
480	pThis->fIsServer = false;
481
482	pThis->hTcpServ = NULL;
483	pThis->hTcpSock = NIL_RTSOCKET;
484
485	pThis->hPollSet = NIL_RTPOLLSET;
486	pThis->hPipeWakeR = NIL_RTPIPE;
487	pThis->hPipeWakeW = NIL_RTPIPE;
488	pThis->fTcpSockInPollSet = false;
489
490	pThis->ListenThread = NIL_RTTHREAD;
491	pThis->fShutdown = false;
492	/* IBase */
493	pDrvIns->IBase.pfnQueryInterface = drvTCPQueryInterface;
494	/* IStream */
495	pThis->IStream.pfnPoll = drvTcpPoll;
496	pThis->IStream.pfnPollInterrupt = drvTcpPollInterrupt;
497	pThis->IStream.pfnRead = drvTcpRead;
498	pThis->IStream.pfnWrite = drvTcpWrite;
499
500	/*
501	* Validate and read the configuration.
502	*/
503	PDMDRV_VALIDATE_CONFIG_RETURN(pDrvIns, "Location\|IsServer", "");
504
505	int rc = CFGMR3QueryStringAlloc(pCfg, "Location", &pThis->pszLocation);
506	if (RT_FAILURE(rc))
507	return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS,
508	N_("Configuration error: querying \"Location\" resulted in %Rrc"), rc);
509	rc = CFGMR3QueryBool(pCfg, "IsServer", &pThis->fIsServer);
510	if (RT_FAILURE(rc))
511	return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS,
512	N_("Configuration error: querying \"IsServer\" resulted in %Rrc"), rc);
513
514	rc = RTPipeCreate(&pThis->hPipeWakeR, &pThis->hPipeWakeW, 0 /* fFlags */);
515	if (RT_FAILURE(rc))
516	return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS,
517	N_("DrvTCP#%d: Failed to create wake pipe"), pDrvIns->iInstance);
518
519	rc = RTPollSetCreate(&pThis->hPollSet);
520	if (RT_FAILURE(rc))
521	return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS,
522	N_("DrvTCP#%d: Failed to create poll set"), pDrvIns->iInstance);
523
524	rc = RTPollSetAddPipe(pThis->hPollSet, pThis->hPipeWakeR,
525	RTPOLL_EVT_READ \| RTPOLL_EVT_ERROR,
526	DRVTCP_POLLSET_ID_WAKEUP);
527	if (RT_FAILURE(rc))
528	return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS,
529	N_("DrvTCP#%d failed to add wakeup pipe for %s to poll set"),
530	pDrvIns->iInstance, pThis->pszLocation);
531
532	/*
533	* Create/Open the socket.
534	*/
535	if (pThis->fIsServer)
536	{
537	uint32_t uPort = 0;
538	rc = RTStrToUInt32Ex(pThis->pszLocation, NULL, 10, &uPort);
539	if (RT_FAILURE(rc))
540	return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS,
541	N_("DrvTCP#%d: The port part of the location is not a numerical value"),
542	pDrvIns->iInstance);
543
544	/** @todo Allow binding to distinct interfaces. */
545	rc = RTTcpServerCreateEx(NULL, uPort, &pThis->hTcpServ);
546	if (RT_FAILURE(rc))
547	return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS,
548	N_("DrvTCP#%d failed to create server socket"), pDrvIns->iInstance);
549
550	rc = RTThreadCreate(&pThis->ListenThread, drvTCPListenLoop, (void *)pThis, 0,
551	RTTHREADTYPE_IO, RTTHREADFLAGS_WAITABLE, "DrvTCPStream");
552	if (RT_FAILURE(rc))
553	return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS,
554	N_("DrvTCP#%d failed to create listening thread"), pDrvIns->iInstance);
555	}
556	else
557	{
558	char *pszPort = strchr(pThis->pszLocation, ':');
559	if (!pszPort)
560	return PDMDrvHlpVMSetError(pDrvIns, VERR_NOT_FOUND, RT_SRC_POS,
561	N_("DrvTCP#%d: The location misses the port to connect to"),
562	pDrvIns->iInstance);
563
564	pszPort = '\0'; / Overwrite temporarily to avoid copying the hostname into a temporary buffer. */
565	uint32_t uPort = 0;
566	rc = RTStrToUInt32Ex(pszPort + 1, NULL, 10, &uPort);
567	if (RT_FAILURE(rc))
568	return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS,
569	N_("DrvTCP#%d: The port part of the location is not a numerical value"),
570	pDrvIns->iInstance);
571
572	rc = RTTcpClientConnect(pThis->pszLocation, uPort, &pThis->hTcpSock);
573	pszPort = ':'; / Restore delimiter before checking the status. */
574	if (RT_FAILURE(rc))
575	return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS,
576	N_("DrvTCP#%d failed to connect to socket %s"),
577	pDrvIns->iInstance, pThis->pszLocation);
578
579	rc = RTPollSetAddSocket(pThis->hPollSet, pThis->hTcpSock,
580	RTPOLL_EVT_READ \| RTPOLL_EVT_WRITE \| RTPOLL_EVT_ERROR,
581	DRVTCP_POLLSET_ID_SOCKET);
582	if (RT_FAILURE(rc))
583	return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS,
584	N_("DrvTCP#%d failed to add socket for %s to poll set"),
585	pDrvIns->iInstance, pThis->pszLocation);
586
587	pThis->fTcpSockInPollSet = true;
588	}
589
590	LogRel(("DrvTCP: %s, %s\n", pThis->pszLocation, pThis->fIsServer ? "server" : "client"));
591	return VINF_SUCCESS;
592	}
593
594
595	/**
596	* TCP stream driver registration record.
597	*/
598	const PDMDRVREG g_DrvTCP =
599	{
600	/* u32Version */
601	PDM_DRVREG_VERSION,
602	/* szName */
603	"TCP",
604	/* szRCMod */
605	"",
606	/* szR0Mod */
607	"",
608	/* pszDescription */
609	"TCP serial stream driver.",
610	/* fFlags */
611	PDM_DRVREG_FLAGS_HOST_BITS_DEFAULT,
612	/* fClass. */
613	PDM_DRVREG_CLASS_STREAM,
614	/* cMaxInstances */
615	~0U,
616	/* cbInstance */
617	sizeof(DRVTCP),
618	/* pfnConstruct */
619	drvTCPConstruct,
620	/* pfnDestruct */
621	drvTCPDestruct,
622	/* pfnRelocate */
623	NULL,
624	/* pfnIOCtl */
625	NULL,
626	/* pfnPowerOn */
627	NULL,
628	/* pfnReset */
629	NULL,
630	/* pfnSuspend */
631	NULL,
632	/* pfnResume */
633	NULL,
634	/* pfnAttach */
635	NULL,
636	/* pfnDetach */
637	NULL,
638	/* pfnPowerOff */
639	drvTCPPowerOff,
640	/* pfnSoftReset */
641	NULL,
642	/* u32EndVersion */
643	PDM_DRVREG_VERSION
644	};
645

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

source: vbox/trunk/src/VBox/Devices/Serial/DrvTCP.cpp@ 69922

Download in other formats: