DrvNamedPipe.cpp@ 78110

Last change on this file since 78110 was 76553, checked in by vboxsync, 6 years ago
scm --update-copyright-year
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 38.1 KB

Line
1	/* $Id: DrvNamedPipe.cpp 76553 2019-01-01 01:45:53Z vboxsync $ */
2	/** @file
3	* Named pipe / local socket stream driver.
4	*/
5
6	/*
7	* Copyright (C) 2006-2019 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_NAMEDPIPE
23	#include <VBox/vmm/pdmdrv.h>
24	#include <iprt/assert.h>
25	#include <iprt/file.h>
26	#include <iprt/stream.h>
27	#include <iprt/alloc.h>
28	#include <iprt/pipe.h>
29	#include <iprt/poll.h>
30	#include <iprt/string.h>
31	#include <iprt/semaphore.h>
32	#include <iprt/socket.h>
33	#include <iprt/uuid.h>
34
35	#include "VBoxDD.h"
36
37	#ifdef RT_OS_WINDOWS
38	# include <iprt/win/windows.h>
39	#else /* !RT_OS_WINDOWS */
40	# include <errno.h>
41	# include <unistd.h>
42	# include <sys/types.h>
43	# include <sys/socket.h>
44	# include <sys/un.h>
45	# ifndef SHUT_RDWR /* OS/2 */
46	# define SHUT_RDWR 3
47	# endif
48	#endif /* !RT_OS_WINDOWS */
49
50
51	/*********************************************************************************************************************************
52	* Defined Constants And Macros *
53	*********************************************************************************************************************************/
54
55	#ifndef RT_OS_WINDOWS
56	# define DRVNAMEDPIPE_POLLSET_ID_SOCKET 0
57	# define DRVNAMEDPIPE_POLLSET_ID_WAKEUP 1
58	#endif
59
60	# define DRVNAMEDPIPE_WAKEUP_REASON_EXTERNAL 0
61	# define DRVNAMEDPIPE_WAKEUP_REASON_NEW_CONNECTION 1
62
63
64	/*********************************************************************************************************************************
65	* Structures and Typedefs *
66	*********************************************************************************************************************************/
67	/**
68	* Named pipe driver instance data.
69	*
70	* @implements PDMISTREAM
71	*/
72	typedef struct DRVNAMEDPIPE
73	{
74	/** The stream interface. */
75	PDMISTREAM IStream;
76	/** Pointer to the driver instance. */
77	PPDMDRVINS pDrvIns;
78	/** Pointer to the named pipe file name. (Freed by MM) */
79	char *pszLocation;
80	/** Flag whether VirtualBox represents the server or client side. */
81	bool fIsServer;
82	#ifdef RT_OS_WINDOWS
83	/** File handle of the named pipe. */
84	HANDLE NamedPipe;
85	/** The wake event handle. */
86	HANDLE hEvtWake;
87	/** Overlapped structure for writes. */
88	OVERLAPPED OverlappedWrite;
89	/** Overlapped structure for reads. */
90	OVERLAPPED OverlappedRead;
91	/** Listen thread wakeup semaphore */
92	RTSEMEVENTMULTI ListenSem;
93	/** Read buffer. */
94	uint8_t abBufRead[32];
95	/** Write buffer. */
96	uint8_t abBufWrite[32];
97	/** Read buffer currently used. */
98	size_t cbReadBufUsed;
99	/** Size of the write buffer used. */
100	size_t cbWriteBufUsed;
101	/** Flag whether a wake operation was caused by an external trigger. */
102	volatile bool fWakeExternal;
103	/** Flag whether a read was started. */
104	bool fReadPending;
105	#else /* !RT_OS_WINDOWS */
106	/** Poll set used to wait for I/O events. */
107	RTPOLLSET hPollSet;
108	/** Reading end of the wakeup pipe. */
109	RTPIPE hPipeWakeR;
110	/** Writing end of the wakeup pipe. */
111	RTPIPE hPipeWakeW;
112	/** Socket handle. */
113	RTSOCKET hSock;
114	/** Flag whether the socket is in the pollset. */
115	bool fSockInPollSet;
116	/** Socket handle of the local socket for server. */
117	int LocalSocketServer;
118	#endif /* !RT_OS_WINDOWS */
119	/** Thread for listening for new connections. */
120	RTTHREAD ListenThread;
121	/** Flag to signal listening thread to shut down. */
122	bool volatile fShutdown;
123	} DRVNAMEDPIPE, *PDRVNAMEDPIPE;
124
125
126	/*********************************************************************************************************************************
127	* Internal Functions *
128	*********************************************************************************************************************************/
129
130
131	/**
132	* Kicks any possibly polling thread to get informed about changes.
133	*
134	* @returns VBOx status code.
135	* @param pThis The named pipe driver instance.
136	* @param bReason The reason code to handle.
137	*/
138	static int drvNamedPipePollerKick(PDRVNAMEDPIPE pThis, uint8_t bReason)
139	{
140	#ifdef RT_OS_WINDOWS
141	if (bReason == DRVNAMEDPIPE_WAKEUP_REASON_EXTERNAL)
142	ASMAtomicXchgBool(&pThis->fWakeExternal, true);
143	if (!SetEvent(pThis->hEvtWake))
144	return RTErrConvertFromWin32(GetLastError());
145
146	return VINF_SUCCESS;
147	#else
148	size_t cbWritten = 0;
149	return RTPipeWrite(pThis->hPipeWakeW, &bReason, 1, &cbWritten);
150	#endif
151	}
152
153
154	/** @interface_method_impl{PDMISTREAM,pfnPoll} */
155	static DECLCALLBACK(int) drvNamedPipePoll(PPDMISTREAM pInterface, uint32_t fEvts, uint32_t *pfEvts, RTMSINTERVAL cMillies)
156	{
157	int rc = VINF_SUCCESS;
158	PDRVNAMEDPIPE pThis = RT_FROM_MEMBER(pInterface, DRVNAMEDPIPE, IStream);
159
160	LogFlowFunc(("pInterface=%#p fEvts=%#x pfEvts=%#p cMillies=%u\n", pInterface, fEvts, pfEvts, cMillies));
161
162	#ifdef RT_OS_WINDOWS
163	/* Immediately return if there is something to read or no write pending and the respective events are set. */
164	*pfEvts = 0;
165	if ( (fEvts & RTPOLL_EVT_READ)
166	&& pThis->cbReadBufUsed > 0)
167	*pfEvts \|= RTPOLL_EVT_READ;
168	if ( (fEvts & RTPOLL_EVT_WRITE)
169	&& !pThis->cbWriteBufUsed)
170	*pfEvts \|= RTPOLL_EVT_WRITE;
171
172	if (*pfEvts)
173	return VINF_SUCCESS;
174
175	while (RT_SUCCESS(rc))
176	{
177	/* Set up the waiting handles. */
178	HANDLE ahEvts[3];
179	unsigned cEvts = 0;
180
181	ahEvts[cEvts++] = pThis->hEvtWake;
182	if (fEvts & RTPOLL_EVT_WRITE)
183	{
184	Assert(pThis->cbWriteBufUsed);
185	ahEvts[cEvts++] = pThis->OverlappedWrite.hEvent;
186	}
187	if ( (fEvts & RTPOLL_EVT_READ)
188	&& pThis->NamedPipe != INVALID_HANDLE_VALUE
189	&& !pThis->fReadPending)
190	{
191	Assert(!pThis->cbReadBufUsed);
192
193	DWORD cbReallyRead;
194	pThis->OverlappedRead.Offset = 0;
195	pThis->OverlappedRead.OffsetHigh = 0;
196	if (!ReadFile(pThis->NamedPipe, &pThis->abBufRead[0], sizeof(pThis->abBufRead), &cbReallyRead, &pThis->OverlappedRead))
197	{
198	DWORD uError = GetLastError();
199
200	if (uError == ERROR_IO_PENDING)
201	{
202	uError = 0;
203	pThis->fReadPending = true;
204	}
205
206	if ( uError == ERROR_PIPE_LISTENING
207	\|\| uError == ERROR_PIPE_NOT_CONNECTED)
208	{
209	/* No connection yet/anymore */
210	cbReallyRead = 0;
211	}
212	else
213	{
214	rc = RTErrConvertFromWin32(uError);
215	Log(("drvNamedPipePoll: ReadFile returned %d (%Rrc)\n", uError, rc));
216	}
217	}
218	else
219	{
220	LogFlowFunc(("Read completed: cbReallyRead=%u\n", cbReallyRead));
221	pThis->fReadPending = false;
222	pThis->cbReadBufUsed = cbReallyRead;
223	*pfEvts \|= RTPOLL_EVT_READ;
224	return VINF_SUCCESS;
225	}
226
227	if (RT_FAILURE(rc))
228	{
229	Log(("drvNamedPipePoll: FileRead returned %Rrc fShutdown=%d\n", rc, pThis->fShutdown));
230	if ( !pThis->fShutdown
231	&& ( rc == VERR_EOF
232	\|\| rc == VERR_BROKEN_PIPE
233	)
234	)
235	{
236	FlushFileBuffers(pThis->NamedPipe);
237	DisconnectNamedPipe(pThis->NamedPipe);
238	if (!pThis->fIsServer)
239	{
240	CloseHandle(pThis->NamedPipe);
241	pThis->NamedPipe = INVALID_HANDLE_VALUE;
242	}
243	/* pretend success */
244	rc = VINF_SUCCESS;
245	}
246	cbReallyRead = 0;
247	}
248	}
249
250	if (pThis->fReadPending)
251	ahEvts[cEvts++] = pThis->OverlappedRead.hEvent;
252
253	DWORD dwMillies = cMillies == RT_INDEFINITE_WAIT ? INFINITE : cMillies;
254	DWORD uErr = WaitForMultipleObjects(cEvts, &ahEvts[0], FALSE /* bWaitAll */, dwMillies);
255	if (uErr == WAIT_TIMEOUT)
256	rc = VERR_TIMEOUT;
257	else if (uErr == WAIT_FAILED)
258	rc = RTErrConvertFromWin32(GetLastError());
259	else
260	{
261	/* Something triggered. */
262	unsigned idxEvt = uErr - WAIT_OBJECT_0;
263	Assert(idxEvt < cEvts);
264
265	LogFlowFunc(("Interrupted by pipe activity: idxEvt=%u\n", idxEvt));
266
267	if (idxEvt == 0)
268	{
269	/* The wakeup triggered. */
270	if (ASMAtomicXchgBool(&pThis->fWakeExternal, false))
271	rc = VERR_INTERRUPTED;
272	else
273	{
274	/*
275	* Internal event because there was a new connection from the listener thread,
276	* restart everything.
277	*/
278	rc = VINF_SUCCESS;
279	}
280	}
281	else if (ahEvts[idxEvt] == pThis->OverlappedWrite.hEvent)
282	{
283	LogFlowFunc(("Write completed\n"));
284	/* Fetch the result of the write. */
285	DWORD cbWritten = 0;
286	if (GetOverlappedResult(pThis->NamedPipe, &pThis->OverlappedWrite, &cbWritten, TRUE) == FALSE)
287	{
288	uErr = GetLastError();
289	rc = RTErrConvertFromWin32(uErr);
290	Log(("drvNamedPipePoll: Write completed with %d (%Rrc)\n", uErr, rc));
291
292	if (RT_FAILURE(rc))
293	{
294	/** @todo WriteFile(pipe) has been observed to return ERROR_NO_DATA
295	* (VERR_NO_DATA) instead of ERROR_BROKEN_PIPE, when the pipe is
296	* disconnected. */
297	if ( rc == VERR_EOF
298	\|\| rc == VERR_BROKEN_PIPE)
299	{
300	FlushFileBuffers(pThis->NamedPipe);
301	DisconnectNamedPipe(pThis->NamedPipe);
302	if (!pThis->fIsServer)
303	{
304	CloseHandle(pThis->NamedPipe);
305	pThis->NamedPipe = INVALID_HANDLE_VALUE;
306	}
307	/* pretend success */
308	rc = VINF_SUCCESS;
309	}
310	cbWritten = (DWORD)pThis->cbWriteBufUsed;
311	}
312	}
313
314	pThis->cbWriteBufUsed -= cbWritten;
315	if (!pThis->cbWriteBufUsed && (fEvts & RTPOLL_EVT_WRITE))
316	{
317	*pfEvts \|= RTPOLL_EVT_WRITE;
318	break;
319	}
320	}
321	else
322	{
323	Assert(ahEvts[idxEvt] == pThis->OverlappedRead.hEvent);
324
325	DWORD cbRead = 0;
326	if (GetOverlappedResult(pThis->NamedPipe, &pThis->OverlappedRead, &cbRead, TRUE) == FALSE)
327	{
328	uErr = GetLastError();
329	rc = RTErrConvertFromWin32(uErr);
330	Log(("drvNamedPipePoll: Read completed with %d (%Rrc)\n", uErr, rc));
331
332	if (RT_FAILURE(rc))
333	{
334	/** @todo WriteFile(pipe) has been observed to return ERROR_NO_DATA
335	* (VERR_NO_DATA) instead of ERROR_BROKEN_PIPE, when the pipe is
336	* disconnected. */
337	if ( rc == VERR_EOF
338	\|\| rc == VERR_BROKEN_PIPE)
339	{
340	FlushFileBuffers(pThis->NamedPipe);
341	DisconnectNamedPipe(pThis->NamedPipe);
342	if (!pThis->fIsServer)
343	{
344	CloseHandle(pThis->NamedPipe);
345	pThis->NamedPipe = INVALID_HANDLE_VALUE;
346	}
347	/* pretend success */
348	rc = VINF_SUCCESS;
349	}
350	cbRead = 0;
351	}
352	}
353
354	LogFlowFunc(("Read completed with cbRead=%u\n", cbRead));
355	pThis->fReadPending = false;
356	pThis->cbReadBufUsed = cbRead;
357	if (pThis->cbReadBufUsed && (fEvts & RTPOLL_EVT_READ))
358	{
359	*pfEvts \|= RTPOLL_EVT_READ;
360	break;
361	}
362	}
363	}
364	}
365	#else
366	if (pThis->hSock != NIL_RTSOCKET)
367	{
368	if (!pThis->fSockInPollSet)
369	{
370	rc = RTPollSetAddSocket(pThis->hPollSet, pThis->hSock,
371	fEvts, DRVNAMEDPIPE_POLLSET_ID_SOCKET);
372	if (RT_SUCCESS(rc))
373	pThis->fSockInPollSet = true;
374	}
375	else
376	{
377	/* Always include error event. */
378	fEvts \|= RTPOLL_EVT_ERROR;
379	rc = RTPollSetEventsChange(pThis->hPollSet, DRVNAMEDPIPE_POLLSET_ID_SOCKET, fEvts);
380	AssertRC(rc);
381	}
382	}
383
384	while (RT_SUCCESS(rc))
385	{
386	uint32_t fEvtsRecv = 0;
387	uint32_t idHnd = 0;
388
389	rc = RTPoll(pThis->hPollSet, cMillies, &fEvtsRecv, &idHnd);
390	if (RT_SUCCESS(rc))
391	{
392	if (idHnd == DRVNAMEDPIPE_POLLSET_ID_WAKEUP)
393	{
394	/* We got woken up, drain the pipe and return. */
395	uint8_t bReason;
396	size_t cbRead = 0;
397	rc = RTPipeRead(pThis->hPipeWakeR, &bReason, 1, &cbRead);
398	AssertRC(rc);
399
400	if (bReason == DRVNAMEDPIPE_WAKEUP_REASON_EXTERNAL)
401	rc = VERR_INTERRUPTED;
402	else if (bReason == DRVNAMEDPIPE_WAKEUP_REASON_NEW_CONNECTION)
403	{
404	Assert(!pThis->fSockInPollSet);
405	rc = RTPollSetAddSocket(pThis->hPollSet, pThis->hSock,
406	fEvts, DRVNAMEDPIPE_POLLSET_ID_SOCKET);
407	if (RT_SUCCESS(rc))
408	pThis->fSockInPollSet = true;
409	}
410	else
411	AssertMsgFailed(("Unknown wakeup reason in pipe %u\n", bReason));
412	}
413	else
414	{
415	Assert(idHnd == DRVNAMEDPIPE_POLLSET_ID_SOCKET);
416
417	/* On error we close the socket here. */
418	if (fEvtsRecv & RTPOLL_EVT_ERROR)
419	{
420	rc = RTPollSetRemove(pThis->hPollSet, DRVNAMEDPIPE_POLLSET_ID_SOCKET);
421	AssertRC(rc);
422
423	RTSocketClose(pThis->hSock);
424	pThis->hSock = NIL_RTSOCKET;
425	pThis->fSockInPollSet = false;
426	/* Continue with polling. */
427	}
428	else
429	{
430	*pfEvts = fEvtsRecv;
431	break;
432	}
433	}
434	}
435	}
436	#endif
437
438	LogFlowFunc(("returns %Rrc\n", rc));
439	return rc;
440	}
441
442
443	/** @interface_method_impl{PDMISTREAM,pfnPollInterrupt} */
444	static DECLCALLBACK(int) drvNamedPipePollInterrupt(PPDMISTREAM pInterface)
445	{
446	PDRVNAMEDPIPE pThis = RT_FROM_MEMBER(pInterface, DRVNAMEDPIPE, IStream);
447	return drvNamedPipePollerKick(pThis, DRVNAMEDPIPE_WAKEUP_REASON_EXTERNAL);
448	}
449
450
451	/** @interface_method_impl{PDMISTREAM,pfnRead} */
452	static DECLCALLBACK(int) drvNamedPipeRead(PPDMISTREAM pInterface, void pvBuf, size_t pcbRead)
453	{
454	int rc = VINF_SUCCESS;
455	PDRVNAMEDPIPE pThis = RT_FROM_MEMBER(pInterface, DRVNAMEDPIPE, IStream);
456	LogFlow(("%s: pvBuf=%p pcbRead=%#x (%s)\n", __FUNCTION__, pvBuf, pcbRead, pThis->pszLocation));
457
458	Assert(pvBuf);
459	#ifdef RT_OS_WINDOWS
460	if (pThis->NamedPipe != INVALID_HANDLE_VALUE)
461	{
462	/* Check if there is something in the read buffer and return as much as we can. */
463	if (pThis->cbReadBufUsed)
464	{
465	size_t cbRead = RT_MIN(*pcbRead, pThis->cbReadBufUsed);
466
467	memcpy(pvBuf, &pThis->abBufRead[0], cbRead);
468	if (cbRead < pThis->cbReadBufUsed)
469	memmove(&pThis->abBufRead[0], &pThis->abBufRead[cbRead], pThis->cbReadBufUsed - cbRead);
470	pThis->cbReadBufUsed -= cbRead;
471	*pcbRead = cbRead;
472	}
473	else
474	*pcbRead = 0;
475	}
476	#else /* !RT_OS_WINDOWS */
477	if (pThis->hSock != NIL_RTSOCKET)
478	{
479	size_t cbRead;
480	size_t cbBuf = *pcbRead;
481	rc = RTSocketReadNB(pThis->hSock, pvBuf, cbBuf, &cbRead);
482	if (RT_SUCCESS(rc))
483	{
484	if (!cbRead && rc != VINF_TRY_AGAIN)
485	{
486	rc = RTPollSetRemove(pThis->hPollSet, DRVNAMEDPIPE_POLLSET_ID_SOCKET);
487	AssertRC(rc);
488
489	RTSocketClose(pThis->hSock);
490	pThis->hSock = NIL_RTSOCKET;
491	pThis->fSockInPollSet = false;
492	rc = VINF_SUCCESS;
493	}
494	*pcbRead = cbRead;
495	}
496	}
497	#endif /* !RT_OS_WINDOWS */
498	else
499	{
500	RTThreadSleep(100);
501	*pcbRead = 0;
502	}
503
504	LogFlow(("%s: pcbRead=%zu returns %Rrc\n", __FUNCTION__, pcbRead, rc));
505	return rc;
506	}
507
508
509	/** @interface_method_impl{PDMISTREAM,pfnWrite} */
510	static DECLCALLBACK(int) drvNamedPipeWrite(PPDMISTREAM pInterface, const void pvBuf, size_t pcbWrite)
511	{
512	int rc = VINF_SUCCESS;
513	PDRVNAMEDPIPE pThis = RT_FROM_MEMBER(pInterface, DRVNAMEDPIPE, IStream);
514	LogFlow(("%s: pvBuf=%p pcbWrite=%#x (%s)\n", __FUNCTION__, pvBuf, pcbWrite, pThis->pszLocation));
515
516	Assert(pvBuf);
517	#ifdef RT_OS_WINDOWS
518	if (pThis->NamedPipe != INVALID_HANDLE_VALUE)
519	{
520	/* Accept the data in case the write buffer is empty. */
521	if (!pThis->cbWriteBufUsed)
522	{
523	size_t cbWrite = RT_MIN(*pcbWrite, sizeof(pThis->cbWriteBufUsed));
524
525	memcpy(&pThis->abBufWrite[0], pvBuf, cbWrite);
526	pThis->cbWriteBufUsed += cbWrite;
527
528	/* Initiate the write. */
529	pThis->OverlappedWrite.Offset = 0;
530	pThis->OverlappedWrite.OffsetHigh = 0;
531	if (!WriteFile(pThis->NamedPipe, pvBuf, (DWORD)cbWrite, NULL, &pThis->OverlappedWrite))
532	{
533	DWORD uError = GetLastError();
534
535	if ( uError == ERROR_PIPE_LISTENING
536	\|\| uError == ERROR_PIPE_NOT_CONNECTED)
537	{
538	/* No connection yet/anymore; just discard the write (pretending everything was written). */
539	pThis->cbWriteBufUsed = 0;
540	cbWrite = *pcbWrite;
541	}
542	else if (uError != ERROR_IO_PENDING) /* We wait for the write to complete in the poll callback. */
543	{
544	rc = RTErrConvertFromWin32(uError);
545	Log(("drvNamedPipeWrite: WriteFile returned %d (%Rrc)\n", uError, rc));
546	cbWrite = 0;
547	}
548	}
549
550	if (RT_FAILURE(rc))
551	{
552	/** @todo WriteFile(pipe) has been observed to return ERROR_NO_DATA
553	* (VERR_NO_DATA) instead of ERROR_BROKEN_PIPE, when the pipe is
554	* disconnected. */
555	if ( rc == VERR_EOF
556	\|\| rc == VERR_BROKEN_PIPE)
557	{
558	FlushFileBuffers(pThis->NamedPipe);
559	DisconnectNamedPipe(pThis->NamedPipe);
560	if (!pThis->fIsServer)
561	{
562	CloseHandle(pThis->NamedPipe);
563	pThis->NamedPipe = INVALID_HANDLE_VALUE;
564	}
565	/* pretend success */
566	rc = VINF_SUCCESS;
567	}
568	cbWrite = 0;
569	}
570
571	*pcbWrite = cbWrite;
572	}
573	else
574	*pcbWrite = 0;
575	}
576	#else /* !RT_OS_WINDOWS */
577	if (pThis->hSock != NIL_RTSOCKET)
578	{
579	size_t cbBuf = *pcbWrite;
580	rc = RTSocketWriteNB(pThis->hSock, pvBuf, cbBuf, pcbWrite);
581	}
582	else
583	*pcbWrite = 0;
584	#endif /* !RT_OS_WINDOWS */
585
586	LogFlow(("%s: returns %Rrc\n", __FUNCTION__, rc));
587	return rc;
588	}
589
590
591	/**
592	* @interface_method_impl{PDMIBASE,pfnQueryInterface}
593	*/
594	static DECLCALLBACK(void ) drvNamedPipeQueryInterface(PPDMIBASE pInterface, const char pszIID)
595	{
596	PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
597	PDRVNAMEDPIPE pThis = PDMINS_2_DATA(pDrvIns, PDRVNAMEDPIPE);
598	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pDrvIns->IBase);
599	PDMIBASE_RETURN_INTERFACE(pszIID, PDMISTREAM, &pThis->IStream);
600	return NULL;
601	}
602
603
604	/* -=-=-=-=- listen thread -=-=-=-=- */
605
606	/**
607	* Receive thread loop.
608	*
609	* @returns 0 on success.
610	* @param hThreadSelf Thread handle to this thread.
611	* @param pvUser User argument.
612	*/
613	static DECLCALLBACK(int) drvNamedPipeListenLoop(RTTHREAD hThreadSelf, void *pvUser)
614	{
615	RT_NOREF(hThreadSelf);
616	PDRVNAMEDPIPE pThis = (PDRVNAMEDPIPE)pvUser;
617	int rc = VINF_SUCCESS;
618	#ifdef RT_OS_WINDOWS
619	HANDLE NamedPipe = pThis->NamedPipe;
620	HANDLE hEvent = CreateEvent(NULL, TRUE, FALSE, 0);
621	#endif
622
623	while (RT_LIKELY(!pThis->fShutdown))
624	{
625	#ifdef RT_OS_WINDOWS
626	OVERLAPPED overlapped;
627
628	memset(&overlapped, 0, sizeof(overlapped));
629	overlapped.hEvent = hEvent;
630
631	BOOL fConnected = ConnectNamedPipe(NamedPipe, &overlapped);
632	if ( !fConnected
633	&& !pThis->fShutdown)
634	{
635	DWORD hrc = GetLastError();
636
637	if (hrc == ERROR_IO_PENDING)
638	{
639	DWORD dummy;
640
641	hrc = 0;
642	if (GetOverlappedResult(pThis->NamedPipe, &overlapped, &dummy, TRUE) == FALSE)
643	hrc = GetLastError();
644	else
645	drvNamedPipePollerKick(pThis, DRVNAMEDPIPE_WAKEUP_REASON_NEW_CONNECTION);
646	}
647
648	if (pThis->fShutdown)
649	break;
650
651	if (hrc == ERROR_PIPE_CONNECTED)
652	{
653	RTSemEventMultiWait(pThis->ListenSem, 250);
654	}
655	else if (hrc != ERROR_SUCCESS)
656	{
657	rc = RTErrConvertFromWin32(hrc);
658	LogRel(("NamedPipe%d: ConnectNamedPipe failed, rc=%Rrc\n", pThis->pDrvIns->iInstance, rc));
659	break;
660	}
661	}
662	#else /* !RT_OS_WINDOWS */
663	if (listen(pThis->LocalSocketServer, 0) == -1)
664	{
665	rc = RTErrConvertFromErrno(errno);
666	LogRel(("NamedPipe%d: listen failed, rc=%Rrc\n", pThis->pDrvIns->iInstance, rc));
667	break;
668	}
669	int s = accept(pThis->LocalSocketServer, NULL, NULL);
670	if (s == -1)
671	{
672	rc = RTErrConvertFromErrno(errno);
673	LogRel(("NamedPipe%d: accept failed, rc=%Rrc\n", pThis->pDrvIns->iInstance, rc));
674	break;
675	}
676	if (pThis->hSock != NIL_RTSOCKET)
677	{
678	LogRel(("NamedPipe%d: only single connection supported\n", pThis->pDrvIns->iInstance));
679	close(s);
680	}
681	else
682	{
683	RTSOCKET hSockNew = NIL_RTSOCKET;
684	rc = RTSocketFromNative(&hSockNew, s);
685	if (RT_SUCCESS(rc))
686	{
687	pThis->hSock = hSockNew;
688	/* Inform the poller about the new socket. */
689	drvNamedPipePollerKick(pThis, DRVNAMEDPIPE_WAKEUP_REASON_NEW_CONNECTION);
690	}
691	else
692	{
693	LogRel(("NamedPipe%d: Failed to wrap socket with %Rrc\n", pThis->pDrvIns->iInstance, rc));
694	close(s);
695	}
696	}
697	#endif /* !RT_OS_WINDOWS */
698	}
699
700	#ifdef RT_OS_WINDOWS
701	CloseHandle(hEvent);
702	#endif
703	return VINF_SUCCESS;
704	}
705
706	/* -=-=-=-=- PDMDRVREG -=-=-=-=- */
707
708	/**
709	* Common worker for drvNamedPipePowerOff and drvNamedPipeDestructor.
710	*
711	* @param pThis The instance data.
712	*/
713	static void drvNamedPipeShutdownListener(PDRVNAMEDPIPE pThis)
714	{
715	/*
716	* Signal shutdown of the listener thread.
717	*/
718	pThis->fShutdown = true;
719	#ifdef RT_OS_WINDOWS
720	if ( pThis->fIsServer
721	&& pThis->NamedPipe != INVALID_HANDLE_VALUE)
722	{
723	FlushFileBuffers(pThis->NamedPipe);
724	DisconnectNamedPipe(pThis->NamedPipe);
725
726	BOOL fRc = CloseHandle(pThis->NamedPipe);
727	Assert(fRc); NOREF(fRc);
728	pThis->NamedPipe = INVALID_HANDLE_VALUE;
729
730	/* Wake up listen thread */
731	if (pThis->ListenSem != NIL_RTSEMEVENT)
732	RTSemEventMultiSignal(pThis->ListenSem);
733	}
734	#else
735	if ( pThis->fIsServer
736	&& pThis->LocalSocketServer != -1)
737	{
738	int rc = shutdown(pThis->LocalSocketServer, SHUT_RDWR);
739	AssertRC(rc == 0); NOREF(rc);
740
741	rc = close(pThis->LocalSocketServer);
742	AssertRC(rc == 0);
743	pThis->LocalSocketServer = -1;
744	}
745	#endif
746	}
747
748
749	/**
750	* Power off a named pipe stream driver instance.
751	*
752	* This does most of the destruction work, to avoid ordering dependencies.
753	*
754	* @param pDrvIns The driver instance data.
755	*/
756	static DECLCALLBACK(void) drvNamedPipePowerOff(PPDMDRVINS pDrvIns)
757	{
758	PDRVNAMEDPIPE pThis = PDMINS_2_DATA(pDrvIns, PDRVNAMEDPIPE);
759	LogFlow(("%s: %s\n", __FUNCTION__, pThis->pszLocation));
760
761	drvNamedPipeShutdownListener(pThis);
762	}
763
764
765	/**
766	* Destruct a named pipe stream driver instance.
767	*
768	* Most VM resources are freed by the VM. This callback is provided so that
769	* any non-VM resources can be freed correctly.
770	*
771	* @param pDrvIns The driver instance data.
772	*/
773	static DECLCALLBACK(void) drvNamedPipeDestruct(PPDMDRVINS pDrvIns)
774	{
775	PDRVNAMEDPIPE pThis = PDMINS_2_DATA(pDrvIns, PDRVNAMEDPIPE);
776	LogFlow(("%s: %s\n", __FUNCTION__, pThis->pszLocation));
777	PDMDRV_CHECK_VERSIONS_RETURN_VOID(pDrvIns);
778
779	drvNamedPipeShutdownListener(pThis);
780
781	/*
782	* While the thread exits, clean up as much as we can.
783	*/
784	#ifdef RT_OS_WINDOWS
785	if (pThis->NamedPipe != INVALID_HANDLE_VALUE)
786	{
787	CloseHandle(pThis->NamedPipe);
788	pThis->NamedPipe = INVALID_HANDLE_VALUE;
789	}
790	if (pThis->OverlappedRead.hEvent != NULL)
791	{
792	CloseHandle(pThis->OverlappedRead.hEvent);
793	pThis->OverlappedRead.hEvent = NULL;
794	}
795	if (pThis->OverlappedWrite.hEvent != NULL)
796	{
797	CloseHandle(pThis->OverlappedWrite.hEvent);
798	pThis->OverlappedWrite.hEvent = NULL;
799	}
800	if (pThis->hEvtWake != NULL)
801	{
802	CloseHandle(pThis->hEvtWake);
803	pThis->hEvtWake = NULL;
804	}
805	#else /* !RT_OS_WINDOWS */
806	Assert(pThis->LocalSocketServer == -1);
807
808	if (pThis->hSock != NIL_RTSOCKET)
809	{
810	int rc = RTPollSetRemove(pThis->hPollSet, DRVNAMEDPIPE_POLLSET_ID_SOCKET);
811	AssertRC(rc);
812
813	rc = RTSocketShutdown(pThis->hSock, true /* fRead /, true / fWrite */);
814	AssertRC(rc);
815
816	rc = RTSocketClose(pThis->hSock);
817	AssertRC(rc); RT_NOREF(rc);
818
819	pThis->hSock = NIL_RTSOCKET;
820	}
821
822	if (pThis->hPipeWakeR != NIL_RTPIPE)
823	{
824	int rc = RTPipeClose(pThis->hPipeWakeR);
825	AssertRC(rc);
826
827	pThis->hPipeWakeR = NIL_RTPIPE;
828	}
829
830	if (pThis->hPipeWakeW != NIL_RTPIPE)
831	{
832	int rc = RTPipeClose(pThis->hPipeWakeW);
833	AssertRC(rc);
834
835	pThis->hPipeWakeW = NIL_RTPIPE;
836	}
837
838	if (pThis->hPollSet != NIL_RTPOLLSET)
839	{
840	int rc = RTPollSetDestroy(pThis->hPollSet);
841	AssertRC(rc);
842
843	pThis->hPollSet = NIL_RTPOLLSET;
844	}
845
846	if ( pThis->fIsServer
847	&& pThis->pszLocation)
848	RTFileDelete(pThis->pszLocation);
849	#endif /* !RT_OS_WINDOWS */
850
851	MMR3HeapFree(pThis->pszLocation);
852	pThis->pszLocation = NULL;
853
854	/*
855	* Wait for the thread.
856	*/
857	if (pThis->ListenThread != NIL_RTTHREAD)
858	{
859	int rc = RTThreadWait(pThis->ListenThread, 30000, NULL);
860	if (RT_SUCCESS(rc))
861	pThis->ListenThread = NIL_RTTHREAD;
862	else
863	LogRel(("NamedPipe%d: listen thread did not terminate (%Rrc)\n", pDrvIns->iInstance, rc));
864	}
865
866	/*
867	* The last bits of cleanup.
868	*/
869	#ifdef RT_OS_WINDOWS
870	if (pThis->ListenSem != NIL_RTSEMEVENT)
871	{
872	RTSemEventMultiDestroy(pThis->ListenSem);
873	pThis->ListenSem = NIL_RTSEMEVENT;
874	}
875	#endif
876	}
877
878
879	/**
880	* Construct a named pipe stream driver instance.
881	*
882	* @copydoc FNPDMDRVCONSTRUCT
883	*/
884	static DECLCALLBACK(int) drvNamedPipeConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags)
885	{
886	RT_NOREF(fFlags);
887	PDMDRV_CHECK_VERSIONS_RETURN(pDrvIns);
888	PDRVNAMEDPIPE pThis = PDMINS_2_DATA(pDrvIns, PDRVNAMEDPIPE);
889
890	/*
891	* Init the static parts.
892	*/
893	pThis->pDrvIns = pDrvIns;
894	pThis->pszLocation = NULL;
895	pThis->fIsServer = false;
896	#ifdef RT_OS_WINDOWS
897	pThis->NamedPipe = INVALID_HANDLE_VALUE;
898	pThis->ListenSem = NIL_RTSEMEVENTMULTI;
899	pThis->OverlappedWrite.hEvent = NULL;
900	pThis->OverlappedRead.hEvent = NULL;
901	pThis->hEvtWake = NULL;
902	#else /* !RT_OS_WINDOWS */
903	pThis->LocalSocketServer = -1;
904	pThis->hSock = NIL_RTSOCKET;
905
906	pThis->hPollSet = NIL_RTPOLLSET;
907	pThis->hPipeWakeR = NIL_RTPIPE;
908	pThis->hPipeWakeW = NIL_RTPIPE;
909	pThis->fSockInPollSet = false;
910	#endif /* !RT_OS_WINDOWS */
911	pThis->ListenThread = NIL_RTTHREAD;
912	pThis->fShutdown = false;
913	/* IBase */
914	pDrvIns->IBase.pfnQueryInterface = drvNamedPipeQueryInterface;
915	/* IStream */
916	pThis->IStream.pfnPoll = drvNamedPipePoll;
917	pThis->IStream.pfnPollInterrupt = drvNamedPipePollInterrupt;
918	pThis->IStream.pfnRead = drvNamedPipeRead;
919	pThis->IStream.pfnWrite = drvNamedPipeWrite;
920
921	/*
922	* Validate and read the configuration.
923	*/
924	PDMDRV_VALIDATE_CONFIG_RETURN(pDrvIns, "Location\|IsServer", "");
925
926	int rc = CFGMR3QueryStringAlloc(pCfg, "Location", &pThis->pszLocation);
927	if (RT_FAILURE(rc))
928	return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS,
929	N_("Configuration error: querying \"Location\" resulted in %Rrc"), rc);
930	rc = CFGMR3QueryBool(pCfg, "IsServer", &pThis->fIsServer);
931	if (RT_FAILURE(rc))
932	return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS,
933	N_("Configuration error: querying \"IsServer\" resulted in %Rrc"), rc);
934
935	/*
936	* Create/Open the pipe.
937	*/
938	#ifdef RT_OS_WINDOWS
939	if (pThis->fIsServer)
940	{
941	pThis->NamedPipe = CreateNamedPipe(pThis->pszLocation,
942	PIPE_ACCESS_DUPLEX \| FILE_FLAG_OVERLAPPED,
943	PIPE_TYPE_BYTE \| PIPE_READMODE_BYTE \| PIPE_WAIT,
944	1, /nMaxInstances/
945	32, /nOutBufferSize/
946	32, /nOutBufferSize/
947	10000, /nDefaultTimeOut/
948	NULL); /* lpSecurityAttributes*/
949	if (pThis->NamedPipe == INVALID_HANDLE_VALUE)
950	{
951	rc = RTErrConvertFromWin32(GetLastError());
952	LogRel(("NamedPipe%d: CreateNamedPipe failed rc=%Rrc\n", pThis->pDrvIns->iInstance));
953	return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS, N_("NamedPipe#%d failed to create named pipe %s"),
954	pDrvIns->iInstance, pThis->pszLocation);
955	}
956
957	rc = RTSemEventMultiCreate(&pThis->ListenSem);
958	AssertRCReturn(rc, rc);
959
960	rc = RTThreadCreate(&pThis->ListenThread, drvNamedPipeListenLoop, (void *)pThis, 0,
961	RTTHREADTYPE_IO, RTTHREADFLAGS_WAITABLE, "SerPipe");
962	if (RT_FAILURE(rc))
963	return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS, N_("NamedPipe#%d failed to create listening thread"),
964	pDrvIns->iInstance);
965
966	}
967	else
968	{
969	/* Connect to the named pipe. */
970	pThis->NamedPipe = CreateFile(pThis->pszLocation, GENERIC_READ \| GENERIC_WRITE, 0, NULL,
971	OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL);
972	if (pThis->NamedPipe == INVALID_HANDLE_VALUE)
973	{
974	rc = RTErrConvertFromWin32(GetLastError());
975	LogRel(("NamedPipe%d: CreateFile failed rc=%Rrc\n", pThis->pDrvIns->iInstance));
976	return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS, N_("NamedPipe#%d failed to connect to named pipe %s"),
977	pDrvIns->iInstance, pThis->pszLocation);
978	}
979	}
980
981	memset(&pThis->OverlappedWrite, 0, sizeof(pThis->OverlappedWrite));
982	pThis->OverlappedWrite.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
983	AssertReturn(pThis->OverlappedWrite.hEvent != NULL, VERR_OUT_OF_RESOURCES);
984
985	memset(&pThis->OverlappedRead, 0, sizeof(pThis->OverlappedRead));
986	pThis->OverlappedRead.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
987	AssertReturn(pThis->OverlappedRead.hEvent != NULL, VERR_OUT_OF_RESOURCES);
988
989	pThis->hEvtWake = CreateEvent(NULL, FALSE, FALSE, NULL);
990	AssertReturn(pThis->hEvtWake != NULL, VERR_OUT_OF_RESOURCES);
991
992	#else /* !RT_OS_WINDOWS */
993	rc = RTPipeCreate(&pThis->hPipeWakeR, &pThis->hPipeWakeW, 0 /* fFlags */);
994	if (RT_FAILURE(rc))
995	return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS,
996	N_("DrvTCP#%d: Failed to create wake pipe"), pDrvIns->iInstance);
997
998	rc = RTPollSetCreate(&pThis->hPollSet);
999	if (RT_FAILURE(rc))
1000	return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS,
1001	N_("DrvTCP#%d: Failed to create poll set"), pDrvIns->iInstance);
1002
1003	rc = RTPollSetAddPipe(pThis->hPollSet, pThis->hPipeWakeR,
1004	RTPOLL_EVT_READ \| RTPOLL_EVT_ERROR,
1005	DRVNAMEDPIPE_POLLSET_ID_WAKEUP);
1006	if (RT_FAILURE(rc))
1007	return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS,
1008	N_("DrvTCP#%d failed to add wakeup pipe for %s to poll set"),
1009	pDrvIns->iInstance, pThis->pszLocation);
1010
1011	int s = socket(PF_UNIX, SOCK_STREAM, 0);
1012	if (s == -1)
1013	return PDMDrvHlpVMSetError(pDrvIns, RTErrConvertFromErrno(errno), RT_SRC_POS,
1014	N_("NamedPipe#%d failed to create local socket"), pDrvIns->iInstance);
1015
1016	struct sockaddr_un addr;
1017	memset(&addr, 0, sizeof(addr));
1018	addr.sun_family = AF_UNIX;
1019	strncpy(addr.sun_path, pThis->pszLocation, sizeof(addr.sun_path) - 1);
1020
1021	if (pThis->fIsServer)
1022	{
1023	/* Bind address to the local socket. */
1024	pThis->LocalSocketServer = s;
1025	RTFileDelete(pThis->pszLocation);
1026	if (bind(s, (struct sockaddr *)&addr, sizeof(addr)) == -1)
1027	return PDMDrvHlpVMSetError(pDrvIns, RTErrConvertFromErrno(errno), RT_SRC_POS,
1028	N_("NamedPipe#%d failed to bind to local socket %s"),
1029	pDrvIns->iInstance, pThis->pszLocation);
1030	rc = RTThreadCreate(&pThis->ListenThread, drvNamedPipeListenLoop, (void *)pThis, 0,
1031	RTTHREADTYPE_IO, RTTHREADFLAGS_WAITABLE, "SerPipe");
1032	if (RT_FAILURE(rc))
1033	return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS,
1034	N_("NamedPipe#%d failed to create listening thread"), pDrvIns->iInstance);
1035	}
1036	else
1037	{
1038	/* Connect to the local socket. */
1039	if (connect(s, (struct sockaddr *)&addr, sizeof(addr)) == -1)
1040	return PDMDrvHlpVMSetError(pDrvIns, RTErrConvertFromErrno(errno), RT_SRC_POS,
1041	N_("NamedPipe#%d failed to connect to local socket %s"),
1042	pDrvIns->iInstance, pThis->pszLocation);
1043
1044	rc = RTSocketFromNative(&pThis->hSock, s);
1045	if (RT_FAILURE(rc))
1046	{
1047	close(s);
1048	return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS,
1049	N_("NamedPipe#%d failed to wrap socket %Rrc"),
1050	pDrvIns->iInstance, pThis->pszLocation);
1051	}
1052	}
1053	#endif /* !RT_OS_WINDOWS */
1054
1055	LogRel(("NamedPipe: location %s, %s\n", pThis->pszLocation, pThis->fIsServer ? "server" : "client"));
1056	return VINF_SUCCESS;
1057	}
1058
1059
1060	/**
1061	* Named pipe driver registration record.
1062	*/
1063	const PDMDRVREG g_DrvNamedPipe =
1064	{
1065	/* u32Version */
1066	PDM_DRVREG_VERSION,
1067	/* szName */
1068	"NamedPipe",
1069	/* szRCMod */
1070	"",
1071	/* szR0Mod */
1072	"",
1073	/* pszDescription */
1074	"Named Pipe stream driver.",
1075	/* fFlags */
1076	PDM_DRVREG_FLAGS_HOST_BITS_DEFAULT,
1077	/* fClass. */
1078	PDM_DRVREG_CLASS_STREAM,
1079	/* cMaxInstances */
1080	~0U,
1081	/* cbInstance */
1082	sizeof(DRVNAMEDPIPE),
1083	/* pfnConstruct */
1084	drvNamedPipeConstruct,
1085	/* pfnDestruct */
1086	drvNamedPipeDestruct,
1087	/* pfnRelocate */
1088	NULL,
1089	/* pfnIOCtl */
1090	NULL,
1091	/* pfnPowerOn */
1092	NULL,
1093	/* pfnReset */
1094	NULL,
1095	/* pfnSuspend */
1096	NULL,
1097	/* pfnResume */
1098	NULL,
1099	/* pfnAttach */
1100	NULL,
1101	/* pfnDetach */
1102	NULL,
1103	/* pfnPowerOff */
1104	drvNamedPipePowerOff,
1105	/* pfnSoftReset */
1106	NULL,
1107	/* u32EndVersion */
1108	PDM_DRVREG_VERSION
1109	};
1110

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

source: vbox/trunk/src/VBox/Devices/Serial/DrvNamedPipe.cpp@ 78110

Download in other formats: