/**
* Reads from a pipe.
*
* @returns @a rc or other status code.
* @param rc The current status of the operation. Error status
* are preserved and returned.
* @param phPipeR Pointer to the pipe handle.
* @param pcbAllocated Pointer to the buffer size variable.
* @param poffCur Pointer to the buffer offset variable.
* @param ppszBuffer Pointer to the buffer pointer variable.
*/
static int rtProcProcessOutput(int rc, PRTPIPE phPipeR, size_t *pcbAllocated, size_t *poffCur, char **ppszBuffer,
RTPOLLSET hPollSet, uint32_t idPollSet)
{
size_t cbRead;
char szTmp[_4K - 1];
for (;;)
{
int rc2 = RTPipeRead(*phPipeR, szTmp, sizeof(szTmp), &cbRead);
if (RT_SUCCESS(rc2) && cbRead)
{
/* Resize the buffer. */
if (*poffCur + cbRead >= *pcbAllocated)
{
if (*pcbAllocated >= _1G)
{
RTPollSetRemove(hPollSet, idPollSet);
rc2 = RTPipeClose(*phPipeR); AssertRC(rc2);
*phPipeR = NIL_RTPIPE;
return RT_SUCCESS(rc) ? VERR_TOO_MUCH_DATA : rc;
}
size_t cbNew = *pcbAllocated ? *pcbAllocated * 2 : sizeof(szTmp) + 1;
Assert(*poffCur + cbRead < cbNew);
rc2 = RTStrRealloc(ppszBuffer, cbNew);
if (RT_FAILURE(rc2))
{
RTPollSetRemove(hPollSet, idPollSet);
rc2 = RTPipeClose(*phPipeR); AssertRC(rc2);
*phPipeR = NIL_RTPIPE;
return RT_SUCCESS(rc) ? rc2 : rc;
}
*pcbAllocated = cbNew;
}
/* Append the new data, terminating it. */
memcpy(*ppszBuffer + *poffCur, szTmp, cbRead);
*poffCur += cbRead;
(*ppszBuffer)[*poffCur] = '\0';
/* Check for null terminators in the string. */
if (RT_SUCCESS(rc) && memchr(szTmp, '\0', cbRead))
rc = VERR_NO_TRANSLATION;
/* If we read a full buffer, try read some more. */
if (RT_SUCCESS(rc) && cbRead == sizeof(szTmp))
continue;
}
else if (rc2 != VINF_TRY_AGAIN)
{
if (RT_FAILURE(rc) && rc2 != VERR_BROKEN_PIPE)
rc = rc2;
RTPollSetRemove(hPollSet, idPollSet);
rc2 = RTPipeClose(*phPipeR); AssertRC(rc2);
*phPipeR = NIL_RTPIPE;
}
return rc;
}
}
/**
* Stop all service threads and free the device chain.
*/
USBProxyBackendUsbIp::~USBProxyBackendUsbIp()
{
LogFlowThisFunc(("\n"));
/*
* Stop the service.
*/
if (isActive())
stop();
/*
* Free resources.
*/
if (m->hPollSet != NIL_RTPOLLSET)
{
disconnect();
int rc = RTPollSetRemove(m->hPollSet, USBIP_POLL_ID_PIPE);
AssertRC(rc);
rc = RTPollSetDestroy(m->hPollSet);
AssertRC(rc);
rc = RTPipeClose(m->hWakeupPipeR);
AssertRC(rc);
rc = RTPipeClose(m->hWakeupPipeW);
AssertRC(rc);
}
if (m->pszHost)
RTStrFree(m->pszHost);
if (m->hMtxDevices != NIL_RTSEMFASTMUTEX)
RTSemFastMutexDestroy(m->hMtxDevices);
delete m;
}
/**
* Disconnects from the host and resets the receive state.
*
* @returns nothing.
*/
void USBProxyBackendUsbIp::disconnect()
{
if (m->hSocket != NIL_RTSOCKET)
{
int rc = RTPollSetRemove(m->hPollSet, USBIP_POLL_ID_SOCKET);
Assert(RT_SUCCESS(rc) || rc == VERR_POLL_HANDLE_ID_NOT_FOUND);
RTTcpClientCloseEx(m->hSocket, false /*fGracefulShutdown*/);
m->hSocket = NIL_RTSOCKET;
}
resetRecvState();
}
/**
* Initializes the object (called right after construction).
*
* @returns S_OK on success and non-fatal failures, some COM error otherwise.
*/
int USBProxyBackendUsbIp::init(void)
{
int rc = VINF_SUCCESS;
m = new Data;
/** @todo: Pass in some config like host and port to connect to. */
/* Setup wakeup pipe and poll set first. */
rc = RTSemFastMutexCreate(&m->hMtxDevices);
if (RT_SUCCESS(rc))
{
rc = RTPipeCreate(&m->hWakeupPipeR, &m->hWakeupPipeW, 0);
if (RT_SUCCESS(rc))
{
rc = RTPollSetCreate(&m->hPollSet);
if (RT_SUCCESS(rc))
{
rc = RTPollSetAddPipe(m->hPollSet, m->hWakeupPipeR,
RTPOLL_EVT_READ, USBIP_POLL_ID_PIPE);
if (RT_SUCCESS(rc))
{
/* Connect to the USB/IP host. */
rc = reconnect();
if (RT_SUCCESS(rc))
rc = start(); /* Start service thread. */
}
if (RT_FAILURE(rc))
{
RTPollSetRemove(m->hPollSet, USBIP_POLL_ID_PIPE);
int rc2 = RTPollSetDestroy(m->hPollSet);
AssertRC(rc2);
}
}
if (RT_FAILURE(rc))
{
int rc2 = RTPipeClose(m->hWakeupPipeR);
AssertRC(rc2);
rc2 = RTPipeClose(m->hWakeupPipeW);
AssertRC(rc2);
}
}
if (RT_FAILURE(rc))
RTSemFastMutexDestroy(m->hMtxDevices);
}
return rc;
}
/** @interface_method_impl{PDMISTREAM,pfnRead} */
static DECLCALLBACK(int) drvTcpRead(PPDMISTREAM pInterface, void *pvBuf, size_t *pcbRead)
{
int rc = VINF_SUCCESS;
PDRVTCP pThis = RT_FROM_MEMBER(pInterface, DRVTCP, IStream);
LogFlow(("%s: pvBuf=%p *pcbRead=%#x (%s)\n", __FUNCTION__, pvBuf, *pcbRead, pThis->pszLocation));
Assert(pvBuf);
if (pThis->hTcpSock != NIL_RTSOCKET)
{
size_t cbRead;
size_t cbBuf = *pcbRead;
rc = RTSocketReadNB(pThis->hTcpSock, pvBuf, cbBuf, &cbRead);
if (RT_SUCCESS(rc))
{
if (!cbRead && rc != VINF_TRY_AGAIN)
{
rc = RTPollSetRemove(pThis->hPollSet, DRVTCP_POLLSET_ID_SOCKET);
AssertRC(rc);
if (pThis->fIsServer)
RTTcpServerDisconnectClient2(pThis->hTcpSock);
else
RTSocketClose(pThis->hTcpSock);
pThis->hTcpSock = NIL_RTSOCKET;
pThis->fTcpSockInPollSet = false;
rc = VINF_SUCCESS;
}
*pcbRead = cbRead;
}
}
else
{
RTThreadSleep(100);
*pcbRead = 0;
}
LogFlow(("%s: *pcbRead=%zu returns %Rrc\n", __FUNCTION__, *pcbRead, rc));
return rc;
}
static void tstRTPoll2(void)
{
RTTestISub("Negative");
/*
* Bad set pointer and handle values.
*/
RTTESTI_CHECK_RC(RTPollSetCreate(NULL), VERR_INVALID_POINTER);
RTPOLLSET hSetInvl = (RTPOLLSET)(intptr_t)-3;
RTTESTI_CHECK_RC(RTPollSetDestroy(hSetInvl), VERR_INVALID_HANDLE);
RTHANDLE Handle;
Handle.enmType = RTHANDLETYPE_PIPE;
Handle.u.hPipe = NIL_RTPIPE;
RTTESTI_CHECK_RC(RTPollSetAdd(hSetInvl, &Handle, RTPOLL_EVT_ERROR, 1), VERR_INVALID_HANDLE);
RTTESTI_CHECK_RC(RTPollSetRemove(hSetInvl, 1), VERR_INVALID_HANDLE);
RTTESTI_CHECK_RC(RTPollSetQueryHandle(hSetInvl, 1, NULL), VERR_INVALID_HANDLE);
RTTESTI_CHECK(RTPollSetGetCount(hSetInvl) == UINT32_MAX);
RTTESTI_CHECK_RC(RTPoll(hSetInvl, 0, NULL, NULL), VERR_INVALID_HANDLE);
RTTESTI_CHECK_RC(RTPollNoResume(hSetInvl, 0, NULL, NULL), VERR_INVALID_HANDLE);
/*
* Invalid arguments and other stuff.
*/
RTPOLLSET hSet = NIL_RTPOLLSET;
RTTESTI_CHECK_RC_RETV(RTPollSetCreate(&hSet), VINF_SUCCESS);
RTTESTI_CHECK_RC(RTPoll(hSet, RT_INDEFINITE_WAIT, NULL, NULL), VERR_DEADLOCK);
RTTESTI_CHECK_RC(RTPollNoResume(hSet, RT_INDEFINITE_WAIT, NULL, NULL), VERR_DEADLOCK);
RTTESTI_CHECK_RC(RTPollSetRemove(hSet, UINT32_MAX), VERR_INVALID_PARAMETER);
RTTESTI_CHECK_RC(RTPollSetQueryHandle(hSet, 1, NULL), VERR_POLL_HANDLE_ID_NOT_FOUND);
RTTESTI_CHECK_RC(RTPollSetRemove(hSet, 1), VERR_POLL_HANDLE_ID_NOT_FOUND);
RTTESTI_CHECK_RC(RTPollSetAdd(hSet, NULL, RTPOLL_EVT_ERROR, 1), VINF_SUCCESS);
RTTESTI_CHECK_RC(RTPollSetAdd(hSet, &Handle, RTPOLL_EVT_ERROR, UINT32_MAX), VERR_INVALID_PARAMETER);
RTTESTI_CHECK_RC(RTPollSetAdd(hSet, &Handle, UINT32_MAX, 3), VERR_INVALID_PARAMETER);
Handle.enmType = RTHANDLETYPE_INVALID;
RTTESTI_CHECK_RC(RTPollSetAdd(hSet, &Handle, RTPOLL_EVT_ERROR, 3), VERR_INVALID_PARAMETER);
RTTESTI_CHECK_RC(RTPollSetAdd(hSet, NULL, RTPOLL_EVT_ERROR, UINT32_MAX), VERR_INVALID_PARAMETER);
/* duplicate id */
RTPIPE hPipeR;
RTPIPE hPipeW;
RTTESTI_CHECK_RC_RETV(RTPipeCreate(&hPipeR, &hPipeW, 0/*fFlags*/), VINF_SUCCESS);
RTTESTI_CHECK_RC(RTPollSetAddPipe(hSet, hPipeR, RTPOLL_EVT_ERROR, 0), VINF_SUCCESS);
RTTESTI_CHECK_RC(RTPollSetAddPipe(hSet, hPipeR, RTPOLL_EVT_ERROR, 0), VERR_POLL_HANDLE_ID_EXISTS);
RTTESTI_CHECK_RC(RTPollSetRemove(hSet, 0), VINF_SUCCESS);
RTPipeClose(hPipeR);
RTPipeClose(hPipeW);
/* non-pollable handle */
RTFILE hBitBucket;
RTTESTI_CHECK_RC_RETV(RTFileOpenBitBucket(&hBitBucket, RTFILE_O_WRITE), VINF_SUCCESS);
Handle.enmType = RTHANDLETYPE_FILE;
Handle.u.hFile = hBitBucket;
RTTESTI_CHECK_RC(RTPollSetAdd(hSet, &Handle, RTPOLL_EVT_WRITE, 10), VERR_POLL_HANDLE_NOT_POLLABLE);
RTFileClose(hBitBucket);
RTTESTI_CHECK_RC_RETV(RTPollSetDestroy(hSet), VINF_SUCCESS);
}
static void tstRTPoll1(void)
{
RTTestISub("Basics");
/* create and destroy. */
RTPOLLSET hSet = NIL_RTPOLLSET;
RTTESTI_CHECK_RC_RETV(RTPollSetCreate(&hSet), VINF_SUCCESS);
RTTESTI_CHECK_RETV(hSet != NIL_RTPOLLSET);
RTTESTI_CHECK_RC(RTPollSetDestroy(hSet), VINF_SUCCESS);
RTTESTI_CHECK_RC(RTPollSetDestroy(NIL_RTPOLLSET), VINF_SUCCESS);
/* empty set, adding a NIL handle. */
hSet = NIL_RTPOLLSET;
RTTESTI_CHECK_RC_RETV(RTPollSetCreate(&hSet), VINF_SUCCESS);
RTTESTI_CHECK_RETV(hSet != NIL_RTPOLLSET);
RTTESTI_CHECK_RETV(RTPollSetGetCount(hSet) == 0);
RTTESTI_CHECK_RC(RTPollSetQueryHandle(hSet, 0, NULL), VERR_POLL_HANDLE_ID_NOT_FOUND);
RTTESTI_CHECK_RC(RTPollSetAddPipe(hSet, NIL_RTPIPE, RTPOLL_EVT_READ, 1 /*id*/), VINF_SUCCESS);
RTTESTI_CHECK_RETV(RTPollSetGetCount(hSet) == 0);
RTTESTI_CHECK_RC(RTPollSetQueryHandle(hSet, 1 /*id*/, NULL), VERR_POLL_HANDLE_ID_NOT_FOUND);
RTTESTI_CHECK_RC(RTPollSetRemove(hSet, 0), VERR_POLL_HANDLE_ID_NOT_FOUND);
RTTESTI_CHECK_RETV(RTPollSetGetCount(hSet) == 0);
RTTESTI_CHECK_RC(RTPollSetDestroy(hSet), VINF_SUCCESS);
/*
* Set with pipes
*/
RTPIPE hPipeR;
RTPIPE hPipeW;
RTTESTI_CHECK_RC_RETV(RTPipeCreate(&hPipeR, &hPipeW, 0/*fFlags*/), VINF_SUCCESS);
hSet = NIL_RTPOLLSET;
RTTESTI_CHECK_RC_RETV(RTPollSetCreate(&hSet), VINF_SUCCESS);
RTTESTI_CHECK_RETV(hSet != NIL_RTPOLLSET);
/* add the read pipe */
RTTESTI_CHECK_RC_RETV(RTPollSetAddPipe(hSet, hPipeR, RTPOLL_EVT_READ, 1 /*id*/), VINF_SUCCESS);
RTTESTI_CHECK_RETV(RTPollSetGetCount(hSet) == 1);
RTTESTI_CHECK_RC(RTPollSetQueryHandle(hSet, 1 /*id*/, NULL), VINF_SUCCESS);
RTHANDLE Handle;
RTTESTI_CHECK_RC_RETV(RTPollSetQueryHandle(hSet, 1 /*id*/, &Handle), VINF_SUCCESS);
RTTESTI_CHECK(Handle.enmType == RTHANDLETYPE_PIPE);
RTTESTI_CHECK(Handle.u.hPipe == hPipeR);
/* poll on the set, should time out. */
RTTESTI_CHECK_RC(RTPoll(hSet, 0, NULL, NULL), VERR_TIMEOUT);
RTTESTI_CHECK_RC(RTPoll(hSet, 1, NULL, NULL), VERR_TIMEOUT);
/* add the write pipe with error detection only, check that poll still times out. remove it again. */
RTTESTI_CHECK_RC(RTPollSetAddPipe(hSet, hPipeW, RTPOLL_EVT_ERROR, 11 /*id*/), VINF_SUCCESS);
RTTESTI_CHECK_RETV(RTPollSetGetCount(hSet) == 2);
RTTESTI_CHECK_RC(RTPollSetQueryHandle(hSet, 11 /*id*/, NULL), VINF_SUCCESS);
RTTESTI_CHECK_RC(RTPoll(hSet, 0, NULL, NULL), VERR_TIMEOUT);
RTTESTI_CHECK_RC(RTPoll(hSet, 1, NULL, NULL), VERR_TIMEOUT);
RTTESTI_CHECK_RC(RTPollSetRemove(hSet, 11), VINF_SUCCESS);
RTTESTI_CHECK_RETV(RTPollSetGetCount(hSet) == 1);
/* add the write pipe */
RTTESTI_CHECK_RC(RTPollSetAddPipe(hSet, hPipeW, RTPOLL_EVT_WRITE, 10 /*id*/), VINF_SUCCESS);
RTTESTI_CHECK_RETV(RTPollSetGetCount(hSet) == 2);
RTTESTI_CHECK_RC(RTPollSetQueryHandle(hSet, 10 /*id*/, NULL), VINF_SUCCESS);
RTTESTI_CHECK_RC_RETV(RTPollSetQueryHandle(hSet, 10 /*id*/, &Handle), VINF_SUCCESS);
RTTESTI_CHECK(Handle.enmType == RTHANDLETYPE_PIPE);
RTTESTI_CHECK(Handle.u.hPipe == hPipeW);
RTTESTI_CHECK_RC_RETV(RTPollSetQueryHandle(hSet, 1 /*id*/, &Handle), VINF_SUCCESS);
RTTESTI_CHECK(Handle.enmType == RTHANDLETYPE_PIPE);
RTTESTI_CHECK(Handle.u.hPipe == hPipeR);
/* poll on the set again, now it should indicate hPipeW is ready. */
int rc;
RTTESTI_CHECK_RC(RTPoll(hSet, 0, NULL, NULL), VINF_SUCCESS);
RTTESTI_CHECK_RC(rc = RTPoll(hSet, 100, NULL, NULL), VINF_SUCCESS);
if (RT_SUCCESS(rc))
RTTESTI_CHECK_RC(RTPoll(hSet, RT_INDEFINITE_WAIT, NULL, NULL), VINF_SUCCESS);
RTTESTI_CHECK_RC(rc = RTPollNoResume(hSet, 0, NULL, NULL), VINF_SUCCESS);
RTTESTI_CHECK_RC(rc = RTPollNoResume(hSet, 100, NULL, NULL), VINF_SUCCESS);
if (RT_SUCCESS(rc))
RTTESTI_CHECK_RC(rc = RTPollNoResume(hSet, RT_INDEFINITE_WAIT, NULL, NULL), VINF_SUCCESS);
uint32_t fEvents = UINT32_MAX;
uint32_t id = UINT32_MAX;
RTTESTI_CHECK_RC(RTPoll(hSet, 0, &fEvents, &id), VINF_SUCCESS);
RTTESTI_CHECK(id == 10);
RTTESTI_CHECK(fEvents == RTPOLL_EVT_WRITE);
fEvents = UINT32_MAX;
id = UINT32_MAX;
RTTESTI_CHECK_RC(rc = RTPoll(hSet, 250, &fEvents, &id), VINF_SUCCESS);
RTTESTI_CHECK(id == 10);
RTTESTI_CHECK(fEvents == RTPOLL_EVT_WRITE);
if (RT_SUCCESS(rc))
{
fEvents = UINT32_MAX;
id = UINT32_MAX;
RTTESTI_CHECK_RC(RTPoll(hSet, RT_INDEFINITE_WAIT, &fEvents, &id), VINF_SUCCESS);
RTTESTI_CHECK(id == 10);
RTTESTI_CHECK(fEvents == RTPOLL_EVT_WRITE);
}
fEvents = UINT32_MAX;
id = UINT32_MAX;
RTTESTI_CHECK_RC(RTPollNoResume(hSet, 0, &fEvents, &id), VINF_SUCCESS);
RTTESTI_CHECK(id == 10);
RTTESTI_CHECK(fEvents == RTPOLL_EVT_WRITE);
fEvents = UINT32_MAX;
id = UINT32_MAX;
RTTESTI_CHECK_RC(rc = RTPollNoResume(hSet, 100, &fEvents, &id), VINF_SUCCESS);
RTTESTI_CHECK(id == 10);
RTTESTI_CHECK(fEvents == RTPOLL_EVT_WRITE);
if (RT_SUCCESS(rc))
{
fEvents = UINT32_MAX;
id = UINT32_MAX;
RTTESTI_CHECK_RC(RTPollNoResume(hSet, RT_INDEFINITE_WAIT, &fEvents, &id), VINF_SUCCESS);
RTTESTI_CHECK(id == 10);
RTTESTI_CHECK(fEvents == RTPOLL_EVT_WRITE);
}
/* Write to the pipe. Currently ASSUMING we'll get the read ready now... Good idea? */
RTTESTI_CHECK_RC(rc = RTPipeWriteBlocking(hPipeW, "hello", 5, NULL), VINF_SUCCESS);
if (RT_SUCCESS(rc))
{
fEvents = UINT32_MAX;
id = UINT32_MAX;
RTTESTI_CHECK_RC(RTPoll(hSet, 0, &fEvents, &id), VINF_SUCCESS);
RTTESTI_CHECK(id == 1);
RTTESTI_CHECK(fEvents == RTPOLL_EVT_READ);
fEvents = UINT32_MAX;
id = UINT32_MAX;
RTTESTI_CHECK_RC(rc = RTPoll(hSet, 256, &fEvents, &id), VINF_SUCCESS);
RTTESTI_CHECK(id == 1);
RTTESTI_CHECK(fEvents == RTPOLL_EVT_READ);
if (RT_SUCCESS(rc))
{
fEvents = UINT32_MAX;
id = UINT32_MAX;
RTTESTI_CHECK_RC(RTPoll(hSet, RT_INDEFINITE_WAIT, &fEvents, &id), VINF_SUCCESS);
RTTESTI_CHECK(id == 1);
RTTESTI_CHECK(fEvents == RTPOLL_EVT_READ);
}
fEvents = UINT32_MAX;
id = UINT32_MAX;
RTTESTI_CHECK_RC(RTPollNoResume(hSet, 0, &fEvents, &id), VINF_SUCCESS);
RTTESTI_CHECK(id == 1);
RTTESTI_CHECK(fEvents == RTPOLL_EVT_READ);
fEvents = UINT32_MAX;
id = UINT32_MAX;
RTTESTI_CHECK_RC(rc = RTPollNoResume(hSet, 383, &fEvents, &id), VINF_SUCCESS);
RTTESTI_CHECK(id == 1);
RTTESTI_CHECK(fEvents == RTPOLL_EVT_READ);
if (RT_SUCCESS(rc))
{
fEvents = UINT32_MAX;
id = UINT32_MAX;
RTTESTI_CHECK_RC(RTPollNoResume(hSet, RT_INDEFINITE_WAIT, &fEvents, &id), VINF_SUCCESS);
RTTESTI_CHECK(id == 1);
RTTESTI_CHECK(fEvents == RTPOLL_EVT_READ);
}
}
/* Remove the read pipe, do a quick poll check. */
RTTESTI_CHECK_RC_RETV(RTPollSetRemove(hSet, 1), VINF_SUCCESS);
RTTESTI_CHECK_RETV(RTPollSetGetCount(hSet) == 1);
RTTESTI_CHECK_RC(RTPollSetQueryHandle(hSet, 1 /*id*/, NULL), VERR_POLL_HANDLE_ID_NOT_FOUND);
RTTESTI_CHECK_RC_RETV(RTPollSetQueryHandle(hSet, 10 /*id*/, &Handle), VINF_SUCCESS);
RTTESTI_CHECK(Handle.enmType == RTHANDLETYPE_PIPE);
RTTESTI_CHECK(Handle.u.hPipe == hPipeW);
RTTESTI_CHECK_RC(RTPoll(hSet, 0, NULL, NULL), VINF_SUCCESS);
/* Add it back and check that we now get the write handle when polling.
(Is this FIFOing a good idea?) */
RTTESTI_CHECK_RC_RETV(RTPoll(hSet, 0, NULL, NULL), VINF_SUCCESS);
RTTESTI_CHECK_RC_RETV(RTPollSetAddPipe(hSet, hPipeR, RTPOLL_EVT_READ, 1 /*id*/), VINF_SUCCESS);
RTTESTI_CHECK_RETV(RTPollSetGetCount(hSet) == 2);
RTTESTI_CHECK_RC(RTPollSetQueryHandle(hSet, 1 /*id*/, NULL), VINF_SUCCESS);
RTTESTI_CHECK_RC_RETV(RTPollSetQueryHandle(hSet, 1 /*id*/, &Handle), VINF_SUCCESS);
RTTESTI_CHECK(Handle.enmType == RTHANDLETYPE_PIPE);
RTTESTI_CHECK(Handle.u.hPipe == hPipeR);
RTTESTI_CHECK_RC_RETV(RTPollSetQueryHandle(hSet, 10 /*id*/, &Handle), VINF_SUCCESS);
RTTESTI_CHECK(Handle.enmType == RTHANDLETYPE_PIPE);
RTTESTI_CHECK(Handle.u.hPipe == hPipeW);
fEvents = UINT32_MAX;
id = UINT32_MAX;
RTTESTI_CHECK_RC(rc = RTPollNoResume(hSet, 555, &fEvents, &id), VINF_SUCCESS);
RTTESTI_CHECK(id == 10);
RTTESTI_CHECK(fEvents == RTPOLL_EVT_WRITE);
/* Remove it again and break the pipe by closing the read end. */
RTTESTI_CHECK_RC_RETV(RTPollSetRemove(hSet, 1), VINF_SUCCESS);
RTTESTI_CHECK_RETV(RTPollSetGetCount(hSet) == 1);
RTTESTI_CHECK_RC(RTPollSetQueryHandle(hSet, 1 /*id*/, NULL), VERR_POLL_HANDLE_ID_NOT_FOUND);
RTTESTI_CHECK_RC_RETV(RTPollSetQueryHandle(hSet, 10 /*id*/, &Handle), VINF_SUCCESS);
RTTESTI_CHECK(Handle.enmType == RTHANDLETYPE_PIPE);
RTTESTI_CHECK(Handle.u.hPipe == hPipeW);
RTTESTI_CHECK_RC(RTPoll(hSet, 0, NULL, NULL), VINF_SUCCESS);
RTTESTI_CHECK_RC(RTPipeClose(hPipeR), VINF_SUCCESS);
fEvents = UINT32_MAX;
id = UINT32_MAX;
RTTESTI_CHECK_RC(RTPollNoResume(hSet, 0, &fEvents, &id), VINF_SUCCESS);
RTTESTI_CHECK(id == 10);
RTTESTI_CHECK_MSG( fEvents == RTPOLL_EVT_ERROR \
|| fEvents == (RTPOLL_EVT_ERROR | RTPOLL_EVT_WRITE), ("%#x\n", fEvents));
RTTESTI_CHECK_RC(RTPollSetDestroy(hSet), VINF_SUCCESS);
RTTESTI_CHECK_RC(RTPipeClose(hPipeW), VINF_SUCCESS);
/*
* Check FIFO order when removing and adding.
*
* Note! FIFO order is not guaranteed when a handle has more than one entry
* in the set.
*/
RTTESTI_CHECK_RC_RETV(RTPipeCreate(&hPipeR, &hPipeW, 0/*fFlags*/), VINF_SUCCESS);
RTPIPE hPipeR2, hPipeW2;
RTTESTI_CHECK_RC_RETV(RTPipeCreate(&hPipeR2, &hPipeW2, 0/*fFlags*/), VINF_SUCCESS);
RTPIPE hPipeR3, hPipeW3;
RTTESTI_CHECK_RC_RETV(RTPipeCreate(&hPipeR3, &hPipeW3, 0/*fFlags*/), VINF_SUCCESS);
RTTESTI_CHECK_RC_RETV(RTPollSetCreate(&hSet), VINF_SUCCESS);
RTTESTI_CHECK_RC_RETV(RTPollSetAddPipe(hSet, hPipeR, RTPOLL_EVT_READ, 1 /*id*/), VINF_SUCCESS);
RTTESTI_CHECK_RC_RETV(RTPollSetAddPipe(hSet, hPipeW, RTPOLL_EVT_WRITE, 2 /*id*/), VINF_SUCCESS);
RTTESTI_CHECK_RC_RETV(RTPollSetAddPipe(hSet, hPipeR2, RTPOLL_EVT_READ, 3 /*id*/), VINF_SUCCESS);
RTTESTI_CHECK_RC_RETV(RTPollSetAddPipe(hSet, hPipeW2, RTPOLL_EVT_WRITE, 4 /*id*/), VINF_SUCCESS);
RTTESTI_CHECK_RC_RETV(RTPollSetAddPipe(hSet, hPipeR3, RTPOLL_EVT_READ, 5 /*id*/), VINF_SUCCESS);
id = UINT32_MAX; fEvents = UINT32_MAX;
RTTESTI_CHECK_RC(RTPoll(hSet, 5, &fEvents, &id), VINF_SUCCESS);
RTTESTI_CHECK(id == 2);
RTTESTI_CHECK(fEvents == RTPOLL_EVT_WRITE);
RTTESTI_CHECK_RC(RTPipeWriteBlocking(hPipeW, "hello", 5, NULL), VINF_SUCCESS);
RTTESTI_CHECK_RC(RTPipeWriteBlocking(hPipeW2, "hello", 5, NULL), VINF_SUCCESS);
RTTESTI_CHECK_RC(RTPipeWriteBlocking(hPipeW3, "hello", 5, NULL), VINF_SUCCESS);
id = UINT32_MAX; fEvents = UINT32_MAX;
RTTESTI_CHECK_RC(RTPoll(hSet, 5, &fEvents, &id), VINF_SUCCESS);
RTTESTI_CHECK(id == 1);
RTTESTI_CHECK(fEvents == RTPOLL_EVT_READ);
RTTESTI_CHECK_RC(RTPollSetRemove(hSet, 1), VINF_SUCCESS);
id = UINT32_MAX; fEvents = UINT32_MAX;
RTTESTI_CHECK_RC(RTPoll(hSet, 5, &fEvents, &id), VINF_SUCCESS);
RTTESTI_CHECK(id == 2);
RTTESTI_CHECK(fEvents == RTPOLL_EVT_WRITE);
RTTESTI_CHECK_RC(RTPollSetRemove(hSet, 2), VINF_SUCCESS);
id = UINT32_MAX; fEvents = UINT32_MAX;
RTTESTI_CHECK_RC(RTPoll(hSet, 5, &fEvents, &id), VINF_SUCCESS);
RTTESTI_CHECK(id == 3);
RTTESTI_CHECK(fEvents == RTPOLL_EVT_READ);
RTTESTI_CHECK_RC(RTPollSetRemove(hSet, 3), VINF_SUCCESS);
id = UINT32_MAX; fEvents = UINT32_MAX;
RTTESTI_CHECK_RC(RTPoll(hSet, 5, &fEvents, &id), VINF_SUCCESS);
RTTESTI_CHECK(id == 4);
RTTESTI_CHECK(fEvents == RTPOLL_EVT_WRITE);
RTTESTI_CHECK_RC(RTPollSetRemove(hSet, 4), VINF_SUCCESS);
id = UINT32_MAX; fEvents = UINT32_MAX;
RTTESTI_CHECK_RC(RTPoll(hSet, 5, &fEvents, &id), VINF_SUCCESS);
RTTESTI_CHECK(id == 5);
RTTESTI_CHECK(fEvents == RTPOLL_EVT_READ);
RTTESTI_CHECK_RC(RTPollSetRemove(hSet, 5), VINF_SUCCESS);
id = UINT32_MAX; fEvents = UINT32_MAX;
RTTESTI_CHECK_RC(RTPoll(hSet, 5, &fEvents, &id), VERR_TIMEOUT);
RTTESTI_CHECK_RC(RTPipeClose(hPipeW), VINF_SUCCESS);
RTTESTI_CHECK_RC(RTPipeClose(hPipeR), VINF_SUCCESS);
RTTESTI_CHECK_RC(RTPipeClose(hPipeW2), VINF_SUCCESS);
RTTESTI_CHECK_RC(RTPipeClose(hPipeR2), VINF_SUCCESS);
RTTESTI_CHECK_RC(RTPipeClose(hPipeW3), VINF_SUCCESS);
RTTESTI_CHECK_RC(RTPipeClose(hPipeR3), VINF_SUCCESS);
RTTESTI_CHECK_RC(RTPollSetDestroy(hSet), VINF_SUCCESS);
}
/**
* Destruct a TCP socket stream driver instance.
*
* Most VM resources are freed by the VM. This callback is provided so that
* any non-VM resources can be freed correctly.
*
* @param pDrvIns The driver instance data.
*/
static DECLCALLBACK(void) drvTCPDestruct(PPDMDRVINS pDrvIns)
{
PDRVTCP pThis = PDMINS_2_DATA(pDrvIns, PDRVTCP);
LogFlow(("%s: %s\n", __FUNCTION__, pThis->pszLocation));
PDMDRV_CHECK_VERSIONS_RETURN_VOID(pDrvIns);
drvTCPShutdownListener(pThis);
/*
* While the thread exits, clean up as much as we can.
*/
if (pThis->hTcpSock != NIL_RTSOCKET)
{
int rc = RTPollSetRemove(pThis->hPollSet, DRVTCP_POLLSET_ID_SOCKET);
AssertRC(rc);
rc = RTSocketShutdown(pThis->hTcpSock, true /* fRead */, true /* fWrite */);
AssertRC(rc);
rc = RTSocketClose(pThis->hTcpSock);
AssertRC(rc); RT_NOREF(rc);
pThis->hTcpSock = NIL_RTSOCKET;
}
if (pThis->hPipeWakeR != NIL_RTPIPE)
{
int rc = RTPipeClose(pThis->hPipeWakeR);
AssertRC(rc);
pThis->hPipeWakeR = NIL_RTPIPE;
}
if (pThis->hPipeWakeW != NIL_RTPIPE)
{
int rc = RTPipeClose(pThis->hPipeWakeW);
AssertRC(rc);
pThis->hPipeWakeW = NIL_RTPIPE;
}
if (pThis->hPollSet != NIL_RTPOLLSET)
{
int rc = RTPollSetDestroy(pThis->hPollSet);
AssertRC(rc);
pThis->hPollSet = NIL_RTPOLLSET;
}
MMR3HeapFree(pThis->pszLocation);
pThis->pszLocation = NULL;
/*
* Wait for the thread.
*/
if (pThis->ListenThread != NIL_RTTHREAD)
{
int rc = RTThreadWait(pThis->ListenThread, 30000, NULL);
if (RT_SUCCESS(rc))
pThis->ListenThread = NIL_RTTHREAD;
else
LogRel(("DrvTCP%d: listen thread did not terminate (%Rrc)\n", pDrvIns->iInstance, rc));
}
}
/** @interface_method_impl{PDMISTREAM,pfnPoll} */
static DECLCALLBACK(int) drvTcpPoll(PPDMISTREAM pInterface, uint32_t fEvts, uint32_t *pfEvts, RTMSINTERVAL cMillies)
{
int rc = VINF_SUCCESS;
PDRVTCP pThis = RT_FROM_MEMBER(pInterface, DRVTCP, IStream);
if (pThis->hTcpSock != NIL_RTSOCKET)
{
if (!pThis->fTcpSockInPollSet)
{
rc = RTPollSetAddSocket(pThis->hPollSet, pThis->hTcpSock,
fEvts, DRVTCP_POLLSET_ID_SOCKET);
if (RT_SUCCESS(rc))
{
pThis->fTcpSockInPollSet = true;
pThis->fXmitBufFull = false;
}
}
else
{
/* Always include error event. */
fEvts |= RTPOLL_EVT_ERROR;
rc = RTPollSetEventsChange(pThis->hPollSet, DRVTCP_POLLSET_ID_SOCKET, fEvts);
AssertRC(rc);
}
}
if (RT_SUCCESS(rc))
{
while (RT_SUCCESS(rc))
{
uint32_t fEvtsRecv = 0;
uint32_t idHnd = 0;
/*
* Just check for data available to be read if the send buffer wasn't full till now and
* the caller wants to check whether writing is possible with the event set.
*
* On Windows the write event is only posted after a send operation returned
* WSAEWOULDBLOCK. So without this we would block in the poll call below waiting
* for an event which would never happen if the buffer has space left.
*/
if ( (fEvts & RTPOLL_EVT_WRITE)
&& !pThis->fXmitBufFull
&& pThis->fTcpSockInPollSet)
cMillies = 0;
rc = RTPoll(pThis->hPollSet, cMillies, &fEvtsRecv, &idHnd);
if (RT_SUCCESS(rc))
{
if (idHnd == DRVTCP_POLLSET_ID_WAKEUP)
{
/* We got woken up, drain the pipe and return. */
uint8_t bReason;
size_t cbRead = 0;
rc = RTPipeRead(pThis->hPipeWakeR, &bReason, 1, &cbRead);
AssertRC(rc);
if (bReason == DRVTCP_WAKEUP_REASON_EXTERNAL)
rc = VERR_INTERRUPTED;
else if (bReason == DRVTCP_WAKEUP_REASON_NEW_CONNECTION)
{
Assert(!pThis->fTcpSockInPollSet);
rc = RTPollSetAddSocket(pThis->hPollSet, pThis->hTcpSock,
fEvts, DRVTCP_POLLSET_ID_SOCKET);
if (RT_SUCCESS(rc))
pThis->fTcpSockInPollSet = true;
}
else
AssertMsgFailed(("Unknown wakeup reason in pipe %u\n", bReason));
}
else
{
Assert(idHnd == DRVTCP_POLLSET_ID_SOCKET);
/* On error we close the socket here. */
if (fEvtsRecv & RTPOLL_EVT_ERROR)
{
rc = RTPollSetRemove(pThis->hPollSet, DRVTCP_POLLSET_ID_SOCKET);
AssertRC(rc);
if (pThis->fIsServer)
RTTcpServerDisconnectClient2(pThis->hTcpSock);
else
RTSocketClose(pThis->hTcpSock);
pThis->hTcpSock = NIL_RTSOCKET;
pThis->fTcpSockInPollSet = false;
/* Continue with polling. */
}
else
{
if (fEvtsRecv & RTPOLL_EVT_WRITE)
pThis->fXmitBufFull = false;
else if (!pThis->fXmitBufFull)
fEvtsRecv |= RTPOLL_EVT_WRITE;
*pfEvts = fEvtsRecv;
break;
}
}
}
else if ( rc == VERR_TIMEOUT
&& !pThis->fXmitBufFull)
{
*pfEvts = RTPOLL_EVT_WRITE;
rc = VINF_SUCCESS;
break;
}
}
}
return rc;
}
