Changeset 103378 in vbox

Timestamp:

Feb 15, 2024 8:45:24 AM (12 months ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

161696

Message:

libs/xpcom: Rewrite the IPCD daemon and cut down on the number of memory allocations made for messages, bugref:10598

Location:

trunk/src/libs/xpcom18a4

Files:

• Makefile.kmk (modified) (1 diff)
• ipc/ipcd/daemon/src/ipcClient.cpp (modified) (7 diffs)
• ipc/ipcd/daemon/src/ipcClient.h (modified) (1 diff)
• ipc/ipcd/daemon/src/ipcCommandModule.cpp (modified) (2 diffs)
• ipc/ipcd/daemon/src/ipcCommandModule.h (modified) (1 diff)
• ipc/ipcd/daemon/src/ipcd.cpp (moved) (moved from trunk/src/libs/xpcom18a4/ipc/ipcd/daemon/src/ipcdUnix.cpp ) (13 diffs)
• ipc/ipcd/daemon/src/ipcd.h (modified) (2 diffs)
• ipc/ipcd/daemon/src/ipcdPrivate.h (deleted)
• ipc/ipcd/shared/src/ipcMessage.cpp (modified) (7 diffs)
• ipc/ipcd/shared/src/ipcMessage.h (modified) (3 diffs)
• ipc/ipcd/shared/src/ipcMessageNew.h (copied) (copied from trunk/src/libs/xpcom18a4/ipc/ipcd/shared/src/ipcMessage.h ) (4 diffs)
• ipc/ipcd/shared/src/ipcm.h (modified) (2 diffs)
• ipc/ipcd/test/module (deleted)

trunk/src/libs/xpcom18a4/Makefile.kmk

@@ -846 +846 @@
         ipc/ipcd/daemon/src/ipcd.cpp \
         ipc/ipcd/daemon/src/ipcClient.cpp \
-        ipc/ipcd/daemon/src/ipcCommandModule.cpp \
-        ipc/ipcd/daemon/src/ipcdUnix.cpp
+        ipc/ipcd/daemon/src/ipcCommandModule.cpp
 VBoxXPCOMIPCD_LDFLAGS.darwin = -install_name $(VBOX_DYLD_EXECUTABLE_PATH)/VBoxXPCOMIPCD.dylib
 VBoxXPCOMIPCD_LIBS = \

trunk/src/libs/xpcom18a4/ipc/ipcd/daemon/src/ipcClient.cpp

@@ -36 +36 @@
  * ***** END LICENSE BLOCK ***** */
 #define LOG_GROUP LOG_GROUP_IPC
+#include <iprt/asm.h>
 #include <iprt/assert.h>
 #include <iprt/errcore.h>
@@ -42 +43 @@
 
 #include "ipcClient.h"
-#include "ipcMessage.h"
 #include "ipcd.h"
 #include "ipcm.h"
 
-PRUint32 ipcClient::gLastID = 0;
+static volatile uint32_t g_idClientLast = 0;
+
 
 //
@@ -54 +55 @@
 //  - object's memory has already been zero'd out.
 //
-void
-ipcClient::Init(uint32_t idPoll, RTSOCKET hSock)
-{
-    mID = ++gLastID;
+DECLHIDDEN(int) ipcdClientInit(PIPCDCLIENT pThis, PIPCDSTATE pIpcd, uint32_t idPoll, RTSOCKET hSock)
+{
+    pThis->idClient = ASMAtomicIncU32(&g_idClientLast);
 
     // every client must be able to handle IPCM messages.
-    mTargets.Append(IPCM_TARGET);
-
-    m_hSock  = hSock;
-    m_idPoll = idPoll;
-    m_fUsed  = true;
+    pThis->mTargets.Append(IPCM_TARGET);
+
+    pThis->pIpcd     = pIpcd;
+    pThis->hSock     = hSock;
+    pThis->idPoll    = idPoll;
+    pThis->fPollEvts = RTPOLL_EVT_READ;
+    pThis->fUsed     = true;
+
+    RTListInit(&pThis->LstMsgsOut);
 
     // although it is tempting to fire off the NotifyClientUp event at this
     // time, we must wait until the client sends us a CLIENT_HELLO event.
     // see ipcCommandModule::OnClientHello.
+
+    return IPCMsgInit(&pThis->MsgIn, 0 /*cbBuf*/);
 }
 
@@ -74 +80 @@
 // called when this client context is going away
 //
-void
-ipcClient::Finalize()
-{
-    RTSocketClose(m_hSock);
-    m_hSock = NIL_RTSOCKET;
-
-    IPC_NotifyClientDown(this);
-
-    mNames.DeleteAll();
-    mTargets.DeleteAll();
-
-    mInMsg.Reset();
-    mOutMsgQ.DeleteAll();
-    m_fUsed = false;
-}
-
-void
-ipcClient::AddName(const char *name)
-{
-    LogFlowFunc(("adding client name: %s\n", name));
-
-    if (HasName(name))
+DECLHIDDEN(void) ipcdClientDestroy(PIPCDCLIENT pThis)
+{
+    RTSocketClose(pThis->hSock);
+    pThis->hSock = NIL_RTSOCKET;
+
+    IPC_NotifyClientDown(pThis);
+
+    pThis->mNames.DeleteAll();
+    pThis->mTargets.DeleteAll();
+
+    IPCMsgFree(&pThis->MsgIn, false /*fFreeStruct*/);
+    pThis->fUsed = false;
+
+    /** @todo Free all outgoing messages. */
+}
+
+
+DECLHIDDEN(void) ipcdClientAddName(PIPCDCLIENT pThis, const char *pszName)
+{
+    LogFlowFunc(("adding client name: %s\n", pszName));
+
+    if (ipcdClientHasName(pThis, pszName))
         return;
 
-    mNames.Append(name);
-}
-
-PRBool
-ipcClient::DelName(const char *name)
-{
-    LogFlowFunc(("deleting client name: %s\n", name));
-
-    return mNames.FindAndDelete(name);
-}
-
-void
-ipcClient::AddTarget(const nsID &target)
+    pThis->mNames.Append(pszName);
+}
+
+
+DECLHIDDEN(bool) ipcdClientDelName(PIPCDCLIENT pThis, const char *pszName)
+{
+    LogFlowFunc(("deleting client name: %s\n", pszName));
+
+    return pThis->mNames.FindAndDelete(pszName);
+}
+
+
+DECLHIDDEN(void) ipcdClientAddTarget(PIPCDCLIENT pThis, const nsID *target)
 {
     LogFlowFunc(("adding client target\n"));
 
-    if (HasTarget(target))
+    if (ipcdClientHasTarget(pThis, target))
         return;
 
-    mTargets.Append(target);
-}
-
-PRBool
-ipcClient::DelTarget(const nsID &target)
+    pThis->mTargets.Append(*target);
+}
+
+
+DECLHIDDEN(bool) ipcdClientDelTarget(PIPCDCLIENT pThis, const nsID *target)
 {
     LogFlowFunc(("deleting client target\n"));
@@ -128 +134 @@
     // cannot remove the IPCM target
     //
-    if (!target.Equals(IPCM_TARGET))
-        return mTargets.FindAndDelete(target);
-
-    return PR_FALSE;
-}
-
-//
-// called to process a client socket
-//
-// params:
-//   poll_flags - the state of the client socket
-//
-// return:
-//   0             - to end session with this client
-//   PR_POLL_READ  - to wait for the client socket to become readable
-//   PR_POLL_WRITE - to wait for the client socket to become writable
-//
-uint32_t
-ipcClient::Process(uint32_t inFlags)
-{
-    if (inFlags & RTPOLL_EVT_ERROR)
+    if (!target->Equals(IPCM_TARGET))
+        return pThis->mTargets.FindAndDelete(*target);
+
+    return false;
+}
+
+//
+// called to write out any messages from the outgoing queue.
+//
+static int ipcdClientWriteMsgs(PIPCDCLIENT pThis)
+{
+    while (!RTListIsEmpty(&pThis->LstMsgsOut))
+    {
+        PIPCMSG pMsg         = RTListGetFirst(&pThis->LstMsgsOut, IPCMSG, NdMsg);
+        const uint8_t *pbBuf = (const uint8_t *)IPCMsgGetBuf(pMsg);
+        size_t cbBuf         = IPCMsgGetSize(pMsg);
+
+        if (pThis->offMsgOutBuf)
+        {
+            Assert(cbBuf > pThis->offMsgOutBuf);
+            pbBuf += pThis->offMsgOutBuf;
+            cbBuf -= pThis->offMsgOutBuf;
+        }
+
+        size_t cbWritten = 0;
+        int vrc = RTSocketWriteNB(pThis->hSock, pbBuf, cbBuf, &cbWritten);
+        if (vrc == VINF_SUCCESS)
+        { /* likely */ Assert(cbWritten > 0); }
+        else
+        {
+            Assert(   RT_FAILURE(vrc)
+                   || (vrc == VINF_TRY_AGAIN && cbWritten == 0));
+            break;
+        }
+
+        LogFlowFunc(("wrote %d bytes\n", cbWritten));
+
+        if (cbWritten == cbBuf)
+        {
+            RTListNodeRemove(&pMsg->NdMsg);
+            IPC_PutMsgIntoCache(pThis->pIpcd, pMsg);
+            pThis->offMsgOutBuf = 0;
+        }
+        else
+            pThis->offMsgOutBuf += cbWritten;
+    }
+
+    return 0;
+}
+
+DECLHIDDEN(uint32_t) ipcdClientProcess(PIPCDCLIENT pThis, uint32_t fPollFlags)
+{
+    if (fPollFlags & RTPOLL_EVT_ERROR)
     {
         LogFlowFunc(("client socket appears to have closed\n"));
@@ -154 +192 @@
     }
 
-    // expect to wait for more data
-    uint32_t outFlags = RTPOLL_EVT_READ;
-
-    if (inFlags & RTPOLL_EVT_READ) {
+    uint32_t fOutFlags = RTPOLL_EVT_READ;
+
+    if (fPollFlags & RTPOLL_EVT_READ) {
         LogFlowFunc(("client socket is now readable\n"));
 
-        char buf[_1K];
+        uint8_t abBuf[_1K];
         size_t cbRead = 0;
-        int vrc = RTSocketReadNB(m_hSock, &buf[0], sizeof(buf), &cbRead);
+        int vrc = RTSocketReadNB(pThis->hSock, &abBuf[0], sizeof(abBuf), &cbRead);
         Assert(vrc != VINF_TRY_AGAIN);
 
@@ -168 +205 @@
             return 0; // cancel connection
 
-        const char *ptr = buf;
+        const uint8_t *pb = abBuf;
         while (cbRead)
         {
-            PRUint32 nread;
-            PRBool complete;
-
-            if (mInMsg.ReadFrom(ptr, PRUint32(cbRead), &nread, &complete) == PR_FAILURE) {
+            size_t cbProcessed;
+            bool fDone;
+
+            int vrc = IPCMsgReadFrom(&pThis->MsgIn, pb, cbRead, &cbProcessed, &fDone);
+            if (RT_FAILURE(vrc))
+            {
                 LogFlowFunc(("message appears to be malformed; dropping client connection\n"));
                 return 0;
             }
 
-            if (complete)
+            if (fDone)
             {
-                IPC_DispatchMsg(this, &mInMsg);
-                mInMsg.Reset();
+                IPC_DispatchMsg(pThis, &pThis->MsgIn);
+                IPCMsgReset(&pThis->MsgIn);
             }
 
-            cbRead -= nread;
-            ptr    += nread;
-        }
-    }
-
-    if (inFlags & RTPOLL_EVT_WRITE) {
+            cbRead -= cbProcessed;
+            pb     += cbProcessed;
+        }
+    }
+
+    if (fPollFlags & RTPOLL_EVT_WRITE)
+    {
         LogFlowFunc(("client socket is now writable\n"));
 
-        if (mOutMsgQ.First())
-            WriteMsgs();
-    }
-
-    if (mOutMsgQ.First())
-        outFlags |= RTPOLL_EVT_WRITE;
-
-    return outFlags;
-}
-
-//
-// called to write out any messages from the outgoing queue.
-//
-int
-ipcClient::WriteMsgs()
-{
-    while (mOutMsgQ.First())
-    {
-        const char *buf = (const char *) mOutMsgQ.First()->MsgBuf();
-        PRInt32 bufLen = (PRInt32) mOutMsgQ.First()->MsgLen();
-
-        if (mSendOffset)
-        {
-            buf += mSendOffset;
-            bufLen -= mSendOffset;
-        }
-
-        size_t cbWritten = 0;
-        int vrc = RTSocketWriteNB(m_hSock, buf, bufLen, &cbWritten);
-        if (vrc == VINF_SUCCESS)
-        { /* likely */ Assert(cbWritten > 0); }
-        else
-        {
-            Assert(   RT_FAILURE(vrc)
-                   || (vrc == VINF_TRY_AGAIN && cbWritten == 0));
-            break;
-        }
-
-        LogFlowFunc(("wrote %d bytes\n", cbWritten));
-
-        if (cbWritten == bufLen)
-        {
-            mOutMsgQ.DeleteFirst();
-            mSendOffset = 0;
-        }
-        else
-            mSendOffset += cbWritten;
-    }
-
-    return 0;
-}
-
+        if (!RTListIsEmpty(&pThis->LstMsgsOut))
+            ipcdClientWriteMsgs(pThis);
+    }
+
+    if (!RTListIsEmpty(&pThis->LstMsgsOut))
+        fOutFlags |= RTPOLL_EVT_WRITE;
+
+    return fOutFlags;
+}

trunk/src/libs/xpcom18a4/ipc/ipcd/daemon/src/ipcClient.h

@@ -42 +42 @@
 #include <iprt/socket.h>
 
-#include "ipcMessageQ.h"
+#include "ipcMessageNew.h"
+
 #include "ipcStringList.h"
 #include "ipcIDList.h"
 
-//-----------------------------------------------------------------------------
-// ipcClient
+
+/** Pointer to the IPCD manager state. */
+typedef struct IPCDSTATE *PIPCDSTATE;
+
+/**
+ * IPC daemon client state.
+ *
+ * @note Treat these as opaque and use the accessor functions below.
+ */
+typedef struct IPCDCLIENT
+{
+    /** Node for the list of clients. */
+    RTLISTNODE      NdClients;
+    /** The owning IPCD state. */
+    PIPCDSTATE      pIpcd;
+    /** Flag whether the client state is currently in use. */
+    bool            fUsed;
+    /** The poll ID for this client. */
+    uint32_t        idPoll;
+    /** Poll event flags */
+    uint32_t        fPollEvts;
+
+    /** Client ID .*/
+    uint32_t        idClient;
+    /** Client socket. */
+    RTSOCKET        hSock;
+    /** The current incoming message. */
+    IPCMSG          MsgIn;
+    /** List of outgoing messages. */
+    RTLISTANCHOR    LstMsgsOut;
+    /** How much of the current message in the output buffer was already sent. */
+    uint32_t        offMsgOutBuf;
+
+    bool            fExpectsSyncReply;
+    ipcStringList   mNames;
+    ipcIDList       mTargets;
+} IPCDCLIENT;
+/** Pointer to an IPCD client state. */
+typedef IPCDCLIENT *PIPCDCLIENT;
+/** Pointer to a const IPCD client state. */
+typedef const IPCDCLIENT *PCIPCDCLIENT;
+
+
+DECLINLINE(PIPCDSTATE) ipcdClientGetDaemonState(PCIPCDCLIENT pThis)
+{
+    return pThis->pIpcd;
+}
+
+
+DECLINLINE(uint32_t) ipcdClientGetId(PCIPCDCLIENT pThis)
+{
+    return pThis->idClient;
+}
+
+
+DECLINLINE(void) ipcdClientEnqueueOutboundMsg(PIPCDCLIENT pThis, PIPCMSG pMsg)
+{
+    RTListAppend(&pThis->LstMsgsOut, &pMsg->NdMsg);
+}
+
+DECLINLINE(bool) ipcdClientHasName(PCIPCDCLIENT pThis, const char *pszName)
+{
+    return pThis->mNames.Find(pszName) != NULL;
+}
+
+DECLHIDDEN(void) ipcdClientAddName(PIPCDCLIENT pThis, const char *pszName);
+
+DECLHIDDEN(bool) ipcdClientDelName(PIPCDCLIENT pThis, const char *pszName);
+
+DECLINLINE(bool) ipcdClientHasTarget(PCIPCDCLIENT pThis, const nsID *target)
+{
+    return pThis->mTargets.Find(*target) != NULL;
+}
+
+DECLHIDDEN(void) ipcdClientAddTarget(PIPCDCLIENT pThis, const nsID *target);
+
+DECLHIDDEN(bool) ipcdClientDelTarget(PIPCDCLIENT pThis, const nsID *target);
+
+DECLHIDDEN(int) ipcdClientInit(PIPCDCLIENT pThis, PIPCDSTATE pIpcd, uint32_t idPoll, RTSOCKET hSock);
+
+DECLHIDDEN(void) ipcdClientDestroy(PIPCDCLIENT pThis);
+
 //
-// NOTE: this class is an implementation detail of the IPC daemon. IPC daemon
-// modules (other than the built-in IPCM module) must not access methods on
-// this class directly. use the API provided via ipcd.h instead.
-//-----------------------------------------------------------------------------
+// called to process a client file descriptor.  the value of pollFlags
+// indicates the state of the socket.
+//
+// returns:
+//   0                - to cancel client connection
+//   RTPOLL_EVT_READ  - to poll for a readable socket
+//   RTPOLL_EVT_WRITE - to poll for a writable socket
+//   (both flags)     - to poll for either a readable or writable socket
+//
+// the socket is non-blocking.
+//
+DECLHIDDEN(uint32_t) ipcdClientProcess(PIPCDCLIENT pThis, uint32_t fPollFlags);
 
-class ipcClient
+DECLINLINE(void) ipcdClientSetExpectsSyncReply(PIPCDCLIENT pThis, bool f)
 {
-public:
-    /** Node for the list of clients. */
-    RTLISTNODE NdClients;
-    bool     m_fUsed;
-    uint32_t m_idPoll;
-    uint32_t m_fPollEvts;
+    pThis->fExpectsSyncReply = f;
+}
 
-    void Init(uint32_t idPoll, RTSOCKET hSock);
-    void Finalize();
-
-    PRUint32 ID() const { return mID; }
-
-    void   AddName(const char *name);
-    PRBool DelName(const char *name);
-    PRBool HasName(const char *name) const { return mNames.Find(name) != NULL; }
-
-    void   AddTarget(const nsID &target);
-    PRBool DelTarget(const nsID &target);
-    PRBool HasTarget(const nsID &target) const { return mTargets.Find(target) != NULL; }
-
-    // list iterators
-    const ipcStringNode *Names()   const { return mNames.First(); }
-    const ipcIDNode     *Targets() const { return mTargets.First(); }
-
-    // returns primary client name (the one specified in the "client hello" message)
-    const char *PrimaryName() const { return mNames.First() ? mNames.First()->Value() : NULL; }
-
-    void   SetExpectsSyncReply(PRBool val) { mExpectsSyncReply = val; }
-    PRBool GetExpectsSyncReply() const     { return mExpectsSyncReply; }
-
-    //
-    // called to process a client file descriptor.  the value of pollFlags
-    // indicates the state of the socket.
-    //
-    // returns:
-    //   0                - to cancel client connection
-    //   RTPOLL_EVT_READ  - to poll for a readable socket
-    //   RTPOLL_EVT_WRITE - to poll for a writable socket
-    //   (both flags)     - to poll for either a readable or writable socket
-    //
-    // the socket is non-blocking.
-    //
-    uint32_t Process(uint32_t pollFlags);
-
-    //
-    // on success or failure, this function takes ownership of |msg| and will
-    // delete it when appropriate.
-    //
-    void EnqueueOutboundMsg(ipcMessage *msg) { mOutMsgQ.Append(msg); }
-
-private:
-    static PRUint32 gLastID;
-
-    PRUint32      mID;
-    ipcStringList mNames;
-    ipcIDList     mTargets;
-    PRBool        mExpectsSyncReply;
-
-    ipcMessage    mInMsg;    // buffer for incoming message
-    ipcMessageQ   mOutMsgQ;  // outgoing message queue
-
-    // keep track of the amount of the first message sent
-    PRUint32      mSendOffset;
-
-    /** Client socket. */
-    RTSOCKET      m_hSock;
-
-    // utility function for writing out messages.
-    int WriteMsgs();
-};
+DECLINLINE(bool) ipcdClientGetExpectsSyncReply(PCIPCDCLIENT pThis)
+{
+    return pThis->fExpectsSyncReply;
+}
 
 #endif // !ipcClientUnix_h__

trunk/src/libs/xpcom18a4/ipc/ipcd/daemon/src/ipcCommandModule.cpp

@@ -40 +40 @@
 #include "ipcCommandModule.h"
 #include "ipcClient.h"
-#include "ipcMessage.h"
-#include "ipcMessageUtils.h"
+#include "ipcMessageNew.h"
 #include "ipcd.h"
 #include "ipcm.h"
@@ -47 +46 @@
 #include <VBox/log.h>
 
-struct ipcCommandModule
-{
-    typedef void (* MsgHandler)(ipcClient *, const ipcMessage *);
+typedef void FNIPCMMSGHANDLER(PIPCDCLIENT pIpcClient, PCIPCMSG pMsg);
+/** Pointer to a IPCM message handler. */
+typedef FNIPCMMSGHANDLER *PFNIPCMMSGHANDLER;
+
+
+DECLINLINE(uint32_t) IPCM_GetType(PCIPCMSG pMsg)
+{
+    return ((const ipcmMessageHeader *)IPCMsgGetPayload(pMsg))->mType;
+}
+
+
+DECLINLINE(uint32_t) IPCM_GetRequestIndex(PCIPCMSG pMsg)
+{
+    return ((const ipcmMessageHeader *)IPCMsgGetPayload(pMsg))->mRequestIndex;
+}
+
+//
+// message handlers
+//
+
+static DECLCALLBACK(void) ipcmOnPing(PIPCDCLIENT pIpcClient, PCIPCMSG pMsg) RT_NOTHROW_DEF
+{
+    Log(("got PING\n"));
+
+    const uint32_t aResp[3] = { IPCM_MSG_ACK_RESULT, IPCM_GetRequestIndex(pMsg), IPCM_OK };
+    IPC_SendMsg(pIpcClient, IPCM_TARGET, &aResp[0], sizeof(aResp));
+}
+
+static DECLCALLBACK(void) ipcmOnClientHello(PIPCDCLIENT pIpcClient, PCIPCMSG pMsg) RT_NOTHROW_DEF
+{
+    Log(("got CLIENT_HELLO\n"));
+
+    const uint32_t aResp[3] = { IPCM_MSG_ACK_CLIENT_ID, IPCM_GetRequestIndex(pMsg), ipcdClientGetId(pIpcClient) };
+    IPC_SendMsg(pIpcClient, IPCM_TARGET, &aResp[0], sizeof(aResp));
 
     //
-    // helpers
+    // NOTE: it would almost make sense for this notification to live
+    // in the transport layer code.  however, clients expect to receive
+    // a CLIENT_ID as the first message following a CLIENT_HELLO, so we
+    // must not allow modules to see a client until after we have sent
+    // the CLIENT_ID message.
     //
-
-    static char **
-    BuildStringArray(const ipcStringNode *nodes)
-    {
-        size_t count = 0;
-
-        const ipcStringNode *node;
-
-        for (node = nodes; node; node = node->mNext)
-            count++;
-
-        char **strs = (char **) malloc((count + 1) * sizeof(char *));
-        if (!strs)
-            return NULL;
-
-        count = 0;
-        for (node = nodes; node; node = node->mNext, ++count)
-            strs[count] = (char *) node->Value();
-        strs[count] = 0;
-
-        return strs;
-    }
-
-    static nsID **
-    BuildIDArray(const ipcIDNode *nodes)
-    {
-        size_t count = 0;
-
-        const ipcIDNode *node;
-
-        for (node = nodes; node; node = node->mNext)
-            count++;
-
-        nsID **ids = (nsID **) calloc(count + 1, sizeof(nsID *));
-        if (!ids)
-            return NULL;
-
-        count = 0;
-        for (node = nodes; node; node = node->mNext, ++count)
-            ids[count] = (nsID *) &node->Value();
-
-        return ids;
-    }
-
-    //
-    // message handlers
-    //
-
-    static void
-    OnPing(ipcClient *client, const ipcMessage *rawMsg)
-    {
-        Log(("got PING\n"));
-
-        IPC_SendMsg(client, new ipcmMessageResult(IPCM_GetRequestIndex(rawMsg), IPCM_OK));
-    }
-
-    static void
-    OnClientHello(ipcClient *client, const ipcMessage *rawMsg)
-    {
-        Log(("got CLIENT_HELLO\n"));
-
-        IPC_SendMsg(client, new ipcmMessageClientID(IPCM_GetRequestIndex(rawMsg), client->ID()));
-
-        //
-        // NOTE: it would almost make sense for this notification to live
-        // in the transport layer code.  however, clients expect to receive
-        // a CLIENT_ID as the first message following a CLIENT_HELLO, so we
-        // must not allow modules to see a client until after we have sent
-        // the CLIENT_ID message.
-        //
-        IPC_NotifyClientUp(client);
-    }
-
-    static void
-    OnClientAddName(ipcClient *client, const ipcMessage *rawMsg)
-    {
-        Log(("got CLIENT_ADD_NAME\n"));
-
-        PRInt32 status = IPCM_OK;
-        PRUint32 requestIndex = IPCM_GetRequestIndex(rawMsg);
-
-        ipcMessageCast<ipcmMessageClientAddName> msg(rawMsg);
-        const char *name = msg->Name();
-        if (name) {
-            ipcClient *result = IPC_GetClientByName(msg->Name());
-            if (result) {
-                Log(("  client with such name already exists (ID = %d)\n", result->ID()));
-                status = IPCM_ERROR_ALREADY_EXISTS;
-            }
-            else
-                client->AddName(name);
-        }
-        else
-            status = IPCM_ERROR_INVALID_ARG;
-
-        IPC_SendMsg(client, new ipcmMessageResult(requestIndex, status));
-    }
-
-    static void
-    OnClientDelName(ipcClient *client, const ipcMessage *rawMsg)
-    {
-        Log(("got CLIENT_DEL_NAME\n"));
-
-        PRInt32 status = IPCM_OK;
-        PRUint32 requestIndex = IPCM_GetRequestIndex(rawMsg);
-
-        ipcMessageCast<ipcmMessageClientDelName> msg(rawMsg);
-        const char *name = msg->Name();
-        if (name) {
-            if (!client->DelName(name)) {
-                Log(("  client doesn't have name '%s'\n", name));
-                status = IPCM_ERROR_NO_SUCH_DATA;
-            }
-        }
-        else
-            status = IPCM_ERROR_INVALID_ARG;
-
-        IPC_SendMsg(client, new ipcmMessageResult(requestIndex, status));
-    }
-
-    static void
-    OnClientAddTarget(ipcClient *client, const ipcMessage *rawMsg)
-    {
-        Log(("got CLIENT_ADD_TARGET\n"));
-
-        PRInt32 status = IPCM_OK;
-        PRUint32 requestIndex = IPCM_GetRequestIndex(rawMsg);
-
-        ipcMessageCast<ipcmMessageClientAddTarget> msg(rawMsg);
-        if (client->HasTarget(msg->Target())) {
-            Log(("  target already defined for client\n"));
+    IPC_NotifyClientUp(pIpcClient);
+}
+
+static DECLCALLBACK(void) ipcmOnClientAddName(PIPCDCLIENT pIpcClient, PCIPCMSG pMsg) RT_NOTHROW_DEF
+{
+    Log(("got CLIENT_ADD_NAME\n"));
+
+    int32_t status = IPCM_OK;
+    uint32_t requestIndex = IPCM_GetRequestIndex(pMsg);
+
+    const char *pszName = (const char *)((uint8_t *)IPCMsgGetPayload(pMsg) + 2 * sizeof(uint32_t));
+    if (pszName)
+    {
+        PIPCDCLIENT pIpcClientResult = IPC_GetClientByName(ipcdClientGetDaemonState(pIpcClient), pszName);
+        if (pIpcClientResult)
+        {
+            Log(("  client with such name already exists (ID = %d)\n", ipcdClientGetId(pIpcClientResult)));
             status = IPCM_ERROR_ALREADY_EXISTS;
         }
         else
-            client->AddTarget(msg->Target());
-
-        IPC_SendMsg(client, new ipcmMessageResult(requestIndex, status));
-    }
-
-    static void
-    OnClientDelTarget(ipcClient *client, const ipcMessage *rawMsg)
-    {
-        Log(("got CLIENT_DEL_TARGET\n"));
-
-        PRInt32 status = IPCM_OK;
-        PRUint32 requestIndex = IPCM_GetRequestIndex(rawMsg);
-
-        ipcMessageCast<ipcmMessageClientDelTarget> msg(rawMsg);
-        if (!client->DelTarget(msg->Target())) {
-            Log(("  client doesn't have the given target\n"));
+            ipcdClientAddName(pIpcClient, pszName);
+    }
+    else
+        status = IPCM_ERROR_INVALID_ARG;
+
+    const uint32_t aResp[3] = { IPCM_MSG_ACK_RESULT, requestIndex, (uint32_t)status };
+    IPC_SendMsg(pIpcClient, IPCM_TARGET, &aResp[0], sizeof(aResp));
+}
+
+static DECLCALLBACK(void) ipcmOnClientDelName(PIPCDCLIENT pIpcClient, PCIPCMSG pMsg) RT_NOTHROW_DEF
+{
+    Log(("got CLIENT_DEL_NAME\n"));
+
+    PRInt32 status = IPCM_OK;
+    PRUint32 requestIndex = IPCM_GetRequestIndex(pMsg);
+
+    const char *pszName = (const char *)((uint8_t *)IPCMsgGetPayload(pMsg) + 2 * sizeof(uint32_t));
+    if (pszName)
+    {
+        if (!ipcdClientDelName(pIpcClient, pszName))
+        {
+            Log(("  client doesn't have name '%s'\n", pszName));
             status = IPCM_ERROR_NO_SUCH_DATA;
         }
-
-        IPC_SendMsg(client, new ipcmMessageResult(requestIndex, status));
-    }
-
-    static void
-    OnQueryClientByName(ipcClient *client, const ipcMessage *rawMsg)
-    {
-        Log(("got QUERY_CLIENT_BY_NAME\n"));
-
-        PRUint32 requestIndex = IPCM_GetRequestIndex(rawMsg);
-
-        ipcMessageCast<ipcmMessageQueryClientByName> msg(rawMsg);
-
-        ipcClient *result = IPC_GetClientByName(msg->Name());
-        if (result) {
-            Log(("  client exists w/ ID = %u\n", result->ID()));
-            IPC_SendMsg(client, new ipcmMessageClientID(requestIndex, result->ID()));
-        }
-        else {
-            Log(("  client does not exist\n"));
-            IPC_SendMsg(client, new ipcmMessageResult(requestIndex, IPCM_ERROR_NO_CLIENT));
-        }
-    }
-
-#if 0
-    static void
-    OnQueryClientInfo(ipcClient *client, const ipcMessage *rawMsg)
-    {
-        Log(("got QUERY_CLIENT_INFO\n"));
-
-        ipcMessageCast<ipcmMessageQueryClientInfo> msg(rawMsg);
-        ipcClient *result = IPC_GetClientByID(msg->ClientID());
-        if (result) {
-            char **names = BuildStringArray(result->Names());
-            nsID **targets = BuildIDArray(result->Targets());
-
-            IPC_SendMsg(client, new ipcmMessageClientInfo(result->ID(),
-                                                          msg->RequestIndex(),
-                                                          (const char **) names,
-                                                          (const nsID **) targets));
-
-            free(names);
-            free(targets);
-        }
-        else {
-            Log(("  client does not exist\n"));
-            IPC_SendMsg(client, new ipcmMessageError(IPCM_ERROR_NO_CLIENT, msg->RequestIndex()));
-        }
-    }
-#endif
-
-    static void
-    OnForward(ipcClient *client, const ipcMessage *rawMsg)
-    {
-        Log(("got FORWARD\n"));
-
-        ipcMessageCast<ipcmMessageForward> msg(rawMsg);
-
-        ipcClient *dest = IPC_GetClientByID(msg->ClientID());
-        if (!dest) {
-            Log(("  destination client not found!\n"));
-            IPC_SendMsg(client, new ipcmMessageResult(IPCM_GetRequestIndex(rawMsg), IPCM_ERROR_NO_CLIENT));
-            return;
-        }
-        // inform client that its message will be forwarded
-        IPC_SendMsg(client, new ipcmMessageResult(IPCM_GetRequestIndex(rawMsg), IPCM_OK));
-
-        ipcMessage *newMsg = new ipcmMessageForward(IPCM_MSG_PSH_FORWARD,
-                                                    client->ID(),
-                                                    msg->InnerTarget(),
-                                                    msg->InnerData(),
-                                                    msg->InnerDataLen());
-        IPC_SendMsg(dest, newMsg);
-    }
-};
-
-void
-IPCM_HandleMsg(ipcClient *client, const ipcMessage *rawMsg)
-{
-    static ipcCommandModule::MsgHandler handlers[] =
-    {
-        ipcCommandModule::OnPing,
-        ipcCommandModule::OnForward,
-        ipcCommandModule::OnClientHello,
-        ipcCommandModule::OnClientAddName,
-        ipcCommandModule::OnClientDelName,
-        ipcCommandModule::OnClientAddTarget,
-        ipcCommandModule::OnClientDelTarget,
-        ipcCommandModule::OnQueryClientByName
+    }
+    else
+        status = IPCM_ERROR_INVALID_ARG;
+
+    const uint32_t aResp[3] = { IPCM_MSG_ACK_RESULT, IPCM_GetRequestIndex(pMsg), (uint32_t)status  };
+    IPC_SendMsg(pIpcClient, IPCM_TARGET, &aResp[0], sizeof(aResp));
+}
+
+static DECLCALLBACK(void) ipcmOnClientAddTarget(PIPCDCLIENT pIpcClient, PCIPCMSG pMsg) RT_NOTHROW_DEF
+{
+    Log(("got CLIENT_ADD_TARGET\n"));
+
+    PRInt32 status = IPCM_OK;
+    PRUint32 requestIndex = IPCM_GetRequestIndex(pMsg);
+
+    const nsID *pidTarget = (const nsID *)((uint8_t *)IPCMsgGetPayload(pMsg) + 2 * sizeof(uint32_t));
+    if (ipcdClientHasTarget(pIpcClient, pidTarget))
+    {
+        Log(("  target already defined for client\n"));
+        status = IPCM_ERROR_ALREADY_EXISTS;
+    }
+    else
+        ipcdClientAddTarget(pIpcClient, pidTarget);
+
+    const uint32_t aResp[3] = { IPCM_MSG_ACK_RESULT, IPCM_GetRequestIndex(pMsg), (uint32_t)status };
+    IPC_SendMsg(pIpcClient, IPCM_TARGET, &aResp[0], sizeof(aResp));
+}
+
+static DECLCALLBACK(void) ipcmOnClientDelTarget(PIPCDCLIENT pIpcClient, PCIPCMSG pMsg) RT_NOTHROW_DEF
+{
+    Log(("got CLIENT_DEL_TARGET\n"));
+
+    PRInt32 status = IPCM_OK;
+    PRUint32 requestIndex = IPCM_GetRequestIndex(pMsg);
+
+    const nsID *pidTarget = (const nsID *)((uint8_t *)IPCMsgGetPayload(pMsg) + 2 * sizeof(uint32_t));
+    if (!ipcdClientDelTarget(pIpcClient, pidTarget))
+    {
+        Log(("  client doesn't have the given target\n"));
+        status = IPCM_ERROR_NO_SUCH_DATA;
+    }
+
+    const uint32_t aResp[3] = { IPCM_MSG_ACK_RESULT, IPCM_GetRequestIndex(pMsg), (uint32_t)status };
+    IPC_SendMsg(pIpcClient, IPCM_TARGET, &aResp[0], sizeof(aResp));
+}
+
+static DECLCALLBACK(void) ipcmOnQueryClientByName(PIPCDCLIENT pIpcClient, PCIPCMSG pMsg) RT_NOTHROW_DEF
+{
+    Log(("got QUERY_CLIENT_BY_NAME\n"));
+
+    PRUint32 requestIndex = IPCM_GetRequestIndex(pMsg);
+
+    const char *pszName = (const char *)((uint8_t *)IPCMsgGetPayload(pMsg) + 2 * sizeof(uint32_t));
+    PIPCDCLIENT pIpcClientResult = IPC_GetClientByName(ipcdClientGetDaemonState(pIpcClient), pszName);
+    if (pIpcClientResult)
+    {
+        Log(("  client exists w/ ID = %u\n", ipcdClientGetId(pIpcClientResult)));
+        const uint32_t aResp[3] = { IPCM_MSG_ACK_CLIENT_ID, requestIndex, ipcdClientGetId(pIpcClientResult) };
+        IPC_SendMsg(pIpcClient, IPCM_TARGET, &aResp[0], sizeof(aResp));
+    }
+    else
+    {
+        Log(("  client does not exist\n"));
+        const uint32_t aResp[3] = { IPCM_MSG_ACK_RESULT, requestIndex, (uint32_t)IPCM_ERROR_NO_CLIENT };
+        IPC_SendMsg(pIpcClient, IPCM_TARGET, &aResp[0], sizeof(aResp));
+    }
+}
+
+static DECLCALLBACK(void) ipcmOnForward(PIPCDCLIENT pIpcClient, PCIPCMSG pMsg) RT_NOTHROW_DEF
+{
+    Log(("got FORWARD\n"));
+
+    uint32_t idClient = *(uint32_t *)((uint8_t *)IPCMsgGetPayload(pMsg) + 2 * sizeof(uint32_t));
+    PIPCDCLIENT pIpcClientDst = IPC_GetClientByID(ipcdClientGetDaemonState(pIpcClient), idClient);
+    if (!pIpcClientDst)
+    {
+        Log(("  destination client not found!\n"));
+        const uint32_t aResp[3] = { IPCM_MSG_ACK_RESULT, IPCM_GetRequestIndex(pMsg), (uint32_t)IPCM_ERROR_NO_CLIENT };
+        IPC_SendMsg(pIpcClient, IPCM_TARGET, &aResp[0], sizeof(aResp));
+        return;
+    }
+    // inform client that its message will be forwarded
+    const uint32_t aResp[3] = { IPCM_MSG_ACK_RESULT, IPCM_GetRequestIndex(pMsg), IPCM_OK };
+    IPC_SendMsg(pIpcClient, IPCM_TARGET, &aResp[0], sizeof(aResp));
+
+    uint32_t aIpcmFwdHdr[3] = { IPCM_MSG_PSH_FORWARD, IPCM_NewRequestIndex(), ipcdClientGetId(pIpcClient) };
+    RTSGSEG aSegs[2];
+
+    aSegs[0].pvSeg = &aIpcmFwdHdr[0];
+    aSegs[0].cbSeg = sizeof(aIpcmFwdHdr);
+
+    aSegs[1].pvSeg = (uint8_t *)IPCMsgGetPayload(pMsg) + sizeof(aIpcmFwdHdr);
+    aSegs[1].cbSeg = IPCMsgGetPayloadSize(pMsg) - sizeof(aIpcmFwdHdr);
+
+    IPC_SendMsgSg(pIpcClientDst, IPCM_TARGET, IPCMsgGetPayloadSize(pMsg), &aSegs[0], RT_ELEMENTS(aSegs));
+}
+
+
+DECLHIDDEN(void) IPCM_HandleMsg(PIPCDCLIENT pIpcClient, PCIPCMSG pMsg)
+{
+    static const PFNIPCMMSGHANDLER aHandlers[] =
+    {
+        ipcmOnPing,
+        ipcmOnForward,
+        ipcmOnClientHello,
+        ipcmOnClientAddName,
+        ipcmOnClientDelName,
+        ipcmOnClientAddTarget,
+        ipcmOnClientDelTarget,
+        ipcmOnQueryClientByName
     };
 
-    int type = IPCM_GetType(rawMsg);
-    Log(("IPCM_HandleMsg [type=%x]\n", type));
-
-    if (!(type & IPCM_MSG_CLASS_REQ)) {
+    uint32_t u32Type = IPCM_GetType(pMsg);
+    Log(("IPCM_HandleMsg [u32Type=%x]\n", u32Type));
+
+    if (!(u32Type & IPCM_MSG_CLASS_REQ))
+    {
         Log(("not a request -- ignoring message\n"));
         return;
     }
 
-    type &= ~IPCM_MSG_CLASS_REQ;
-    type--;
-    if (type < 0 || type >= (int) (sizeof(handlers)/sizeof(handlers[0]))) {
+    u32Type &= ~IPCM_MSG_CLASS_REQ;
+    u32Type--;
+    if (u32Type >= RT_ELEMENTS(aHandlers))
+    {
         Log(("unknown request -- ignoring message\n"));
         return;
     }
 
-    (handlers[type])(client, rawMsg);
-}
+    aHandlers[u32Type](pIpcClient, pMsg);
+}

trunk/src/libs/xpcom18a4/ipc/ipcd/daemon/src/ipcCommandModule.h

@@ -39 +39 @@
 #define ipcCommandModule_h__
 
-#include "ipcm.h" // for IPCM_TARGET
+#include "ipcMessageNew.h"
+#include "ipcClient.h"
 
-class ipcClient;
-class ipcMessage;
-
-void IPCM_HandleMsg(ipcClient *, const ipcMessage *);
+DECLHIDDEN(void) IPCM_HandleMsg(PIPCDCLIENT pIpcClient, PCIPCMSG pMsg);
 
 #endif // !ipcCommandModule_h__

trunk/src/libs/xpcom18a4/ipc/ipcd/daemon/src/ipcd.cpp

@@ -61 +61 @@
 
 #include "ipcConfig.h"
-#include "ipcMessage.h"
+#include "ipcMessageNew.h"
 #include "ipcClient.h"
-#include "ipcdPrivate.h"
+#include "ipcCommandModule.h"
 #include "ipcd.h"
-
+#include "ipcm.h"
+
+
+//
+// upper limit on the number of active connections
+// XXX may want to make this more dynamic
+//
+#define IPC_MAX_CLIENTS 100
+
+/** How many messages should stay in the message cache. */
+#define IPC_MAX_MSGS_IN_CACHE 5
 
 /**
@@ -72 +82 @@
 typedef struct IPCDSTATE
 {
-    RTSOCKET hSockListen;
-    int      fdListen;
-    int      ipcLockFD;
-    int      ipcClientCount;
-
-    //
-    // the first element of this array is always zero; this is done so that the
-    // k'th element of ipcClientArray corresponds to the k'th element of
-    // ipcPollList.
-    //
-    ipcClient ipcClientArray[IPC_MAX_CLIENTS];
-
-    RTPOLLSET hPollSet;
-    RTTHREAD  hThread;
+    RTSOCKET    hSockListen;
+    int         fdListen;
+    int         ipcLockFD;
+    int         ipcClientCount;
+
+    IPCDCLIENT  ipcClientArray[IPC_MAX_CLIENTS];
+    RTLISTANCHOR LstIpcClients;
+
+    RTLISTANCHOR LstIpcMsgsFree;
+    uint32_t     cIpcMsgsFree;
+
+    RTPOLLSET   hPollSet;
+    RTTHREAD    hThread;
 } IPCDSTATE;
 typedef IPCDSTATE *PIPCDSTATE;
@@ -251 +260 @@
 
 //-----------------------------------------------------------------------------
-// poll list
-//-----------------------------------------------------------------------------
-
-//
-// declared in ipcdPrivate.h
-//
-DECL_HIDDEN_DATA(RTLISTANCHOR) g_LstIpcClients;
-static RTPOLLSET g_hPollSet = NIL_RTPOLLSET;
-
-
-//-----------------------------------------------------------------------------
 
 static int AddClient(PIPCDSTATE pThis, RTSOCKET hSock)
@@ -273 +271 @@
     for (uint32_t i = 0; i < RT_ELEMENTS(pThis->ipcClientArray); i++)
     {
-        if (!pThis->ipcClientArray[i].m_fUsed)
-        {
-            pThis->ipcClientArray[i].Init(i, hSock);
-            pThis->ipcClientArray[i].m_fPollEvts = RTPOLL_EVT_READ;
-            int vrc = RTPollSetAddSocket(pThis->hPollSet, hSock, RTPOLL_EVT_READ, i);
+        if (!pThis->ipcClientArray[i].fUsed)
+        {
+            int vrc = ipcdClientInit(&pThis->ipcClientArray[i], pThis, i, hSock);
+            if (RT_SUCCESS(vrc))
+                vrc = RTPollSetAddSocket(pThis->hPollSet, hSock, RTPOLL_EVT_READ, i);
             if (RT_SUCCESS(vrc))
             {
-                RTListAppend(&g_LstIpcClients, &pThis->ipcClientArray[i].NdClients);
+                RTListAppend(&pThis->LstIpcClients, &pThis->ipcClientArray[i].NdClients);
                 pThis->ipcClientCount++;
                 return 0;
             }
 
-            pThis->ipcClientArray[i].Finalize();
+            ipcdClientDestroy(&pThis->ipcClientArray[i]);
             break;
         }
@@ -300 +298 @@
 
     RTListNodeRemove(&pThis->ipcClientArray[idClient].NdClients);
-    pThis->ipcClientArray[idClient].Finalize();
+    ipcdClientDestroy(&pThis->ipcClientArray[idClient]);
     pThis->ipcClientCount--;
     return 0;
@@ -309 +307 @@
 static void PollLoop(PIPCDSTATE pThis)
 {
-    RTListInit(&g_LstIpcClients);
-
     for (;;)
     {
@@ -356 +352 @@
         else
         {
-            uint32_t fNewFlags = pThis->ipcClientArray[idPoll].Process(fEvents);
+            uint32_t fNewFlags = ipcdClientProcess(&pThis->ipcClientArray[idPoll], fEvents);
             if (!fNewFlags)
             {
@@ -369 +365 @@
                 }
             }
-            else if (pThis->ipcClientArray[idPoll].m_fPollEvts != fNewFlags)
+            else if (pThis->ipcClientArray[idPoll].fPollEvts != fNewFlags)
             {
                 /* Change flags. */
                 vrc = RTPollSetEventsChange(pThis->hPollSet, idPoll, fNewFlags);
                 AssertRC(vrc);
-                pThis->ipcClientArray[idPoll].m_fPollEvts = fNewFlags;
+                pThis->ipcClientArray[idPoll].fPollEvts = fNewFlags;
             }
         }
@@ -382 +378 @@
 //-----------------------------------------------------------------------------
 
-PRStatus
-IPC_PlatformSendMsg(ipcClient  *client, ipcMessage *msg)
+static int ipcdPlatformSendMsg(PIPCDCLIENT pIpcClient, PIPCMSG pMsg)
 {
     LogFlowFunc(("IPC_PlatformSendMsg\n"));
 
-    //
-    // must copy message onto send queue.
-    //
-    client->EnqueueOutboundMsg(msg);
-
-    //
-    // since our Process method may have already been called, we must ensure
-    // that the RTPOLL_EVT_WRITE flag is set.
-    //
-    if (!(client->m_fPollEvts & RTPOLL_EVT_WRITE))
-    {
-        client->m_fPollEvts |= RTPOLL_EVT_WRITE;
-        int vrc = RTPollSetEventsChange(g_hPollSet, client->m_idPoll, client->m_fPollEvts);
+    PIPCDSTATE pThis = ipcdClientGetDaemonState(pIpcClient);
+
+    ipcdClientEnqueueOutboundMsg(pIpcClient, pMsg);
+
+    /*
+     * Since our Process method may have already been called, we must ensure
+     * that the RTPOLL_EVT_WRITE flag is set.
+     */
+    if (!(pIpcClient->fPollEvts & RTPOLL_EVT_WRITE))
+    {
+        pIpcClient->fPollEvts |= RTPOLL_EVT_WRITE;
+        int vrc = RTPollSetEventsChange(pThis->hPollSet, pIpcClient->idPoll, pIpcClient->fPollEvts);
         AssertRC(vrc);
     }
 
-    return PR_SUCCESS;
+    return VINF_SUCCESS;
+}
+
+
+//-----------------------------------------------------------------------------
+
+DECLHIDDEN(int) IPC_DispatchMsg(PIPCDCLIENT pIpcClient, PCIPCMSG pMsg)
+{
+    AssertPtr(pIpcClient);
+    AssertPtr(pMsg);
+
+    // remember if client is expecting SYNC_REPLY.  we'll add that flag to the
+    // next message sent to the client.
+    if (IPCMsgIsFlagSet(pMsg, IPC_MSG_FLAG_SYNC_QUERY))
+    {
+        Assert(!ipcdClientGetExpectsSyncReply(pIpcClient));
+        // XXX shouldn't we remember the TargetID as well, and only set the
+        //     SYNC_REPLY flag on the next message sent to the same TargetID?
+        ipcdClientSetExpectsSyncReply(pIpcClient, true);
+    }
+
+    if (IPCMsgGetTarget(pMsg)->Equals(IPCM_TARGET))
+        IPCM_HandleMsg(pIpcClient, pMsg);
+
+    return VINF_SUCCESS;
+}
+
+
+DECLHIDDEN(int) IPC_SendMsg(PIPCDCLIENT pIpcClient, PIPCMSG pMsg)
+{
+    Assert(pMsg);
+    Assert(pIpcClient);
+
+    // add SYNC_REPLY flag to message if client is expecting...
+    if (ipcdClientGetExpectsSyncReply(pIpcClient)) {
+        pMsg->pMsgHdr->u16Flags |= IPC_MSG_FLAG_SYNC_REPLY;
+        ipcdClientSetExpectsSyncReply(pIpcClient, false);
+    }
+
+    if (ipcdClientHasTarget(pIpcClient, IPCMsgGetTarget(pMsg)))
+        return ipcdPlatformSendMsg(pIpcClient, pMsg);
+
+    Log(("  no registered message handler\n"));
+    return VERR_NOT_FOUND;
+}
+
+
+DECLHIDDEN(void) IPC_NotifyClientUp(PIPCDCLIENT pIpcClient)
+{
+    Log(("IPC_NotifyClientUp: clientID=%d\n", ipcdClientGetId(pIpcClient)));
+
+    PIPCDSTATE pThis = ipcdClientGetDaemonState(pIpcClient);
+    PIPCDCLIENT pIt;
+    RTListForEach(&pThis->LstIpcClients, pIt, IPCDCLIENT, NdClients)
+    {
+        if (pIt != pIpcClient)
+        {
+            uint32_t aResp[4] = { IPCM_MSG_PSH_CLIENT_STATE, 0, ipcdClientGetId(pIpcClient), IPCM_CLIENT_STATE_UP };
+            IPC_SendMsg(pIt, IPCM_TARGET, &aResp[0], sizeof(aResp));
+        }
+    }
+}
+
+
+DECLHIDDEN(void) IPC_NotifyClientDown(PIPCDCLIENT pIpcClient)
+{
+    Log(("IPC_NotifyClientDown: clientID=%d\n", ipcdClientGetId(pIpcClient)));
+
+    PIPCDSTATE pThis = ipcdClientGetDaemonState(pIpcClient);
+    PIPCDCLIENT pIt;
+    RTListForEach(&pThis->LstIpcClients, pIt, IPCDCLIENT, NdClients)
+    {
+        if (pIt != pIpcClient)
+        {
+            uint32_t aResp[4] = { IPCM_MSG_PSH_CLIENT_STATE, 0, ipcdClientGetId(pIpcClient), IPCM_CLIENT_STATE_DOWN };
+            IPC_SendMsg(pIt, IPCM_TARGET, &aResp[0], sizeof(aResp));
+        }
+    }
+}
+
+//-----------------------------------------------------------------------------
+// IPC daemon methods
+//-----------------------------------------------------------------------------
+
+DECLHIDDEN(int) IPC_SendMsg(PIPCDCLIENT pIpcClient, const nsID &target, const void *pvData, size_t cbData)
+{
+    RTSGSEG Seg = { (void *)pvData, cbData };
+    return IPC_SendMsgSg(pIpcClient, target, cbData, &Seg, 1);
+}
+
+
+DECLHIDDEN(int) IPC_SendMsgSg(PIPCDCLIENT pIpcClient, const nsID &target, size_t cbTotal, PCRTSGSEG paSegs, uint32_t cSegs)
+{
+    PIPCDSTATE pThis = ipcdClientGetDaemonState(pIpcClient);
+    PIPCMSG pMsg = NULL;
+
+    if (!pThis->cIpcMsgsFree)
+    {
+        pMsg = IPCMsgNewSg(target, cbTotal, paSegs, cSegs);
+        if (!pMsg)
+            return VERR_NO_MEMORY;
+    }
+    else
+    {
+        pMsg = RTListRemoveFirst(&pThis->LstIpcMsgsFree, IPCMSG, NdMsg);
+        AssertPtr(pMsg);
+        pThis->cIpcMsgsFree--;
+
+        int vrc = IPCMsgInitSg(pMsg, target, cbTotal, paSegs, cSegs);
+        if (RT_FAILURE(vrc))
+        {
+            RTListAppend(&pThis->LstIpcMsgsFree, &pMsg->NdMsg);
+            pThis->cIpcMsgsFree++;
+            return vrc;
+        }
+    }
+
+    return IPC_SendMsg(pIpcClient, pMsg);
+}
+
+
+DECLHIDDEN(void) IPC_PutMsgIntoCache(PIPCDSTATE pIpcd, PIPCMSG pMsg)
+{
+    if (pIpcd->cIpcMsgsFree < IPC_MAX_MSGS_IN_CACHE)
+    { /*likely*/ }
+    else
+    {
+        IPCMsgFree(pMsg, true /*fFreeStruct*/);
+        return;
+    }
+
+    pIpcd->cIpcMsgsFree++;
+    IPCMsgReset(pMsg);
+    RTListAppend(&pIpcd->LstIpcMsgsFree, &pMsg->NdMsg);
+}
+
+
+DECLHIDDEN(PIPCDCLIENT) IPC_GetClientByID(PIPCDSTATE pIpcd, uint32_t idClient)
+{
+    // linear search OK since number of clients should be small
+    PIPCDCLIENT pIt;
+    RTListForEach(&pIpcd->LstIpcClients, pIt, IPCDCLIENT, NdClients)
+    {
+        if (ipcdClientGetId(pIt) == idClient)
+            return pIt;
+    }
+    return NULL;
+}
+
+
+DECLHIDDEN(PIPCDCLIENT) IPC_GetClientByName(PIPCDSTATE pIpcd, const char *pszName)
+{
+    // linear search OK since number of clients should be small
+    PIPCDCLIENT pIt;
+    RTListForEach(&pIpcd->LstIpcClients, pIt, IPCDCLIENT, NdClients)
+    {
+        if (ipcdClientHasName(pIt, pszName))
+            return pIt;
+    }
+    return NULL;
 }
 
@@ -409 +562 @@
 static int ipcdInit(PIPCDSTATE pThis, const char *pszSocketPath)
 {
+    RTListInit(&pThis->LstIpcClients);
+    RTListInit(&pThis->LstIpcMsgsFree);
+    pThis->cIpcMsgsFree   = 0;
     pThis->fdListen       = 0;
     pThis->hPollSet       = NIL_RTPOLLSET;
@@ -435 +591 @@
             // we terminate
             if (status != ELockFileOwner)
-                printf(("Cannot create a lock file for '%s'.\n"
-                        "Check permissions.\n", addr.sun_path));
+                printf("Cannot create a lock file for '%s'.\n"
+                        "Check permissions.\n", addr.sun_path);
             return VERR_INVALID_PARAMETER;
         }
@@ -495 +651 @@
     }
 
-    g_hPollSet = pThis->hPollSet;
-
     vrc = RTPollSetAddSocket(pThis->hPollSet, pThis->hSockListen, RTPOLL_EVT_READ | RTPOLL_EVT_ERROR, UINT32_MAX - 1);
     if (RT_FAILURE(vrc))
@@ -540 +694 @@
         AssertRC(vrc);
         pThis->hSockListen = NIL_RTSOCKET;
+    }
+
+    /* Free all the cached messages. */
+    PIPCMSG pIt, pItNext;
+    RTListForEachSafe(&pThis->LstIpcMsgsFree, pIt, pItNext, IPCMSG, NdMsg)
+    {
+        RTListNodeRemove(&pIt->NdMsg);
+        IPCMsgFree(pIt, true /*fFreeStruct*/);
     }
 }

trunk/src/libs/xpcom18a4/ipc/ipcd/daemon/src/ipcd.h

@@ -39 +39 @@
 #define IPCD_H__
 
-#include "ipcMessage.h"
+#include <iprt/sg.h>
 
-//
-// a client handle is used to efficiently reference a client instance object
-// used by the daemon to represent a connection with a particular client app.
-//
-// modules should treat it as an opaque type.
-//
-typedef class ipcClient *ipcClientHandle;
-
-//
-// enumeration functions may return FALSE to stop enumeration.
-//
-typedef PRBool (* ipcClientEnumFunc)       (void *closure, ipcClientHandle client, PRUint32 clientID);
-typedef PRBool (* ipcClientNameEnumFunc)   (void *closure, ipcClientHandle client, const char *name);
-typedef PRBool (* ipcClientTargetEnumFunc) (void *closure, ipcClientHandle client, const nsID &target);
+#include "ipcClient.h"
+#include "ipcMessageNew.h"
 
 //-----------------------------------------------------------------------------
@@ -63 +51 @@
 //-----------------------------------------------------------------------------
 
-PRStatus        IPC_DispatchMsg          (ipcClientHandle client, const nsID &target, const void *data, PRUint32 dataLen);
-PRStatus        IPC_SendMsg              (ipcClientHandle client, const nsID &target, const void *data, PRUint32 dataLen);
-ipcClientHandle IPC_GetClientByID        (PRUint32 id);
-ipcClientHandle IPC_GetClientByName      (const char *name);
-void            IPC_EnumClients          (ipcClientEnumFunc func, void *closure);
-PRUint32        IPC_GetClientID          (ipcClientHandle client);
-PRBool          IPC_ClientHasName        (ipcClientHandle client, const char *name);
-PRBool          IPC_ClientHasTarget      (ipcClientHandle client, const nsID &target);
-void            IPC_EnumClientNames      (ipcClientHandle client, ipcClientNameEnumFunc func, void *closure);
-void            IPC_EnumClientTargets    (ipcClientHandle client, ipcClientTargetEnumFunc func, void *closure);
+DECLHIDDEN(int)         IPC_SendMsg(PIPCDCLIENT pIpcClient, const nsID &target, const void *pvData, size_t cbData);
+DECLHIDDEN(int)         IPC_SendMsgSg(PIPCDCLIENT pIpcClient, const nsID &target, size_t cbTotal, PCRTSGSEG paSegs, uint32_t cSegs);
+DECLHIDDEN(PIPCDCLIENT) IPC_GetClientByID(PIPCDSTATE pIpcd, uint32_t idClient);
+DECLHIDDEN(PIPCDCLIENT) IPC_GetClientByName(PIPCDSTATE pIpcd, const char *pszName);
 
-//-----------------------------------------------------------------------------
-// other internal IPCD methods
-//-----------------------------------------------------------------------------
+DECLHIDDEN(void)        IPC_PutMsgIntoCache(PIPCDSTATE pIpcd, PIPCMSG pMsg);
 
 //
 // dispatch message
 //
-PRStatus IPC_DispatchMsg(ipcClientHandle client, const ipcMessage *msg);
+DECLHIDDEN(int) IPC_DispatchMsg(PIPCDCLIENT pIpcClient, PCIPCMSG pMsg);
 
 //
 // send message, takes ownership of |msg|.
 //
-PRStatus IPC_SendMsg(ipcClientHandle client, ipcMessage *msg);
+DECLHIDDEN(int) IPC_SendMsg(PIPCDCLIENT pIpcClient, PIPCMSG pMsg);
 
 //
 // dispatch notifications about client connects and disconnects
 //
-void IPC_NotifyClientUp(ipcClientHandle client);
-void IPC_NotifyClientDown(ipcClientHandle client);
+DECLHIDDEN(void) IPC_NotifyClientUp(PIPCDCLIENT pIpcClient);
+DECLHIDDEN(void) IPC_NotifyClientDown(PIPCDCLIENT pIpcClient);
 
 #endif // !IPCD_H__

trunk/src/libs/xpcom18a4/ipc/ipcd/shared/src/ipcMessage.cpp

@@ -46 +46 @@
 ipcMessage::~ipcMessage()
 {
-    if (mMsgHdr)
-        RTMemFree(mMsgHdr);
+    if (m_pvBuf)
+        RTMemFree(m_pvBuf);
+
+    mMsgHdr    = NULL;
+    m_pvBuf    = NULL;
+    m_cbBufMax = 0;
 }
 
@@ -53 +57 @@
 ipcMessage::Reset()
 {
-    if (mMsgHdr) {
-        RTMemFree(mMsgHdr);
-        mMsgHdr = NULL;
-    }
-
-    mMsgOffset = 0;
+    mMsgHdr      = NULL;
+    mMsgOffset   = 0;
     mMsgComplete = PR_FALSE;
+
+    /* For large messages we don't want to keep the memory around forever. */
+    if (m_cbBufMax > _16K)
+    {
+        RTMemFree(m_pvBuf);
+        m_pvBuf    = NULL;
+        m_cbBufMax = 0;
+    }
 }
 
@@ -71 +79 @@
     // copy buf if non-null
     if (mMsgHdr) {
-        clone->mMsgHdr = (ipcMessageHeader *) RTMemDup(mMsgHdr, mMsgHdr->mLen);
+        clone->mMsgHdr    = (ipcMessageHeader *) RTMemDup(mMsgHdr, mMsgHdr->mLen);
+        clone->m_pvBuf    = clone->mMsgHdr;
+        clone->m_cbBufMax = mMsgHdr->mLen;
     }
     else
@@ -85 +95 @@
 ipcMessage::Init(const nsID &target, const char *data, PRUint32 dataLen)
 {
-    if (mMsgHdr)
-        RTMemFree(mMsgHdr);
-
     mMsgComplete = PR_FALSE;
 
     // allocate message data
     PRUint32 msgLen = IPC_MSG_HEADER_SIZE + dataLen;
-    mMsgHdr = (ipcMessageHeader *) RTMemAlloc(msgLen);
-    if (!mMsgHdr) {
-        mMsgHdr = NULL;
-        return PR_FAILURE;
-    }
+    if (m_cbBufMax < msgLen)
+    {
+        void *pvNew = RTMemRealloc(m_pvBuf, msgLen);
+        if (!pvNew)
+            return PR_FAILURE;
+
+        m_pvBuf    = pvNew;
+        m_cbBufMax = msgLen;
+    }
+
+    mMsgHdr = (ipcMessageHeader *)m_pvBuf;
 
     // fill in message data
@@ -203 +216 @@
                 *bytesRead = count;
 
-                if (MsgLen() > IPC_MSG_GUESSED_SIZE) {
+                if (MsgLen() > m_cbBufMax) {
                     // realloc message buffer to the correct size
-                    mMsgHdr = (ipcMessageHeader *) RTMemRealloc(mMsgHdr, MsgLen());
+                    void *pvNew = RTMemRealloc(m_pvBuf, MsgLen());
+                    if (!pvNew)
+                        return PR_FAILURE;
+                    m_pvBuf    = pvNew;
+                    m_cbBufMax = MsgLen();
+                    mMsgHdr = (ipcMessageHeader *)m_pvBuf;
                 }
             }
@@ -215 +233 @@
             // allocate a partial buffer
             PRUint32 msgLen = IPC_MSG_GUESSED_SIZE;
-            mMsgHdr = (ipcMessageHeader *) RTMemAlloc(msgLen);
-            if (!mMsgHdr)
-                return PR_FAILURE;
+            if (msgLen > m_cbBufMax)
+            {
+                void *pvNew = RTMemRealloc(m_pvBuf, msgLen);
+                if (!pvNew)
+                    return PR_FAILURE;
+                m_pvBuf    = pvNew;
+                m_cbBufMax = msgLen;
+                mMsgHdr = (ipcMessageHeader *)m_pvBuf;
+            }
+
             memcpy(mMsgHdr, buf, bufLen);
             mMsgOffset = bufLen;
@@ -226 +251 @@
         else {
             PRUint32 msgLen = *(PRUint32 *) buf;
-            mMsgHdr = (ipcMessageHeader *) RTMemAlloc(msgLen);
-            if (!mMsgHdr)
-                return PR_FAILURE;
+            if (msgLen > m_cbBufMax)
+            {
+                void *pvNew = RTMemRealloc(m_pvBuf, msgLen);
+                if (!pvNew)
+                    return PR_FAILURE;
+                m_pvBuf    = pvNew;
+                m_cbBufMax = msgLen;
+            }
+            mMsgHdr = (ipcMessageHeader *)m_pvBuf;
             mMsgHdr->mLen = msgLen;
             mMsgOffset = 0;

trunk/src/libs/xpcom18a4/ipc/ipcd/shared/src/ipcMessage.h

@@ -100 +100 @@
         , mMsgOffset(0)
         , mMsgComplete(PR_FALSE)
+        , m_cbBufMax(0)
+        , m_pvBuf(NULL)
         { }
     ipcMessage(const nsID &target, const char *data, PRUint32 dataLen)
@@ -106 +108 @@
         , mMsgHdr(NULL)
         , mMsgOffset(0)
+        , m_cbBufMax(0)
+        , m_pvBuf(NULL)
         { Init(target, data, dataLen); }
    ~ipcMessage() NS_HIDDEN;
@@ -210 +214 @@
     PRUint32          mMsgOffset;
     PRPackedBool      mMsgComplete;
+
+    size_t            m_cbBufMax;
+    void              *m_pvBuf;
 };
 

trunk/src/libs/xpcom18a4/ipc/ipcd/shared/src/ipcMessageNew.h

@@ -36 +36 @@
  * ***** END LICENSE BLOCK ***** */
 
-#ifndef ipcMessage_h__
-#define ipcMessage_h__
+#ifndef ipcMessageNew_h__
+#define ipcMessageNew_h__
+
+#include <iprt/assert.h>
+#include <iprt/assertcompile.h>
+#include <iprt/cdefs.h>
+#include <iprt/err.h>
+#include <iprt/list.h>
+#include <iprt/types.h>
+#include <iprt/mem.h>
+#include <iprt/sg.h>
 
 #include "nsID.h"
@@ -58 +67 @@
 // is a 16 byte UUID indicating the intended receiver of this message.
 //
-
-struct ipcMessageHeader
-{
-    PRUint32 mLen;
-    PRUint16 mVersion;
-    PRUint16 mFlags;
-    nsID     mTarget;
-};
-
-#define IPC_MSG_VERSION       (0x1)
-#define IPC_MSG_HEADER_SIZE   (sizeof(ipcMessageHeader))
-#define IPC_MSG_GUESSED_SIZE  (IPC_MSG_HEADER_SIZE + 64)
+typedef struct IPCMSGHDR
+{
+    /** Size of the message in bytes, including this header. */
+    uint32_t cbMsg;
+    /** The version of the IPC message header. */
+    uint16_t u16Version;
+    /** Flags for the message. */
+    uint16_t u16Flags;
+    /** The target ID for this message. */
+    nsID     idTarget;
+} IPCMSGHDR;
+AssertCompileSize(IPCMSGHDR, 4 + 2 + 2 + 16);
+/** Pointer to the IPC message header. */
+typedef IPCMSGHDR *PIPCMSGHDR;
+/** Pointer to a const IPC message header. */
+typedef const IPCMSGHDR *PCIPCMSGHDR;
+
+/** IPC message version. */
+#define IPC_MSG_HDR_VERSION         UINT16_C(0x1)
 
 //
@@ -77 +93 @@
 // it is expecting a response with the SYNC_REPLY flag set.
 //
-#define IPC_MSG_FLAG_SYNC_QUERY (0x1)
-#define IPC_MSG_FLAG_SYNC_REPLY (0x2)
+#define IPC_MSG_HDR_FLAG_SYNC_QUERY RT_BIT(0)
+#define IPC_MSG_HDR_FLAG_SYNC_REPLY RT_BIT(1)
 
 //
@@ -85 +101 @@
 // in WaitTarget().
 //
-#define IPC_MSG_FLAG_IN_PROCESS (0x4)
-
-//-----------------------------------------------------------------------------
-// ipcMessage
-//-----------------------------------------------------------------------------
-
-class ipcMessage
-{
-public:
-    ipcMessage()
-        : mNext(NULL)
-        , mMetaData(0)
-        , mMsgHdr(NULL)
-        , mMsgOffset(0)
-        , mMsgComplete(PR_FALSE)
-        { }
-    ipcMessage(const nsID &target, const char *data, PRUint32 dataLen)
-        : mNext(NULL)
-        , mMetaData(0)
-        , mMsgHdr(NULL)
-        , mMsgOffset(0)
-        { Init(target, data, dataLen); }
-   ~ipcMessage() NS_HIDDEN;
-
-    //
-    // reset message to uninitialized state
-    //
-    NS_HIDDEN_(void) Reset();
-
-    // 
-    // create a copy of this message
-    //
-    NS_HIDDEN_(ipcMessage *) Clone() const;
-
-    //
-    // initialize message
-    //
-    // param:
-    //   topic   - message topic string
-    //   data    - message data (may be null to leave data uninitialized)
-    //   dataLen - message data len
-    //
-    NS_HIDDEN_(PRStatus) Init(const nsID &target, const char *data, PRUint32 dataLen);
-
-    //
-    // copy data into the message's data section, starting from offset.  this
-    // function can be used to write any portion of the message's data.
-    //
-    // param:
-    //   offset  - destination offset
-    //   data    - data to write
-    //   dataLen - number of bytes to write
-    //
-    NS_HIDDEN_(PRStatus) SetData(PRUint32 offset, const char *data, PRUint32 dataLen);
-
-    //
-    // access message flags
-    //
-    void SetFlag(PRUint16 flag)          { mMsgHdr->mFlags |= flag; }
-    void ClearFlag(PRUint16 flag)        { mMsgHdr->mFlags &= ~flag; }
-    PRBool TestFlag(PRUint16 flag) const { return mMsgHdr->mFlags & flag; }
-
-    //
-    // if true, the message is complete and the members of the message
-    // can be accessed.
-    //
-    PRBool IsComplete() const { return mMsgComplete; }
-
-    //
-    // readonly accessors
-    //
-    const ipcMessageHeader *Header()  const { return mMsgHdr; }
-    const nsID             &Target()  const { return mMsgHdr->mTarget; }
-    const char             *Data()    const { return (char *) mMsgHdr + IPC_MSG_HEADER_SIZE; }
-    PRUint32                DataLen() const { return mMsgHdr->mLen - IPC_MSG_HEADER_SIZE; }
-    const char             *MsgBuf()  const { return (char *) mMsgHdr; }
-    PRUint32                MsgLen()  const { return mMsgHdr->mLen; }
-
-    //
-    // message comparison functions
-    //
-    // param:
-    //   topic   - message topic (may be null)
-    //   data    - message data (must not be null)
-    //   dataLen - message data length 
-    //
-    NS_HIDDEN_(PRBool) Equals(const nsID &target, const char *data, PRUint32 dataLen) const;
-    NS_HIDDEN_(PRBool) Equals(const ipcMessage *msg) const;
-
-    //
-    // write the message to a buffer segment; segment need not be large
-    // enough to hold entire message.  called repeatedly.
-    //
-    NS_HIDDEN_(PRStatus) WriteTo(char     *buf,
-                                 PRUint32  bufLen,
-                                 PRUint32 *bytesWritten,
-                                 PRBool   *complete);
-
-    //
-    // read the message from a buffer segment; segment need not contain
-    // the entire messgae.  called repeatedly.
-    //
-    NS_HIDDEN_(PRStatus) ReadFrom(const char *buf,
-                                  PRUint32    bufLen,
-                                  PRUint32   *bytesRead,
-                                  PRBool     *complete);
-
-    //
-    // a message can be added to a singly-linked list.
-    //
-    class ipcMessage *mNext;
-
-    //
-    // meta data associated with this message object.  the owner of the
-    // ipcMessage object is free to use this field for any purpose.  by
-    // default, it is initialized to 0.
-    //
-    PRUint32          mMetaData;
-
-private:
-    ipcMessageHeader *mMsgHdr;
-
-    // XXX document me
-    PRUint32          mMsgOffset;
-    PRPackedBool      mMsgComplete;
-};
-
-#endif // !ipcMessage_h__
+#define IPC_MSG_HDR_FLAG_IN_PROCESS RT_BIT(2)
+
+
+/**
+ * IPC message structure.
+ */
+typedef struct IPCMSG
+{
+    /** List node for putting the message onto a list. */
+    RTLISTNODE              NdMsg;
+    /** Pointer to the IPC message header. */
+    PIPCMSGHDR              pMsgHdr;
+    /** Size of the message buffer in bytes (maximum size of the buffer). */
+    size_t                  cbBuf;
+    /** Pointer to the message buffer. */
+    uint8_t                 *pbBuf;
+    /** Offset into the message buffer to append data to. */
+    uint32_t                offAppend;
+    /** Flag whether the message is complete and the buffer is therefore readonly right now. */
+    bool                    fReadonly;
+} IPCMSG;
+/** Pointer to an IPC message. */
+typedef IPCMSG *PIPCMSG;
+/** Pointer to a const IPC message. */
+typedef const IPCMSG *PCIPCMSG;
+
+
+DECLINLINE(int) IPCMsgInit(PIPCMSG pThis, size_t cbBuf)
+{
+    Assert(!pThis->pbBuf);
+
+    pThis->pbBuf = (uint8_t *)RTMemAlloc(sizeof(*pThis->pMsgHdr) + cbBuf);
+    if (RT_UNLIKELY(!pThis->pbBuf))
+        return VERR_NO_MEMORY;
+
+    pThis->cbBuf     = sizeof(*pThis->pMsgHdr) + cbBuf;
+    pThis->offAppend = 0;
+    pThis->fReadonly = false;
+    pThis->pMsgHdr   = NULL;
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * Allocates a new IPC message structure which can hold the given amount of data initially.
+ *
+ * @returns Pointer to the IPC message structure or NULL if out of memory.
+ * @param   cbMsg       Size of the payload message buffer in bytes, can be 0 if not known at allocation time.
+ */
+DECLINLINE(PIPCMSG) IPCMsgAlloc(size_t cbMsg)
+{
+    PIPCMSG pThis = (PIPCMSG)RTMemAllocZ(sizeof(*pThis));
+    if (RT_UNLIKELY(!pThis))
+        return NULL;
+
+    if (cbMsg)
+    {
+        pThis->pbBuf = (uint8_t *)RTMemAlloc(sizeof(*pThis->pMsgHdr) + cbMsg);
+        if (RT_UNLIKELY(!pThis->pbBuf))
+        {
+            RTMemFree(pThis);
+            return NULL;
+        }
+
+        pThis->cbBuf = sizeof(*pThis->pMsgHdr) + cbMsg;
+    }
+
+    return pThis;
+}
+
+
+/**
+ * Frees the given message and all associated resources.
+ *
+ * @param   pThis       The IPC message to free.
+ * @param   fFreeStruct Flag whether to free the structure (true) or just the message buffer (false).
+ */
+DECLINLINE(void) IPCMsgFree(PIPCMSG pThis, bool fFreeStruct)
+{
+    if (pThis->pbBuf)
+        RTMemFree(pThis->pbBuf);
+    pThis->pbBuf     = NULL;
+    pThis->pMsgHdr   = NULL;
+    pThis->cbBuf     = 0;
+    pThis->offAppend = 0;
+    pThis->fReadonly = false;
+
+    if (fFreeStruct)
+        RTMemFree(pThis);
+}
+
+
+/**
+ * Reset the given message structure to accept a new message.
+ *
+ * @param   pThis       The IPC message to reset.
+ */
+DECLINLINE(void) IPCMsgReset(PIPCMSG pThis)
+{
+    pThis->pMsgHdr   = NULL;
+    pThis->offAppend = 0;
+    pThis->fReadonly = false;
+}
+
+
+/**
+ * Returns a pointer to the message data including the header.
+ *
+ * @param   pThis       The IPC message.
+ */
+DECLINLINE(void *) IPCMsgGetBuf(PCIPCMSG pThis)
+{
+    AssertReturn(pThis->pMsgHdr, NULL);
+
+    return pThis->pMsgHdr;
+}
+
+
+/**
+ * Returns the size of the message in bytes including the header.
+ *
+ * @param   pThis       The IPC message.
+ */
+DECLINLINE(size_t) IPCMsgGetSize(PCIPCMSG pThis)
+{
+    AssertReturn(pThis->pMsgHdr, 0);
+
+    return pThis->pMsgHdr->cbMsg;
+}
+
+
+/**
+ * Returns the message header of the given message.
+ *
+ * @returns Pointer to the IPC message header.
+ * @param   pThis       The IPC message.
+ */
+DECLINLINE(PCIPCMSGHDR) IPCMsgGetHdr(PCIPCMSG pThis)
+{
+    Assert(pThis->pMsgHdr);
+    return pThis->pMsgHdr;
+}
+
+
+DECLINLINE(const nsID *) IPCMsgGetTarget(PCIPCMSG pThis)
+{
+    AssertReturn(pThis->pMsgHdr, NULL);
+    return &pThis->pMsgHdr->idTarget;
+}
+
+
+/**
+ * Returns a pointer to the message payload data.
+ *
+ * @param   pThis       The IPC message.
+ */
+DECLINLINE(void *) IPCMsgGetPayload(PCIPCMSG pThis)
+{
+    AssertReturn(pThis->pMsgHdr, NULL);
+
+    return pThis->pMsgHdr + 1;
+}
+
+
+/**
+ * Returns the size of the message payload in bytes.
+ *
+ * @param   pThis       The IPC message.
+ */
+DECLINLINE(size_t) IPCMsgGetPayloadSize(PCIPCMSG pThis)
+{
+    AssertReturn(pThis->pMsgHdr, 0);
+
+    return pThis->pMsgHdr->cbMsg - sizeof(*pThis->pMsgHdr);
+}
+
+
+/**
+ * Returns whether the message is readonly (or complete).
+ *
+ * @returns Flag whether the message is readonly.
+ * @param   pThis       The IPC message.
+ */
+DECLINLINE(bool) IPCMsgIsReadonly(PCIPCMSG pThis)
+{
+    return pThis->fReadonly;
+}
+
+
+/**
+ * Returns whether the given flag is set in the message header.
+ *
+ * @returns true if the flag is set false it is clear.
+ * @param   pThis       The IPC message.
+ * @param   fFlag       The flag (or combination) to check.
+ */
+DECLINLINE(bool) IPCMsgIsFlagSet(PCIPCMSG pThis, uint16_t fFlag)
+{
+    return RT_BOOL(pThis->pMsgHdr->u16Flags & fFlag);
+}
+
+
+/**
+ * Sets the given flag in the message header.
+ *
+ * @param   pThis       The IPC message.
+ * @param   fFlag       The flag to set.
+ */
+DECLINLINE(void) IPCMsgSetFlag(PIPCMSG pThis, uint16_t fFlag)
+{
+    pThis->pMsgHdr->u16Flags |= fFlag;
+}
+
+
+/**
+ * Init worker for a given message frame.
+ *
+ * @param   pThis       The message to initialize.
+ * @param   target      the target for the message.
+ * @param   cbTotal     Size of the payload in bytes.
+ * @param   paSegs      Pointer to the segment array making up the message payload.
+ * @param   cSegs       Number of segments in the array.
+ */
+DECLINLINE(void) ipcMsgInitWorker(PIPCMSG pThis, const nsID &target, size_t cbTotal, PCRTSGSEG paSegs, uint32_t cSegs)
+{
+    pThis->pMsgHdr             = (PIPCMSGHDR)pThis->pbBuf;
+    pThis->pMsgHdr->cbMsg      = sizeof(*pThis->pMsgHdr) + cbTotal;
+    pThis->pMsgHdr->u16Version = IPC_MSG_HDR_VERSION;
+    pThis->pMsgHdr->u16Flags   = 0;
+    pThis->pMsgHdr->idTarget   = target;
+
+    uint8_t *pb = (uint8_t *)(pThis->pMsgHdr + 1);
+    for (uint32_t i = 0; i < cSegs; i++)
+    {
+        memcpy(pb, paSegs[i].pvSeg, paSegs[i].cbSeg);
+        pb += paSegs[i].cbSeg;
+    }
+
+    pThis->fReadonly = true;
+}
+
+
+/**
+ * Allocates a new message with the given target and content.
+ *
+ * @returns Pointer to the allocated message structure or NULL if out of memory.
+ * @param   target      The target for the message.
+ * @param   cbTotal     Size of the payload in bytes.
+ * @param   paSegs      Pointer to the segment array making up the message payload.
+ * @param   cSegs       Number of segments in the array.
+ */
+DECLINLINE(PIPCMSG) IPCMsgNewSg(const nsID &target, size_t cbTotal, PCRTSGSEG paSegs, uint32_t cSegs)
+{
+    PIPCMSG pThis = IPCMsgAlloc(cbTotal);
+    if (RT_LIKELY(pThis))
+        ipcMsgInitWorker(pThis, target, cbTotal, paSegs, cSegs);
+
+    return pThis;
+}
+
+
+/**
+ * Initializes a given message frame, growing the data buffer if necessary.
+ *
+ * @param   pThis       The message to initialize.
+ * @param   target      the target for the message.
+ * @param   cbTotal     Size of the payload in bytes.
+ * @param   paSegs      Pointer to the segment array making up the message payload.
+ * @param   cSegs       Number of segments in the array.
+ */
+DECLINLINE(int) IPCMsgInitSg(PIPCMSG pThis, const nsID &target, size_t cbTotal, PCRTSGSEG paSegs, uint32_t cSegs)
+{
+    uint32_t cbMsg = sizeof(*pThis->pMsgHdr) + cbTotal;
+    if (pThis->cbBuf < cbMsg)
+    {
+        uint8_t *pbBufNew = (uint8_t *)RTMemRealloc(pThis->pbBuf, cbMsg);
+        if (!pbBufNew)
+            return VERR_NO_MEMORY;
+
+        pThis->pbBuf = pbBufNew;
+        pThis->cbBuf = cbMsg;
+    }
+
+    ipcMsgInitWorker(pThis, target, cbTotal, paSegs, cSegs);
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * Reads data for the given message from the given buffer.
+ *
+ * @returns IPRT status code.
+ * @param   pThis       The message to read into.
+ * @param   pvData      The data buffer holding message data.
+ * @param   cbData      Size of the data buffer in bytes.
+ * @param   pcbRead     Where to store the number of bytes read from the data buffer.
+ * @param   pfDone      Where to store the flag whether the message is complete and can be parsed after returning from this call.
+ */
+DECLINLINE(int) IPCMsgReadFrom(PIPCMSG pThis, const void *pvData, size_t cbData, size_t *pcbRead, bool *pfDone)
+{
+    size_t cbHdrRead = 0;
+    if (!pThis->pMsgHdr)
+    {
+        /* No full header received yet. */
+        Assert(pThis->cbBuf >= sizeof(*pThis->pMsgHdr));
+
+        cbHdrRead = RT_MIN(cbData, sizeof(*pThis->pMsgHdr) - pThis->offAppend);
+        memcpy(pThis->pbBuf + pThis->offAppend, pvData, cbHdrRead);
+
+        pThis->offAppend += cbHdrRead;
+        Assert(pThis->offAppend <= sizeof(*pThis->pMsgHdr));
+        if (pThis->offAppend == sizeof(*pThis->pMsgHdr))
+        {
+            /* Complete header received. */
+            pThis->pMsgHdr = (PIPCMSGHDR)pThis->pbBuf;
+
+            if (pThis->pMsgHdr->cbMsg > pThis->cbBuf)
+            {
+                Assert(pThis->pMsgHdr->cbMsg < 10 * _1M);
+
+                uint8_t *pbBufNew = (uint8_t *)RTMemRealloc(pThis->pbBuf, pThis->pMsgHdr->cbMsg);
+                if (!pbBufNew)
+                    return VERR_NO_MEMORY;
+
+                pThis->pbBuf   = pbBufNew;
+                pThis->pMsgHdr = (PIPCMSGHDR)pbBufNew;
+                pThis->cbBuf   = pThis->pMsgHdr->cbMsg;
+            }
+
+            /* fall through below after adjusting the buffer pointers. */
+            pvData = (const uint8_t *)pvData + cbHdrRead;
+            cbData -= cbHdrRead;
+        }
+        else
+        {
+            *pfDone  = false;
+            *pcbRead = cbHdrRead;
+            return VINF_SUCCESS;
+        }
+    }
+
+    Assert(pThis->pMsgHdr);
+    Assert(pThis->pMsgHdr->cbMsg <= pThis->cbBuf);
+
+    /* We know the size of the message because a full message header was received already. */
+    size_t cbLeft = pThis->pMsgHdr->cbMsg - pThis->offAppend;
+    cbData = RT_MIN(cbData, cbLeft);
+    Assert(pThis->offAppend + cbData <= pThis->cbBuf);
+
+    if (cbData == cbLeft)
+        *pfDone = true;
+    else
+        *pfDone = false;
+
+    memcpy(pThis->pbBuf + pThis->offAppend, pvData, cbData);
+    pThis->offAppend += cbData;
+    *pcbRead          = cbData + cbHdrRead;
+    return VINF_SUCCESS;
+}
+
+#endif // !ipcMessageNew_h__

trunk/src/libs/xpcom18a4/ipc/ipcd/shared/src/ipcm.h

@@ -39 +39 @@
 #define ipcm_h__
 
+#include <iprt/assertcompile.h>
+
 #include "ipcMessage.h"
 #include "ipcMessagePrimitives.h"
@@ -118 +120 @@
     PRUint32 mRequestIndex;
 };
+AssertCompileSize(struct ipcmMessageHeader, 8);
 
 //