Adding upstream version 6.0.4-dfsg.upstream/6.0.4-dfsgupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 960 insertions, 0 deletions

diff --git a/src/VBox/Runtime/testcase/tstRTLocalIpc.cpp b/src/VBox/Runtime/testcase/tstRTLocalIpc.cpp
new file mode 100644
index 00000000..a24c5459
--- /dev/null
+++ b/src/VBox/Runtime/testcase/tstRTLocalIpc.cpp
@@ -0,0 +1,960 @@
+/* $Id: tstRTLocalIpc.cpp $ */
+/** @file
+ * IPRT Testcase - RTLocalIpc API.
+ */
+
+/*
+ * Copyright (C) 2013-2019 Oracle Corporation
+ *
+ * This file is part of VirtualBox Open Source Edition (OSE), as
+ * available from http://www.virtualbox.org. This file is free software;
+ * you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License (GPL) as published by the Free Software
+ * Foundation, in version 2 as it comes in the "COPYING" file of the
+ * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+ * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+ *
+ * The contents of this file may alternatively be used under the terms
+ * of the Common Development and Distribution License Version 1.0
+ * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
+ * VirtualBox OSE distribution, in which case the provisions of the
+ * CDDL are applicable instead of those of the GPL.
+ *
+ * You may elect to license modified versions of this file under the
+ * terms and conditions of either the GPL or the CDDL or both.
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#include <iprt/localipc.h>
+
+#include <iprt/asm.h>
+#include <iprt/env.h>
+#include <iprt/err.h>
+#include <iprt/initterm.h>
+#include <iprt/mem.h>
+#include <iprt/message.h>
+#include <iprt/path.h>
+#include <iprt/process.h>
+#include <iprt/rand.h>
+#include <iprt/string.h>
+#include <iprt/test.h>
+#include <iprt/thread.h>
+#include <iprt/time.h>
+
+
+/*********************************************************************************************************************************
+*   Global Variables                                                                                                             *
+*********************************************************************************************************************************/
+/** The test instance.*/
+static RTTEST g_hTest;
+
+
+
+static void testBasics(void)
+{
+    RTTestISub("Basics");
+
+    /* Server-side. */
+    RTTESTI_CHECK_RC(RTLocalIpcServerCreate(NULL, NULL, 0), VERR_INVALID_POINTER);
+    RTLOCALIPCSERVER hIpcServer;
+    int rc;
+    RTTESTI_CHECK_RC(rc = RTLocalIpcServerCreate(&hIpcServer, NULL, 0), VERR_INVALID_POINTER);
+    if (RT_SUCCESS(rc)) RTLocalIpcServerDestroy(hIpcServer);
+    RTTESTI_CHECK_RC(rc = RTLocalIpcServerCreate(&hIpcServer, "", 0), VERR_INVALID_NAME);
+    if (RT_SUCCESS(rc)) RTLocalIpcServerDestroy(hIpcServer);
+    RTTESTI_CHECK_RC(rc = RTLocalIpcServerCreate(&hIpcServer, "BasicTest", 1234 /* Invalid flags */), VERR_INVALID_FLAGS);
+    if (RT_SUCCESS(rc)) RTLocalIpcServerDestroy(hIpcServer);
+
+    RTTESTI_CHECK_RC(RTLocalIpcServerCancel(NULL), VERR_INVALID_HANDLE);
+    RTTESTI_CHECK_RC(RTLocalIpcServerDestroy(NULL), VINF_SUCCESS);
+
+    /* Basic server creation / destruction. */
+    RTTESTI_CHECK_RC_RETV(RTLocalIpcServerCreate(&hIpcServer, "BasicTest", 0), VINF_SUCCESS);
+    RTTESTI_CHECK_RC(RTLocalIpcServerCancel(hIpcServer), VINF_SUCCESS);
+    RTTESTI_CHECK_RC(RTLocalIpcServerDestroy(hIpcServer), VINF_OBJECT_DESTROYED);
+
+    /* Client-side (per session). */
+    RTTESTI_CHECK_RC(RTLocalIpcSessionConnect(NULL, NULL, 0), VERR_INVALID_POINTER);
+    RTLOCALIPCSESSION hIpcSession;
+    RTTESTI_CHECK_RC(RTLocalIpcSessionConnect(&hIpcSession, NULL, 0), VERR_INVALID_POINTER);
+    if (RT_SUCCESS(rc)) RTLocalIpcSessionClose(hIpcSession);
+    RTTESTI_CHECK_RC(RTLocalIpcSessionConnect(&hIpcSession, "", 0), VERR_INVALID_NAME);
+    if (RT_SUCCESS(rc)) RTLocalIpcSessionClose(hIpcSession);
+    RTTESTI_CHECK_RC(RTLocalIpcSessionConnect(&hIpcSession, "BasicTest", 1234 /* Invalid flags */), VERR_INVALID_FLAGS);
+    if (RT_SUCCESS(rc)) RTLocalIpcSessionClose(hIpcSession);
+
+    RTTESTI_CHECK_RC(RTLocalIpcSessionCancel(NULL), VERR_INVALID_HANDLE);
+    RTTESTI_CHECK_RC(RTLocalIpcSessionClose(NULL), VINF_SUCCESS);
+
+    /* Basic client creation / destruction. */
+    RTTESTI_CHECK_RC_RETV(rc = RTLocalIpcSessionConnect(&hIpcSession, "BasicTest", 0), VERR_FILE_NOT_FOUND);
+    if (RT_SUCCESS(rc)) RTLocalIpcSessionClose(hIpcSession);
+    //RTTESTI_CHECK_RC(RTLocalIpcServerCancel(hIpcServer), VERR_INVALID_HANDLE);  - accessing freed memory, bad idea.
+    //RTTESTI_CHECK_RC(RTLocalIpcServerDestroy(hIpcServer), VERR_INVALID_HANDLE); - accessing freed memory, bad idea.
+}
+
+
+
+/*********************************************************************************************************************************
+*                                                                                                                                *
+*   testSessionConnection - Connecting.                                                                                          *
+*                                                                                                                                *
+*********************************************************************************************************************************/
+
+static DECLCALLBACK(int) testServerListenThread(RTTHREAD hSelf, void *pvUser)
+{
+    RTLOCALIPCSERVER hIpcServer = (RTLOCALIPCSERVER)pvUser;
+    RTTEST_CHECK_RC_OK_RET(g_hTest, RTTestSetDefault(g_hTest, NULL), rcCheck);
+
+    RTTESTI_CHECK_RC_OK(RTThreadUserSignal(hSelf));
+
+    int rc;
+    for (;;)
+    {
+        RTLOCALIPCSESSION hIpcSession;
+        rc = RTLocalIpcServerListen(hIpcServer, &hIpcSession);
+        if (RT_SUCCESS(rc))
+        {
+            RTThreadSleep(8); /* windows output fudge (purely esthetical) */
+            RTTestIPrintf(RTTESTLVL_INFO, "testServerListenThread: Got new client connection.\n");
+            RTTESTI_CHECK_RC(RTLocalIpcSessionClose(hIpcSession), VINF_OBJECT_DESTROYED);
+        }
+        else
+        {
+            RTTESTI_CHECK_RC(rc, VERR_CANCELLED);
+            break;
+        }
+    }
+    return rc;
+}
+
+
+/**
+ * Used both as a thread procedure and child process worker.
+ */
+static DECLCALLBACK(int) tstRTLocalIpcSessionConnectionChild(RTTHREAD hSelf, void *pvUser)
+{
+    RTLOCALIPCSESSION hClientSession;
+    RT_NOREF_PV(hSelf); RT_NOREF_PV(pvUser);
+
+    RTTEST_CHECK_RC_OK_RET(g_hTest, RTTestSetDefault(g_hTest, NULL), rcCheck);
+
+    RTTEST_CHECK_RC_RET(g_hTest, RTLocalIpcSessionConnect(&hClientSession, "tstRTLocalIpcSessionConnection",0 /* Flags */),
+                        VINF_SUCCESS, rcCheck);
+    RTTEST_CHECK_RC_RET(g_hTest, RTLocalIpcSessionClose(hClientSession),
+                        VINF_OBJECT_DESTROYED, rcCheck);
+
+    return VINF_SUCCESS;
+}
+
+
+static void testSessionConnection(const char *pszExecPath)
+{
+    RTTestISub(!pszExecPath ? "Connect from thread" : "Connect from child");
+
+    /*
+     * Create the test server.
+     */
+    RTLOCALIPCSERVER hIpcServer;
+    RTTESTI_CHECK_RC_RETV(RTLocalIpcServerCreate(&hIpcServer, "tstRTLocalIpcSessionConnection", 0), VINF_SUCCESS);
+
+    /*
+     * Create worker thread that listens and closes incoming connections until
+     * cancelled.
+     */
+    int rc;
+    RTTHREAD hListenThread;
+    RTTESTI_CHECK_RC_OK(rc = RTThreadCreate(&hListenThread, testServerListenThread, hIpcServer, 0 /* Stack */,
+                                            RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, "listen-1"));
+    if (RT_SUCCESS(rc))
+    {
+        RTThreadUserWait(hListenThread, 32);
+
+        /*
+         * Two variations here: Client connects from thread or a child process.
+         */
+        if (pszExecPath)
+        {
+            RTPROCESS hClientProc;
+            const char *apszArgs[4] = { pszExecPath, "child", "tstRTLocalIpcSessionConnectionChild", NULL };
+            RTTESTI_CHECK_RC_OK(rc = RTProcCreate(pszExecPath, apszArgs, RTENV_DEFAULT, 0 /* fFlags*/, &hClientProc));
+            if (RT_SUCCESS(rc))
+            {
+                RTPROCSTATUS ProcStatus;
+                RTTESTI_CHECK_RC_OK(rc = RTProcWait(hClientProc, RTPROCWAIT_FLAGS_BLOCK, &ProcStatus));
+                if (RT_SUCCESS(rc) && (ProcStatus.enmReason != RTPROCEXITREASON_NORMAL || ProcStatus.iStatus != 0))
+                    RTTestIFailed("Chiled exited with enmReason=%d iStatus=%d", ProcStatus.enmReason, ProcStatus.iStatus);
+            }
+        }
+        else
+        {
+            RTTHREAD hClientThread;
+            RTTESTI_CHECK_RC_OK(rc = RTThreadCreate(&hClientThread, tstRTLocalIpcSessionConnectionChild, NULL,
+                                                    0 /* Stack */, RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, "client-1"));
+            if (RT_SUCCESS(rc))
+            {
+                int rcThread;
+                RTTESTI_CHECK_RC_OK(rc = RTThreadWait(hClientThread, RT_MS_1MIN / 2, &rcThread));
+                if (RT_SUCCESS(rc))
+                    RTTESTI_CHECK_RC(rcThread, VINF_SUCCESS);
+            }
+        }
+
+
+        /*
+         * Terminate the server thread.
+         */
+        //RTTestIPrintf(RTTESTLVL_INFO, "Child terminated, waiting for server thread ...\n");
+        RTTESTI_CHECK_RC(RTLocalIpcServerCancel(hIpcServer), VINF_SUCCESS);
+        int rcThread;
+        RTTESTI_CHECK_RC(rc = RTThreadWait(hListenThread, 30 * 1000 /* 30s timeout */, &rcThread), VINF_SUCCESS);
+        if (RT_SUCCESS(rc))
+            RTTESTI_CHECK_RC(rcThread, VERR_CANCELLED);
+    }
+
+    RTTESTI_CHECK_RC(RTLocalIpcServerDestroy(hIpcServer), VINF_OBJECT_DESTROYED);
+}
+
+
+
+/*********************************************************************************************************************************
+*                                                                                                                                *
+*   testSessionWait - RTLocalIpcSessionWaitForData.                                                                              *
+*                                                                                                                                *
+*********************************************************************************************************************************/
+
+static DECLCALLBACK(int) testSessionWaitThread(RTTHREAD hSelf, void *pvUser)
+{
+    RTLOCALIPCSERVER hIpcServer = (RTLOCALIPCSERVER)pvUser;
+    RTTEST_CHECK_RC_OK_RET(g_hTest, RTTestSetDefault(g_hTest, NULL), rcCheck);
+
+    int rc;
+    for (;;)
+    {
+        RTLOCALIPCSESSION hIpcSession;
+        rc = RTLocalIpcServerListen(hIpcServer, &hIpcSession);
+        if (RT_SUCCESS(rc))
+        {
+            RTTestIPrintf(RTTESTLVL_INFO, "testSessionWaitThread: Got new client connection.\n");
+
+            /* Wait for the client to trigger a disconnect by writing us something. */
+            RTTESTI_CHECK_RC(RTLocalIpcSessionWaitForData(hIpcSession, RT_MS_1MIN), VINF_SUCCESS);
+
+            size_t cbRead;
+            char szCmd[64];
+            RT_ZERO(szCmd);
+            RTTESTI_CHECK_RC(rc = RTLocalIpcSessionReadNB(hIpcSession, szCmd, sizeof(szCmd) - 1, &cbRead), VINF_SUCCESS);
+            if (RT_SUCCESS(rc) && (cbRead != sizeof("disconnect") - 1 || strcmp(szCmd, "disconnect")) )
+                RTTestIFailed("cbRead=%zu, expected %zu; szCmd='%s', expected 'disconnect'\n",
+                              cbRead, sizeof("disconnect") - 1, szCmd);
+
+            RTTESTI_CHECK_RC(RTLocalIpcSessionClose(hIpcSession), VINF_OBJECT_DESTROYED);
+            RTTESTI_CHECK_RC_OK(RTThreadUserSignal(hSelf));
+        }
+        else
+        {
+            RTTESTI_CHECK_RC(rc, VERR_CANCELLED);
+            break;
+        }
+    }
+    RTTESTI_CHECK_RC_OK(RTThreadUserSignal(hSelf));
+    return rc;
+}
+
+
+/**
+ * Used both as a thread procedure and child process worker.
+ */
+static DECLCALLBACK(int) tstRTLocalIpcSessionWaitChild(RTTHREAD hSelf, void *pvUser)
+{
+    RTTEST_CHECK_RC_OK_RET(g_hTest, RTTestSetDefault(g_hTest, NULL), rcCheck);
+    RT_NOREF_PV(hSelf); RT_NOREF_PV(pvUser);
+
+    RTLOCALIPCSESSION hClientSession;
+    RTTESTI_CHECK_RC_RET(RTLocalIpcSessionConnect(&hClientSession, "tstRTLocalIpcSessionWait", 0 /*fFlags*/),
+                         VINF_SUCCESS, rcCheck);
+
+    /*
+     * The server side won't write anything.  It will close the connection
+     * as soon as we write something.
+     */
+    RTTESTI_CHECK_RC(RTLocalIpcSessionWaitForData(hClientSession, 0 /*cMsTimeout*/), VERR_TIMEOUT);
+    RTTESTI_CHECK_RC(RTLocalIpcSessionWaitForData(hClientSession, 8 /*cMsTimeout*/), VERR_TIMEOUT);
+    uint8_t abBuf[4];
+    size_t cbRead = _4M-1;
+    RTTESTI_CHECK_RC(RTLocalIpcSessionReadNB(hClientSession, abBuf, sizeof(abBuf), &cbRead), VINF_TRY_AGAIN);
+    RTTESTI_CHECK(cbRead == 0);
+
+    /* Trigger server disconnect. */
+    int rc;
+    RTTESTI_CHECK_RC(rc = RTLocalIpcSessionWrite(hClientSession, RT_STR_TUPLE("disconnect")), VINF_SUCCESS);
+    if (RT_SUCCESS(rc))
+    {
+        /*
+         * When we wait now, we should get an broken pipe error as
+         * the server has close its end.
+         */
+        RTTESTI_CHECK_RC(rc = RTLocalIpcSessionWaitForData(hClientSession, RT_MS_1MIN), VERR_BROKEN_PIPE);
+        RTTESTI_CHECK_RC(RTLocalIpcSessionWaitForData(hClientSession, 0), VERR_BROKEN_PIPE);
+        RTTESTI_CHECK_RC(RTLocalIpcSessionWaitForData(hClientSession, RT_MS_1SEC), VERR_BROKEN_PIPE);
+
+        bool fMayPanic = RTAssertSetMayPanic(false);
+        bool fQuiet    = RTAssertSetQuiet(true);
+
+        RTTESTI_CHECK_RC(RTLocalIpcSessionWrite(hClientSession, RT_STR_TUPLE("broken")), VERR_BROKEN_PIPE);
+        RTTESTI_CHECK_RC(RTLocalIpcSessionRead(hClientSession, abBuf, sizeof(abBuf), NULL), VERR_BROKEN_PIPE);
+        cbRead = _4M-1;
+        RTTESTI_CHECK_RC(RTLocalIpcSessionRead(hClientSession, abBuf, sizeof(abBuf), &cbRead), VERR_BROKEN_PIPE);
+        cbRead = _1G/2;
+        RTTESTI_CHECK_RC(RTLocalIpcSessionReadNB(hClientSession, abBuf, sizeof(abBuf), &cbRead), VERR_BROKEN_PIPE);
+
+        RTAssertSetMayPanic(fMayPanic);
+        RTAssertSetQuiet(fQuiet);
+    }
+
+    RTTESTI_CHECK_RC(RTLocalIpcSessionClose(hClientSession), VINF_OBJECT_DESTROYED);
+
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * @note This is identical to testSessionData with a couple of string and
+ *       function pointers replaced.
+ */
+static void testSessionWait(const char *pszExecPath)
+{
+    RTTestISub(!pszExecPath ? "Wait for data in thread" : "Wait for data in child");
+
+    /*
+     * Create the test server.
+     */
+    RTLOCALIPCSERVER hIpcServer;
+    RTTESTI_CHECK_RC_RETV(RTLocalIpcServerCreate(&hIpcServer, "tstRTLocalIpcSessionWait", 0), VINF_SUCCESS);
+
+    /*
+     * Create worker thread that listens and processes incoming connections
+     * until cancelled.
+     */
+    int rc;
+    RTTHREAD hListenThread;
+    RTTESTI_CHECK_RC_OK(rc = RTThreadCreate(&hListenThread, testSessionWaitThread, hIpcServer, 0 /* Stack */,
+                                            RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, "listen-2"));
+    if (RT_SUCCESS(rc))
+    {
+        /*
+         * Create a client process or thread and connects to the server.
+         * It will perform the wait-for-data test.
+         */
+        RTPROCESS hClientProc = NIL_RTPROCESS;
+        RTTHREAD  hClientThread = NIL_RTTHREAD;
+        if (pszExecPath)
+        {
+            const char *apszArgs[4] = { pszExecPath, "child", "tstRTLocalIpcSessionWaitChild", NULL };
+            RTTESTI_CHECK_RC_OK(rc = RTProcCreate(pszExecPath, apszArgs, RTENV_DEFAULT, 0 /* fFlags*/, &hClientProc));
+        }
+        else
+            RTTESTI_CHECK_RC_OK(rc = RTThreadCreate(&hClientThread, tstRTLocalIpcSessionWaitChild, g_hTest, 0 /*cbStack*/,
+                                                    RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, "client-2"));
+
+        /*
+         * Wait for the server thread to indicate that it has processed one
+         * connection, then shut it all down.
+         */
+        if (RT_SUCCESS(rc))
+            RTTESTI_CHECK_RC_OK(RTThreadUserWait(hListenThread, RT_MS_1MIN / 2));
+
+        RTTESTI_CHECK_RC(RTLocalIpcServerCancel(hIpcServer), VINF_SUCCESS);
+        int rcThread;
+        RTTESTI_CHECK_RC(rc = RTThreadWait(hListenThread, RT_MS_1MIN / 2, &rcThread), VINF_SUCCESS);
+        if (RT_SUCCESS(rc))
+            RTTESTI_CHECK_RC(rcThread, VERR_CANCELLED);
+
+        RTTESTI_CHECK_RC(RTLocalIpcServerDestroy(hIpcServer), VINF_OBJECT_DESTROYED);
+
+        /*
+         * Check that client ran successfully.
+         */
+        if (pszExecPath)
+        {
+            if (hClientProc != NIL_RTPROCESS)
+            {
+                RTPROCSTATUS ProcStatus;
+                RTTESTI_CHECK_RC_OK(rc = RTProcWait(hClientProc, RTPROCWAIT_FLAGS_BLOCK, &ProcStatus));
+                if (RT_SUCCESS(rc) && (ProcStatus.enmReason != RTPROCEXITREASON_NORMAL || ProcStatus.iStatus != 0))
+                    RTTestIFailed("Chiled exited with enmReason=%d iStatus=%d", ProcStatus.enmReason, ProcStatus.iStatus);
+            }
+        }
+        else if (hClientThread != NIL_RTTHREAD)
+        {
+            RTTESTI_CHECK_RC_OK(rc = RTThreadWait(hClientThread, RT_MS_1MIN / 2, &rcThread));
+            if (RT_SUCCESS(rc))
+                RTTESTI_CHECK_RC(rcThread, VINF_SUCCESS);
+        }
+    }
+}
+
+
+
+/*********************************************************************************************************************************
+*                                                                                                                                *
+*   testSessionData - Data transfer integrity.                                                                                   *
+*                                                                                                                                *
+*********************************************************************************************************************************/
+
+/** The max message size. */
+#define MAX_DATA_MSG_SIZE   _1M
+
+static int testSessionDataReadMessages(RTLOCALIPCSESSION hIpcSession, uint32_t cRounds)
+{
+    /*
+     * Message scratch buffer.  Search message starts with a uint32_t word
+     * that indicates the message length.  The remaining words are set to
+     * the message number.
+     */
+    uint32_t *pau32ScratchBuf = (uint32_t *)RTMemAlloc(MAX_DATA_MSG_SIZE);
+    RTTESTI_CHECK_RET(pau32ScratchBuf != NULL, VERR_NO_MEMORY);
+
+    int rc = VINF_SUCCESS;
+    for (uint32_t iRound = 0; iRound < cRounds && rc == VINF_SUCCESS; iRound++)
+    {
+        /* Read the message length. */
+        uint32_t cbMsg;
+        RTTESTI_CHECK_RC_BREAK(rc = RTLocalIpcSessionRead(hIpcSession, &cbMsg, sizeof(cbMsg), NULL), VINF_SUCCESS);
+        if (cbMsg >= sizeof(cbMsg) && cbMsg <= MAX_DATA_MSG_SIZE)
+        {
+            pau32ScratchBuf[0] = cbMsg;
+
+            /* Read the message body. */
+            uint32_t cbLeft = cbMsg - sizeof(uint32_t);
+            uint8_t *pbCur  = (uint8_t *)&pau32ScratchBuf[1];
+            while (cbLeft > 0)
+            {
+                uint32_t cbCur = RTRandU32Ex(1, cbLeft + cbLeft / 4);
+                cbCur = RT_MIN(cbCur, cbLeft);
+                if ((iRound % 3) == 1)
+                {
+                    size_t cbRead = _1G;
+                    RTTESTI_CHECK_RC_BREAK(rc = RTLocalIpcSessionRead(hIpcSession, pbCur, cbCur, &cbRead), VINF_SUCCESS);
+                    RTTESTI_CHECK(cbCur >= cbRead);
+                    cbCur = (uint32_t)cbRead;
+                }
+                else
+                    RTTESTI_CHECK_RC_BREAK(rc = RTLocalIpcSessionRead(hIpcSession, pbCur, cbCur, NULL), VINF_SUCCESS);
+                pbCur  += cbCur;
+                cbLeft -= cbCur;
+            }
+
+            /* Check the message body. */
+            if (RT_SUCCESS(rc))
+            {
+                uint32_t offLast = cbMsg & (sizeof(uint32_t) - 1);
+                if (offLast)
+                    memcpy((uint8_t *)pau32ScratchBuf + cbMsg, (uint8_t const *)&iRound + offLast, sizeof(uint32_t) - offLast);
+
+                ASMCompilerBarrier(); /* Guard against theoretical alias issues in the above code.  */
+
+                uint32_t cWords = RT_ALIGN_32(cbMsg, sizeof(uint32_t)) / sizeof(uint32_t);
+                for (uint32_t iWord = 1; iWord < cWords; iWord++)
+                    if (pau32ScratchBuf[iWord] != iRound)
+                    {
+                        RTTestIFailed("Message body word #%u mismatch: %#x, expected %#x", iWord, pau32ScratchBuf[iWord], iRound);
+                        break;
+                    }
+            }
+        }
+        else
+        {
+            RTTestIFailed("cbMsg=%#x is out of range", cbMsg);
+            rc = VERR_OUT_OF_RANGE;
+        }
+    }
+
+    RTMemFree(pau32ScratchBuf);
+    return rc;
+}
+
+
+static int testSessionDataWriteMessages(RTLOCALIPCSESSION hIpcSession, uint32_t cRounds)
+{
+    /*
+     * Message scratch buffer.  Search message starts with a uint32_t word
+     * that indicates the message length.  The remaining words are set to
+     * the message number.
+     */
+    uint32_t   cbScratchBuf = RTRandU32Ex(64, MAX_DATA_MSG_SIZE);
+    cbScratchBuf = RT_ALIGN_32(cbScratchBuf, sizeof(uint32_t));
+
+    uint32_t *pau32ScratchBuf = (uint32_t *)RTMemAlloc(cbScratchBuf);
+    RTTESTI_CHECK_RET(pau32ScratchBuf != NULL, VERR_NO_MEMORY);
+
+    size_t cbSent = 0;
+    int rc = VINF_SUCCESS;
+    for (uint32_t iRound = 0; iRound < cRounds && rc == VINF_SUCCESS; iRound++)
+    {
+        /* Construct the message. */
+        uint32_t cbMsg  = RTRandU32Ex(sizeof(uint32_t), cbScratchBuf);
+        uint32_t cWords = RT_ALIGN_32(cbMsg, sizeof(uint32_t)) / sizeof(uint32_t);
+
+        uint32_t iWord  = 0;
+        pau32ScratchBuf[iWord++] = cbMsg;
+        while (iWord < cWords)
+            pau32ScratchBuf[iWord++] = iRound;
+
+        /* Send it. */
+        uint32_t cbLeft = cbMsg;
+        uint8_t const *pbCur = (uint8_t *)pau32ScratchBuf;
+        while (cbLeft > 0)
+        {
+            uint32_t cbCur = RT_MIN(iRound + 1, cbLeft);
+            RTTESTI_CHECK_RC_BREAK(rc = RTLocalIpcSessionWrite(hIpcSession, pbCur, cbCur), VINF_SUCCESS);
+            pbCur  += cbCur;
+            cbSent += cbCur;
+            cbLeft -= cbCur;
+        }
+    }
+
+    RTTestIPrintf(RTTESTLVL_ALWAYS, "Sent %'zu bytes over %u rounds.\n", cbSent, cRounds);
+    RTMemFree(pau32ScratchBuf);
+    return rc;
+}
+
+
+static DECLCALLBACK(int) testSessionDataThread(RTTHREAD hSelf, void *pvUser)
+{
+    RTLOCALIPCSERVER hIpcServer = (RTLOCALIPCSERVER)pvUser;
+    RTTEST_CHECK_RC_OK_RET(g_hTest, RTTestSetDefault(g_hTest, NULL), rcCheck);
+
+    int rc;
+    for (;;)
+    {
+        RTLOCALIPCSESSION hIpcSession;
+        rc = RTLocalIpcServerListen(hIpcServer, &hIpcSession);
+        if (RT_SUCCESS(rc))
+        {
+            RTTestIPrintf(RTTESTLVL_INFO, "testSessionDataThread: Got new client connection\n");
+
+            /* The server is the initator. First message sets the number of rounds. */
+            uint32_t cRounds = RTRandU32Ex(32, _1K);
+            RTTESTI_CHECK_RC(rc = RTLocalIpcSessionWrite(hIpcSession, &cRounds, sizeof(cRounds)), VINF_SUCCESS);
+            if (RT_SUCCESS(rc))
+            {
+                rc = testSessionDataWriteMessages(hIpcSession, cRounds);
+                if (RT_SUCCESS(rc))
+                    rc = testSessionDataReadMessages(hIpcSession, cRounds);
+            }
+
+            RTTESTI_CHECK_RC(RTLocalIpcSessionClose(hIpcSession), VINF_OBJECT_DESTROYED);
+            RTTESTI_CHECK_RC_OK(RTThreadUserSignal(hSelf));
+        }
+        else
+        {
+            RTTESTI_CHECK_RC(rc, VERR_CANCELLED);
+            break;
+        }
+    }
+    RTTESTI_CHECK_RC_OK(RTThreadUserSignal(hSelf));
+    return rc;
+}
+
+
+/**
+ * Used both as a thread procedure and child process worker.
+ */
+static DECLCALLBACK(int) tstRTLocalIpcSessionDataChild(RTTHREAD hSelf, void *pvUser)
+{
+    RTTEST_CHECK_RC_OK_RET(g_hTest, RTTestSetDefault(g_hTest, NULL), rcCheck);
+    RT_NOREF_PV(hSelf); RT_NOREF_PV(pvUser);
+
+    /*
+     * Connect.
+     */
+    RTLOCALIPCSESSION hClientSession;
+    RTTESTI_CHECK_RC_RET(RTLocalIpcSessionConnect(&hClientSession, "tstRTLocalIpcSessionData", 0 /*fFlags*/),
+                         VINF_SUCCESS, rcCheck);
+
+    /*
+     * The server first sends us a rounds count.
+     */
+    int rc;
+    uint32_t cRounds = 0;
+    RTTESTI_CHECK_RC(rc = RTLocalIpcSessionRead(hClientSession, &cRounds, sizeof(cRounds), NULL), VINF_SUCCESS);
+    if (RT_SUCCESS(rc))
+    {
+        if (cRounds >= 32 && cRounds <= _1K)
+        {
+            rc = testSessionDataReadMessages(hClientSession, cRounds);
+            if (RT_SUCCESS(rc))
+                rc = testSessionDataWriteMessages(hClientSession, cRounds);
+        }
+        else
+            RTTestIFailed("cRounds=%#x is out of range", cRounds);
+    }
+
+    RTTESTI_CHECK_RC(RTLocalIpcSessionClose(hClientSession), VINF_OBJECT_DESTROYED);
+
+    return rc;
+}
+
+
+/**
+ * @note This is identical to testSessionWait with a couple of strings, function
+ *       pointers, and timeouts replaced.
+ */
+static void testSessionData(const char *pszExecPath)
+{
+    RTTestISub(!pszExecPath ? "Data exchange with thread" : "Data exchange with child");
+
+    /*
+     * Create the test server.
+     */
+    RTLOCALIPCSERVER hIpcServer;
+    RTTESTI_CHECK_RC_RETV(RTLocalIpcServerCreate(&hIpcServer, "tstRTLocalIpcSessionData", 0), VINF_SUCCESS);
+
+    /*
+     * Create worker thread that listens and processes incoming connections
+     * until cancelled.
+     */
+    int rc;
+    RTTHREAD hListenThread;
+    RTTESTI_CHECK_RC_OK(rc = RTThreadCreate(&hListenThread, testSessionDataThread, hIpcServer, 0 /* Stack */,
+                                            RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, "listen-3"));
+    if (RT_SUCCESS(rc))
+    {
+        /*
+         * Create a client thread or process.
+         */
+        RTPROCESS hClientProc   = NIL_RTPROCESS;
+        RTTHREAD  hClientThread = NIL_RTTHREAD;
+        if (pszExecPath)
+        {
+            const char *apszArgs[4] = { pszExecPath, "child", "tstRTLocalIpcSessionDataChild", NULL };
+            RTTESTI_CHECK_RC_OK(rc = RTProcCreate(pszExecPath, apszArgs, RTENV_DEFAULT, 0 /* fFlags*/, &hClientProc));
+        }
+        else
+            RTTESTI_CHECK_RC_OK(rc = RTThreadCreate(&hClientThread, tstRTLocalIpcSessionDataChild, g_hTest, 0 /*cbStack*/,
+                                                    RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, "client-2"));
+
+        /*
+         * Wait for the server thread to indicate that it has processed one
+         * connection, then shut it all down.
+         */
+        if (RT_SUCCESS(rc))
+            RTTESTI_CHECK_RC_OK(RTThreadUserWait(hListenThread, RT_MS_1MIN * 3));
+
+        RTTESTI_CHECK_RC(RTLocalIpcServerCancel(hIpcServer), VINF_SUCCESS);
+        int rcThread;
+        RTTESTI_CHECK_RC(rc = RTThreadWait(hListenThread, RT_MS_1MIN / 2, &rcThread), VINF_SUCCESS);
+        if (RT_SUCCESS(rc))
+            RTTESTI_CHECK_RC(rcThread, VERR_CANCELLED);
+
+        RTTESTI_CHECK_RC(RTLocalIpcServerDestroy(hIpcServer), VINF_OBJECT_DESTROYED);
+
+        /*
+         * Check that client ran successfully.
+         */
+        if (pszExecPath)
+        {
+            if (hClientProc != NIL_RTPROCESS)
+            {
+                RTPROCSTATUS ProcStatus;
+                RTTESTI_CHECK_RC_OK(rc = RTProcWait(hClientProc, RTPROCWAIT_FLAGS_BLOCK, &ProcStatus));
+                if (RT_SUCCESS(rc) && (ProcStatus.enmReason != RTPROCEXITREASON_NORMAL || ProcStatus.iStatus != 0))
+                    RTTestIFailed("Chiled exited with enmReason=%d iStatus=%d", ProcStatus.enmReason, ProcStatus.iStatus);
+            }
+        }
+        else if (hClientThread != NIL_RTTHREAD)
+        {
+            RTTESTI_CHECK_RC_OK(rc = RTThreadWait(hClientThread, RT_MS_1MIN / 2, &rcThread));
+            if (RT_SUCCESS(rc))
+                RTTESTI_CHECK_RC(rcThread, VINF_SUCCESS);
+        }
+    }
+}
+
+
+/*********************************************************************************************************************************
+*                                                                                                                                *
+*   testSessionPerf - Performance measurements.                                                                                  *
+*                                                                                                                                *
+*********************************************************************************************************************************/
+
+#define IPC_PERF_LAST_MSG   UINT32_C(0x7fffeeee)
+#define IPC_PERF_MSG_REPLY(uMsg)    ((uMsg) | RT_BIT_32(31))
+
+
+static DECLCALLBACK(int) testSessionPerfThread(RTTHREAD hSelf, void *pvUser)
+{
+    RTLOCALIPCSERVER hIpcServer = (RTLOCALIPCSERVER)pvUser;
+    RTTEST_CHECK_RC_OK_RET(g_hTest, RTTestSetDefault(g_hTest, NULL), rcCheck);
+
+    int rc;
+    for (;;)
+    {
+        RTLOCALIPCSESSION hIpcSession;
+        rc = RTLocalIpcServerListen(hIpcServer, &hIpcSession);
+        if (RT_SUCCESS(rc))
+        {
+            RTTestIPrintf(RTTESTLVL_INFO, "testSessionPerfThread: Got new client connection\n");
+
+            /* The server is the initator, so we start sending messages. */
+            uint64_t cNsElapsed = _4G;
+            uint64_t nsStart    = RTTimeNanoTS();
+            uint32_t cMessages  = 0;
+            for (;; )
+            {
+                uint32_t uMsg = cMessages;
+                RTTESTI_CHECK_RC_BREAK(rc = RTLocalIpcSessionWrite(hIpcSession, &uMsg, sizeof(uMsg)), VINF_SUCCESS);
+                uMsg = UINT32_MAX;
+                RTTESTI_CHECK_RC_BREAK(rc = RTLocalIpcSessionRead(hIpcSession, &uMsg, sizeof(uMsg), NULL), VINF_SUCCESS);
+                if (uMsg == IPC_PERF_MSG_REPLY(cMessages))
+                { /* likely */ }
+                else
+                {
+                    RTTestIFailed("uMsg=%#x expected %#x", uMsg, IPC_PERF_MSG_REPLY(cMessages));
+                    rc = VERR_OUT_OF_RANGE;
+                    break;
+                }
+
+                /* next */
+                cMessages++;
+                if (cMessages & _16K)
+                { /* likely */ }
+                else
+                {
+                    cNsElapsed = RTTimeNanoTS() - nsStart;
+                    if (cNsElapsed > 2*RT_NS_1SEC_64)
+                    {
+                        uMsg = IPC_PERF_LAST_MSG;
+                        RTTESTI_CHECK_RC_BREAK(rc = RTLocalIpcSessionWrite(hIpcSession, &uMsg, sizeof(uMsg)), VINF_SUCCESS);
+                        break;
+                    }
+                }
+            }
+            if (RT_SUCCESS(rc))
+            {
+                RTThreadSleep(8); /* windows output fudge (purely esthetical) */
+                RTTestIValue("roundtrip", cNsElapsed / cMessages, RTTESTUNIT_NS_PER_ROUND_TRIP);
+                RTTestIValue("roundtrips", RT_NS_1SEC / (cNsElapsed / cMessages), RTTESTUNIT_OCCURRENCES_PER_SEC);
+            }
+
+            RTTESTI_CHECK_RC(RTLocalIpcSessionClose(hIpcSession), VINF_OBJECT_DESTROYED);
+            RTTESTI_CHECK_RC_OK(RTThreadUserSignal(hSelf));
+        }
+        else
+        {
+            RTTESTI_CHECK_RC(rc, VERR_CANCELLED);
+            break;
+        }
+    }
+    RTTESTI_CHECK_RC_OK(RTThreadUserSignal(hSelf));
+    return rc;
+}
+
+
+/**
+ * Used both as a thread procedure and child process worker.
+ */
+static DECLCALLBACK(int) tstRTLocalIpcSessionPerfChild(RTTHREAD hSelf, void *pvUser)
+{
+    RTTEST_CHECK_RC_OK_RET(g_hTest, RTTestSetDefault(g_hTest, NULL), rcCheck);
+    RT_NOREF_PV(hSelf); RT_NOREF_PV(pvUser);
+
+    /*
+     * Connect.
+     */
+    RTLOCALIPCSESSION hClientSession;
+    RTTESTI_CHECK_RC_RET(RTLocalIpcSessionConnect(&hClientSession, "tstRTLocalIpcSessionPerf", 0 /*fFlags*/),
+                         VINF_SUCCESS, rcCheck);
+
+    /*
+     * Process messages.  Server does all the timing and stuff.
+     */
+    int rc = VINF_SUCCESS;
+    for (uint32_t cMessages = 0; ; cMessages++)
+    {
+        /* Read the next message from the server. */
+        uint32_t uMsg = UINT32_MAX;
+        RTTESTI_CHECK_RC_BREAK(rc = RTLocalIpcSessionRead(hClientSession, &uMsg, sizeof(uMsg), NULL), VINF_SUCCESS);
+        if (uMsg == cMessages)
+        {
+            uMsg = IPC_PERF_MSG_REPLY(uMsg);
+            RTTESTI_CHECK_RC_BREAK(rc = RTLocalIpcSessionWrite(hClientSession, &uMsg, sizeof(uMsg)), VINF_SUCCESS);
+        }
+        else if (uMsg == IPC_PERF_LAST_MSG)
+            break;
+        else
+        {
+            RTTestIFailed("uMsg=%#x expected %#x", uMsg, cMessages);
+            rc = VERR_OUT_OF_RANGE;
+            break;
+        }
+    }
+
+    RTTESTI_CHECK_RC(RTLocalIpcSessionClose(hClientSession), VINF_OBJECT_DESTROYED);
+    return rc;
+}
+
+
+/**
+ * @note This is identical to testSessionWait with a couple of string and
+ *       function pointers replaced.
+ */
+static void testSessionPerf(const char *pszExecPath)
+{
+    RTTestISub(!pszExecPath ? "Thread performance" : "Child performance");
+
+    /*
+     * Create the test server.
+     */
+    RTLOCALIPCSERVER hIpcServer;
+    RTTESTI_CHECK_RC_RETV(RTLocalIpcServerCreate(&hIpcServer, "tstRTLocalIpcSessionPerf", 0), VINF_SUCCESS);
+
+    /*
+     * Create worker thread that listens and processes incoming connections
+     * until cancelled.
+     */
+    int rc;
+    RTTHREAD hListenThread;
+    RTTESTI_CHECK_RC_OK(rc = RTThreadCreate(&hListenThread, testSessionPerfThread, hIpcServer, 0 /* Stack */,
+                                            RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, "listen-3"));
+    if (RT_SUCCESS(rc))
+    {
+        /*
+         * Create a client thread or process.
+         */
+        RTPROCESS hClientProc   = NIL_RTPROCESS;
+        RTTHREAD  hClientThread = NIL_RTTHREAD;
+        if (pszExecPath)
+        {
+            const char *apszArgs[4] = { pszExecPath, "child", "tstRTLocalIpcSessionPerfChild", NULL };
+            RTTESTI_CHECK_RC_OK(rc = RTProcCreate(pszExecPath, apszArgs, RTENV_DEFAULT, 0 /* fFlags*/, &hClientProc));
+        }
+        else
+            RTTESTI_CHECK_RC_OK(rc = RTThreadCreate(&hClientThread, tstRTLocalIpcSessionPerfChild, g_hTest, 0 /*cbStack*/,
+                                                    RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, "client-2"));
+
+        /*
+         * Wait for the server thread to indicate that it has processed one
+         * connection, then shut it all down.
+         */
+        if (RT_SUCCESS(rc))
+            RTTESTI_CHECK_RC_OK(RTThreadUserWait(hListenThread, RT_MS_1MIN / 2));
+
+        RTTESTI_CHECK_RC(RTLocalIpcServerCancel(hIpcServer), VINF_SUCCESS);
+        int rcThread;
+        RTTESTI_CHECK_RC(rc = RTThreadWait(hListenThread, RT_MS_1MIN / 2, &rcThread), VINF_SUCCESS);
+        if (RT_SUCCESS(rc))
+            RTTESTI_CHECK_RC(rcThread, VERR_CANCELLED);
+
+        RTTESTI_CHECK_RC(RTLocalIpcServerDestroy(hIpcServer), VINF_OBJECT_DESTROYED);
+
+        /*
+         * Check that client ran successfully.
+         */
+        if (pszExecPath)
+        {
+            if (hClientProc != NIL_RTPROCESS)
+            {
+                RTPROCSTATUS ProcStatus;
+                RTTESTI_CHECK_RC_OK(rc = RTProcWait(hClientProc, RTPROCWAIT_FLAGS_BLOCK, &ProcStatus));
+                if (RT_SUCCESS(rc) && (ProcStatus.enmReason != RTPROCEXITREASON_NORMAL || ProcStatus.iStatus != 0))
+                    RTTestIFailed("Chiled exited with enmReason=%d iStatus=%d", ProcStatus.enmReason, ProcStatus.iStatus);
+            }
+        }
+        else if (hClientThread != NIL_RTTHREAD)
+        {
+            RTTESTI_CHECK_RC_OK(rc = RTThreadWait(hClientThread, RT_MS_1MIN / 2, &rcThread));
+            if (RT_SUCCESS(rc))
+                RTTESTI_CHECK_RC(rcThread, VINF_SUCCESS);
+        }
+    }
+}
+
+
+int main(int argc, char **argv)
+{
+    int rc = RTR3InitExe(argc, &argv, 0);
+    if (RT_FAILURE(rc))
+        return RTMsgInitFailure(rc);
+
+    /*
+     * Main process.
+     */
+    if (argc == 1)
+    {
+        rc = RTTestCreate("tstRTLocalIpc", &g_hTest);
+        if (RT_FAILURE(rc))
+            return RTEXITCODE_FAILURE;
+        RTTestBanner(g_hTest);
+
+        /* Basics first. */
+        bool fMayPanic = RTAssertSetMayPanic(false);
+        bool fQuiet    = RTAssertSetQuiet(true);
+        testBasics();
+        RTAssertSetMayPanic(fMayPanic);
+        RTAssertSetQuiet(fQuiet);
+
+        /* Do real tests if the basics are fine. */
+        char szExecPath[RTPATH_MAX];
+        if (RTProcGetExecutablePath(szExecPath, sizeof(szExecPath)))
+        {
+            if (RTTestErrorCount(g_hTest) == 0)
+                testSessionConnection(NULL);
+            if (RTTestErrorCount(g_hTest) == 0)
+                testSessionConnection(szExecPath);
+
+            if (RTTestErrorCount(g_hTest) == 0)
+                testSessionWait(NULL);
+            if (RTTestErrorCount(g_hTest) == 0)
+                testSessionWait(szExecPath);
+
+            if (RTTestErrorCount(g_hTest) == 0)
+                testSessionData(NULL);
+            if (RTTestErrorCount(g_hTest) == 0)
+                testSessionData(szExecPath);
+
+            if (RTTestErrorCount(g_hTest) == 0)
+                testSessionPerf(NULL);
+            if (RTTestErrorCount(g_hTest) == 0)
+                testSessionPerf(szExecPath);
+        }
+        else
+            RTTestIFailed("RTProcGetExecutablePath failed");
+    }
+    /*
+     * Child process.
+     */
+    else if (   argc == 3
+             && !strcmp(argv[1], "child"))
+    {
+        rc = RTTestCreateChild(argv[2], &g_hTest);
+        if (RT_FAILURE(rc))
+            return RTEXITCODE_FAILURE;
+
+        if (!strcmp(argv[2], "tstRTLocalIpcSessionConnectionChild"))
+            tstRTLocalIpcSessionConnectionChild(RTThreadSelf(), g_hTest);
+        else if (!strcmp(argv[2], "tstRTLocalIpcSessionWaitChild"))
+            tstRTLocalIpcSessionWaitChild(RTThreadSelf(), g_hTest);
+        else if (!strcmp(argv[2], "tstRTLocalIpcSessionDataChild"))
+            tstRTLocalIpcSessionDataChild(RTThreadSelf(), g_hTest);
+        else if (!strcmp(argv[2], "tstRTLocalIpcSessionPerfChild"))
+            tstRTLocalIpcSessionPerfChild(RTThreadSelf(), g_hTest);
+        else
+            RTTestIFailed("Unknown child function '%s'", argv[2]);
+    }
+    /*
+     * Invalid parameters.
+     */
+    else
+        return RTEXITCODE_SYNTAX;
+
+    /*
+     * Summary.
+     */
+    return RTTestSummaryAndDestroy(g_hTest);
+}
+