Changeset 103472 in vbox for trunk/src/libs/xpcom18a4/ipc

Timestamp:

Feb 20, 2024 9:26:18 AM (12 months ago)

Author:

vboxsync

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

161808

Message:

libs/xpcom: Rewrite the IPC client side to reduce the number of memory allocations, bugref:10598

Location:

trunk/src/libs/xpcom18a4/ipc/ipcd

Files:

• client/public/ipcIService.idl (modified) (1 diff)
• client/public/ipcdclient.h (modified) (1 diff)
• client/src/ipcConnection.h (modified) (3 diffs)
• client/src/ipcConnectionUnix.cpp (modified) (13 diffs)
• client/src/ipcService.cpp (modified) (2 diffs)
• client/src/ipcdclient.cpp (modified) (46 diffs)
• daemon/src/ipcCommandModule.cpp (modified) (10 diffs)
• daemon/src/ipcd.cpp (modified) (4 diffs)
• shared/src/ipcConfig.cpp (modified) (1 diff)
• shared/src/ipcMessage.cpp (deleted)
• shared/src/ipcMessage.h (deleted)
• shared/src/ipcMessageNew.h (modified) (8 diffs)
• shared/src/ipcMessagePrimitives.cpp (deleted)
• shared/src/ipcMessagePrimitives.h (deleted)
• shared/src/ipcMessageQ.h (deleted)
• shared/src/ipcMessageUtils.h (deleted)
• shared/src/ipcm.cpp (modified) (2 diffs)
• shared/src/ipcm.h (modified) (3 diffs)

trunk/src/libs/xpcom18a4/ipc/ipcd/client/public/ipcIService.idl

@@ -118 +118 @@
      */
     unsigned long resolveClientName(in string aName);
-
-
-    /**
-     * tests whether a particular client is connected to the IPC daemon.
-     */
-    boolean clientExists(in unsigned long aClientID);
 
 

trunk/src/libs/xpcom18a4/ipc/ipcd/client/public/ipcdclient.h

@@ -291 +291 @@
 );
 
-/**
- * Tests whether the client is connected to the IPC daemon.
- */
-IPC_METHOD IPC_ClientExists(
-  PRUint32  aClientID,
-  PRBool   *aResult
-);
-
 /*****************************************************************************/
 

trunk/src/libs/xpcom18a4/ipc/ipcd/client/src/ipcConnection.h

@@ -40 +40 @@
 
 #include "nscore.h"
-
-class ipcMessage;
+#include "ipcMessageNew.h"
 
 #define IPC_METHOD_PRIVATE_(type)   NS_HIDDEN_(type)
@@ -88 +87 @@
  * NOTE: This function may be called on any thread.
  */
-IPC_METHOD_PRIVATE IPC_SendMsg(ipcMessage *msg);
+IPC_METHOD_PRIVATE IPC_SendMsg(PIPCMSG pMsg);
 
 /**
@@ -140 +139 @@
  *
  * This function is called whenever an incoming message is read from the IPC
- * daemon.  The ipcMessage object, |msg|, must be deleted by the implementation
- * of IPC_OnMessageAvailable when the object is no longer needed.
+ * daemon.  The implementer of this method must not assume ownership over the
+ * message.
  */
-IPC_METHOD_PRIVATE_(void) IPC_OnMessageAvailable(ipcMessage *msg);
+DECLHIDDEN(void) IPC_OnMessageAvailable(PCIPCMSG pMsg);
+
+/**
+ * IPC_MsgFree
+ *
+ * This function is called whenever an outgoing message was sent by the
+ * connection code and the message can be freed.
+ */
+DECLHIDDEN(void) IPC_MsgFree(PIPCMSG pMsg);
 
 #endif // ipcConnection_h__

trunk/src/libs/xpcom18a4/ipc/ipcd/client/src/ipcConnectionUnix.cpp

@@ -39 +39 @@
 #include <iprt/err.h>
 #include <iprt/env.h>
+#include <iprt/list.h>
 #include <iprt/mem.h>
 #include <iprt/pipe.h>
@@ -57 +58 @@
 
 #include "ipcConnection.h"
-#include "ipcMessageQ.h"
+#include "ipcMessageNew.h"
+#include "ipcList.h"
 #include "ipcConfig.h"
 
@@ -129 +131 @@
     RTPOLLSET    hPollSet;
     ipcCallbackQ callback_queue;
-    ipcMessageQ  send_queue;
-    PRUint32     send_offset; // amount of send_queue.First() already written.
-    ipcMessage  *in_msg;
     bool         fShutdown;
+    /** The list of messages waiting for sending out. */
+    RTLISTANCHOR LstMsgsOut;
+    /** Number of bytes in the message of the first message on the list which was already sent. */
+    size_t       offSendFirst;
+    /** The message currently being received. */
+    IPCMSG       MsgIn;
 };
 
@@ -146 +151 @@
     RTSocketClose(s->hSockConn);
 
-    if (s->in_msg)
-        delete s->in_msg;
-
-    s->send_queue.DeleteAll();
+    IPCMsgFree(&s->MsgIn, false /*fFreeStruct*/);
+
+    PIPCMSG pIt, pItNext;
+    RTListForEachSafe(&s->LstMsgsOut, pIt, pItNext, IPCMSG, NdMsg)
+    {
+        RTListNodeRemove(&pIt->NdMsg);
+        IPCMsgFree(pIt, true /*fFreeStruct*/);
+    }
+
     RTMemFree(s);
 }
@@ -159 +169 @@
       return NULL;
 
-    s->send_offset = 0;
-    s->in_msg = NULL;
-    s->fShutdown = false;
-
-    int vrc = RTCritSectInit(&s->CritSect);
+    RTListInit(&s->LstMsgsOut);
+    s->offSendFirst = 0;
+    s->fShutdown    = false;
+
+    int vrc = IPCMsgInit(&s->MsgIn, 0 /*cbBuf*/);
     if (RT_SUCCESS(vrc))
     {
-        vrc = RTPollSetCreate(&s->hPollSet);
+        vrc = RTCritSectInit(&s->CritSect);
         if (RT_SUCCESS(vrc))
         {
-            RTPIPE hPipeR;
-
-            vrc = RTPipeCreate(&s->hWakeupPipeR, &s->hWakeupPipeW, 0 /*fFlags*/);
+            vrc = RTPollSetCreate(&s->hPollSet);
             if (RT_SUCCESS(vrc))
             {
-                vrc = RTPollSetAddSocket(s->hPollSet, hSockConn, RTPOLL_EVT_READ | RTPOLL_EVT_ERROR, SOCK);
+                vrc = RTPipeCreate(&s->hWakeupPipeR, &s->hWakeupPipeW, 0 /*fFlags*/);
                 if (RT_SUCCESS(vrc))
                 {
-                    vrc = RTPollSetAddPipe(s->hPollSet, s->hWakeupPipeR, RTPOLL_EVT_READ | RTPOLL_EVT_ERROR, POLL);
+                    vrc = RTPollSetAddSocket(s->hPollSet, hSockConn, RTPOLL_EVT_READ | RTPOLL_EVT_ERROR, SOCK);
                     if (RT_SUCCESS(vrc))
                     {
-                        vrc = RTSocketSetInheritance(hSockConn, false /*fInheritable*/);
+                        vrc = RTPollSetAddPipe(s->hPollSet, s->hWakeupPipeR, RTPOLL_EVT_READ | RTPOLL_EVT_ERROR, POLL);
                         if (RT_SUCCESS(vrc))
                         {
-                            s->hSockConn = hSockConn;
-                            return s;
+                            vrc = RTSocketSetInheritance(hSockConn, false /*fInheritable*/);
+                            if (RT_SUCCESS(vrc))
+                            {
+                                s->hSockConn = hSockConn;
+                                return s;
+                            }
+
+                            LogFlowFunc(("coudn't make IPC socket non-inheritable [err=%Rrc]\n", vrc));
+                            vrc = RTPollSetRemove(s->hPollSet, POLL); AssertRC(vrc);
                         }
 
-                        LogFlowFunc(("coudn't make IPC socket non-inheritable [err=%Rrc]\n", vrc));
-                        vrc = RTPollSetRemove(s->hPollSet, POLL); AssertRC(vrc);
+                        vrc = RTPollSetRemove(s->hPollSet, SOCK); AssertRC(vrc);
                     }
 
-                    vrc = RTPollSetRemove(s->hPollSet, SOCK); AssertRC(vrc);
+                    vrc = RTPipeClose(s->hWakeupPipeR); AssertRC(vrc);
+                    vrc = RTPipeClose(s->hWakeupPipeW); AssertRC(vrc);
                 }
 
-                vrc = RTPipeClose(s->hWakeupPipeR); AssertRC(vrc);
-                vrc = RTPipeClose(s->hWakeupPipeW); AssertRC(vrc);
-            }
-
-            vrc = RTPollSetDestroy(s->hPollSet); AssertRC(vrc);
-        }
-
-        RTCritSectDelete(&s->CritSect);
+                vrc = RTPollSetDestroy(s->hPollSet); AssertRC(vrc);
+            }
+
+            RTCritSectDelete(&s->CritSect);
+        }
+
+        IPCMsgFree(&s->MsgIn, false /*fFreeStruct*/);
     }
 
@@ -236 +250 @@
         while (cbRead)
         {
-            PRUint32 bytesRead;
-            PRBool fComplete = PR_FALSE;
-
-            /* No message frame available? Allocate a new one. */
-            if (!s->in_msg)
-            {
-                s->in_msg = new ipcMessage;
-                if (RT_UNLIKELY(!s->in_msg))
-                {
-                    rv = NS_ERROR_OUT_OF_MEMORY;
-                    break;
-                }
-            }
-
-            if (s->in_msg->ReadFrom(pdata, cbRead, &bytesRead, &fComplete) != PR_SUCCESS)
+            size_t cbProcessed = 0;
+            bool fComplete = false;
+
+            if (IPCMsgReadFrom(&s->MsgIn, pdata, cbRead, &cbProcessed, &fComplete) != VINF_SUCCESS)
             {
                 LogFlowFunc(("error reading IPC message\n"));
@@ -257 +260 @@
             }
 
-            Assert(cbRead >= bytesRead);
-            cbRead -= bytesRead;
-            pdata  += bytesRead;
+            Assert(cbRead >= cbProcessed);
+            cbRead -= cbProcessed;
+            pdata  += cbProcessed;
 
             if (fComplete)
             {
-                // protect against weird re-entrancy cases...
-                ipcMessage *m = s->in_msg;
-                s->in_msg = NULL;
-
-                IPC_OnMessageAvailable(m);
+                IPC_OnMessageAvailable(&s->MsgIn);
+                IPCMsgReset(&s->MsgIn);
             }
         }
@@ -281 +281 @@
     RTCritSectEnter(&s->CritSect);
 
-    // write one message and then return.
-    if (s->send_queue.First())
+    /* Write as much as we can. */
+    while (!RTListIsEmpty(&s->LstMsgsOut))
     {
         size_t cbWritten = 0;
+        PIPCMSG pMsg = RTListGetFirst(&s->LstMsgsOut, IPCMSG, NdMsg);
         int vrc = RTSocketWriteNB(s->hSockConn,
-                                  s->send_queue.First()->MsgBuf() + s->send_offset,
-                                  s->send_queue.First()->MsgLen() - s->send_offset,
+                                  (const uint8_t *)IPCMsgGetBuf(pMsg) + s->offSendFirst,
+                                  IPCMsgGetSize(pMsg) - s->offSendFirst,
                                   &cbWritten);
         if (vrc == VINF_SUCCESS && cbWritten)
         {
-            s->send_offset += cbWritten;
-            if (s->send_offset == s->send_queue.First()->MsgLen())
-            {
-                s->send_queue.DeleteFirst();
-                s->send_offset = 0;
-
-                /* if the send queue is empty, then we need to stop trying to write. */
-                if (s->send_queue.IsEmpty())
-                {
-                    vrc = RTPollSetEventsChange(s->hPollSet, SOCK, RTPOLL_EVT_READ | RTPOLL_EVT_ERROR);
-                    AssertRC(vrc);
-                }
-            }
-        }
-        else if (vrc != VINF_TRY_AGAIN)
+            s->offSendFirst += cbWritten;
+            if (s->offSendFirst == IPCMsgGetSize(pMsg))
+            {
+                RTListNodeRemove(&pMsg->NdMsg);
+                IPC_MsgFree(pMsg);
+                s->offSendFirst = 0;
+            }
+        }
+        else if (vrc == VINF_TRY_AGAIN)
+            break;
+        else
         {
             Assert(RT_FAILURE(vrc));
@@ -311 +308 @@
             rv = NS_ERROR_UNEXPECTED;
         }
+    }
+
+    /* if the send queue is empty, then we need to stop trying to write. */
+    if (RTListIsEmpty(&s->LstMsgsOut))
+    {
+        int vrc = RTPollSetEventsChange(s->hPollSet, SOCK, RTPOLL_EVT_READ | RTPOLL_EVT_ERROR);
+        AssertRC(vrc);
     }
 
@@ -375 +379 @@
                 RTCritSectEnter(&s->CritSect);
 
-                if (!s->send_queue.IsEmpty())
+                if (!RTListIsEmpty(&s->LstMsgsOut))
                 {
                     vrc = RTPollSetEventsChange(s->hPollSet, SOCK, RTPOLL_EVT_READ | RTPOLL_EVT_WRITE | RTPOLL_EVT_ERROR);
@@ -387 +391 @@
                 // request until after all queued up messages have been sent and until
                 // after all queued up callbacks have been run.
-                if (s->fShutdown && s->send_queue.IsEmpty() && s->callback_queue.IsEmpty())
+                if (s->fShutdown && RTListIsEmpty(&s->LstMsgsOut) && s->callback_queue.IsEmpty())
                     rv = NS_ERROR_ABORT;
 
@@ -559 +563 @@
 }
 
-nsresult IPC_SendMsg(ipcMessage *msg)
+nsresult IPC_SendMsg(PIPCMSG pMsg)
 {
     if (!gConnState || !gConnThread)
@@ -565 +569 @@
 
     RTCritSectEnter(&gConnState->CritSect);
-    gConnState->send_queue.Append(msg);
+    RTListAppend(&gConnState->LstMsgsOut, &pMsg->NdMsg);
     size_t cbWrittenIgn = 0;
     int vrc = RTPipeWrite(gConnState->hWakeupPipeW, &magicChar, sizeof(magicChar), &cbWrittenIgn);

trunk/src/libs/xpcom18a4/ipc/ipcd/client/src/ipcService.cpp

@@ -79 +79 @@
 }
 
+#if 0 /*unused*/
 NS_IMETHODIMP
 ipcService::ClientExists(PRUint32 aClientID, PRBool *aResult)
@@ -84 +85 @@
     return IPC_ClientExists(aClientID, aResult);
 }
+#endif
 
 NS_IMETHODIMP

trunk/src/libs/xpcom18a4/ipc/ipcd/client/src/ipcdclient.cpp

@@ -39 +39 @@
 #include "ipcConnection.h"
 #include "ipcConfig.h"
-#include "ipcMessageQ.h"
-#include "ipcMessageUtils.h"
 #include "ipcm.h"
 
@@ -91 +89 @@
 
   // incoming messages are added to this list
-  ipcMessageQ pendingQ;
+  RTLISTANCHOR            LstPendingMsgs;
 
   // non-zero if the observer has been disabled (this means that new messages
@@ -104 +102 @@
     , observerDisabled(0)
     , refcnt(0)
-    {}
+    {
+        RTListInit(&LstPendingMsgs);
+    }
 
   ~ipcTargetData()
@@ -110 +110 @@
     if (monitor)
       nsAutoMonitor::DestroyMonitor(monitor);
+
+    /* Free all the pending messages. */
+    PIPCMSG pIt, pItNext;
+    RTListForEachSafe(&LstPendingMsgs, pIt, pItNext, IPCMSG, NdMsg)
+    {
+        RTListNodeRemove(&pIt->NdMsg);
+        IPCMsgFree(pIt, true /*fFreeStruct*/);
+    }
   }
 
@@ -153 +161 @@
   {
     RTCritSectRwDelete(&critSect);
+    RTCritSectDelete(&CritSectCache);
+
+    /* Free all the cached messages. */
+    PIPCMSG pIt, pItNext;
+    RTListForEachSafe(&LstMsgCache, pIt, pItNext, IPCMSG, NdMsg)
+    {
+        RTListNodeRemove(&pIt->NdMsg);
+        IPCMsgFree(pIt, true /*fFreeStruct*/);
+    }
   }
 
@@ -165 +182 @@
   nsCOMArray<ipcIClientObserver> clientObservers;
 
+  RTCRITSECT     CritSectCache;
+  RTLISTANCHOR  LstMsgCache;
+  uint32_t      cMsgsInCache;
+
 private:
 
@@ -174 +195 @@
     /* Not employing the lock validator here to keep performance up in debug builds. */
     RTCritSectRwInitEx(&critSect, RTCRITSECT_FLAGS_NO_LOCK_VAL, NIL_RTLOCKVALCLASS, RTLOCKVAL_SUB_CLASS_NONE, NULL);
+
+    RTCritSectInit(&CritSectCache);
+    RTListInit(&LstMsgCache);
+    cMsgsInCache = 0;
   }
 };
@@ -196 +221 @@
 
 static ipcClientState *gClientState;
+
+DECLHIDDEN(void) IPC_MsgFree(PIPCMSG pMsg)
+{
+    if (pMsg->fStack)
+        return;
+
+    int vrc = RTCritSectTryEnter(&gClientState->CritSectCache);
+    if (RT_SUCCESS(vrc))
+    {
+        if (gClientState->cMsgsInCache < 10)
+        {
+            RTListAppend(&gClientState->LstMsgCache, &pMsg->NdMsg);
+            gClientState->cMsgsInCache++;
+            RTCritSectLeave(&gClientState->CritSectCache);
+            return;
+        }
+
+        RTCritSectLeave(&gClientState->CritSectCache);
+    }
+
+    IPCMsgFree(pMsg, true /*fFreeStruct*/);
+}
+
+DECLINLINE(PIPCMSG) ipcdMsgGetFromCache(void)
+{
+    PIPCMSG pMsg = NULL;
+
+    if (gClientState->cMsgsInCache)
+    {
+        int vrc = RTCritSectTryEnter(&gClientState->CritSectCache);
+        if (RT_SUCCESS(vrc))
+        {
+            if (gClientState->cMsgsInCache)
+            {
+                pMsg = RTListRemoveFirst(&gClientState->LstMsgCache, IPCMSG, NdMsg);
+                gClientState->cMsgsInCache--;
+            }
+
+            RTCritSectLeave(&gClientState->CritSectCache);
+        }
+    }
+
+    return pMsg;
+}
+
+static PIPCMSG IPC_MsgClone(PCIPCMSG pMsg)
+{
+    PIPCMSG pClone = ipcdMsgGetFromCache();
+    if (pClone)
+    {
+        int vrc = IPCMsgCloneWithMsg(pMsg, pClone);
+        if (RT_SUCCESS(vrc))
+            return pClone;
+
+        /* Don't bother putting the clone back into the cache. */
+        IPCMsgFree(pClone, true /*fFreeStruct*/);
+    }
+
+    /* Allocate new */
+    return IPCMsgClone(pMsg);
+}
+
+static PIPCMSG IPC_MsgNewSg(const nsID &target, size_t cbTotal, PCRTSGSEG paSegs, uint32_t cSegs)
+{
+    PIPCMSG pMsg = ipcdMsgGetFromCache();
+    if (pMsg)
+    {
+        int vrc = IPCMsgInitSg(pMsg, target, cbTotal, paSegs, cSegs);
+        if (RT_SUCCESS(vrc))
+            return pMsg;
+    }
+
+    return IPCMsgNewSg(target, cbTotal, paSegs, cSegs);
+}
+
 
 static PRBool
@@ -247 +347 @@
 ProcessPendingQ(const nsID &aTarget)
 {
-  ipcMessageQ tempQ;
-
-  nsRefPtr<ipcTargetData> td;
-  if (GetTarget(aTarget, getter_AddRefs(td)))
-  {
-    nsAutoMonitor mon(td->monitor);
-
-    // if the observer for this target has been temporarily disabled, then
-    // we must not processing any pending messages at this time.
-
-    if (!td->observerDisabled)
-      td->pendingQ.MoveTo(tempQ);
-  }
-
-  // process pending queue outside monitor
-  while (!tempQ.IsEmpty())
-  {
-    ipcMessage *msg = tempQ.First();
-
-    // it is possible that messages for other targets are in the queue
-    // (currently, this can be only a IPCM_MSG_PSH_CLIENT_STATE message
-    // initially addressed to IPCM_TARGET, see IPC_OnMessageAvailable())
-    // --ignore them.
-    if (td->observer && msg->Target().Equals(aTarget))
-      td->observer->OnMessageAvailable(msg->mMetaData,
-                                       msg->Target(),
-                                       (const PRUint8 *) msg->Data(),
-                                       msg->DataLen());
-    else
-    {
-      // the IPCM target does not have an observer, and therefore any IPCM
-      // messages that make it here will simply be dropped.
-      NS_ASSERTION(aTarget.Equals(IPCM_TARGET) || msg->Target().Equals(IPCM_TARGET),
-                   "unexpected target");
-      Log(("dropping IPCM message: type=%x\n", IPCM_GetType(msg)));
-    }
-    tempQ.DeleteFirst();
-  }
+    RTLISTANCHOR LstPendingMsgs;
+    RTListInit(&LstPendingMsgs);
+
+    nsRefPtr<ipcTargetData> td;
+    if (GetTarget(aTarget, getter_AddRefs(td)))
+    {
+        nsAutoMonitor mon(td->monitor);
+
+        // if the observer for this target has been temporarily disabled, then
+        // we must not processing any pending messages at this time.
+
+        if (!td->observerDisabled)
+            RTListMove(&LstPendingMsgs, &td->LstPendingMsgs);
+    }
+
+    // process pending queue outside monitor
+    while (!RTListIsEmpty(&LstPendingMsgs))
+    {
+        PIPCMSG pMsg = RTListGetFirst(&LstPendingMsgs, IPCMSG, NdMsg);
+        RTListNodeRemove(&pMsg->NdMsg);
+
+        // it is possible that messages for other targets are in the queue
+        // (currently, this can be only a IPCM_MSG_PSH_CLIENT_STATE message
+        // initially addressed to IPCM_TARGET, see IPC_OnMessageAvailable())
+        // --ignore them.
+        if (td->observer && IPCMsgGetTarget(pMsg)->Equals(aTarget))
+            td->observer->OnMessageAvailable(pMsg->upUser,
+                                             *IPCMsgGetTarget(pMsg),
+                                             (const PRUint8 *)IPCMsgGetPayload(pMsg),
+                                             IPCMsgGetPayloadSize(pMsg));
+        else
+        {
+          // the IPCM target does not have an observer, and therefore any IPCM
+          // messages that make it here will simply be dropped.
+          NS_ASSERTION(   aTarget.Equals(IPCM_TARGET)
+                       || IPCMsgGetTarget(pMsg)->Equals(IPCM_TARGET),
+                       "unexpected target");
+          Log(("dropping IPCM message: type=%x\n", IPCM_GetType(pMsg)));
+        }
+        IPC_MsgFree(pMsg);
+    }
 }
 
@@ -292 +395 @@
 // message target.  the selector is called while inside the target's monitor.
 
-typedef nsresult (* ipcMessageSelector)(
-  void *arg,
-  ipcTargetData *td,
-  const ipcMessage *msg
-);
+typedef nsresult (* ipcMessageSelector)(void *arg, ipcTargetData *td, PCIPCMSG pMsg);
 
 // selects any
-static nsresult
-DefaultSelector(void *arg, ipcTargetData *td, const ipcMessage *msg)
+static nsresult DefaultSelector(void *arg, ipcTargetData *td, PCIPCMSG pMsg)
 {
   return NS_OK;
@@ -308 +406 @@
 WaitTarget(const nsID           &aTarget,
            RTMSINTERVAL         aTimeout,
-           ipcMessage          **aMsg,
+           PIPCMSG              *ppMsg,
            ipcMessageSelector    aSelector = nsnull,
            void                 *aArg = nsnull)
 {
-  *aMsg = nsnull;
+  *ppMsg = NULL;
 
   if (!aSelector)
@@ -338 +436 @@
   }
 
-  ipcMessage *lastChecked = nsnull, *beforeLastChecked = nsnull;
   nsresult rv = NS_ERROR_ABORT;
 
@@ -350 +447 @@
   while (gClientState->connected && (!gClientState->shutdown || isIPCMTarget))
   {
-    NS_ASSERTION(!lastChecked, "oops");
-
     //
     // NOTE:
@@ -365 +460 @@
     //
 
-    lastChecked = td->pendingQ.First();
-    beforeLastChecked = nsnull;
-
+    PIPCMSG pIt, pItNext;
     // loop over pending queue until we find a message that our selector likes.
-    while (lastChecked)
+    RTListForEachSafe(&td->LstPendingMsgs, pIt, pItNext, IPCMSG, NdMsg)
     {
       //
@@ -378 +471 @@
       // to guarantee that every message is processed only once.
       //
-
-      if (!lastChecked->TestFlag(IPC_MSG_FLAG_IN_PROCESS))
+      if (!IPCMsgIsFlagSet(pIt, IPC_MSG_HDR_FLAG_IN_PROCESS))
       {
-        lastChecked->SetFlag(IPC_MSG_FLAG_IN_PROCESS);
-        nsresult acceptedRV = (aSelector)(aArg, td, lastChecked);
-        lastChecked->ClearFlag(IPC_MSG_FLAG_IN_PROCESS);
+        IPCMsgSetFlag(pIt, IPC_MSG_HDR_FLAG_IN_PROCESS);
+        nsresult acceptedRV = (aSelector)(aArg, td, pIt);
+        IPCMsgClearFlag(pIt, IPC_MSG_HDR_FLAG_IN_PROCESS);
 
         if (acceptedRV != IPC_WAIT_NEXT_MESSAGE)
@@ -390 +482 @@
           {
             // remove from pending queue
-            if (beforeLastChecked)
-              td->pendingQ.RemoveAfter(beforeLastChecked);
-            else
-              td->pendingQ.RemoveFirst();
-
-            lastChecked->mNext = nsnull;
-            *aMsg = lastChecked;
+            RTListNodeRemove(&pIt->NdMsg);
+            *ppMsg = pIt;
             break;
           }
           else /* acceptedRV == IPC_DISCARD_MESSAGE */
           {
-            ipcMessage *nextToCheck = lastChecked->mNext;
-
-            // discard from pending queue
-            if (beforeLastChecked)
-              td->pendingQ.DeleteAfter(beforeLastChecked);
-            else
-              td->pendingQ.DeleteFirst();
-
-            lastChecked = nextToCheck;
-
+            RTListNodeRemove(&pIt->NdMsg);
+            IPC_MsgFree(pIt);
             continue;
           }
         }
       }
-
-      beforeLastChecked = lastChecked;
-      lastChecked = lastChecked->mNext;
-    }
-
-    if (*aMsg)
+    }
+
+    if (*ppMsg)
     {
       rv = NS_OK;
@@ -434 +510 @@
       if (aliveRV != IPC_WAIT_NEXT_MESSAGE)
       {
-        *aMsg = NULL;
+        *ppMsg = NULL;
         break;
       }
@@ -452 +528 @@
 
     Log(("woke up from sleep [pendingQempty=%d connected=%d shutdown=%d isIPCMTarget=%d]\n",
-          td->pendingQ.IsEmpty(), gClientState->connected,
+          RTListIsEmpty(&td->LstPendingMsgs), gClientState->connected,
           gClientState->shutdown, isIPCMTarget));
   }
@@ -592 +668 @@
     nsAutoMonitor mon(td->monitor);
     if (td->observerDisabled > 0 && --td->observerDisabled == 0)
-      if (!td->pendingQ.IsEmpty())
+      if (!RTListIsEmpty(&td->LstPendingMsgs))
         CallProcessPendingQ(aTarget, td);
   }
@@ -600 +676 @@
 
 // converts IPCM_ERROR_* status codes to NS_ERROR_* status codes
-static nsresult nsresult_from_ipcm_result(PRInt32 status)
+static nsresult nsresult_from_ipcm_result(int32_t status)
 {
   nsresult rv = NS_ERROR_FAILURE;
@@ -622 +698 @@
 // selects the next IPCM message with matching request index
 static nsresult
-WaitIPCMResponseSelector(void *arg, ipcTargetData *td, const ipcMessage *msg)
+WaitIPCMResponseSelector(void *arg, ipcTargetData *td, PCIPCMSG pMsg)
 {
 #ifdef VBOX
-  if (!msg)
+  if (!pMsg)
     return IPC_WAIT_NEXT_MESSAGE;
 #endif /* VBOX */
   PRUint32 requestIndex = *(PRUint32 *) arg;
-  return IPCM_GetRequestIndex(msg) == requestIndex ? NS_OK : IPC_WAIT_NEXT_MESSAGE;
+  return IPCM_GetRequestIndex(pMsg) == requestIndex ? NS_OK : IPC_WAIT_NEXT_MESSAGE;
 }
 
@@ -637 +713 @@
 // status code is mapped to a nsresult and returned by this function.
 static nsresult
-WaitIPCMResponse(PRUint32 requestIndex, ipcMessage **responseMsg = nsnull)
-{
-  ipcMessage *msg;
-
-  nsresult rv = WaitTarget(IPCM_TARGET, IPC_REQUEST_TIMEOUT, &msg,
+WaitIPCMResponse(PRUint32 requestIndex, PIPCMSG *ppMsgResponse = NULL)
+{
+  PIPCMSG pMsg;
+
+  nsresult rv = WaitTarget(IPCM_TARGET, IPC_REQUEST_TIMEOUT, &pMsg,
                            WaitIPCMResponseSelector, &requestIndex);
   if (NS_FAILED(rv))
     return rv;
 
-  if (IPCM_GetType(msg) == IPCM_MSG_ACK_RESULT)
-  {
-    ipcMessageCast<ipcmMessageResult> result(msg);
-    if (result->Status() < 0)
-      rv = nsresult_from_ipcm_result(result->Status());
+  if (IPCM_GetType(pMsg) == IPCM_MSG_ACK_RESULT)
+  {
+    PCIPCMMSGRESULT pIpcmRes = (PCIPCMMSGRESULT)IPCMsgGetPayload(pMsg);
+    if (pIpcmRes->i32Status < 0)
+      rv = nsresult_from_ipcm_result(pIpcmRes->i32Status);
     else
       rv = NS_OK;
   }
 
-  if (responseMsg)
-    *responseMsg = msg;
+  if (ppMsgResponse)
+    *ppMsgResponse = pMsg;
   else
-    delete msg;
+    IPC_MsgFree(pMsg);
 
   return rv;
@@ -665 +741 @@
 // make an IPCM request and wait for a response.
 static nsresult
-MakeIPCMRequest(ipcMessage *msg, ipcMessage **responseMsg = nsnull)
-{
-  if (!msg)
-    return NS_ERROR_OUT_OF_MEMORY;
-
-  PRUint32 requestIndex = IPCM_GetRequestIndex(msg);
-
-  // suppress 'ProcessPendingQ' for IPCM messages until we receive the
-  // response to this IPCM request.  if we did not do this then there
-  // would be a race condition leading to the possible removal of our
-  // response from the pendingQ between sending the request and waiting
-  // for the response.
-  DisableMessageObserver(IPCM_TARGET);
-
-  nsresult rv = IPC_SendMsg(msg);
-  if (NS_SUCCEEDED(rv))
-    rv = WaitIPCMResponse(requestIndex, responseMsg);
-
-  EnableMessageObserver(IPCM_TARGET);
-  return rv;
-}
-
-/* ------------------------------------------------------------------------- */
-
-static void
-RemoveTarget(const nsID &aTarget, PRBool aNotifyDaemon)
-{
-  DelTarget(aTarget);
-
-  if (aNotifyDaemon)
-  {
-    nsresult rv = MakeIPCMRequest(new ipcmMessageClientDelTarget(aTarget));
-    if (NS_FAILED(rv))
-      Log(("failed to delete target: rv=%x\n", rv));
-  }
+MakeIPCMRequest(PIPCMSG pMsg, PIPCMSG *ppMsgResponse = NULL)
+{
+    AssertPtrReturn(pMsg, NS_ERROR_OUT_OF_MEMORY);
+
+    uint32_t requestIndex = IPCM_GetRequestIndex(pMsg);
+
+    // suppress 'ProcessPendingQ' for IPCM messages until we receive the
+    // response to this IPCM request.  if we did not do this then there
+    // would be a race condition leading to the possible removal of our
+    // response from the pendingQ between sending the request and waiting
+    // for the response.
+    DisableMessageObserver(IPCM_TARGET);
+
+    nsresult rv = IPC_SendMsg(pMsg);
+    if (NS_SUCCEEDED(rv))
+        rv = WaitIPCMResponse(requestIndex, ppMsgResponse);
+
+    EnableMessageObserver(IPCM_TARGET);
+    return rv;
+}
+
+/* ------------------------------------------------------------------------- */
+
+static void RemoveTarget(const nsID &aTarget, PRBool aNotifyDaemon)
+{
+    DelTarget(aTarget);
+
+    if (aNotifyDaemon)
+    {
+        IPCMMSGSTACK IpcmMsg;
+        IPCMSG IpcMsg;
+
+        IPCMMsgDelTargetInit(&IpcmMsg.Ipcm.AddDelTarget, aTarget);
+        IPCMsgInitStack(&IpcMsg, IPCM_TARGET, &IpcmMsg, sizeof(IpcmMsg.Ipcm.AddDelTarget));
+        nsresult rv = MakeIPCMRequest(&IpcMsg);
+        if (NS_FAILED(rv))
+            Log(("failed to delete target: rv=%x\n", rv));
+    }
 }
 
@@ -709 +788 @@
              ipcTargetData       **aResult)
 {
-  nsresult rv;
-
-  nsRefPtr<ipcTargetData> td( ipcTargetData::Create() );
-  if (!td)
-    return NS_ERROR_OUT_OF_MEMORY;
-  td->SetObserver(aObserver, aOnCurrentThread);
-
-  if (!PutTarget(aTarget, td))
-    return NS_ERROR_OUT_OF_MEMORY;
-
-  if (aNotifyDaemon)
-  {
-    rv = MakeIPCMRequest(new ipcmMessageClientAddTarget(aTarget));
-    if (NS_FAILED(rv))
-    {
-      Log(("failed to add target: rv=%x\n", rv));
-      RemoveTarget(aTarget, PR_FALSE);
-      return rv;
-    }
-  }
-
-  if (aResult)
-    NS_ADDREF(*aResult = td);
-  return NS_OK;
+    nsresult rv;
+
+    nsRefPtr<ipcTargetData> td( ipcTargetData::Create() );
+    if (!td)
+        return NS_ERROR_OUT_OF_MEMORY;
+    td->SetObserver(aObserver, aOnCurrentThread);
+
+    if (!PutTarget(aTarget, td))
+        return NS_ERROR_OUT_OF_MEMORY;
+
+    if (aNotifyDaemon)
+    {
+        IPCMMSGSTACK IpcmMsg;
+        IPCMSG IpcMsg;
+
+        IPCMMsgAddTargetInit(&IpcmMsg.Ipcm.AddDelTarget, aTarget);
+        IPCMsgInitStack(&IpcMsg, IPCM_TARGET, &IpcmMsg, sizeof(IpcmMsg.Ipcm.AddDelTarget));
+        rv = MakeIPCMRequest(&IpcMsg);
+        if (NS_FAILED(rv))
+        {
+          Log(("failed to add target: rv=%x\n", rv));
+          RemoveTarget(aTarget, PR_FALSE);
+          return rv;
+        }
+    }
+
+    if (aResult)
+        NS_ADDREF(*aResult = td);
+    return NS_OK;
 }
 
@@ -740 +824 @@
 TryConnect()
 {
-  nsCAutoString dpath;
-  nsresult rv = GetDaemonPath(dpath);
-  if (NS_FAILED(rv))
+    nsCAutoString dpath;
+    nsresult rv = GetDaemonPath(dpath);
+    if (NS_FAILED(rv))
+        return rv;
+
+    rv = IPC_Connect(dpath.get());
+    if (NS_FAILED(rv))
+        return rv;
+
+    gClientState->connected = PR_TRUE;
+
+    rv = DefineTarget(IPCM_TARGET, nsnull, PR_FALSE, PR_FALSE, nsnull);
+    if (NS_FAILED(rv))
+        return rv;
+
+    PIPCMSG pMsg = NULL;
+
+    // send CLIENT_HELLO and wait for CLIENT_ID response...
+    IPCMMSGSTACK IpcmMsg;
+    IPCMSG IpcMsg;
+
+    IPCMMsgClientHelloInit(&IpcmMsg.Ipcm.ClientHello);
+    IPCMsgInitStack(&IpcMsg, IPCM_TARGET, &IpcmMsg, sizeof(IpcmMsg.Ipcm.ClientHello));
+    rv = MakeIPCMRequest(&IpcMsg, &pMsg);
+    if (NS_FAILED(rv))
+    {
+#ifdef VBOX  /* MakeIPCMRequest may return a failure (e.g. NS_ERROR_CALL_FAILED) and a response msg. */
+        if (pMsg)
+            IPC_MsgFree(pMsg);
+#endif
+        return rv;
+    }
+
+    if (IPCM_GetType(pMsg) == IPCM_MSG_ACK_CLIENT_ID)
+    {
+        PCIPCMMSGCLIENTID pIpcmClientId = (PCIPCMMSGCLIENTID)IPCMsgGetPayload(pMsg);
+        gClientState->selfID = pIpcmClientId->u32ClientId;
+    }
+    else
+    {
+        Log(("unexpected response from CLIENT_HELLO message: type=%x!\n", IPCM_GetType(pMsg)));
+        rv = NS_ERROR_UNEXPECTED;
+    }
+
+    IPC_MsgFree(pMsg);
     return rv;
-
-  rv = IPC_Connect(dpath.get());
-  if (NS_FAILED(rv))
-    return rv;
-
-  gClientState->connected = PR_TRUE;
-
-  rv = DefineTarget(IPCM_TARGET, nsnull, PR_FALSE, PR_FALSE, nsnull);
-  if (NS_FAILED(rv))
-    return rv;
-
-  ipcMessage *msg = NULL;
-
-  // send CLIENT_HELLO and wait for CLIENT_ID response...
-  rv = MakeIPCMRequest(new ipcmMessageClientHello(), &msg);
-  if (NS_FAILED(rv))
-  {
-#ifdef VBOX  /* MakeIPCMRequest may return a failure (e.g. NS_ERROR_CALL_FAILED) and a response msg. */
-    if (msg)
-      delete msg;
-#endif
-    return rv;
-  }
-
-  if (IPCM_GetType(msg) == IPCM_MSG_ACK_CLIENT_ID)
-    gClientState->selfID = ipcMessageCast<ipcmMessageClientID>(msg)->ClientID();
-  else
-  {
-    Log(("unexpected response from CLIENT_HELLO message: type=%x!\n",
-        IPCM_GetType(msg)));
-    rv = NS_ERROR_UNEXPECTED;
-  }
-
-  delete msg;
-  return rv;
 }
 
@@ -925 +1016 @@
                 PRUint32       aDataLen)
 {
-  NS_ENSURE_TRUE(gClientState, NS_ERROR_NOT_INITIALIZED);
-
-  // do not permit sending IPCM messages
-  if (aTarget.Equals(IPCM_TARGET))
-    return NS_ERROR_INVALID_ARG;
-
-  nsresult rv;
-  if (aReceiverID == 0)
-  {
-    ipcMessage *msg = new ipcMessage(aTarget, (const char *) aData, aDataLen);
-    if (!msg)
-      return NS_ERROR_OUT_OF_MEMORY;
-
-    rv = IPC_SendMsg(msg);
-  }
-  else
-    rv = MakeIPCMRequest(new ipcmMessageForward(IPCM_MSG_REQ_FORWARD,
-                                                aReceiverID,
-                                                aTarget,
-                                                (const char *) aData,
-                                                aDataLen));
-
-  return rv;
+    NS_ENSURE_TRUE(gClientState, NS_ERROR_NOT_INITIALIZED);
+
+    // do not permit sending IPCM messages
+    if (aTarget.Equals(IPCM_TARGET))
+      return NS_ERROR_INVALID_ARG;
+
+    nsresult rv;
+    if (aReceiverID == 0)
+    {
+        RTSGSEG Seg = { (void *)aData, aDataLen };
+        PIPCMSG pMsg = IPC_MsgNewSg(aTarget, aDataLen, &Seg, 1 /*cSegs*/);
+        if (!pMsg)
+            return NS_ERROR_OUT_OF_MEMORY;
+
+        rv = IPC_SendMsg(pMsg);
+    }
+    else
+    {
+        IPCMSGHDR InnerMsgHdr;
+        IPCMMSGFORWARD IpcmFwd;
+        RTSGSEG aSegs[3];
+
+        /* Construct the forwarded message. */
+        IpcmFwd.Hdr.u32Type         = IPCM_MSG_REQ_FORWARD;
+        IpcmFwd.Hdr.u32RequestIndex = IPCM_NewRequestIndex();
+        IpcmFwd.u32ClientId         = aReceiverID;
+
+        aSegs[0].pvSeg = &IpcmFwd;
+        aSegs[0].cbSeg = sizeof(IpcmFwd);
+        aSegs[1].pvSeg = IPCMsgHdrInit(&InnerMsgHdr, aTarget, aDataLen);
+        aSegs[1].cbSeg = sizeof(InnerMsgHdr);
+        aSegs[2].pvSeg = (void *)aData;
+        aSegs[2].cbSeg = aDataLen;
+
+        PIPCMSG pMsg = IPC_MsgNewSg(IPCM_TARGET, aDataLen + sizeof(IpcmFwd) + sizeof(InnerMsgHdr),
+                                    &aSegs[0], RT_ELEMENTS(aSegs));
+        rv = MakeIPCMRequest(pMsg);
+    }
+
+    return rv;
 }
 
@@ -957 +1065 @@
 };
 
-static nsresult WaitMessageSelector(void *arg, ipcTargetData *td, const ipcMessage *msg)
+static nsresult WaitMessageSelector(void *arg, ipcTargetData *td, PCIPCMSG pMsg)
 {
   WaitMessageSelectorData *data = (WaitMessageSelectorData *) arg;
 #ifdef VBOX
-  if (!msg)
+  if (!pMsg)
   {
     /* Special NULL message which asks to check whether the client is
@@ -981 +1089 @@
   // sender we're waiting a message from has died.
 
-  if (msg->Target().Equals(IPCM_TARGET))
-  {
-    switch (IPCM_GetType(msg))
+  if (IPCMsgGetTarget(pMsg)->Equals(IPCM_TARGET))
+  {
+    switch (IPCM_GetType(pMsg))
     {
       case IPCM_MSG_PSH_CLIENT_STATE:
       {
-        ipcMessageCast<ipcmMessageClientState> status(msg);
+        PCIPCMMSGCLIENTSTATE pClientState = (PCIPCMMSGCLIENTSTATE)IPCMsgGetPayload(pMsg);
         if ((data->senderID == IPC_SENDER_ANY ||
-             status->ClientID() == data->senderID) &&
-            status->ClientState() == IPCM_CLIENT_STATE_DOWN)
+             pClientState->u32ClientId == data->senderID) &&
+             pClientState->u32ClientStatus == IPCM_CLIENT_STATE_DOWN)
         {
           Log(("sender (%d) we're waiting a message from (%d) has died\n",
-               status->ClientID(), data->senderID));
+               pClientState->u32ClientId, data->senderID));
 
           if (data->senderID != IPC_SENDER_ANY)
@@ -1014 +1122 @@
             NS_ASSERTION(obs, "must at least have a default observer");
 
-            nsresult rv = obs->OnMessageAvailable(status->ClientID(), nsID(), 0, 0);
+            nsresult rv = obs->OnMessageAvailable(pClientState->u32ClientId, nsID(), 0, 0);
             if (rv != IPC_WAIT_NEXT_MESSAGE)
               data->senderDead = PR_TRUE;
@@ -1023 +1131 @@
 #ifdef VBOX
         else if ((data->senderID == IPC_SENDER_ANY ||
-                  status->ClientID() == data->senderID) &&
-                 status->ClientState() == IPCM_CLIENT_STATE_UP)
+                  pClientState->u32ClientId) &&
+                 pClientState->u32ClientStatus == IPCM_CLIENT_STATE_UP)
         {
           Log(("sender (%d) we're waiting a message from (%d) has come up\n",
-               status->ClientID(), data->senderID));
+               pClientState->u32ClientId, data->senderID));
           if (data->senderID == IPC_SENDER_ANY)
           {
@@ -1038 +1146 @@
             NS_ASSERTION(obs, "must at least have a default observer");
 
-            nsresult rv = obs->OnMessageAvailable(status->ClientID(), nsID(), 0, 1);
+            nsresult rv = obs->OnMessageAvailable(pClientState->u32ClientId, nsID(), 0, 1);
             /* VBoxSVC/VBoxXPCOMIPCD auto-start can cause that a client up
              * message arrives while we're already waiting for a response
@@ -1062 +1170 @@
 
   if (data->senderID == IPC_SENDER_ANY ||
-      msg->mMetaData == data->senderID)
+      pMsg->upUser == data->senderID)
   {
     ipcIMessageObserver *obs = data->observer;
@@ -1069 +1177 @@
     NS_ASSERTION(obs, "must at least have a default observer");
 
-    rv = obs->OnMessageAvailable(msg->mMetaData,
-                                 msg->Target(),
-                                 (const PRUint8 *) msg->Data(),
-                                 msg->DataLen());
+    rv = obs->OnMessageAvailable(pMsg->upUser,
+                                 *IPCMsgGetTarget(pMsg),
+                                 (const PRUint8 *)IPCMsgGetPayload(pMsg),
+                                 IPCMsgGetPayloadSize(pMsg));
   }
 
@@ -1095 +1203 @@
   WaitMessageSelectorData data = { aSenderID, aObserver, PR_FALSE };
 
-  ipcMessage *msg;
-  nsresult rv = WaitTarget(aTarget, aTimeout, &msg, WaitMessageSelector, &data);
+  PIPCMSG pMsg;
+  nsresult rv = WaitTarget(aTarget, aTimeout, &pMsg, WaitMessageSelector, &data);
   if (NS_FAILED(rv))
     return rv;
@@ -1106 +1214 @@
   if (aObserver && aConsumer)
   {
-    aConsumer->OnMessageAvailable(msg->mMetaData,
-                                  msg->Target(),
-                                  (const PRUint8 *) msg->Data(),
-                                  msg->DataLen());
-  }
-
-  delete msg;
+    aConsumer->OnMessageAvailable(pMsg->upUser,
+                                  *IPCMsgGetTarget(pMsg),
+                                  (const PRUint8 *)IPCMsgGetPayload(pMsg),
+                                  IPCMsgGetPayloadSize(pMsg));
+  }
+
+  IPC_MsgFree(pMsg);
 
   // if the requested sender has died while waiting, return an error
@@ -1135 +1243 @@
 IPC_AddName(const char *aName)
 {
-  NS_ENSURE_TRUE(gClientState, NS_ERROR_NOT_INITIALIZED);
-
-  return MakeIPCMRequest(new ipcmMessageClientAddName(aName));
+    NS_ENSURE_TRUE(gClientState, NS_ERROR_NOT_INITIALIZED);
+
+    size_t cbStr = strlen(aName) + 1; /* Includes terminator. */
+    const IPCMMSGHDR Hdr = { IPCM_MSG_REQ_CLIENT_ADD_NAME, IPCM_NewRequestIndex() };
+    RTSGSEG aSegs[2];
+
+    aSegs[0].pvSeg = (void *)&Hdr;
+    aSegs[0].cbSeg = sizeof(Hdr);
+
+    aSegs[1].pvSeg = (void *)aName;
+    aSegs[1].cbSeg = cbStr;
+
+    PIPCMSG pMsg = IPC_MsgNewSg(IPCM_TARGET, cbStr + sizeof(Hdr),
+                                &aSegs[0], RT_ELEMENTS(aSegs));
+    return MakeIPCMRequest(pMsg);
 }
 
@@ -1143 +1263 @@
 IPC_RemoveName(const char *aName)
 {
-  NS_ENSURE_TRUE(gClientState, NS_ERROR_NOT_INITIALIZED);
-
-  return MakeIPCMRequest(new ipcmMessageClientDelName(aName));
+    NS_ENSURE_TRUE(gClientState, NS_ERROR_NOT_INITIALIZED);
+
+    size_t cbStr = strlen(aName) + 1; /* Includes terminator. */
+    const IPCMMSGHDR Hdr = { IPCM_MSG_REQ_CLIENT_DEL_NAME, IPCM_NewRequestIndex() };
+    RTSGSEG aSegs[2];
+
+    aSegs[0].pvSeg = (void *)&Hdr;
+    aSegs[0].cbSeg = sizeof(Hdr);
+
+    aSegs[1].pvSeg = (void *)aName;
+    aSegs[1].cbSeg = cbStr;
+
+    PIPCMSG pMsg = IPC_MsgNewSg(IPCM_TARGET, cbStr + sizeof(Hdr),
+                                &aSegs[0], RT_ELEMENTS(aSegs));
+    return MakeIPCMRequest(pMsg);
 }
 
@@ -1179 +1311 @@
 IPC_ResolveClientName(const char *aName, PRUint32 *aClientID)
 {
-  NS_ENSURE_TRUE(gClientState, NS_ERROR_NOT_INITIALIZED);
-
-  ipcMessage *msg = NULL;
-
-  nsresult rv = MakeIPCMRequest(new ipcmMessageQueryClientByName(aName), &msg);
-  if (NS_FAILED(rv))
-  {
-#ifdef VBOX  /* MakeIPCMRequest may return a failure (e.g. NS_ERROR_CALL_FAILED) and a response msg. */
-    if (msg)
-      delete msg;
-#endif
+    NS_ENSURE_TRUE(gClientState, NS_ERROR_NOT_INITIALIZED);
+
+    size_t cbStr = strlen(aName) + 1; /* Includes terminator. */
+    const IPCMMSGHDR Hdr = { IPCM_MSG_REQ_QUERY_CLIENT_BY_NAME, IPCM_NewRequestIndex() };
+    RTSGSEG aSegs[2];
+
+    aSegs[0].pvSeg = (void *)&Hdr;
+    aSegs[0].cbSeg = sizeof(Hdr);
+
+    aSegs[1].pvSeg = (void *)aName;
+    aSegs[1].cbSeg = cbStr;
+
+    PIPCMSG pMsg = IPC_MsgNewSg(IPCM_TARGET, cbStr + sizeof(Hdr),
+                                &aSegs[0], RT_ELEMENTS(aSegs));
+
+    PIPCMSG pMsgResp = NULL;
+    nsresult rv = MakeIPCMRequest(pMsg, &pMsgResp);
+    if (NS_FAILED(rv))
+    {
+        /* MakeIPCMRequest may return a failure (e.g. NS_ERROR_CALL_FAILED) and a response msg. */
+        if (pMsgResp)
+            IPC_MsgFree(pMsgResp);
+
+        return rv;
+    }
+
+    if (IPCM_GetType(pMsgResp) == IPCM_MSG_ACK_CLIENT_ID)
+    {
+        PCIPCMMSGCLIENTID pClientId = (PCIPCMMSGCLIENTID)IPCMsgGetPayload(pMsgResp);
+        *aClientID = pClientId->u32ClientId;
+    }
+    else
+    {
+        Log(("unexpected IPCM response: type=%x\n", IPCM_GetType(pMsg)));
+        rv = NS_ERROR_UNEXPECTED;
+    }
+
+    IPC_MsgFree(pMsgResp);
     return rv;
-  }
-
-  if (IPCM_GetType(msg) == IPCM_MSG_ACK_CLIENT_ID)
-    *aClientID = ipcMessageCast<ipcmMessageClientID>(msg)->ClientID();
-  else
-  {
-    Log(("unexpected IPCM response: type=%x\n", IPCM_GetType(msg)));
-    rv = NS_ERROR_UNEXPECTED;
-  }
-
-  delete msg;
-  return rv;
-}
-
-/* ------------------------------------------------------------------------- */
-
-nsresult
-IPC_ClientExists(PRUint32 aClientID, PRBool *aResult)
-{
-  // this is a bit of a hack.  we forward a PING to the specified client.
-  // the assumption is that the forwarding will only succeed if the client
-  // exists, so we wait for the RESULT message corresponding to the FORWARD
-  // request.  if that gives a successful status, then we know that the
-  // client exists.
-
-  ipcmMessagePing ping;
-
-  return MakeIPCMRequest(new ipcmMessageForward(IPCM_MSG_REQ_FORWARD,
-                                                aClientID,
-                                                IPCM_TARGET,
-                                                ping.Data(),
-                                                ping.DataLen()));
-}
+}
+
 
 /* ------------------------------------------------------------------------- */
@@ -1246 +1374 @@
                                          "--inherit-startup-pipe",
                                          &szPipeInheritFd[0], NULL };
-      char c;
 
       ssize_t cch = RTStrFormatU32(&szPipeInheritFd[0], sizeof(szPipeInheritFd),
                                    (uint32_t)RTPipeToNative(hPipeWr), 10 /*uiBase*/,
                                    0 /*cchWidth*/, 0 /*cchPrecision*/, 0 /*fFlags*/);
-      Assert(cch > 0);
+      Assert(cch > 0); RT_NOREF(cch);
 
       RTHANDLE hStdNil;
@@ -1315 +1442 @@
 
 static void
-PlaceOnPendingQ(const nsID &target, ipcTargetData *td, ipcMessage *msg)
+PlaceOnPendingQ(const nsID &target, ipcTargetData *td, PIPCMSG pMsg)
 {
   nsAutoMonitor mon(td->monitor);
@@ -1321 +1448 @@
   // we only want to dispatch a 'ProcessPendingQ' event if we have not
   // already done so.
-  PRBool dispatchEvent = td->pendingQ.IsEmpty();
+  PRBool dispatchEvent = RTListIsEmpty(&td->LstPendingMsgs);
 
   // put this message on our pending queue
-  td->pendingQ.Append(msg);
+  RTListAppend(&td->LstPendingMsgs, &pMsg->NdMsg);
 
 #ifdef LOG_ENABLED
@@ -1350 +1477 @@
   {
     // place a message clone to a target's event queue
-    ipcMessage *msg = (ipcMessage *) userArg;
-    PlaceOnPendingQ(aKey, aData, msg->Clone());
+    PCIPCMSG pMsg = (PCIPCMSG)userArg;
+    PlaceOnPendingQ(aKey, aData, IPC_MsgClone(pMsg));
   }
 
@@ -1360 +1487 @@
 
 // called on a background thread
-void
-IPC_OnMessageAvailable(ipcMessage *msg)
-{
+DECLHIDDEN(void) IPC_OnMessageAvailable(PCIPCMSG pMsg)
+{
+  const nsID target = *IPCMsgGetTarget(pMsg);
+
 #ifdef LOG_ENABLED
   {
-    char *targetStr = msg->Target().ToString();
+    char *targetStr = target.ToString();
     Log(("got message for target: %s\n", targetStr));
     nsMemory::Free(targetStr);
@@ -1373 +1501 @@
 #endif
 
-  if (msg->Target().Equals(IPCM_TARGET))
-  {
-    switch (IPCM_GetType(msg))
-    {
-      // if this is a forwarded message, then post the inner message instead.
+  if (target.Equals(IPCM_TARGET))
+  {
+    switch (IPCM_GetType(pMsg))
+    {
       case IPCM_MSG_PSH_FORWARD:
       {
-        ipcMessageCast<ipcmMessageForward> fwd(msg);
-        ipcMessage *innerMsg = new ipcMessage(fwd->InnerTarget(),
-                                              fwd->InnerData(),
-                                              fwd->InnerDataLen());
-        // store the sender's client id in the meta-data field of the message.
-        innerMsg->mMetaData = fwd->ClientID();
-
-        delete msg;
-
-        // recurse so we can handle forwarded IPCM messages
-        IPC_OnMessageAvailable(innerMsg);
+        PCIPCMMSGFORWARD pFwd = (PCIPCMMSGFORWARD)IPCMsgGetPayload(pMsg);
+
+        /** @todo De-uglify this. */
+        /* Forward the inner message. */
+        IPCMSG InnerMsg; RT_ZERO(InnerMsg);
+        InnerMsg.pMsgHdr = (PIPCMSGHDR)(pFwd + 1);
+        InnerMsg.cbBuf   = InnerMsg.pMsgHdr->cbMsg;
+        InnerMsg.pbBuf   = (uint8_t *)InnerMsg.pMsgHdr;
+        InnerMsg.upUser  = pFwd->u32ClientId;
+
+        /* Recurse to forward the inner message (it will get cloned). */
+        IPC_OnMessageAvailable(&InnerMsg);
         return;
       }
       case IPCM_MSG_PSH_CLIENT_STATE:
       {
-        ipcMessageCast<ipcmMessageClientState> status(msg);
-        PostEventToMainThread(new ipcEvent_ClientState(status->ClientID(),
-                                                       status->ClientState()));
+        PCIPCMMSGCLIENTSTATE pClientState = (PCIPCMMSGCLIENTSTATE)IPCMsgGetPayload(pMsg);
+        PostEventToMainThread(new ipcEvent_ClientState(pClientState->u32ClientId,
+                                                       pClientState->u32ClientStatus));
 
         // go through the target map, and place this message to every target's
@@ -1404 +1532 @@
         // the peer client death, when appropriate.
         RTCritSectRwEnterShared(&gClientState->critSect);
-        gClientState->targetMap.EnumerateRead(EnumerateTargetMapAndPlaceMsg, msg);
+        gClientState->targetMap.EnumerateRead(EnumerateTargetMapAndPlaceMsg, (void *)pMsg);
         RTCritSectRwLeaveShared(&gClientState->critSect);
-
-        delete msg;
         return;
       }
@@ -1414 +1540 @@
 
   nsRefPtr<ipcTargetData> td;
-  if (GetTarget(msg->Target(), getter_AddRefs(td)))
-  {
-    // make copy of target since |msg| may end up pointing to free'd memory
-    // once we notify the monitor inside PlaceOnPendingQ().
-    const nsID target = msg->Target();
-
-    PlaceOnPendingQ(target, td, msg);
+  if (GetTarget(target, getter_AddRefs(td)))
+  {
+    PIPCMSG pClone = IPC_MsgClone(pMsg);
+    PlaceOnPendingQ(target, td, pClone);
   }
   else
-  {
     NS_WARNING("message target is undefined");
-#ifdef VBOX
-    delete msg;
-#endif
-  }
-}
+}

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

@@ -51 +51 @@
 
 
-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
@@ -70 +59 @@
     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));
+    const IPCMMSGRESULT IcpmRes = { { IPCM_MSG_ACK_RESULT, IPCM_GetRequestIndex(pMsg) }, IPCM_OK }; 
+    IPC_SendMsg(pIpcClient, IPCM_TARGET, &IcpmRes, sizeof(IcpmRes));
 }
 
@@ -78 +67 @@
     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));
+    const IPCMMSGCLIENTID IcmpRes = { { IPCM_MSG_ACK_CLIENT_ID, IPCM_GetRequestIndex(pMsg) }, ipcdClientGetId(pIpcClient) };
+    IPC_SendMsg(pIpcClient, IPCM_TARGET, &IcmpRes, sizeof(IcmpRes));
 
     //
@@ -113 +102 @@
         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));
+    const IPCMMSGRESULT IcpmRes = { { IPCM_MSG_ACK_RESULT, requestIndex }, status }; 
+    IPC_SendMsg(pIpcClient, IPCM_TARGET, &IcpmRes, sizeof(IcpmRes));
 }
 
@@ -136 +125 @@
         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));
+    const IPCMMSGRESULT IcpmRes = { { IPCM_MSG_ACK_RESULT, requestIndex }, status }; 
+    IPC_SendMsg(pIpcClient, IPCM_TARGET, &IcpmRes, sizeof(IcpmRes));
 }
 
@@ -156 +145 @@
         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));
+    const IPCMMSGRESULT IcpmRes = { { IPCM_MSG_ACK_RESULT, requestIndex }, status }; 
+    IPC_SendMsg(pIpcClient, IPCM_TARGET, &IcpmRes, sizeof(IcpmRes));
 }
 
@@ -174 +163 @@
     }
 
-    const uint32_t aResp[3] = { IPCM_MSG_ACK_RESULT, IPCM_GetRequestIndex(pMsg), (uint32_t)status };
-    IPC_SendMsg(pIpcClient, IPCM_TARGET, &aResp[0], sizeof(aResp));
+    const IPCMMSGRESULT IcpmRes = { { IPCM_MSG_ACK_RESULT, requestIndex }, status }; 
+    IPC_SendMsg(pIpcClient, IPCM_TARGET, &IcpmRes, sizeof(IcpmRes));
 }
 
@@ -189 +178 @@
     {
         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));
+        const IPCMMSGCLIENTID IcmpRes = { { IPCM_MSG_ACK_CLIENT_ID, requestIndex }, ipcdClientGetId(pIpcClientResult) };
+        IPC_SendMsg(pIpcClient, IPCM_TARGET, &IcmpRes, sizeof(IcmpRes));
     }
     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));
+        const IPCMMSGRESULT IcpmRes = { { IPCM_MSG_ACK_RESULT, requestIndex }, IPCM_ERROR_NO_CLIENT }; 
+        IPC_SendMsg(pIpcClient, IPCM_TARGET, &IcpmRes, sizeof(IcpmRes));
     }
 }
@@ -203 +192 @@
 {
     Log(("got FORWARD\n"));
+
+    PRUint32 requestIndex = IPCM_GetRequestIndex(pMsg);
 
     uint32_t idClient = *(uint32_t *)((uint8_t *)IPCMsgGetPayload(pMsg) + 2 * sizeof(uint32_t));
@@ -209 +200 @@
     {
         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));
+        const IPCMMSGRESULT IcpmRes = { { IPCM_MSG_ACK_RESULT, requestIndex }, IPCM_ERROR_NO_CLIENT }; 
+        IPC_SendMsg(pIpcClient, IPCM_TARGET, &IcpmRes, sizeof(IcpmRes));
         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));
+    const IPCMMSGRESULT IcpmRes = { { IPCM_MSG_ACK_RESULT, requestIndex }, IPCM_OK }; 
+    IPC_SendMsg(pIpcClient, IPCM_TARGET, &IcpmRes, sizeof(IcpmRes));
 
     uint32_t aIpcmFwdHdr[3] = { IPCM_MSG_PSH_FORWARD, IPCM_NewRequestIndex(), ipcdClientGetId(pIpcClient) };

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

@@ -116 +116 @@
     const char lockName[] = "lock";
 
-    int dirLen = strlen(baseDir);
-    int len = dirLen            // baseDir
-            + 1                 // "/"
-            + sizeof(lockName); // "lock"
+    size_t dirLen = strlen(baseDir);
+    size_t len = dirLen            // baseDir
+               + 1                 // "/"
+               + sizeof(lockName); // "lock"
 
     //
@@ -410 +410 @@
     // 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))
+    if (IPCMsgIsFlagSet(pMsg, IPC_MSG_HDR_FLAG_SYNC_QUERY))
     {
         Assert(!ipcdClientGetExpectsSyncReply(pIpcClient));
@@ -432 +432 @@
     // add SYNC_REPLY flag to message if client is expecting...
     if (ipcdClientGetExpectsSyncReply(pIpcClient)) {
-        pMsg->pMsgHdr->u16Flags |= IPC_MSG_FLAG_SYNC_REPLY;
+        pMsg->pMsgHdr->u16Flags |= IPC_MSG_HDR_FLAG_SYNC_REPLY;
         ipcdClientSetExpectsSyncReply(pIpcClient, false);
     }
@@ -591 +591 @@
             // we terminate
             if (status != ELockFileOwner)
-                printf("Cannot create a lock file for '%s'.\n"
-                        "Check permissions.\n", addr.sun_path);
+                RTMsgError("Cannot create a lock file for '%s'.\n"
+                           "Check permissions.\n", addr.sun_path);
             return VERR_INVALID_PARAMETER;
         }

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

@@ -53 +53 @@
 {
     const char *logName;
-    int len;
 
     char *pszDst = buf;

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

@@ -121 +121 @@
     /** Flag whether the message is complete and the buffer is therefore readonly right now. */
     bool                    fReadonly;
+    /** Flag whether the message is living on the stack and shouldn't be freed. */
+    bool                    fStack;
+    /** Some metadata which is up to the user to use. */
+    uintptr_t               upUser;
 } IPCMSG;
 /** Pointer to an IPC message. */
@@ -128 +132 @@
 
 
+DECLINLINE(PIPCMSGHDR) IPCMsgHdrInit(PIPCMSGHDR pMsgHdr, const nsID &target, size_t cbPayload)
+{
+    Assert(cbPayload == (uint32_t)cbPayload);
+
+    pMsgHdr->cbMsg      = sizeof(*pMsgHdr) + (uint32_t)cbPayload;
+    pMsgHdr->u16Version = IPC_MSG_HDR_VERSION;
+    pMsgHdr->u16Flags   = 0;
+    pMsgHdr->idTarget   = target;
+
+    return pMsgHdr;
+} 
+
+
+DECLINLINE(void) IPCMsgInitStack(PIPCMSG pThis, const nsID &target, const void *pvData, size_t cbData)
+{
+    pThis->fStack              = true;
+    pThis->fReadonly           = true;
+    pThis->pbBuf               = (uint8_t *)pvData;
+    pThis->cbBuf               = sizeof(*pThis->pMsgHdr) + cbData;
+    pThis->pMsgHdr             = (PIPCMSGHDR)pThis->pbBuf;
+    pThis->pMsgHdr->cbMsg      = sizeof(*pThis->pMsgHdr) + cbData;
+    pThis->pMsgHdr->u16Version = IPC_MSG_HDR_VERSION;
+    pThis->pMsgHdr->u16Flags   = 0;
+    pThis->pMsgHdr->idTarget   = target;
+}
+
+
 DECLINLINE(int) IPCMsgInit(PIPCMSG pThis, size_t cbBuf)
 {
@@ -155 +186 @@
     if (RT_UNLIKELY(!pThis))
         return NULL;
+
+    pThis->fStack = false;
 
     if (cbMsg)
@@ -180 +213 @@
 DECLINLINE(void) IPCMsgFree(PIPCMSG pThis, bool fFreeStruct)
 {
+    /* Stack based messages are never freed. */
+    if (pThis->fStack)
+        return;
+
     if (pThis->pbBuf)
         RTMemFree(pThis->pbBuf);
@@ -316 +353 @@
 
 /**
+ * Clears the given flag in the message header.
+ *
+ * @param   pThis       The IPC message.
+ * @param   fFlag       The flag to clear.
+ */
+DECLINLINE(void) IPCMsgClearFlag(PIPCMSG pThis, uint16_t fFlag)
+{
+    pThis->pMsgHdr->u16Flags &= ~fFlag;
+}
+
+
+/**
  * Init worker for a given message frame.
  *
@@ -373 +422 @@
 DECLINLINE(int) IPCMsgInitSg(PIPCMSG pThis, const nsID &target, size_t cbTotal, PCRTSGSEG paSegs, uint32_t cSegs)
 {
+    Assert(!pThis->fStack);
+
     uint32_t cbMsg = sizeof(*pThis->pMsgHdr) + cbTotal;
     if (pThis->cbBuf < cbMsg)
@@ -389 +440 @@
 
 
+DECLINLINE(PIPCMSG) IPCMsgClone(PCIPCMSG pThis)
+{
+    size_t cbPayload = pThis->pMsgHdr->cbMsg - sizeof(*pThis->pMsgHdr);
+    PIPCMSG pClone = IPCMsgAlloc(cbPayload);
+    if (!pClone)
+        return NULL;
+
+    pClone->pMsgHdr = (PIPCMSGHDR)pClone->pbBuf;
+    *pClone->pMsgHdr = *pThis->pMsgHdr;
+    pClone->upUser = pThis->upUser;
+    memcpy(pClone->pMsgHdr + 1, pThis->pMsgHdr + 1, cbPayload);
+    return pClone;
+}
+
+
+DECLINLINE(int) IPCMsgCloneWithMsg(PCIPCMSG pThis, PIPCMSG pClone)
+{
+    RTSGSEG Seg;
+    Seg.pvSeg = (void *)IPCMsgGetPayload(pThis);
+    Seg.cbSeg = IPCMsgGetPayloadSize(pThis);
+
+    pClone->upUser = pThis->upUser;
+    return IPCMsgInitSg(pClone, *IPCMsgGetTarget(pThis),
+                        Seg.cbSeg, &Seg, 1 /*cSeg*/);
+}
+
+
 /**
  * Reads data for the given message from the given buffer.
@@ -401 +479 @@
 DECLINLINE(int) IPCMsgReadFrom(PIPCMSG pThis, const void *pvData, size_t cbData, size_t *pcbRead, bool *pfDone)
 {
+    Assert(!pThis->fStack);
+
     size_t cbHdrRead = 0;
     if (!pThis->pMsgHdr)

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

@@ -36 +36 @@
  * ***** END LICENSE BLOCK ***** */
 
-#include <string.h>
 #include "ipcm.h"
 
@@ -49 +48 @@
 };
 
-PRUint32
-IPCM_NewRequestIndex()
+DECLHIDDEN(uint32_t) IPCM_NewRequestIndex()
 {
     static volatile uint32_t sRequestIndex = 0;
     return ASMAtomicIncU32(&sRequestIndex);
 }
-
-#if 0
-
-//
-// MSG_TYPE values
-//
-const PRUint32 ipcmMessagePing::MSG_TYPE = IPCM_MSG_TYPE_PING;
-const PRUint32 ipcmMessageError::MSG_TYPE = IPCM_MSG_TYPE_ERROR;
-const PRUint32 ipcmMessageClientHello::MSG_TYPE = IPCM_MSG_TYPE_CLIENT_HELLO;
-const PRUint32 ipcmMessageClientID::MSG_TYPE = IPCM_MSG_TYPE_CLIENT_ID;
-const PRUint32 ipcmMessageClientInfo::MSG_TYPE = IPCM_MSG_TYPE_CLIENT_INFO;
-const PRUint32 ipcmMessageClientAddName::MSG_TYPE = IPCM_MSG_TYPE_CLIENT_ADD_NAME;
-const PRUint32 ipcmMessageClientDelName::MSG_TYPE = IPCM_MSG_TYPE_CLIENT_DEL_NAME;
-const PRUint32 ipcmMessageClientAddTarget::MSG_TYPE = IPCM_MSG_TYPE_CLIENT_ADD_TARGET;
-const PRUint32 ipcmMessageClientDelTarget::MSG_TYPE = IPCM_MSG_TYPE_CLIENT_DEL_TARGET;
-const PRUint32 ipcmMessageQueryClientByName::MSG_TYPE = IPCM_MSG_TYPE_QUERY_CLIENT_BY_NAME;
-const PRUint32 ipcmMessageQueryClientInfo::MSG_TYPE = IPCM_MSG_TYPE_QUERY_CLIENT_INFO;
-const PRUint32 ipcmMessageForward::MSG_TYPE = IPCM_MSG_TYPE_FORWARD;
-const PRUint32 ipcmMessageClientStatus::MSG_TYPE = IPCM_MSG_TYPE_CLIENT_STATUS;
-
-//
-// CLIENT_INFO message
-//
-//  +-----------------------------------------+
-//  | DWORD : MSG_TYPE                        |
-//  +--------------------+--------------------+
-//  | DWORD : clientID                        |
-//  +--------------------+--------------------+
-//  | DWORD : requestIndex                    |
-//  +--------------------+--------------------+
-//  | WORD : nameStart   | WORD : nameCount   |
-//  +--------------------+--------------------+
-//  | WORD : targetStart | WORD : targetCount |
-//  +--------------------+--------------------+
-//  | name[0]            | (null byte)        |
-//  +--------------------+--------------------+
-//  .                    .                    .
-//  .                    .                    .
-//  +--------------------+--------------------+
-//  | name[count - 1]    | (null byte)        |
-//  +--------------------+--------------------+
-//  | target[0]                               |
-//  +-----------------------------------------+
-//  .                    .                    .
-//  .                    .                    .
-//  +-----------------------------------------+
-//  | target[count - 1]                       |
-//  +-----------------------------------------+
-//
-
-struct ipcmClientInfoHeader
-{
-    PRUint32 mType;
-    PRUint32 mID;
-    PRUint32 mRequestIndex;
-    PRUint16 mNameStart;
-    PRUint16 mNameCount;
-    PRUint16 mTargetStart;
-    PRUint16 mTargetCount;
-};
-
-ipcmMessageClientInfo::ipcmMessageClientInfo(PRUint32 cID, PRUint32 rIdx, const char *names[], const nsID *targets[])
-{
-    ipcmClientInfoHeader hdr = {0};
-
-    hdr.mType = MSG_TYPE;
-    hdr.mID = cID;
-    hdr.mRequestIndex = rIdx;
-    hdr.mNameStart = sizeof(hdr);
-
-    PRUint32 i, namesLen = 0;
-
-    i = 0;
-    while (names[i]) {
-        namesLen += (strlen(names[i]) + 1);
-        ++hdr.mNameCount;
-        ++i;
-    }
-
-    i = 0;
-    while (targets[i]) {
-        ++hdr.mTargetCount;
-        ++i;
-    }
-
-    //
-    // compute target array starting offset
-    //
-    hdr.mTargetStart = hdr.mNameStart + namesLen;
-
-    //
-    // compute message length
-    //
-    PRUint32 dataLen = sizeof(hdr) + namesLen + hdr.mTargetCount * sizeof(nsID);
-
-    Init(IPCM_TARGET, NULL, dataLen);
-    
-    //
-    // write message data
-    //
-    SetData(0, (const char *) &hdr, sizeof(hdr));
-
-    PRUint32 offset = sizeof(hdr);
-
-    for (i = 0; names[i]; ++i) {
-        PRUint32 len = strlen(names[i]) + 1;
-        SetData(offset, names[i], len);
-        offset += len;
-    }
-
-    for (i = 0; targets[i]; ++i) {
-        PRUint32 len = sizeof(nsID);
-        SetData(offset, (const char *) targets[i], len);
-        offset += len;
-    }
-}
-
-PRUint32
-ipcmMessageClientInfo::ClientID() const
-{
-    ipcmClientInfoHeader *hdr = (ipcmClientInfoHeader *) Data();
-    return hdr->mID;
-}
-
-PRUint32
-ipcmMessageClientInfo::RequestIndex() const
-{
-    ipcmClientInfoHeader *hdr = (ipcmClientInfoHeader *) Data();
-    return hdr->mRequestIndex;
-}
-
-PRUint32
-ipcmMessageClientInfo::NameCount() const
-{
-    ipcmClientInfoHeader *hdr = (ipcmClientInfoHeader *) Data();
-    return hdr->mNameCount;
-}
-
-PRUint32
-ipcmMessageClientInfo::TargetCount() const
-{
-    ipcmClientInfoHeader *hdr = (ipcmClientInfoHeader *) Data();
-    return hdr->mTargetCount;
-}
-
-const char *
-ipcmMessageClientInfo::NextName(const char *name) const
-{
-    ipcmClientInfoHeader *hdr = (ipcmClientInfoHeader *) Data();
-
-    if (!name)
-        return (const char *) hdr + hdr->mNameStart;
-
-    name += strlen(name) + 1;
-    if (name == (const char *) hdr + hdr->mTargetStart)
-        name = NULL;
-    return name;
-}
-
-const nsID *
-ipcmMessageClientInfo::NextTarget(const nsID *target) const
-{
-    ipcmClientInfoHeader *hdr = (ipcmClientInfoHeader *) Data();
-
-    if (!target)
-        return (const nsID *) (Data() + hdr->mTargetStart);
-
-    if (++target == (const nsID *) (MsgBuf() + MsgLen()))
-        target = NULL;
-    return target;
-}
-#endif
-
-//
-// FORWARD message
-//
-//  +-------------------------+
-//  | DWORD : MSG_TYPE        |
-//  +-------------------------+
-//  | clientID                |
-//  +-------------------------+
-//  | innerMsgHeader          |
-//  +-------------------------+
-//  | innerMsgData            |
-//  +-------------------------+
-//
-
-ipcmMessageForward::ipcmMessageForward(PRUint32 type,
-                                       PRUint32 cID,
-                                       const nsID &target,
-                                       const char *data,
-                                       PRUint32 dataLen)
-{
-    int len = sizeof(ipcmMessageHeader) +  // IPCM header
-              sizeof(cID) +                // cID
-              IPC_MSG_HEADER_SIZE +        // innerMsgHeader
-              dataLen;                     // innerMsgData
-
-    Init(IPCM_TARGET, NULL, len);
-
-    ipcmMessageHeader ipcmHdr =
-        { type, IPCM_NewRequestIndex() };
-
-    SetData(0, (char *) &ipcmHdr, sizeof(ipcmHdr));
-    SetData(sizeof(ipcmHdr), (char *) &cID, sizeof(cID));
-
-    ipcMessageHeader hdr;
-    hdr.mLen = IPC_MSG_HEADER_SIZE + dataLen;
-    hdr.mVersion = IPC_MSG_VERSION;
-    hdr.mFlags = 0;
-    hdr.mTarget = target;
-
-    SetData(sizeof(ipcmHdr) + sizeof(cID), (char *) &hdr, IPC_MSG_HEADER_SIZE);
-    if (data)
-        SetInnerData(0, data, dataLen);
-}
-
-void
-ipcmMessageForward::SetInnerData(PRUint32 offset, const char *data, PRUint32 dataLen)
-{
-    SetData(sizeof(ipcmMessageHeader) + 4 + IPC_MSG_HEADER_SIZE + offset, data, dataLen);
-}
-
-PRUint32
-ipcmMessageForward::ClientID() const
-{
-    return ((PRUint32 *) Data())[2];
-}
-
-const nsID &
-ipcmMessageForward::InnerTarget() const
-{
-    ipcMessageHeader *hdr = (ipcMessageHeader *) (Data() + 12);
-    return hdr->mTarget;
-}
-
-const char *
-ipcmMessageForward::InnerData() const
-{
-    return Data() + 12 + IPC_MSG_HEADER_SIZE;
-}
-
-PRUint32
-ipcmMessageForward::InnerDataLen() const
-{
-    ipcMessageHeader *hdr = (ipcMessageHeader *) (Data() + 12);
-    return hdr->mLen - IPC_MSG_HEADER_SIZE;
-}

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

@@ -41 +41 @@
 #include <iprt/assertcompile.h>
 
-#include "ipcMessage.h"
-#include "ipcMessagePrimitives.h"
+#include "ipcMessageNew.h"
 
 //-----------------------------------------------------------------------------
@@ -115 +114 @@
 // IPCM header
 //
-struct ipcmMessageHeader
-{
-    PRUint32 mType;
-    PRUint32 mRequestIndex;
-};
-AssertCompileSize(struct ipcmMessageHeader, 8);
-
-//
-// returns IPCM message type.
-//
-static inline int
-IPCM_GetType(const ipcMessage *msg)
-{
-    return ((const ipcmMessageHeader *) msg->Data())->mType;
-}
-
-//
-// return IPCM message request index.
-//
-static inline PRUint32
-IPCM_GetRequestIndex(const ipcMessage *msg)
-{
-    return ((const ipcmMessageHeader *) msg->Data())->mRequestIndex;
-}
+typedef struct IPCMMSGHDR
+{
+    uint32_t u32Type;
+    uint32_t u32RequestIndex;
+} IPCMMSGHDR;
+AssertCompileSize(struct IPCMMSGHDR, 8);
+/** Pointer to an IPCM header. */
+typedef IPCMMSGHDR *PIPCMMSGHDR;
+/** Pointer to a const IPCM header. */
+typedef const IPCMMSGHDR *PCIPCMMSGHDR;
+
+
+DECLINLINE(uint32_t) IPCM_GetType(PCIPCMSG pMsg)
+{
+    return ((PCIPCMMSGHDR)IPCMsgGetPayload(pMsg))->u32Type;
+}
+
+
+DECLINLINE(uint32_t) IPCM_GetRequestIndex(PCIPCMSG pMsg)
+{
+    return ((PCIPCMMSGHDR)IPCMsgGetPayload(pMsg))->u32RequestIndex;
+}
+
 
 //
 // return a request index that is unique to this process.
 //
-NS_HIDDEN_(PRUint32)
-IPCM_NewRequestIndex();
+DECLHIDDEN(uint32_t) IPCM_NewRequestIndex();
 
 //-----------------------------------------------------------------------------
@@ -322 +319 @@
 //
 
-//-----------------------------------------------------------------------------
-
-//
-// NOTE: This file declares some helper classes that simplify constructing
-//       and parsing IPCM messages.  Each class subclasses ipcMessage, but
-//       adds no additional member variables.  |operator new| should be used
-//       to allocate one of the IPCM helper classes, e.g.:
-//
-//          ipcMessage *msg = new ipcmMessageClientHello("foo");
-//
-//       Given an arbitrary ipcMessage, it can be parsed using logic similar
-//       to the following:
-//
-//          void func(const ipcMessage *unknown)
-//          {
-//            if (unknown->Topic().Equals(IPCM_TARGET)) {
-//              if (IPCM_GetMsgType(unknown) == IPCM_MSG_TYPE_CLIENT_ID) {
-//                ipcMessageCast<ipcmMessageClientID> msg(unknown);
-//                printf("Client ID: %u\n", msg->ClientID());
-//              }
-//            }
-//          }
-//
-
 // REQUESTS
 
-class ipcmMessagePing : public ipcMessage_DWORD_DWORD
-{
-public:
-    ipcmMessagePing()
-        : ipcMessage_DWORD_DWORD(
-            IPCM_TARGET,
-            IPCM_MSG_REQ_PING,
-            IPCM_NewRequestIndex()) {}
-};
-
-class ipcmMessageForward : public ipcMessage
-{
-public:
-    // @param type        the type of this message: IPCM_MSG_{REQ,PSH}_FORWARD
-    // @param clientID    the client id of the sender or receiver
-    // @param target      the message target
-    // @param data        the message data
-    // @param dataLen     the message data length
-    ipcmMessageForward(PRUint32 type,
-                       PRUint32 clientID,
-                       const nsID &target,
-                       const char *data,
-                       PRUint32 dataLen) NS_HIDDEN;
-
-    // set inner message data, constrained to the data length passed
-    // to this class's constructor.
-    NS_HIDDEN_(void) SetInnerData(PRUint32 offset, const char *data, PRUint32 dataLen);
-
-    NS_HIDDEN_(PRUint32)     ClientID() const;
-    NS_HIDDEN_(const nsID &) InnerTarget() const;
-    NS_HIDDEN_(const char *) InnerData() const;
-    NS_HIDDEN_(PRUint32)     InnerDataLen() const;
-};
-
-class ipcmMessageClientHello : public ipcMessage_DWORD_DWORD
-{
-public:
-    ipcmMessageClientHello()
-        : ipcMessage_DWORD_DWORD(
-            IPCM_TARGET,
-            IPCM_MSG_REQ_CLIENT_HELLO,
-            IPCM_NewRequestIndex()) {}
-};
-
-class ipcmMessageClientAddName : public ipcMessage_DWORD_DWORD_STR
-{
-public:
-    ipcmMessageClientAddName(const char *name)
-        : ipcMessage_DWORD_DWORD_STR(
-            IPCM_TARGET,
-            IPCM_MSG_REQ_CLIENT_ADD_NAME,
-            IPCM_NewRequestIndex(),
-            name) {}
-
-    const char *Name() const { return Third(); }
-};
-
-class ipcmMessageClientDelName : public ipcMessage_DWORD_DWORD_STR
-{
-public:
-    ipcmMessageClientDelName(const char *name)
-        : ipcMessage_DWORD_DWORD_STR(
-            IPCM_TARGET,
-            IPCM_MSG_REQ_CLIENT_DEL_NAME,
-            IPCM_NewRequestIndex(),
-            name) {}
-
-    const char *Name() const { return Third(); }
-};
-
-class ipcmMessageClientAddTarget : public ipcMessage_DWORD_DWORD_ID
-{
-public:
-    ipcmMessageClientAddTarget(const nsID &target)
-        : ipcMessage_DWORD_DWORD_ID(
-            IPCM_TARGET,
-            IPCM_MSG_REQ_CLIENT_ADD_TARGET,
-            IPCM_NewRequestIndex(),
-            target) {}
-
-    const nsID &Target() const { return Third(); }
-};
-
-class ipcmMessageClientDelTarget : public ipcMessage_DWORD_DWORD_ID
-{
-public:
-    ipcmMessageClientDelTarget(const nsID &target)
-        : ipcMessage_DWORD_DWORD_ID(
-            IPCM_TARGET,
-            IPCM_MSG_REQ_CLIENT_ADD_TARGET,
-            IPCM_NewRequestIndex(),
-            target) {}
-
-    const nsID &Target() const { return Third(); }
-};
-
-class ipcmMessageQueryClientByName : public ipcMessage_DWORD_DWORD_STR
-{
-public:
-    ipcmMessageQueryClientByName(const char *name)
-        : ipcMessage_DWORD_DWORD_STR(
-            IPCM_TARGET,
-            IPCM_MSG_REQ_QUERY_CLIENT_BY_NAME,
-            IPCM_NewRequestIndex(),
-            name) {}
-
-    const char *Name() const { return Third(); }
-    PRUint32 RequestIndex() const { return Second(); }
-};
+/** The ping message consists of just the header. */
+typedef IPCMMSGHDR IPCMMSGPING;
+typedef IPCMMSGPING *PIPCMMSGPING;
+
+DECLINLINE(void) IPCMMsgPingInit(PIPCMMSGPING pThis)
+{
+    pThis->u32Type         = IPCM_MSG_REQ_PING;
+    pThis->u32RequestIndex = IPCM_NewRequestIndex();
+}
+
+
+/** The client hello message consists of just the header. */
+typedef IPCMMSGHDR IPCMMSGCLIENTHELLO;
+typedef IPCMMSGCLIENTHELLO *PIPCMMSGCLIENTHELLO;
+
+DECLINLINE(void) IPCMMsgClientHelloInit(PIPCMMSGCLIENTHELLO pThis)
+{
+    pThis->u32Type         = IPCM_MSG_REQ_CLIENT_HELLO;
+    pThis->u32RequestIndex = IPCM_NewRequestIndex();
+}
+
+
+typedef struct IPCMMSGFORWARD
+{
+    IPCMMSGHDR          Hdr;
+    uint32_t            u32ClientId;
+} IPCMMSGFORWARD;
+AssertCompileSize(IPCMMSGFORWARD, 3 * sizeof(uint32_t));
+typedef IPCMMSGFORWARD *PIPCMMSGFORWARD;
+typedef const IPCMMSGFORWARD *PCIPCMMSGFORWARD;
+
+
+DECLINLINE(int) ipcmMsgInitHdrStr(PIPCMSG pMsg, uint32_t u32Type, const char *psz)
+{
+    size_t cbStr = strlen(psz) + 1; /* Includes terminator. */
+    const IPCMMSGHDR Hdr = { u32Type, IPCM_NewRequestIndex() };
+    RTSGSEG aSegs[2];
+
+    aSegs[0].pvSeg = (void *)&Hdr;
+    aSegs[0].cbSeg = sizeof(Hdr);
+
+    aSegs[1].pvSeg = (void *)psz;
+    aSegs[1].cbSeg = cbStr;
+    return IPCMsgInitSg(pMsg, IPCM_TARGET, cbStr + sizeof(Hdr), &aSegs[0], RT_ELEMENTS(aSegs));
+}
+
+
+DECLINLINE(int) IPCMMsgClientAddNameInit(PIPCMSG pMsg, const char *pszName)
+{
+    return ipcmMsgInitHdrStr(pMsg, IPCM_MSG_REQ_CLIENT_ADD_NAME, pszName);
+}
+
+
+DECLINLINE(int) IPCMMsgClientDelNameInit(PIPCMSG pMsg, const char *pszName)
+{
+    return ipcmMsgInitHdrStr(pMsg, IPCM_MSG_REQ_CLIENT_DEL_NAME, pszName);
+}
+
+
+typedef struct IPCMMSGCLIENTADDDELTARGET
+{
+    IPCMMSGHDR          Hdr;
+    nsID                idTarget;
+} IPCMMSGCLIENTADDDELTARGET;
+AssertCompileSize(IPCMMSGCLIENTADDDELTARGET, 2 * sizeof(uint32_t) + sizeof(nsID));
+typedef IPCMMSGCLIENTADDDELTARGET *PIPCMMSGCLIENTADDDELTARGET;
+typedef const IPCMMSGCLIENTADDDELTARGET *PCIPCMMSGCLIENTADDDELTARGET;
+
+DECLINLINE(void) IPCMMsgAddTargetInit(PIPCMMSGCLIENTADDDELTARGET pThis, const nsID &target)
+{
+    pThis->Hdr.u32Type         = IPCM_MSG_REQ_CLIENT_ADD_TARGET;
+    pThis->Hdr.u32RequestIndex = IPCM_NewRequestIndex();
+    pThis->idTarget            = target;
+}
+
+
+DECLINLINE(void) IPCMMsgDelTargetInit(PIPCMMSGCLIENTADDDELTARGET pThis, const nsID &target)
+{
+    pThis->Hdr.u32Type         = IPCM_MSG_REQ_CLIENT_DEL_TARGET;
+    pThis->Hdr.u32RequestIndex = IPCM_NewRequestIndex();
+    pThis->idTarget            = target;
+}
+
+
+DECLINLINE(int) IPCMMsgQueryClientByNameInit(PIPCMSG pMsg, const char *pszName)
+{
+    return ipcmMsgInitHdrStr(pMsg, IPCM_MSG_REQ_QUERY_CLIENT_BY_NAME, pszName);
+}
+
 
 // ACKNOWLEDGEMENTS
 
-class ipcmMessageResult : public ipcMessage_DWORD_DWORD_DWORD
-{
-public:
-    ipcmMessageResult(PRUint32 requestIndex, PRInt32 status)
-        : ipcMessage_DWORD_DWORD_DWORD(
-            IPCM_TARGET,
-            IPCM_MSG_ACK_RESULT,
-            requestIndex,
-            (PRUint32) status) {}
-
-    PRInt32 Status() const { return (PRInt32) Third(); }
-};
-
-class ipcmMessageClientID : public ipcMessage_DWORD_DWORD_DWORD
-{
-public:
-    ipcmMessageClientID(PRUint32 requestIndex, PRUint32 clientID)
-        : ipcMessage_DWORD_DWORD_DWORD(
-            IPCM_TARGET,
-            IPCM_MSG_ACK_CLIENT_ID,
-            requestIndex,
-            clientID) {}
-
-    PRUint32 ClientID() const { return Third(); }
-};
+typedef struct IPCMMSGRESULT
+{
+    IPCMMSGHDR          Hdr;
+    int32_t             i32Status;
+} IPCMMSGRESULT;
+AssertCompileSize(IPCMMSGRESULT, 3 * sizeof(uint32_t));
+typedef IPCMMSGRESULT *PIPCMMSGRESULT;
+typedef const IPCMMSGRESULT *PCIPCMMSGRESULT;
+
+typedef struct IPCMMSGCLIENTID
+{
+    IPCMMSGHDR          Hdr;
+    uint32_t            u32ClientId;
+} IPCMMSGCLIENTID;
+AssertCompileSize(IPCMMSGCLIENTID, 3 * sizeof(uint32_t));
+typedef IPCMMSGCLIENTID *PIPCMMSGCLIENTID;
+typedef const IPCMMSGCLIENTID *PCIPCMMSGCLIENTID;
+
 
 // PUSH MESSAGES
 
-class ipcmMessageClientState : public ipcMessage_DWORD_DWORD_DWORD_DWORD
-{
-public:
-    ipcmMessageClientState(PRUint32 clientID, PRUint32 clientStatus)
-        : ipcMessage_DWORD_DWORD_DWORD_DWORD(
-            IPCM_TARGET,
-            IPCM_MSG_PSH_CLIENT_STATE,
-            0,
-            clientID,
-            clientStatus) {}
-
-    PRUint32 ClientID() const { return Third(); }
-    PRUint32 ClientState() const { return Fourth(); }
-};
+typedef struct IPCMMSGCLIENTSTATE
+{
+    IPCMMSGHDR          Hdr;
+    uint32_t            u32ClientId;
+    uint32_t            u32ClientStatus;
+} IPCMMSGCLIENTSTATE;
+AssertCompileSize(IPCMMSGCLIENTSTATE, 4 * sizeof(uint32_t));
+typedef IPCMMSGCLIENTSTATE *PIPCMMSGCLIENTSTATE;
+typedef const IPCMMSGCLIENTSTATE *PCIPCMMSGCLIENTSTATE;
+
+/**
+ * Helper structure for stack based messages.
+ */
+typedef struct IPCMMSGSTACK
+{
+    IPCMSGHDR                       Hdr;
+    union
+    {
+        IPCMMSGHDR                  Hdr;
+        IPCMMSGPING                 Ping;
+        IPCMMSGCLIENTHELLO          ClientHello;
+        IPCMMSGCLIENTADDDELTARGET   AddDelTarget;
+        IPCMMSGRESULT               Result;
+        IPCMMSGCLIENTID             ClientId;
+        IPCMMSGCLIENTSTATE          ClientState;
+    } Ipcm;
+} IPCMMSGSTACK;
 
 #endif // !ipcm_h__