VirtualBox

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

Last change on this file since 74942 was 69664, checked in by vboxsync, 7 years ago

Devices/Serial: Fix stuck I/O on Windows when using named pipes
  • 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 69664 2017-11-12 23:46:38Z vboxsync $ */
2/** @file
3 * Named pipe / local socket stream 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_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 */
72typedef 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 */
138static 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} */
155static 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} */
444static 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} */
452static 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} */
510static 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 */
594static 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 */
613static 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 */
713static 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 */
756static 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 */
773static 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 */
884static 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 */
1063const 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.

© 2023 Oracle
Contact – Privacy policy – Terms of Use