VirtualBox

Changeset 58282 in vbox


Ignore:
Timestamp:
Oct 16, 2015 2:51:40 PM (9 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
103476
Message:

localipc-posix.cpp: Partly debugged code.

Location:
trunk/src/VBox/Runtime
Files:
1 added
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Runtime/Makefile.kmk

    r58269 r58282  
    836836        r3/posix/fs3-posix.cpp \
    837837        r3/posix/ldrNative-posix.cpp \
     838        r3/posix/localipc-posix.cpp \
    838839        r3/posix/path-posix.cpp \
    839840        r3/posix/path2-posix.cpp \

  • trunk/src/VBox/Runtime/VBox/VBoxRTDeps.cpp

    r57358 r58282  
    3434#include <iprt/asm.h>
    3535#include <iprt/assert.h>
     36#include <iprt/localipc.h>
    3637#include <iprt/buildconfig.h>
    3738#include <iprt/system.h>
    … …  
    6263#endif
    6364    (PFNRT)xmlLoadCatalogs,
     65    (PFNRT)RTLocalIpcServerCreate,
    6466    (PFNRT)MD5_Init,
    6567    (PFNRT)RC4,

  • trunk/src/VBox/Runtime/include/internal/socket.h

    r56290 r58282  
    5252
    5353#ifndef IPRT_INTERNAL_SOCKET_POLLING_ONLY
    54 int rtSocketResolverError(void);
    55 int rtSocketCreateForNative(RTSOCKETINT **ppSocket, RTSOCKETNATIVE hNative);
    56 int rtSocketCreate(PRTSOCKET phSocket, int iDomain, int iType, int iProtocol);
    57 int rtSocketBind(RTSOCKET hSocket, PCRTNETADDR pAddr);
    58 int rtSocketBindRawAddr(RTSOCKET hSocket, void const *pvAddr, size_t cbAddr);
    59 int rtSocketListen(RTSOCKET hSocket, int cMaxPending);
    60 int rtSocketAccept(RTSOCKET hSocket, PRTSOCKET phClient, struct sockaddr *pAddr, size_t *pcbAddr);
    61 int rtSocketConnect(RTSOCKET hSocket, PCRTNETADDR pAddr, RTMSINTERVAL cMillies);
    62 int rtSocketSetOpt(RTSOCKET hSocket, int iLevel, int iOption, void const *pvValue, int cbValue);
     54DECLHIDDEN(int) rtSocketResolverError(void);
     55DECLHIDDEN(int) rtSocketCreateForNative(RTSOCKETINT **ppSocket, RTSOCKETNATIVE hNative);
     56DECLHIDDEN(int) rtSocketCreate(PRTSOCKET phSocket, int iDomain, int iType, int iProtocol);
     57DECLHIDDEN(int) rtSocketBind(RTSOCKET hSocket, PCRTNETADDR pAddr);
     58DECLHIDDEN(int) rtSocketBindRawAddr(RTSOCKET hSocket, void const *pvAddr, size_t cbAddr);
     59DECLHIDDEN(int) rtSocketListen(RTSOCKET hSocket, int cMaxPending);
     60DECLHIDDEN(int) rtSocketAccept(RTSOCKET hSocket, PRTSOCKET phClient, struct sockaddr *pAddr, size_t *pcbAddr);
     61DECLHIDDEN(int) rtSocketConnect(RTSOCKET hSocket, PCRTNETADDR pAddr, RTMSINTERVAL cMillies);
     62DECLHIDDEN(int) rtSocketConnectRaw(RTSOCKET hSocket, void const *pvAddr, size_t cbAddr);
     63DECLHIDDEN(int) rtSocketSetOpt(RTSOCKET hSocket, int iLevel, int iOption, void const *pvValue, int cbValue);
    6364#endif /* IPRT_INTERNAL_SOCKET_POLLING_ONLY */
    6465
    65 int         rtSocketPollGetHandle(RTSOCKET hSocket, uint32_t fEvents, PRTHCINTPTR phNative);
    66 uint32_t    rtSocketPollStart(RTSOCKET hSocket, RTPOLLSET hPollSet, uint32_t fEvents, bool fFinalEntry, bool fNoWait);
    67 uint32_t    rtSocketPollDone(RTSOCKET hSocket, uint32_t fEvents, bool fFinalEntry, bool fHarvestEvents);
     66DECLHIDDEN(int)         rtSocketPollGetHandle(RTSOCKET hSocket, uint32_t fEvents, PRTHCINTPTR phNative);
     67DECLHIDDEN(uint32_t)    rtSocketPollStart(RTSOCKET hSocket, RTPOLLSET hPollSet, uint32_t fEvents, bool fFinalEntry, bool fNoWait);
     68DECLHIDDEN(uint32_t)    rtSocketPollDone(RTSOCKET hSocket, uint32_t fEvents, bool fFinalEntry, bool fHarvestEvents);
    6869
    6970RT_C_DECLS_END

  • trunk/src/VBox/Runtime/r3/socket.cpp

    r57978 r58282  
    212212 * @returns iprt status code.
    213213 */
    214 int rtSocketResolverError(void)
     214DECLHIDDEN(int) rtSocketResolverError(void)
    215215{
    216216#ifdef RT_OS_WINDOWS
    … …  
    400400 * @param   hNative         The native handle.
    401401 */
    402 int rtSocketCreateForNative(RTSOCKETINT **ppSocket, RTSOCKETNATIVE hNative)
     402DECLHIDDEN(int) rtSocketCreateForNative(RTSOCKETINT **ppSocket, RTSOCKETNATIVE hNative)
    403403{
    404404    RTSOCKETINT *pThis = (RTSOCKETINT *)RTMemPoolAlloc(RTMEMPOOL_DEFAULT, sizeof(*pThis));
    … …  
    444444 * @param   iProtocol           Socket parameter, usually 0.
    445445 */
    446 int rtSocketCreate(PRTSOCKET phSocket, int iDomain, int iType, int iProtocol)
     446DECLHIDDEN(int) rtSocketCreate(PRTSOCKET phSocket, int iDomain, int iType, int iProtocol)
    447447{
    448448    /*
    … …  
    14251425
    14261426
    1427 RTDECL(int) RTSocketSelectOneEx(RTSOCKET hSocket, uint32_t fEvents, uint32_t *pfEvents,
    1428                                 RTMSINTERVAL cMillies)
     1427RTDECL(int) RTSocketSelectOneEx(RTSOCKET hSocket, uint32_t fEvents, uint32_t *pfEvents, RTMSINTERVAL cMillies)
    14291428{
    14301429    /*
    … …  
    15871586 * @param   pAddr               The address to bind to.
    15881587 */
    1589 int rtSocketBind(RTSOCKET hSocket, PCRTNETADDR pAddr)
     1588DECLHIDDEN(int) rtSocketBind(RTSOCKET hSocket, PCRTNETADDR pAddr)
    15901589{
    15911590    RTSOCKADDRUNION u;
    … …  
    16071606 * @param   cbAddr              The size of the address.
    16081607 */
    1609 int rtSocketBindRawAddr(RTSOCKET hSocket, void const *pvAddr, size_t cbAddr)
     1608DECLHIDDEN(int) rtSocketBindRawAddr(RTSOCKET hSocket, void const *pvAddr, size_t cbAddr)
    16101609{
    16111610    /*
    … …  
    16371636 * @param   cMaxPending         The max number of pending connections.
    16381637 */
    1639 int rtSocketListen(RTSOCKET hSocket, int cMaxPending)
     1638DECLHIDDEN(int) rtSocketListen(RTSOCKET hSocket, int cMaxPending)
    16401639{
    16411640    /*
    … …  
    16681667 *                              size of what's stored at @a pAddr.
    16691668 */
    1670 int rtSocketAccept(RTSOCKET hSocket, PRTSOCKET phClient, struct sockaddr *pAddr, size_t *pcbAddr)
     1669DECLHIDDEN(int) rtSocketAccept(RTSOCKET hSocket, PRTSOCKET phClient, struct sockaddr *pAddr, size_t *pcbAddr)
    16711670{
    16721671    /*
    … …  
    17271726 *                              configured on the running system.
    17281727 */
    1729 int rtSocketConnect(RTSOCKET hSocket, PCRTNETADDR pAddr, RTMSINTERVAL cMillies)
     1728DECLHIDDEN(int) rtSocketConnect(RTSOCKET hSocket, PCRTNETADDR pAddr, RTMSINTERVAL cMillies)
    17301729{
    17311730    /*
    … …  
    18171816
    18181817/**
     1818 * Wrapper around connect, raw address, no timeout.
     1819 *
     1820 * @returns IPRT status code.
     1821 * @param   hSocket             The socket handle.
     1822 * @param   pvAddr              The raw socket address to connect to.
     1823 * @param   cbAddr              The size of the raw address.
     1824 */
     1825DECLHIDDEN(int) rtSocketConnectRaw(RTSOCKET hSocket, void const *pvAddr, size_t cbAddr)
     1826{
     1827    /*
     1828     * Validate input.
     1829     */
     1830    RTSOCKETINT *pThis = hSocket;
     1831    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
     1832    AssertReturn(pThis->u32Magic == RTSOCKET_MAGIC, VERR_INVALID_HANDLE);
     1833    AssertReturn(rtSocketTryLock(pThis), VERR_CONCURRENT_ACCESS);
     1834
     1835    int rc;
     1836    if (connect(pThis->hNative, (const struct sockaddr *)pvAddr, (int)cbAddr) == 0)
     1837        rc = VINF_SUCCESS;
     1838    else
     1839        rc = rtSocketError();
     1840
     1841    rtSocketUnlock(pThis);
     1842    return rc;
     1843}
     1844
     1845
     1846/**
    18191847 * Wrapper around setsockopt.
    18201848 *
    … …  
    18261854 * @param   cbValue             The size of the value pointed to by pvValue.
    18271855 */
    1828 int rtSocketSetOpt(RTSOCKET hSocket, int iLevel, int iOption, void const *pvValue, int cbValue)
     1856DECLHIDDEN(int) rtSocketSetOpt(RTSOCKET hSocket, int iLevel, int iOption, void const *pvValue, int cbValue)
    18291857{
    18301858    /*
    … …  
    18541882 * @param   phNative            Where to put the primary handle.
    18551883 */
    1856 int rtSocketPollGetHandle(RTSOCKET hSocket, uint32_t fEvents, PRTHCINTPTR phNative)
     1884DECLHIDDEN(int) rtSocketPollGetHandle(RTSOCKET hSocket, uint32_t fEvents, PRTHCINTPTR phNative)
    18571885{
    18581886    RTSOCKETINT *pThis = hSocket;
    … …  
    20532081 *          @c true, we don't currently care about that oddity...
    20542082 */
    2055 uint32_t rtSocketPollStart(RTSOCKET hSocket, RTPOLLSET hPollSet, uint32_t fEvents, bool fFinalEntry, bool fNoWait)
     2083DECLHIDDEN(uint32_t) rtSocketPollStart(RTSOCKET hSocket, RTPOLLSET hPollSet, uint32_t fEvents, bool fFinalEntry, bool fNoWait)
    20562084{
    20572085    RTSOCKETINT *pThis = hSocket;
    … …  
    21252153 * @param   fHarvestEvents      Set if we should check for pending events.
    21262154 */
    2127 uint32_t rtSocketPollDone(RTSOCKET hSocket, uint32_t fEvents, bool fFinalEntry, bool fHarvestEvents)
     2155DECLHIDDEN(uint32_t) rtSocketPollDone(RTSOCKET hSocket, uint32_t fEvents, bool fFinalEntry, bool fHarvestEvents)
    21282156{
    21292157    RTSOCKETINT *pThis = hSocket;

  • trunk/src/VBox/Runtime/r3/win/localipc-win.cpp

    r57974 r58282  
    343343     */
    344344    AssertPtrReturn(phServer, VERR_INVALID_POINTER);
     345
     346    AssertReturn(!(fFlags & ~RTLOCALIPC_FLAGS_VALID_MASK), VERR_INVALID_FLAGS);
     347    AssertReturn(fFlags & RTLOCALIPC_FLAGS_MULTI_SESSION, VERR_INVALID_FLAGS); /** @todo Implement !RTLOCALIPC_FLAGS_MULTI_SESSION */
     348
    345349    AssertPtrReturn(pszName, VERR_INVALID_POINTER);
    346     AssertReturn(*pszName, VERR_INVALID_PARAMETER);
    347     AssertReturn(!(fFlags & ~(RTLOCALIPC_FLAGS_VALID_MASK)), VERR_INVALID_PARAMETER);
    348     AssertReturn((fFlags & RTLOCALIPC_FLAGS_MULTI_SESSION), VERR_INVALID_PARAMETER); /** @todo Implement !RTLOCALIPC_FLAGS_MULTI_SESSION */
     350    AssertReturn(*pszName, VERR_INVALID_NAME);
    349351
    350352    /*
    … …  
    650652    AssertPtrReturn(phSession, VERR_INVALID_POINTER);
    651653    AssertPtrReturn(pszName, VERR_INVALID_POINTER);
    652     AssertReturn(*pszName, VERR_INVALID_PARAMETER);
    653     AssertReturn(!fFlags, VERR_INVALID_PARAMETER); /* Flags currently unused, must be 0. */
     654    AssertReturn(*pszName, VERR_INVALID_NAME);
     655    AssertReturn(!fFlags, VERR_INVALID_FLAGS); /* Flags currently unused, must be 0. */
    654656
    655657    PRTLOCALIPCSESSIONINT pThis = (PRTLOCALIPCSESSIONINT)RTMemAlloc(sizeof(*pThis));

  • trunk/src/VBox/Runtime/testcase/Makefile.kmk

    r57956 r58282  
    8181        tstLdr \
    8282        tstLdrLoad \
     83        tstRTLocalIpc \
    8384        tstRTLdrVerifyPeImage \
    8485        tstRTList \
    … …  
    148149PROGRAMS.win += \
    149150        tstRTCritSectW32 \
    150         tstRTLocalIpc \
    151151        tstRTProcWait \
    152152        tstFileAppendWin-1 \

  • trunk/src/VBox/Runtime/testcase/tstRTLocalIpc.cpp

    r58280 r58282  
    6060static DECLCALLBACK(int) testServerListenAndCancelThread(RTTHREAD hSelf, void *pvUser)
    6161{
    62     PRTLOCALIPCSERVER pServer = (PRTLOCALIPCSERVER)pvUser;
    63     AssertPtr(pServer);
     62    PRTLOCALIPCSERVER phServer = (PRTLOCALIPCSERVER)pvUser;
     63    AssertPtr(phServer);
    6464
    6565    RTThreadSleep(5000); /* Wait a bit to simulate waiting in main thread. */
    6666
    67     int rc = RTLocalIpcServerCancel(*pServer);
     67    int rc = RTLocalIpcServerCancel(*phServer);
    6868    AssertRC(rc);
    6969
    … …  
    7575    RTTestSub(hTest, "testServerListenAndCancel");
    7676
    77     RTLOCALIPCSERVER ipcServer;
    78     int rc = RTLocalIpcServerCreate(&ipcServer, "testServerListenAndCancel",
     77    RTLOCALIPCSERVER hIpcServer;
     78    int rc = RTLocalIpcServerCreate(&hIpcServer, "testServerListenAndCancel",
    7979                                    RTLOCALIPC_FLAGS_MULTI_SESSION);
    8080    if (RT_SUCCESS(rc))
    … …  
    8484        RTTHREAD hThread;
    8585        rc = RTThreadCreate(&hThread, testServerListenAndCancelThread,
    86                             &ipcServer, 0 /* Stack */, RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, "tstIpc1");
     86                            &hIpcServer, 0 /* Stack */, RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, "tstIpc1");
    8787        if (RT_SUCCESS(rc))
    8888        {
    … …  
    9090            {
    9191                RTTestPrintf(hTest, RTTESTLVL_INFO, "Listening for incoming connections ...\n");
    92                 RTLOCALIPCSESSION ipcSession;
    93                 RTTEST_CHECK_RC_BREAK(hTest, RTLocalIpcServerListen(ipcServer, &ipcSession), VERR_CANCELLED);
    94                 RTTEST_CHECK_RC_BREAK(hTest, RTLocalIpcServerCancel(ipcServer), VINF_SUCCESS);
    95                 RTTEST_CHECK_RC_BREAK(hTest, RTLocalIpcServerDestroy(ipcServer), VINF_SUCCESS);
     92                RTLOCALIPCSESSION hIpcSession;
     93                RTTEST_CHECK_RC_BREAK(hTest, RTLocalIpcServerListen(hIpcServer, &hIpcSession), VERR_CANCELLED);
     94                RTTEST_CHECK_RC_BREAK(hTest, RTLocalIpcServerCancel(hIpcServer), VINF_SUCCESS);
     95                RTTEST_CHECK_RC_BREAK(hTest, RTLocalIpcServerDestroy(hIpcServer), VINF_SUCCESS);
    9696
    9797                RTTestPrintf(hTest, RTTESTLVL_INFO, "Waiting for thread to exit ...\n");
    98                 RTTEST_CHECK_RC(hTest, RTThreadWait(hThread,
    99                                                     30 * 1000 /* 30s timeout */, NULL), VINF_SUCCESS);
     98                RTTEST_CHECK_RC(hTest, RTThreadWait(hThread, 30 * 1000 /* 30s timeout */, NULL), VINF_SUCCESS);
    10099            } while (0);
    101100        }
    … …  
    109108}
    110109
    111 static DECLCALLBACK(int) testSessionConnectionThread(RTTHREAD hSelf, void *pvUser)
     110static DECLCALLBACK(int) testServerListenThread(RTTHREAD hSelf, void *pvUser)
    112111{
    113112    PLOCALIPCTHREADCTX pCtx = (PLOCALIPCTHREADCTX)pvUser;
    … …  
    115114
    116115    int rc;
    117     RTTestPrintf(pCtx->hTest, RTTESTLVL_INFO, "testSessionConnectionThread: Listening for incoming connections ...\n");
     116    RTTestPrintf(pCtx->hTest, RTTESTLVL_INFO, "testServerListenThread: Listening for incoming connections ...\n");
    118117    for (;;)
    119118    {
    120         RTLOCALIPCSESSION ipcSession;
    121         rc = RTLocalIpcServerListen(pCtx->hServer, &ipcSession);
    122         RTTestPrintf(pCtx->hTest, RTTESTLVL_DEBUG, "testSessionConnectionThread: Listening returned with rc=%Rrc\n", rc);
    123         if (RT_SUCCESS(rc))
    124         {
    125             RTTestPrintf(pCtx->hTest, RTTESTLVL_INFO, "testSessionConnectionThread: Got new client connection\n");
     119        RTLOCALIPCSESSION hIpcSession;
     120        rc = RTLocalIpcServerListen(pCtx->hServer, &hIpcSession);
     121        RTTestPrintf(pCtx->hTest, RTTESTLVL_DEBUG, "testServerListenThread: Listening returned with rc=%Rrc\n", rc);
     122        if (RT_SUCCESS(rc))
     123        {
     124            RTTestPrintf(pCtx->hTest, RTTESTLVL_INFO, "testServerListenThread: Got new client connection\n");
     125            RTTEST_CHECK_RC(pCtx->hTest, RTLocalIpcSessionClose(hIpcSession), VINF_SUCCESS);
    126126        }
    127127        else
    … …  
    129129    }
    130130
    131     RTTestPrintf(pCtx->hTest, RTTESTLVL_INFO, "testSessionConnectionThread: Ended with rc=%Rrc\n", rc);
     131    RTTestPrintf(pCtx->hTest, RTTESTLVL_INFO, "testServerListenThread: Ended with rc=%Rrc\n", rc);
    132132    return rc;
    133133}
    … …  
    138138    {
    139139        RTThreadSleep(2000); /* Fudge */
    140         RTLOCALIPCSESSION clientSession;
    141         RTTEST_CHECK_RC_BREAK(hTest, RTLocalIpcSessionConnect(&clientSession, "tstRTLocalIpcSessionConnection",
    142                                                               0 /* Flags */), VINF_SUCCESS);
     140        RTLOCALIPCSESSION hClientSession;
     141        RTTEST_CHECK_RC_BREAK(hTest, RTLocalIpcSessionConnect(&hClientSession, "tstRTLocalIpcSessionConnection",0 /* Flags */),
     142                              VINF_SUCCESS);
    143143        RTThreadSleep(5000); /* Fudge */
    144         RTTEST_CHECK_RC_BREAK(hTest, RTLocalIpcSessionClose(clientSession), VINF_SUCCESS);
     144        RTTEST_CHECK_RC_BREAK(hTest, RTLocalIpcSessionClose(hClientSession), VINF_SUCCESS);
    145145
    146146    } while (0);
    … …  
    153153    RTTestSub(hTest, "testSessionConnection");
    154154
    155     RTLOCALIPCSERVER ipcServer;
    156     int rc = RTLocalIpcServerCreate(&ipcServer, "tstRTLocalIpcSessionConnection",
    157                                     RTLOCALIPC_FLAGS_MULTI_SESSION);
     155    RTLOCALIPCSERVER hIpcServer;
     156    int rc = RTLocalIpcServerCreate(&hIpcServer, "tstRTLocalIpcSessionConnection", RTLOCALIPC_FLAGS_MULTI_SESSION);
    158157    if (RT_SUCCESS(rc))
    159158    {
    160159#ifndef VBOX_TESTCASES_WITH_NO_THREADING
    161         LOCALIPCTHREADCTX threadCtx = { ipcServer, hTest };
     160        LOCALIPCTHREADCTX threadCtx = { hIpcServer, hTest };
    162161
    163162        /* Spawn a simple worker thread and let it listen for incoming connections.
    164163         * In the meanwhile we try to cancel the server and see what happens. */
    165164        RTTHREAD hThread;
    166         rc = RTThreadCreate(&hThread, testSessionConnectionThread,
     165        rc = RTThreadCreate(&hThread, testServerListenThread,
    167166                            &threadCtx, 0 /* Stack */, RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, "tstIpc2");
    168167        if (RT_SUCCESS(rc))
    … …  
    171170            {
    172171                RTPROCESS hProc;
    173                 const char *apszArgs[4] = { pszExecPath, "child", "tstRTLocalIpcSessionConnectionFork", NULL };
    174                 RTTEST_CHECK_RC_BREAK(hTest, RTProcCreate(pszExecPath, apszArgs,
    175                                                           RTENV_DEFAULT, 0 /* fFlags*/, &hProc), VINF_SUCCESS);
     172                const char *apszArgs[4] = { pszExecPath, "child", "testSessionConnectionChild", NULL };
     173                RTTEST_CHECK_RC_BREAK(hTest, RTProcCreate(pszExecPath, apszArgs, RTENV_DEFAULT, 0 /* fFlags*/, &hProc),
     174                                      VINF_SUCCESS);
    176175                RTPROCSTATUS stsChild;
    177176                RTTEST_CHECK_RC_BREAK(hTest, RTProcWait(hProc, RTPROCWAIT_FLAGS_BLOCK, &stsChild), VINF_SUCCESS);
    178177                RTTestPrintf(hTest, RTTESTLVL_INFO, "Child terminated, waiting for server thread ...\n");
    179                 RTTEST_CHECK_RC_BREAK(hTest, RTLocalIpcServerCancel(ipcServer), VINF_SUCCESS);
    180                 int threadRc;
    181                 RTTEST_CHECK_RC(hTest, RTThreadWait(hThread,
    182                                                     30 * 1000 /* 30s timeout */, &threadRc), VINF_SUCCESS);
    183                 RTTEST_CHECK_RC_BREAK(hTest, threadRc,  VERR_CANCELLED);
     178
     179                RTTEST_CHECK_RC_BREAK(hTest, RTLocalIpcServerCancel(hIpcServer), VINF_SUCCESS);
     180                int rcThread;
     181                RTTEST_CHECK_RC(hTest, RTThreadWait(hThread, 30 * 1000 /* 30s timeout */, &rcThread), VINF_SUCCESS);
     182                RTTEST_CHECK_RC_BREAK(hTest, rcThread,  VERR_CANCELLED);
    184183                RTTestPrintf(hTest, RTTESTLVL_INFO, "Server thread terminated successfully\n");
    185                 RTTEST_CHECK_RC_BREAK(hTest, RTLocalIpcServerDestroy(ipcServer), VINF_SUCCESS);
     184
     185                RTTEST_CHECK_RC_BREAK(hTest, RTLocalIpcServerDestroy(hIpcServer), VINF_SUCCESS);
     186                hIpcServer = NIL_RTLOCALIPCSERVER;
     187
    186188                RTTEST_CHECK_BREAK(hTest, stsChild.enmReason == RTPROCEXITREASON_NORMAL);
    187189                RTTEST_CHECK_BREAK(hTest, stsChild.iStatus == 0);
    188             }
    189             while (0);
     190            } while (0);
    190191        }
    191192        else
    … …  
    195196        {
    196197            RTPROCESS hProc;
    197             const char *apszArgs[4] = { pszExecPath, "child", "tstRTLocalIpcSessionConnectionFork", NULL };
    198             RTTEST_CHECK_RC_BREAK(hTest, RTProcCreate(pszExecPath, apszArgs,
    199                                                       RTENV_DEFAULT, 0 /* fFlags*/, &hProc), VINF_SUCCESS);
    200             RTLOCALIPCSESSION ipcSession;
    201             rc = RTLocalIpcServerListen(ipcServer, &ipcSession);
     198            const char *apszArgs[4] = { pszExecPath, "child", "testSessionConnectionChild", NULL };
     199            RTTEST_CHECK_RC_BREAK(hTest, RTProcCreate(pszExecPath, apszArgs, RTENV_DEFAULT, 0 /* fFlags*/, &hProc), VINF_SUCCESS);
     200
     201            RTLOCALIPCSESSION hIpcSession;
     202            rc = RTLocalIpcServerListen(hIpcServer, &hIpcSession);
    202203            if (RT_SUCCESS(rc))
    203204            {
    204                 RTTestPrintf(hTest, RTTESTLVL_INFO, "testSessionConnectionThread: Got new client connection\n");
     205                RTTestPrintf(hTest, RTTESTLVL_INFO, "testServerListenThread: Got new client connection\n");
     206                RTTEST_CHECK_RC_BREAK(hTest, RTLocalIpcSessionClose(hIpcSession), VINF_SUCCESS);
    205207            }
    206208            else
    … …  
    209211        } while (0);
    210212#endif
     213        if (hIpcServer != NIL_RTLOCALIPCSERVER)
     214            RTTEST_CHECK_RC(hTest, RTLocalIpcServerDestroy(hIpcServer), VINF_SUCCESS);
    211215    }
    212216    else
    … …  
    225229    {
    226230        RTTestPrintf(pCtx->hTest, RTTESTLVL_INFO, "testSessionWaitThread: Listening for incoming connections ...\n");
    227         RTLOCALIPCSESSION ipcSession;
    228         rc = RTLocalIpcServerListen(pCtx->hServer, &ipcSession);
     231        RTLOCALIPCSESSION hIpcSession;
     232        rc = RTLocalIpcServerListen(pCtx->hServer, &hIpcSession);
    229233        if (RT_SUCCESS(rc))
    230234        {
    231235            RTTestPrintf(pCtx->hTest, RTTESTLVL_INFO, "testSessionWaitThread: Got new client connection, waiting a bit ...\n");
    232236            RTThreadSleep(2000);
    233             rc = RTLocalIpcSessionClose(ipcSession);
     237            rc = RTLocalIpcSessionClose(hIpcSession);
    234238        }
    235239        else
    … …  
    253257                                                              0 /* Flags */), VINF_SUCCESS);
    254258        RTTEST_CHECK_RC_BREAK(hTest, RTLocalIpcSessionWaitForData(clientSession, 100       /* 100ms timeout */),
    255                                                                   VERR_TIMEOUT);
     259                              VERR_TIMEOUT);
    256260        /* Next, try 60s timeout. Should be returning way earlier because the server closed the
    257261         * connection after the first client connected. */
    258262        RTTEST_CHECK_RC_BREAK(hTest, RTLocalIpcSessionWaitForData(clientSession, 60 * 1000),
    259                                                                   VERR_BROKEN_PIPE);
     263                              VERR_BROKEN_PIPE);
    260264        /* Last try, also should fail because the server should be not around anymore. */
    261265        RTTEST_CHECK_RC_BREAK(hTest, RTLocalIpcSessionWaitForData(clientSession, 5 * 1000),
    262                                                                   VERR_BROKEN_PIPE);
     266                              VERR_BROKEN_PIPE);
    263267        RTTEST_CHECK_RC_BREAK(hTest, RTLocalIpcSessionClose(clientSession), VINF_SUCCESS);
    264268
    … …  
    272276    RTTestSub(hTest, "testSessionWait");
    273277
    274     RTLOCALIPCSERVER ipcServer;
    275     int rc = RTLocalIpcServerCreate(&ipcServer, "tstRTLocalIpcSessionWait",
     278    RTLOCALIPCSERVER hIpcServer;
     279    int rc = RTLocalIpcServerCreate(&hIpcServer, "tstRTLocalIpcSessionWait",
    276280                                    RTLOCALIPC_FLAGS_MULTI_SESSION);
    277281    if (RT_SUCCESS(rc))
    278282    {
    279         LOCALIPCTHREADCTX threadCtx = { ipcServer, hTest };
     283        LOCALIPCTHREADCTX threadCtx = { hIpcServer, hTest };
    280284
    281285        /* Spawn a simple worker thread and let it listen for incoming connections.
    … …  
    290294                RTPROCESS hProc;
    291295                const char *apszArgs[4] = { pszExecPath, "child", "tstRTLocalIpcSessionWaitFork", NULL };
    292                 RTTEST_CHECK_RC_BREAK(hTest, RTProcCreate(pszExecPath, apszArgs,
    293                                                           RTENV_DEFAULT, 0 /* fFlags*/, &hProc), VINF_SUCCESS);
     296                RTTEST_CHECK_RC_BREAK(hTest, RTProcCreate(pszExecPath, apszArgs, RTENV_DEFAULT, 0 /* fFlags*/, &hProc),
     297                                      VINF_SUCCESS);
    294298                RTThreadSleep(5000); /* Let the server run for some time ... */
    295299                RTTestPrintf(hTest, RTTESTLVL_INFO, "Cancelling server listening\n");
    296                 RTTEST_CHECK_RC_BREAK(hTest, RTLocalIpcServerCancel(ipcServer), VINF_SUCCESS);
     300                RTTEST_CHECK_RC_BREAK(hTest, RTLocalIpcServerCancel(hIpcServer), VINF_SUCCESS);
    297301                /* Wait for the server thread to terminate. */
    298                 int threadRc;
    299                 RTTEST_CHECK_RC(hTest, RTThreadWait(hThread,
    300                                                     30 * 1000 /* 30s timeout */, &threadRc), VINF_SUCCESS);
    301                 RTTEST_CHECK_RC_BREAK(hTest, threadRc, VERR_CANCELLED);
    302                 RTTEST_CHECK_RC(hTest, RTLocalIpcServerDestroy(ipcServer), VINF_SUCCESS);
     302                int rcThread;
     303                RTTEST_CHECK_RC(hTest, RTThreadWait(hThread, 30 * 1000 /* 30s timeout */, &rcThread), VINF_SUCCESS);
     304                RTTEST_CHECK_RC_BREAK(hTest, rcThread, VERR_CANCELLED);
     305                RTTEST_CHECK_RC(hTest, RTLocalIpcServerDestroy(hIpcServer), VINF_SUCCESS);
    303306                RTTestPrintf(hTest, RTTESTLVL_INFO, "Server thread terminated successfully\n");
    304307                /* Check if the child ran successfully. */
    … …  
    485488    RTTestSub(hTest, "testSessionData");
    486489
    487     RTLOCALIPCSERVER ipcServer;
    488     int rc = RTLocalIpcServerCreate(&ipcServer, "tstRTLocalIpcSessionData",
     490    RTLOCALIPCSERVER hIpcServer;
     491    int rc = RTLocalIpcServerCreate(&hIpcServer, "tstRTLocalIpcSessionData",
    489492                                    RTLOCALIPC_FLAGS_MULTI_SESSION);
    490493    if (RT_SUCCESS(rc))
    491494    {
    492         LOCALIPCTHREADCTX threadCtx = { ipcServer, hTest };
     495        LOCALIPCTHREADCTX threadCtx = { hIpcServer, hTest };
    493496#if 0
    494497        /* Run server + client in threads instead of fork'ed processes (useful for debugging). */
    … …  
    503506            do
    504507            {
    505                 int threadRc;
     508                int rcThread;
    506509                RTTEST_CHECK_RC(hTest, RTThreadWait(hThreadServer,
    507                                                     5 * 60 * 1000 /* 5 minutes timeout */, &threadRc), VINF_SUCCESS);
    508                 RTTEST_CHECK_RC_BREAK(hTest, threadRc, VINF_SUCCESS);
     510                                                    5 * 60 * 1000 /* 5 minutes timeout */, &rcThread), VINF_SUCCESS);
     511                RTTEST_CHECK_RC_BREAK(hTest, rcThread, VINF_SUCCESS);
    509512                RTTEST_CHECK_RC(hTest, RTThreadWait(hThreadClient,
    510                                                     5 * 60 * 1000 /* 5 minutes timeout */, &threadRc), VINF_SUCCESS);
    511                 RTTEST_CHECK_RC_BREAK(hTest, threadRc, VINF_SUCCESS);
     513                                                    5 * 60 * 1000 /* 5 minutes timeout */, &rcThread), VINF_SUCCESS);
     514                RTTEST_CHECK_RC_BREAK(hTest, rcThread, VINF_SUCCESS);
    512515
    513516            } while (0);
    … …  
    528531                                                          RTENV_DEFAULT, 0 /* fFlags*/, &hProc), VINF_SUCCESS);
    529532                /* Wait for the server thread to terminate. */
    530                 int threadRc;
     533                int rcThread;
    531534                RTTEST_CHECK_RC(hTest, RTThreadWait(hThread,
    532                                                     5 * 60 * 1000 /* 5 minutes timeout */, &threadRc), VINF_SUCCESS);
    533                 RTTEST_CHECK_RC_BREAK(hTest, threadRc, VINF_SUCCESS);
    534                 RTTEST_CHECK_RC(hTest, RTLocalIpcServerDestroy(ipcServer), VINF_SUCCESS);
     535                                                    5 * 60 * 1000 /* 5 minutes timeout */, &rcThread), VINF_SUCCESS);
     536                RTTEST_CHECK_RC_BREAK(hTest, rcThread, VINF_SUCCESS);
     537                RTTEST_CHECK_RC(hTest, RTLocalIpcServerDestroy(hIpcServer), VINF_SUCCESS);
    535538                RTTestPrintf(hTest, RTTESTLVL_INFO, "Server thread terminated successfully\n");
    536539                /* Check if the child ran successfully. */
    … …  
    569572#endif
    570573
    571     if (!RTStrICmp(argv[2], "tstRTLocalIpcSessionConnectionFork"))
     574    if (!RTStrICmp(argv[2], "testSessionConnectionChild"))
    572575        rcExit = testSessionConnectionChild(argc, argv, hTest);
    573576    else if (!RTStrICmp(argv[2], "tstRTLocalIpcSessionWaitFork"))
    … …  
    579582}
    580583
    581 static int testBasics(void)
     584static void testBasics(void)
    582585{
    583586    RTTestISub("Basics");
    584587
    585588    /* Server-side. */
    586     RTTESTI_CHECK_RC_RET(RTLocalIpcServerCreate(NULL, NULL, 0), VERR_INVALID_POINTER, 1);
    587     RTLOCALIPCSERVER ipcServer;
    588     RTTESTI_CHECK_RC_RET(RTLocalIpcServerCreate(&ipcServer, NULL, 0), VERR_INVALID_POINTER, 1);
    589     RTTESTI_CHECK_RC_RET(RTLocalIpcServerCreate(&ipcServer, "", 0), VERR_INVALID_PARAMETER, 1);
    590     RTTESTI_CHECK_RC_RET(RTLocalIpcServerCreate(&ipcServer, "BasicTest", 0 /* Invalid flags */), VERR_INVALID_PARAMETER, 1);
    591     RTTESTI_CHECK_RC_RET(RTLocalIpcServerCreate(&ipcServer, "BasicTest", 1234 /* Invalid flags */), VERR_INVALID_PARAMETER, 1);
    592     RTTESTI_CHECK_RC_RET(RTLocalIpcServerCancel(NULL), VERR_INVALID_HANDLE, 1);
    593     RTTESTI_CHECK_RC_RET(RTLocalIpcServerDestroy(NULL), VINF_SUCCESS, 1);
     589    RTTESTI_CHECK_RC(RTLocalIpcServerCreate(NULL, NULL, 0), VERR_INVALID_POINTER);
     590    RTLOCALIPCSERVER hIpcServer;
     591    int rc;
     592    RTTESTI_CHECK_RC(rc = RTLocalIpcServerCreate(&hIpcServer, NULL, RTLOCALIPC_FLAGS_MULTI_SESSION), VERR_INVALID_POINTER);
     593    if (RT_SUCCESS(rc)) RTLocalIpcServerDestroy(hIpcServer);
     594    RTTESTI_CHECK_RC(rc = RTLocalIpcServerCreate(&hIpcServer, "", RTLOCALIPC_FLAGS_MULTI_SESSION), VERR_INVALID_NAME);
     595    if (RT_SUCCESS(rc)) RTLocalIpcServerDestroy(hIpcServer);
     596    RTTESTI_CHECK_RC(rc = RTLocalIpcServerCreate(&hIpcServer, "BasicTest", 1234 /* Invalid flags */), VERR_INVALID_FLAGS);
     597    if (RT_SUCCESS(rc)) RTLocalIpcServerDestroy(hIpcServer);
     598
     599    RTTESTI_CHECK_RC(RTLocalIpcServerCancel(NULL), VERR_INVALID_HANDLE);
     600    RTTESTI_CHECK_RC(RTLocalIpcServerDestroy(NULL), VINF_SUCCESS);
     601
    594602    /* Basic server creation / destruction. */
    595     RTTESTI_CHECK_RC_RET(RTLocalIpcServerCreate(&ipcServer, "BasicTest", RTLOCALIPC_FLAGS_MULTI_SESSION), VINF_SUCCESS, 1);
    596     RTTESTI_CHECK_RC_RET(RTLocalIpcServerCancel(ipcServer), VINF_SUCCESS, 1);
    597     RTTESTI_CHECK_RC_RET(RTLocalIpcServerDestroy(ipcServer), VINF_SUCCESS, 1);
     603    RTTESTI_CHECK_RC_RETV(RTLocalIpcServerCreate(&hIpcServer, "BasicTest", RTLOCALIPC_FLAGS_MULTI_SESSION), VINF_SUCCESS);
     604    RTTESTI_CHECK_RC(RTLocalIpcServerCancel(hIpcServer), VINF_SUCCESS);
     605    RTTESTI_CHECK_RC(RTLocalIpcServerDestroy(hIpcServer), VINF_SUCCESS);
    598606
    599607    /* Client-side (per session). */
    600     RTTESTI_CHECK_RC_RET(RTLocalIpcSessionConnect(NULL, NULL, 0), VERR_INVALID_POINTER, 1);
    601     RTLOCALIPCSESSION ipcSession;
    602     RTTESTI_CHECK_RC_RET(RTLocalIpcSessionConnect(&ipcSession, NULL, 0), VERR_INVALID_POINTER, 1);
    603     RTTESTI_CHECK_RC_RET(RTLocalIpcSessionConnect(&ipcSession, "", 0), VERR_INVALID_PARAMETER, 1);
    604     RTTESTI_CHECK_RC_RET(RTLocalIpcSessionConnect(&ipcSession, "BasicTest", 1234 /* Invalid flags */), VERR_INVALID_PARAMETER, 1);
    605     RTTESTI_CHECK_RC_RET(RTLocalIpcSessionCancel(NULL), VERR_INVALID_HANDLE, 1);
    606     RTTESTI_CHECK_RC_RET(RTLocalIpcSessionClose(NULL), VINF_SUCCESS, 1);
     608    RTTESTI_CHECK_RC(RTLocalIpcSessionConnect(NULL, NULL, 0), VERR_INVALID_POINTER);
     609    RTLOCALIPCSESSION hIpcSession;
     610    RTTESTI_CHECK_RC(RTLocalIpcSessionConnect(&hIpcSession, NULL, 0), VERR_INVALID_POINTER);
     611    if (RT_SUCCESS(rc)) RTLocalIpcSessionClose(hIpcSession);
     612    RTTESTI_CHECK_RC(RTLocalIpcSessionConnect(&hIpcSession, "", 0), VERR_INVALID_NAME);
     613    if (RT_SUCCESS(rc)) RTLocalIpcSessionClose(hIpcSession);
     614    RTTESTI_CHECK_RC(RTLocalIpcSessionConnect(&hIpcSession, "BasicTest", 1234 /* Invalid flags */), VERR_INVALID_FLAGS);
     615    if (RT_SUCCESS(rc)) RTLocalIpcSessionClose(hIpcSession);
     616
     617    RTTESTI_CHECK_RC(RTLocalIpcSessionCancel(NULL), VERR_INVALID_HANDLE);
     618    RTTESTI_CHECK_RC(RTLocalIpcSessionClose(NULL), VINF_SUCCESS);
     619
    607620    /* Basic client creation / destruction. */
    608     RTTESTI_CHECK_RC_RET(RTLocalIpcSessionConnect(&ipcSession, "BasicTest", 0), VERR_FILE_NOT_FOUND, 1);
    609     RTTESTI_CHECK_RC_RET(RTLocalIpcServerCancel(ipcServer), VERR_INVALID_MAGIC, 1);
    610     RTTESTI_CHECK_RC_RET(RTLocalIpcServerDestroy(ipcServer), VERR_INVALID_MAGIC, 1);
    611 
    612     return 0;
     621    RTTESTI_CHECK_RC_RETV(rc = RTLocalIpcSessionConnect(&hIpcSession, "BasicTest", 0), VERR_FILE_NOT_FOUND);
     622    if (RT_SUCCESS(rc)) RTLocalIpcSessionClose(hIpcSession);
     623    RTTESTI_CHECK_RC(RTLocalIpcServerCancel(hIpcServer), VERR_INVALID_HANDLE);
     624    RTTESTI_CHECK_RC(RTLocalIpcServerDestroy(hIpcServer), VERR_INVALID_HANDLE);
    613625}
    614626
    … …  
    630642
    631643    bool fMayPanic = RTAssertSetMayPanic(false);
    632     bool fQuiet    = RTAssertSetQuiet(false);
     644    bool fQuiet    = RTAssertSetQuiet(true);
    633645    testBasics();
    634646    RTAssertSetMayPanic(fMayPanic);
Note: See TracChangeset for help on using the changeset viewer.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette