Changeset 49349 in vbox for trunk/src/VBox/Main/src-client

Timestamp:

Oct 31, 2013 4:40:46 PM (12 years ago)

Author:

vboxsync

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

90367

Message:

Guest Control:

• Implemented IGuestSession::DirectoryRemove, IGuestSession::DirectoryRemoveRecursive, IGuestSession::DirectoryRename + IGuestSession::FileRename.
• Added appropriate commands to VBoxManage (basic support for now).
• Implemented support for proper guest session process termination via SCM.
• Implemented support for internal anonymous wait events which are not relying on the public API's VBoxEventType_T.
• Various bugfixes.

Location:

trunk/src/VBox/Main/src-client

Files:

• GuestCtrlImpl.cpp (modified) (6 diffs)
• GuestCtrlPrivate.cpp (modified) (13 diffs)
• GuestDirectoryImpl.cpp (modified) (10 diffs)
• GuestFileImpl.cpp (modified) (17 diffs)
• GuestProcessImpl.cpp (modified) (47 diffs)
• GuestSessionImpl.cpp (modified) (30 diffs)
• GuestSessionImplTasks.cpp (modified) (1 diff)

trunk/src/VBox/Main/src-client/GuestCtrlImpl.cpp

@@ -297 +297 @@
                     break;
 
-                case GUEST_SESSION_NOTIFY:
-                    rc = pSession->dispatchToThis(pCtxCb, pSvcCb);
-                    break;
-
                 case GUEST_EXEC_STATUS:
                 case GUEST_EXEC_OUTPUT:
@@ -312 +308 @@
                     break;
 
+                case GUEST_SESSION_NOTIFY:
+                    rc = pSession->dispatchToThis(pCtxCb, pSvcCb);
+                    break;
+
                 default:
-                    rc = VERR_NOT_SUPPORTED;
+                    rc = pSession->dispatchToObject(pCtxCb, pSvcCb);
+                    if (rc == VERR_NOT_FOUND)
+                    {
+                        AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+                        rc = pSession->dispatchGeneric(pCtxCb, pSvcCb);
+                    }
+#ifndef DEBUG_andy
+                    if (rc == VERR_NOT_IMPLEMENTED)
+                        AssertMsgFailed(("Received not handled function %RU32\n", pCtxCb->uFunction));
+#endif
                     break;
             }
@@ -323 +333 @@
         rc = VERR_NOT_FOUND;
 
-    LogFlowThisFunc(("Returning rc=%Rrc\n", rc));
+    LogFlowFuncLeaveRC(rc);
     return rc;
 }
@@ -329 +339 @@
 int Guest::sessionRemove(GuestSession *pSession)
 {
+    AssertPtrReturn(pSession, VERR_INVALID_POINTER);
+
     LogFlowThisFuncEnter();
 
@@ -364 +376 @@
     }
 
-    LogFlowThisFunc(("Returning rc=%Rrc\n", rc));
+    LogFlowFuncLeaveRC(rc);
     return rc;
 }
@@ -445 +457 @@
     }
 
-    LogFlowThisFunc(("Returning rc=%Rrc\n", rc));
+    LogFlowFuncLeaveRC(rc);
     return rc;
 }

trunk/src/VBox/Main/src-client/GuestCtrlPrivate.cpp

@@ -680 +680 @@
 
 /**
- * Returns the current offset of the parser within
- * the internal data buffer.
- *
- * @return  uint32_t            Parser offset.
- */
-uint32_t GuestProcessStream::GetOffset()
-{
-    return m_cbOffset;
-}
-
-uint32_t GuestProcessStream::GetSize()
-{
-    return m_cbSize;
-}
-
-/**
  * Tries to parse the next upcoming pair block within the internal
  * buffer.
@@ -814 +798 @@
     if (RT_SUCCESS(rc))
     {
-        GuestWaitEventTypes::iterator itEventTypes = mWaitEvents.begin();
-        while (itEventTypes != mWaitEvents.end())
-        {
-            GuestWaitEvents::iterator itEvents = itEventTypes->second.begin();
-            while (itEvents != itEventTypes->second.end())
+        GuestEventGroup::iterator itEventGroups = mWaitEventGroups.begin();
+        while (itEventGroups != mWaitEventGroups.end())
+        {
+            GuestWaitEvents::iterator itEvents = itEventGroups->second.begin();
+            while (itEvents != itEventGroups->second.end())
             {
-                GuestWaitEvent *pEvent = (*itEvents);
+                GuestWaitEvent *pEvent = itEvents->second;
                 AssertPtr(pEvent);
 
                 /*
-                 * Just cancel the event and remove it from the wait events
-                 * map. Don't delete it though, this (hopefully) is done by
-                 * the caller using unregisterWaitEvent().
+                 * Just cancel the event, but don't remove it from the
+                 * wait events map. Don't delete it though, this (hopefully)
+                 * is done by the caller using unregisterWaitEvent().
                  */
-                int rc2 = pEvent->Signal(NULL /* Cancel */);
+                int rc2 = pEvent->Cancel();
                 AssertRC(rc2);
-                itEvents = itEventTypes->second.erase(itEvents);
+
+                itEvents++;
             }
 
-            mWaitEvents.erase(itEventTypes);
-            itEventTypes = mWaitEvents.begin();
+            itEventGroups++;
         }
 
@@ -846 +830 @@
 }
 
+int GuestBase::dispatchGeneric(PVBOXGUESTCTRLHOSTCBCTX pCtxCb, PVBOXGUESTCTRLHOSTCALLBACK pSvcCb)
+{
+    LogFlowFunc(("pCtxCb=%p, pSvcCb=%p\n", pCtxCb, pSvcCb));
+
+    AssertPtrReturn(pCtxCb, VERR_INVALID_POINTER);
+    AssertPtrReturn(pSvcCb, VERR_INVALID_POINTER);
+
+    int vrc = VINF_SUCCESS;
+
+    try
+    {
+        LogFlowFunc(("uFunc=%RU32, cParms=%RU32\n",
+                     pCtxCb->uFunction, pSvcCb->mParms));
+
+        switch (pCtxCb->uFunction)
+        {
+            case GUEST_MSG_PROGRESS_UPDATE:
+                break;
+
+            case GUEST_MSG_REPLY:
+            {
+                if (pSvcCb->mParms >= 3)
+                {
+                    int idx = 1; /* Current parameter index. */
+                    CALLBACKDATA_MSG_REPLY dataCb;
+                    /* pSvcCb->mpaParms[0] always contains the context ID. */
+                    vrc = pSvcCb->mpaParms[idx++].getUInt32(&dataCb.uType);
+                    AssertRCReturn(vrc, vrc);
+                    vrc = pSvcCb->mpaParms[idx++].getUInt32(&dataCb.rc);
+                    AssertRCReturn(vrc, vrc);
+                    vrc = pSvcCb->mpaParms[idx++].getPointer(&dataCb.pvPayload, &dataCb.cbPayload);
+                    AssertRCReturn(vrc, vrc);
+
+                    GuestWaitEventPayload evPayload(dataCb.uType, dataCb.pvPayload, dataCb.cbPayload);
+                    int rc2 = signalWaitEventInternal(pCtxCb, dataCb.rc, &evPayload);
+                    AssertRC(rc2);
+                }
+                else
+                    vrc = VERR_INVALID_PARAMETER;
+                break;
+            }
+
+            default:
+                vrc = VERR_NOT_SUPPORTED;
+                break;
+        }
+    }
+    catch (std::bad_alloc)
+    {
+        vrc = VERR_NO_MEMORY;
+    }
+    catch (int rc)
+    {
+        vrc = rc;
+    }
+
+    LogFlowFuncLeaveRC(vrc);
+    return vrc;
+}
+
 int GuestBase::generateContextID(uint32_t uSessionID, uint32_t uObjectID, uint32_t *puContextID)
 {
@@ -869 +913 @@
 
 int GuestBase::registerWaitEvent(uint32_t uSessionID, uint32_t uObjectID,
-                                 const std::list<VBoxEventType_T> &lstEvents,
+                                 GuestWaitEvent **ppEvent)
+{
+    GuestEventTypes eventTypesEmpty;
+    return registerWaitEvent(uSessionID, uObjectID, eventTypesEmpty, ppEvent);
+}
+
+int GuestBase::registerWaitEvent(uint32_t uSessionID, uint32_t uObjectID,
+                                 const GuestEventTypes &lstEvents,
                                  GuestWaitEvent **ppEvent)
 {
@@ -887 +938 @@
             AssertPtr(pEvent);
 
-            for (std::list<VBoxEventType_T>::const_iterator itEvents = lstEvents.begin();
+            /* Insert event into matching event group. This is for faster per-group
+             * lookup of all events later. */
+            for (GuestEventTypes::const_iterator itEvents = lstEvents.begin();
                  itEvents != lstEvents.end(); itEvents++)
             {
-                mWaitEvents[(*itEvents)].push_back(pEvent);
+                mWaitEventGroups[(*itEvents)].insert(
+                   std::pair<uint32_t, GuestWaitEvent*>(uContextID, pEvent));
+                /** @todo Check for key collision. */
             }
+
+            /* Register event in regular event list. */
+            /** @todo Check for key collisions. */
+            mWaitEvents[uContextID] = pEvent;
 
             *ppEvent = pEvent;
@@ -908 +967 @@
 }
 
-int GuestBase::signalWaitEvents(VBoxEventType_T aType, IEvent *aEvent)
+int GuestBase::signalWaitEvent(VBoxEventType_T aType, IEvent *aEvent)
 {
     int rc = RTCritSectEnter(&mWaitEventCritSect);
+#ifdef DEBUG
+    uint32_t cEvents = 0;
+#endif
     if (RT_SUCCESS(rc))
     {
-        GuestWaitEventTypes::iterator itTypes = mWaitEvents.find(aType);
-        if (itTypes != mWaitEvents.end())
-        {
-            for (GuestWaitEvents::iterator itEvents = itTypes->second.begin();
-                 itEvents != itTypes->second.end(); itEvents++)
+        GuestEventGroup::iterator itGroups = mWaitEventGroups.find(aType);
+        if (itGroups != mWaitEventGroups.end())
+        {
+            for (GuestWaitEvents::iterator itEvents = itGroups->second.begin();
+                 itEvents != itGroups->second.end(); itEvents++)
             {
-                LogFlowThisFunc(("Signalling event=%p with type=%ld ...\n",
-                                 (*itEvents), aType));
-
+#ifdef DEBUG
+                LogFlowThisFunc(("Signalling event=%p, type=%ld (CID %RU32: Sesion=%RU32, Object=%RU32, Count=%RU32) ...\n",
+                                 itEvents->second, aType, itEvents->first,
+                                 VBOX_GUESTCTRL_CONTEXTID_GET_SESSION(itEvents->first),
+                                 VBOX_GUESTCTRL_CONTEXTID_GET_OBJECT(itEvents->first),
+                                 VBOX_GUESTCTRL_CONTEXTID_GET_COUNT(itEvents->first)));
+#endif
                 ComPtr<IEvent> pThisEvent = aEvent;
                 Assert(!pThisEvent.isNull());
-                int rc2 = (*itEvents)->Signal(aEvent);
+                int rc2 = itEvents->second->SignalExternal(aEvent);
                 if (RT_SUCCESS(rc))
                     rc = rc2;
+#ifdef DEBUG
+                cEvents++;
+#endif
             }
         }
@@ -935 +1004 @@
     }
 
-    return rc;
+#ifdef DEBUG
+    LogFlowThisFunc(("Signalled %RU32 events, rc=%Rrc\n", cEvents, rc));
+#endif
+    return rc;
+}
+
+int GuestBase::signalWaitEventInternal(PVBOXGUESTCTRLHOSTCBCTX pCbCtx,
+                                       int guestRc, const GuestWaitEventPayload *pPayload)
+{
+    if (RT_SUCCESS(guestRc))
+        return signalWaitEventInternalEx(pCbCtx, VINF_SUCCESS,
+                                         0 /* Guest rc */, pPayload);
+
+    return signalWaitEventInternalEx(pCbCtx, VERR_GSTCTL_GUEST_ERROR,
+                                     guestRc, pPayload);
+}
+
+int GuestBase::signalWaitEventInternalEx(PVBOXGUESTCTRLHOSTCBCTX pCbCtx,
+                                         int rc, int guestRc,
+                                         const GuestWaitEventPayload *pPayload)
+{
+    AssertPtrReturn(pCbCtx, VERR_INVALID_POINTER);
+    /* pPayload is optional. */
+
+    int rc2;
+    GuestWaitEvents::iterator itEvent = mWaitEvents.find(pCbCtx->uContextID);
+    if (itEvent != mWaitEvents.end())
+    {
+        LogFlowThisFunc(("Signalling event=%p (CID %RU32, rc=%Rrc, guestRc=%Rrc, pPayload=%p) ...\n",
+                         itEvent->second, itEvent->first, rc, guestRc, pPayload));
+        GuestWaitEvent *pEvent = itEvent->second;
+        AssertPtr(pEvent);
+        rc2 = pEvent->SignalInternal(rc, guestRc, pPayload);
+    }
+    else
+        rc2 = VERR_NOT_FOUND;
+
+    return rc2;
 }
 
@@ -946 +1052 @@
     if (RT_SUCCESS(rc))
     {
-        const std::list<VBoxEventType_T> lstTypes = pEvent->Types();
-        for (std::list<VBoxEventType_T>::const_iterator itEvents = lstTypes.begin();
+        const GuestEventTypes lstTypes = pEvent->Types();
+        for (GuestEventTypes::const_iterator itEvents = lstTypes.begin();
              itEvents != lstTypes.end(); itEvents++)
         {
             /** @todo Slow O(n) lookup. Optimize this. */
-            GuestWaitEvents::iterator itCurEvent = mWaitEvents[(*itEvents)].begin();
-            while (itCurEvent != mWaitEvents[(*itEvents)].end())
+            GuestWaitEvents::iterator itCurEvent = mWaitEventGroups[(*itEvents)].begin();
+            while (itCurEvent != mWaitEventGroups[(*itEvents)].end())
             {
-             if ((*itCurEvent) == pEvent)
+             if (itCurEvent->second == pEvent)
              {
-                 itCurEvent = mWaitEvents[(*itEvents)].erase(itCurEvent);
+                 itCurEvent = mWaitEventGroups[(*itEvents)].erase(itCurEvent);
                  break;
              }
@@ -973 +1079 @@
 }
 
+/**
+ * Waits for a formerly registered guest event.
+ *
+ * @return  IPRT status code.
+ * @param   pEvent                  Pointer to event to wait for.
+ * @param   uTimeoutMS              Timeout (in ms) for waiting.
+ * @param   pType                   Event type of following IEvent.
+ *                                  Optional.
+ * @param   ppEvent                 Pointer to IEvent which got triggered
+ *                                  for this event. Optional.
+ */
 int GuestBase::waitForEvent(GuestWaitEvent *pEvent, uint32_t uTimeoutMS,
                             VBoxEventType_T *pType, IEvent **ppEvent)
 {
     AssertPtrReturn(pEvent, VERR_INVALID_POINTER);
+    /* pType is optional. */
+    /* ppEvent is optional. */
 
     int vrc = pEvent->Wait(uTimeoutMS);
@@ -982 +1101 @@
     {
         const ComPtr<IEvent> pThisEvent = pEvent->Event();
-        Assert(!pThisEvent.isNull());
-
-        if (pType)
-        {
-            HRESULT hr = pThisEvent->COMGETTER(Type)(pType);
-            if (FAILED(hr))
-                vrc = VERR_COM_UNEXPECTED;
-        }
-        if (   RT_SUCCESS(vrc)
-            && ppEvent)
-            pThisEvent.queryInterfaceTo(ppEvent);
-
-        unconst(pThisEvent).setNull();
+        if (!pThisEvent.isNull()) /* Having a VBoxEventType_ event is optional. */
+        {
+            if (pType)
+            {
+                HRESULT hr = pThisEvent->COMGETTER(Type)(pType);
+                if (FAILED(hr))
+                    vrc = VERR_COM_UNEXPECTED;
+            }
+            if (   RT_SUCCESS(vrc)
+                && ppEvent)
+                pThisEvent.queryInterfaceTo(ppEvent);
+
+            unconst(pThisEvent).setNull();
+        }
     }
 
@@ -1022 +1142 @@
 }
 
-int GuestObject::registerWaitEvent(const std::list<VBoxEventType_T> &lstEvents,
+int GuestObject::registerWaitEvent(const GuestEventTypes &lstEvents,
                                    GuestWaitEvent **ppEvent)
 {
@@ -1058 +1178 @@
 }
 
-GuestWaitEvent::GuestWaitEvent(uint32_t uCID,
-                               const std::list<VBoxEventType_T> &lstEvents)
-    : fAborted(false),
-      mCID(uCID),
-      mEventTypes(lstEvents),
-      mEventSem(NIL_RTSEMEVENT)
-{
-    int rc = RTSemEventCreate(&mEventSem);
-    AssertRC(rc);
-    /** @todo Throw an exception on failure! */
-}
-
-GuestWaitEvent::~GuestWaitEvent(void)
-{
-}
-
-/**
- * Signals the event. Passing NULL will abort (cancel)
- * the event.
- *
- * @return  IPRT status code.
- * @param   pEvent              IEvent to associate.
- */
-int GuestWaitEvent::Signal(IEvent *pEvent)
-{
-    AssertReturn(mEventSem != NIL_RTSEMEVENT, VERR_CANCELLED);
-
-    if (pEvent)
-        mEvent = pEvent;
+GuestWaitEventBase::GuestWaitEventBase(void)
+    : mCID(0),
+      mEventSem(NIL_RTSEMEVENT),
+      mfAborted(false),
+      mRc(VINF_SUCCESS),
+      mGuestRc(VINF_SUCCESS)
+{
+}
+
+GuestWaitEventBase::~GuestWaitEventBase(void)
+{
+}
+
+int GuestWaitEventBase::Init(uint32_t uCID)
+{
+    mCID = uCID;
+
+    return RTSemEventCreate(&mEventSem);
+}
+
+int GuestWaitEventBase::SignalInternal(int rc, int guestRc,
+                                       const GuestWaitEventPayload *pPayload)
+{
+    AssertReturn(!mfAborted, VERR_CANCELLED);
+
+#ifdef VBOX_STRICT
+    if (rc == VERR_GSTCTL_GUEST_ERROR)
+        AssertMsg(RT_FAILURE(guestRc), ("Guest error indicated but no actual guest error set (%Rrc)\n", guestRc));
     else
-        ASMAtomicWriteBool(&fAborted, true);
-
-    return RTSemEventSignal(mEventSem);
-}
-
-int GuestWaitEvent::Wait(RTMSINTERVAL uTimeoutMS)
+        AssertMsg(RT_SUCCESS(guestRc), ("No guest error indicated but actual guest error set (%Rrc)\n", guestRc));
+#endif
+
+    int rc2;
+    if (pPayload)
+        rc2 = mPayload.CopyFromDeep(*pPayload);
+    else
+        rc2 = VINF_SUCCESS;
+    if (RT_SUCCESS(rc2))
+    {
+        mRc = rc;
+        mGuestRc = guestRc;
+
+        rc2 = RTSemEventSignal(mEventSem);
+    }
+
+    return rc2;
+}
+
+int GuestWaitEventBase::Wait(RTMSINTERVAL uTimeoutMS)
 {
     int rc = VINF_SUCCESS;
 
-    if (ASMAtomicReadBool(&fAborted))
+    if (ASMAtomicReadBool(&mfAborted))
         rc = VERR_CANCELLED;
 
@@ -1108 +1241 @@
             msInterval = RT_INDEFINITE_WAIT;
         rc = RTSemEventWait(mEventSem, msInterval);
-        if (ASMAtomicReadBool(&fAborted))
+        if (ASMAtomicReadBool(&mfAborted))
             rc = VERR_CANCELLED;
-    }
-
-    return rc;
-}
-
+        if (RT_SUCCESS(rc))
+        {
+            /* If waiting succeeded, return the overall
+             * result code. */
+            rc = mRc;
+        }
+    }
+
+    return rc;
+}
+
+GuestWaitEvent::GuestWaitEvent(uint32_t uCID,
+                               const GuestEventTypes &lstEvents)
+{
+    int rc2 = Init(uCID);
+    AssertRC(rc2); /** @todo Throw exception here. */
+
+    mEventTypes = lstEvents;
+}
+
+GuestWaitEvent::GuestWaitEvent(uint32_t uCID)
+{
+    int rc2 = Init(uCID);
+    AssertRC(rc2); /** @todo Throw exception here. */
+}
+
+GuestWaitEvent::~GuestWaitEvent(void)
+{
+
+}
+
+/**
+ * Cancels the event.
+ */
+int GuestWaitEvent::Cancel(void)
+{
+    AssertReturn(!mfAborted, VERR_CANCELLED);
+    ASMAtomicWriteBool(&mfAborted, true);
+
+    return RTSemEventSignal(mEventSem);
+}
+
+int GuestWaitEvent::Init(uint32_t uCID)
+{
+    return GuestWaitEventBase::Init(uCID);
+}
+
+/**
+ * Signals the event.
+ *
+ * @return  IPRT status code.
+ * @param   pEvent              Public IEvent to associate.
+ *                              Optional.
+ */
+int GuestWaitEvent::SignalExternal(IEvent *pEvent)
+{
+    AssertReturn(mEventSem != NIL_RTSEMEVENT, VERR_CANCELLED);
+
+    if (pEvent)
+        mEvent = pEvent;
+
+    return RTSemEventSignal(mEventSem);
+}
+

trunk/src/VBox/Main/src-client/GuestDirectoryImpl.cpp

@@ -59 +59 @@
 /////////////////////////////////////////////////////////////////////////////
 
-int GuestDirectory::init(GuestSession *aSession,
-                         const Utf8Str &strPath, const Utf8Str &strFilter, uint32_t uFlags)
-{
-    LogFlowThisFunc(("strPath=%s, strFilter=%s, uFlags=%x\n",
-                     strPath.c_str(), strFilter.c_str(), uFlags));
+int GuestDirectory::init(Console *pConsole, GuestSession *pSession,
+                         ULONG uDirID, const GuestDirectoryOpenInfo &openInfo)
+{
+    LogFlowThisFunc(("pConsole=%p, pSession=%p, uDirID=%RU32, strPath=%s, strFilter=%s, uFlags=%x\n",
+                     pConsole, pSession, uDirID, openInfo.mPath.c_str(), openInfo.mFilter.c_str(),
+                     openInfo.mFlags));
+
+    AssertPtrReturn(pConsole, VERR_INVALID_POINTER);
+    AssertPtrReturn(pSession, VERR_INVALID_POINTER);
 
     /* Enclose the state transition NotReady->InInit->Ready. */
@@ -69 +73 @@
     AssertReturn(autoInitSpan.isOk(), E_FAIL);
 
-    mData.mSession = aSession;
-    mData.mName    = strPath;
-    mData.mFilter  = strFilter;
-    mData.mFlags   = uFlags;
-
-    /* Start the directory process on the guest. */
-    GuestProcessStartupInfo procInfo;
-    procInfo.mName      = Utf8StrFmt(tr("Reading directory \"%s\"", strPath.c_str()));
-    procInfo.mCommand   = Utf8Str(VBOXSERVICE_TOOL_LS);
-    procInfo.mTimeoutMS = 5 * 60 * 1000; /* 5 minutes timeout. */
-    procInfo.mFlags     = ProcessCreateFlag_WaitForStdOut;
-
-    procInfo.mArguments.push_back(Utf8Str("--machinereadable"));
-    /* We want the long output format which contains all the object details. */
-    procInfo.mArguments.push_back(Utf8Str("-l"));
+#ifndef VBOX_WITH_GUEST_CONTROL
+    autoInitSpan.setSucceeded();
+    return VINF_SUCCESS;
+#else
+    int vrc = bindToSession(pConsole, pSession, uDirID /* Object ID */);
+    if (RT_SUCCESS(vrc))
+    {
+        mSession = pSession;
+
+        mData.mID = uDirID;
+        mData.mOpenInfo = openInfo;
+    }
+
+    if (RT_SUCCESS(vrc))
+    {
+        /* Start the directory process on the guest. */
+        GuestProcessStartupInfo procInfo;
+        procInfo.mName      = Utf8StrFmt(tr("Reading directory \"%s\"", openInfo.mPath.c_str()));
+        procInfo.mCommand   = Utf8Str(VBOXSERVICE_TOOL_LS);
+        procInfo.mTimeoutMS = 5 * 60 * 1000; /* 5 minutes timeout. */
+        procInfo.mFlags     = ProcessCreateFlag_WaitForStdOut;
+
+        procInfo.mArguments.push_back(Utf8Str("--machinereadable"));
+        /* We want the long output format which contains all the object details. */
+        procInfo.mArguments.push_back(Utf8Str("-l"));
 #if 0 /* Flags are not supported yet. */
-    if (uFlags & DirectoryOpenFlag_NoSymlinks)
-        procInfo.mArguments.push_back(Utf8Str("--nosymlinks")); /** @todo What does GNU here? */
+        if (uFlags & DirectoryOpenFlag_NoSymlinks)
+            procInfo.mArguments.push_back(Utf8Str("--nosymlinks")); /** @todo What does GNU here? */
 #endif
-    /** @todo Recursion support? */
-    procInfo.mArguments.push_back(strPath); /* The directory we want to open. */
-
-    /*
-     * Start the process asynchronously and keep it around so that we can use
-     * it later in subsequent read() calls.
-     * Note: No guest rc available because operation is asynchronous.
-     */
-    int rc = mData.mProcessTool.Init(mData.mSession, procInfo,
-                                     true /* Async */, NULL /* Guest rc */);
-    if (RT_SUCCESS(rc))
+        /** @todo Recursion support? */
+        procInfo.mArguments.push_back(openInfo.mPath); /* The directory we want to open. */
+
+        /*
+         * Start the process asynchronously and keep it around so that we can use
+         * it later in subsequent read() calls.
+         * Note: No guest rc available because operation is asynchronous.
+         */
+        vrc = mData.mProcessTool.Init(mSession, procInfo,
+                                      true /* Async */, NULL /* Guest rc */);
+    }
+
+    if (RT_SUCCESS(vrc))
     {
         /* Confirm a successful initialization when it's the case. */
         autoInitSpan.setSucceeded();
-        return rc;
-    }
-
-    autoInitSpan.setFailed();
-    return rc;
+        return vrc;
+    }
+    else
+        autoInitSpan.setFailed();
+
+    return vrc;
+#endif /* VBOX_WITH_GUEST_CONTROL */
 }
 
@@ -139 +157 @@
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    mData.mName.cloneTo(aName);
+    mData.mOpenInfo.mPath.cloneTo(aName);
 
     return S_OK;
@@ -155 +173 @@
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    mData.mFilter.cloneTo(aFilter);
+    mData.mOpenInfo.mFilter.cloneTo(aFilter);
 
     return S_OK;
@@ -162 +180 @@
 // private methods
 /////////////////////////////////////////////////////////////////////////////
+
+int GuestDirectory::callbackDispatcher(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCb)
+{
+    AssertPtrReturn(pCbCtx, VERR_INVALID_POINTER);
+    AssertPtrReturn(pSvcCb, VERR_INVALID_POINTER);
+
+    LogFlowThisFunc(("strPath=%s, uContextID=%RU32, uFunction=%RU32, pSvcCb=%p\n",
+                     mData.mOpenInfo.mPath.c_str(), pCbCtx->uContextID, pCbCtx->uFunction, pSvcCb));
+
+    int vrc;
+    switch (pCbCtx->uFunction)
+    {
+        case GUEST_DIR_NOTIFY:
+        {
+            int idx = 1; /* Current parameter index. */
+            CALLBACKDATA_DIR_NOTIFY dataCb;
+            /* pSvcCb->mpaParms[0] always contains the context ID. */
+            pSvcCb->mpaParms[idx++].getUInt32(&dataCb.uType);
+            pSvcCb->mpaParms[idx++].getUInt32(&dataCb.rc);
+
+            int guestRc = (int)dataCb.rc; /* uint32_t vs. int. */
+
+            LogFlowFunc(("uType=%RU32, guestRc=%Rrc\n",
+                         dataCb.uType, guestRc));
+
+            switch (dataCb.uType)
+            {
+                /* Nothing here yet, nothing to dispatch further. */
+
+                default:
+                    vrc = VERR_NOT_SUPPORTED;
+                    break;
+            }
+            break;
+        }
+
+        default:
+            /* Silently ignore not implemented functions. */
+            vrc = VERR_NOT_SUPPORTED;
+            break;
+    }
+
+#ifdef DEBUG
+    LogFlowFuncLeaveRC(vrc);
+#endif
+    return vrc;
+}
+
+/* static */
+Utf8Str GuestDirectory::guestErrorToString(int guestRc)
+{
+    Utf8Str strError;
+
+    /** @todo pData->u32Flags: int vs. uint32 -- IPRT errors are *negative* !!! */
+    switch (guestRc)
+    {
+        case VERR_DIR_NOT_EMPTY:
+            strError += Utf8StrFmt("Directoy is not empty");
+            break;
+
+        default:
+            strError += Utf8StrFmt("%Rrc", guestRc);
+            break;
+    }
+
+    return strError;
+}
+
+/* static */
+HRESULT GuestDirectory::setErrorExternal(VirtualBoxBase *pInterface, int guestRc)
+{
+    AssertPtr(pInterface);
+    AssertMsg(RT_FAILURE(guestRc), ("Guest rc does not indicate a failure when setting error\n"));
+
+    return pInterface->setError(VBOX_E_IPRT_ERROR, GuestDirectory::guestErrorToString(guestRc).c_str());
+}
 
 // implementation of public methods
@@ -176 +270 @@
     if (FAILED(autoCaller.rc())) return autoCaller.rc();
 
-    AssertPtr(mData.mSession);
-    int rc = mData.mSession->directoryRemoveFromList(this);
+    AssertPtr(mSession);
+    int rc = mSession->directoryRemoveFromList(this);
     AssertRC(rc);
 
@@ -188 +282 @@
         switch (rc)
         {
-           case VERR_GSTCTL_GUEST_ERROR:
+            case VERR_GSTCTL_GUEST_ERROR:
                 hr = GuestProcess::setErrorExternal(this, guestRc);
                 break;
@@ -200 +294 @@
                 hr = setError(VBOX_E_IPRT_ERROR,
                               tr("Terminating open guest directory \"%s\" failed: %Rrc"),
-                              mData.mName.c_str(), rc);
+                              mData.mOpenInfo.mPath.c_str(), rc);
                 break;
         }
@@ -293 +387 @@
             case VERR_ACCESS_DENIED:
                 hr = setError(VBOX_E_IPRT_ERROR, tr("Reading directory \"%s\" failed: Unable to read / access denied"),
-                              mData.mName.c_str());
+                              mData.mOpenInfo.mPath.c_str());
                 break;
 
             case VERR_PATH_NOT_FOUND:
                 hr = setError(VBOX_E_IPRT_ERROR, tr("Reading directory \"%s\" failed: Path not found"),
-                              mData.mName.c_str());
+                              mData.mOpenInfo.mPath.c_str());
                 break;
 
@@ -304 +398 @@
                 /* See SDK reference. */
                 hr = setError(VBOX_E_OBJECT_NOT_FOUND, tr("No more entries for directory \"%s\""),
-                              mData.mName.c_str());
+                              mData.mOpenInfo.mPath.c_str());
                 break;
 
             default:
                 hr = setError(VBOX_E_IPRT_ERROR, tr("Error while reading directory \"%s\": %Rrc\n"),
-                              mData.mName.c_str(), rc);
+                              mData.mOpenInfo.mPath.c_str(), rc);
                 break;
         }

trunk/src/VBox/Main/src-client/GuestFileImpl.cpp

@@ -77 +77 @@
             {
                 Assert(!mFile.isNull());
-                int rc2 = mFile->signalWaitEvents(aType, aEvent);
+                int rc2 = mFile->signalWaitEvent(aType, aEvent);
 #ifdef DEBUG_andy
                 LogFlowFunc(("Signalling events of type=%ld, file=%p resulted in rc=%Rrc\n",
@@ -411 +411 @@
 int GuestFile::callbackDispatcher(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCb)
 {
-#ifdef DEBUG
+    AssertPtrReturn(pCbCtx, VERR_INVALID_POINTER);
+    AssertPtrReturn(pSvcCb, VERR_INVALID_POINTER);
+
     LogFlowThisFunc(("strName=%s, uContextID=%RU32, uFunction=%RU32, pSvcCb=%p\n",
                      mData.mOpenInfo.mFileName.c_str(), pCbCtx->uContextID, pCbCtx->uFunction, pSvcCb));
-#endif
-    AssertPtrReturn(pSvcCb, VERR_INVALID_POINTER);
 
     int vrc;
@@ -447 +447 @@
 
     GuestWaitEvent *pEvent = NULL;
-    std::list < VBoxEventType_T > eventTypes;
+    GuestEventTypes eventTypes;
     try
     {
@@ -539 +539 @@
         AssertRC(rc2);
 
+        rc2 = signalWaitEventInternal(pCbCtx,
+                                      guestRc, NULL /* pPayload */);
+        AssertRC(rc2);
+
         return VINF_SUCCESS; /* Report to the guest. */
     }
@@ -548 +552 @@
             int rc2 = setFileStatus(FileStatus_Error, guestRc);
             AssertRC(rc2);
+
             break;
         }
@@ -561 +566 @@
                     AssertMsg(mData.mID == VBOX_GUESTCTRL_CONTEXTID_GET_OBJECT(pCbCtx->uContextID),
                               ("File ID %RU32 does not match context ID %RU32\n", mData.mID,
-                               VBOX_GUESTCTRL_CONTEXTID_GET_OBJECT(pCbCtx->uContextID)));
+                              VBOX_GUESTCTRL_CONTEXTID_GET_OBJECT(pCbCtx->uContextID)));
 
                     /* Set the initial offset. On the guest the whole opening operation
@@ -570 +575 @@
                 /* Set the process status. */
                 int rc2 = setFileStatus(FileStatus_Open, guestRc);
-                if (RT_SUCCESS(vrc))
-                    vrc = rc2;
+                AssertRC(rc2);
             }
             else
@@ -678 +682 @@
     }
 
+    if (RT_SUCCESS(vrc))
+    {
+        GuestWaitEventPayload payload(dataCb.uType, &dataCb, sizeof(dataCb));
+        int rc2 = signalWaitEventInternal(pCbCtx, guestRc, &payload);
+        AssertRC(rc2);
+    }
+
     LogFlowThisFunc(("uType=%RU32, guestRc=%Rrc\n",
                      dataCb.uType, dataCb.rc));
@@ -708 +719 @@
 
     GuestWaitEvent *pEvent = NULL;
-    std::list < VBoxEventType_T > eventTypes;
+    GuestEventTypes eventTypes;
     try
     {
@@ -765 +776 @@
 
     GuestWaitEvent *pEvent = NULL;
-    std::list < VBoxEventType_T > eventTypes;
+    GuestEventTypes eventTypes;
     try
     {
@@ -820 +831 @@
 
     GuestWaitEvent *pEvent = NULL;
-    std::list < VBoxEventType_T > eventTypes;
+    GuestEventTypes eventTypes;
     try
     {
@@ -876 +887 @@
 
     GuestWaitEvent *pEvent = NULL;
-    std::list < VBoxEventType_T > eventTypes;
+    GuestEventTypes eventTypes;
     try
     {
@@ -970 +981 @@
     AssertPtrReturn(pEvent, VERR_INVALID_POINTER);
 
-    VBoxEventType_T evtType;
-    ComPtr<IEvent> pIEvent;
     int vrc = waitForEvent(pEvent, uTimeoutMS,
-                           &evtType, pIEvent.asOutParam());
-    if (RT_SUCCESS(vrc))
-    {
-        if (evtType == VBoxEventType_OnGuestFileOffsetChanged)
-        {
-            if (puOffset)
-            {
-                ComPtr<IGuestFileOffsetChangedEvent> pFileEvent = pIEvent;
-                Assert(!pFileEvent.isNull());
-
-                HRESULT hr = pFileEvent->COMGETTER(Offset)((LONG64*)puOffset);
-                ComAssertComRC(hr);
-            }
+                           NULL /* Event type */, NULL /* IEvent */);
+    if (RT_SUCCESS(vrc))
+    {
+        Assert(pEvent->Payload().Size() == sizeof(CALLBACKDATA_FILE_NOTIFY));
+        const PCALLBACKDATA_FILE_NOTIFY pvCbData =
+            (PCALLBACKDATA_FILE_NOTIFY)pEvent->Payload().Raw();
+        Assert(pvCbData->uType == GUEST_FILE_NOTIFYTYPE_SEEK);
+
+        if (puOffset)
+            *puOffset = pvCbData->u.seek.uOffActual;
+    }
+
+    return vrc;
+}
+
+int GuestFile::waitForRead(GuestWaitEvent *pEvent,
+                           uint32_t uTimeoutMS,
+                           void *pvData, size_t cbData, uint32_t *pcbRead)
+{
+    AssertPtrReturn(pEvent, VERR_INVALID_POINTER);
+
+    int vrc = waitForEvent(pEvent, uTimeoutMS,
+                           NULL /* Event type */, NULL /* IEvent */);
+    if (RT_SUCCESS(vrc))
+    {
+        Assert(pEvent->Payload().Size() == sizeof(CALLBACKDATA_FILE_NOTIFY));
+        const PCALLBACKDATA_FILE_NOTIFY pvCbData =
+            (PCALLBACKDATA_FILE_NOTIFY)pEvent->Payload().Raw();
+        Assert(pvCbData->uType == GUEST_FILE_NOTIFYTYPE_READ);
+
+        uint32_t cbRead = pvCbData->u.read.cbData;
+        if (   cbRead
+            && cbRead <= cbData)
+        {
+            memcpy(pvData,
+                   pvCbData->u.read.pvData, cbRead);
         }
         else
-            vrc = VWRN_GSTCTL_OBJECTSTATE_CHANGED;
-    }
-
-    return vrc;
-}
-
-int GuestFile::waitForRead(GuestWaitEvent *pEvent,
-                           uint32_t uTimeoutMS, void *pvData, size_t cbData, uint32_t *pcbRead)
-{
-    AssertPtrReturn(pEvent, VERR_INVALID_POINTER);
-
-    VBoxEventType_T evtType;
-    ComPtr<IEvent> pIEvent;
-    int vrc = waitForEvent(pEvent, uTimeoutMS,
-                           &evtType, pIEvent.asOutParam());
-    if (RT_SUCCESS(vrc))
-    {
-        if (evtType == VBoxEventType_OnGuestFileRead)
-        {
-            ComPtr<IGuestFileReadEvent> pFileEvent = pIEvent;
-            Assert(!pFileEvent.isNull());
-
-            HRESULT hr;
-            if (pvData)
-            {
-                com::SafeArray <BYTE> data;
-                hr = pFileEvent->COMGETTER(Data)(ComSafeArrayAsOutParam(data));
-                ComAssertComRC(hr);
-                size_t cbRead = data.size();
-                if (   cbRead
-                    && cbRead <= cbData)
-                {
-                    memcpy(pvData, data.raw(), data.size());
-                }
-                else
-                    vrc = VERR_BUFFER_OVERFLOW;
-            }
-            if (pcbRead)
-            {
-                hr = pFileEvent->COMGETTER(Processed)((ULONG*)pcbRead);
-                ComAssertComRC(hr);
-            }
-        }
-        else
-            vrc = VWRN_GSTCTL_OBJECTSTATE_CHANGED;
+            vrc = VERR_BUFFER_OVERFLOW;
+
+        if (pcbRead)
+            *pcbRead = cbRead;
     }
 
@@ -1042 +1033 @@
 {
     AssertPtrReturn(pEvent, VERR_INVALID_POINTER);
-    /* pFileStatus is optional. */
-
-    VBoxEventType_T evtType;
-    ComPtr<IEvent> pIEvent;
+
     int vrc = waitForEvent(pEvent, uTimeoutMS,
-                           &evtType, pIEvent.asOutParam());
-    if (RT_SUCCESS(vrc))
-    {
-        Assert(evtType == VBoxEventType_OnGuestFileStateChanged);
-        ComPtr<IGuestFileStateChangedEvent> pFileEvent = pIEvent;
-        Assert(!pFileEvent.isNull());
-
-        HRESULT hr;
-        if (pFileStatus)
-        {
-            hr = pFileEvent->COMGETTER(Status)(pFileStatus);
-            ComAssertComRC(hr);
-        }
-
-        ComPtr<IVirtualBoxErrorInfo> errorInfo;
-        hr = pFileEvent->COMGETTER(Error)(errorInfo.asOutParam());
-        ComAssertComRC(hr);
-
-        LONG lGuestRc;
-        hr = errorInfo->COMGETTER(ResultDetail)(&lGuestRc);
-        ComAssertComRC(hr);
-
-        LogFlowThisFunc(("resultDetail=%RI32 (rc=%Rrc)\n",
-                         lGuestRc, lGuestRc));
-
-        if (RT_FAILURE((int)lGuestRc))
-            vrc = VERR_GSTCTL_GUEST_ERROR;
+                           NULL /* Event type */, NULL /* IEvent */);
+    if (RT_SUCCESS(vrc))
+    {
+        Assert(pEvent->Payload().Size() == sizeof(CALLBACKDATA_FILE_NOTIFY));
+        const PCALLBACKDATA_FILE_NOTIFY pvCbData =
+            (PCALLBACKDATA_FILE_NOTIFY)pEvent->Payload().Raw();
+        /* Note: pvCbData->uType can be different types. */;
+
+
 
         if (pGuestRc)
-            *pGuestRc = (int)lGuestRc;
+            *pGuestRc = pvCbData->rc; /* int vs. uint32_t */
     }
 
@@ -1087 +1057 @@
     AssertPtrReturn(pEvent, VERR_INVALID_POINTER);
 
-    VBoxEventType_T evtType;
-    ComPtr<IEvent> pIEvent;
     int vrc = waitForEvent(pEvent, uTimeoutMS,
-                           &evtType, pIEvent.asOutParam());
-    if (RT_SUCCESS(vrc))
-    {
-        if (evtType == VBoxEventType_OnGuestFileWrite)
-        {
-            if (pcbWritten)
-            {
-                ComPtr<IGuestFileWriteEvent> pFileEvent = pIEvent;
-                Assert(!pFileEvent.isNull());
-
-                HRESULT hr = pFileEvent->COMGETTER(Processed)((ULONG*)pcbWritten);
-                ComAssertComRC(hr);
-            }
-        }
-        else
-            vrc = VWRN_GSTCTL_OBJECTSTATE_CHANGED;
+                           NULL /* Event type */, NULL /* IEvent */);
+    if (RT_SUCCESS(vrc))
+    {
+        Assert(pEvent->Payload().Size() == sizeof(CALLBACKDATA_FILE_NOTIFY));
+        const PCALLBACKDATA_FILE_NOTIFY pvCbData =
+            (PCALLBACKDATA_FILE_NOTIFY)pEvent->Payload().Raw();
+        Assert(pvCbData->uType == GUEST_FILE_NOTIFYTYPE_WRITE);
+
+        if (pcbWritten)
+            *pcbWritten = pvCbData->u.write.cbWritten;
     }
 
@@ -1125 +1087 @@
 
     GuestWaitEvent *pEvent = NULL;
-    std::list < VBoxEventType_T > eventTypes;
+    GuestEventTypes eventTypes;
     try
     {
@@ -1184 +1146 @@
 
     GuestWaitEvent *pEvent = NULL;
-    std::list < VBoxEventType_T > eventTypes;
+    GuestEventTypes eventTypes;
     try
     {

trunk/src/VBox/Main/src-client/GuestProcessImpl.cpp

@@ -116 +116 @@
             {
                 Assert(!mProcess.isNull());
-                int rc2 = mProcess->signalWaitEvents(aType, aEvent);
-#ifdef DEBUG_andy
+                int rc2 = mProcess->signalWaitEvent(aType, aEvent);
+#ifdef DEBUG
                 LogFlowThisFunc(("Signalling events of type=%ld, process=%p resulted in rc=%Rrc\n",
                                  aType, mProcess, rc2));
@@ -512 +512 @@
 
 #ifdef DEBUG
-    LogFlowThisFunc(("Returning rc=%Rrc\n", vrc));
+    LogFlowFuncLeaveRC(vrc);
 #endif
     return vrc;
@@ -647 +647 @@
     int vrc = setProcessStatus(ProcessStatus_Down, VINF_SUCCESS);
 
-    LogFlowThisFunc(("Returning rc=%Rrc\n", vrc));
+    LogFlowFuncLeaveRC(vrc);
     return vrc;
 }
@@ -714 +714 @@
     }
 
-    LogFlowThisFunc(("Returning rc=%Rrc\n", vrc));
+    LogFlowFuncLeaveRC(vrc);
     return vrc;
 }
@@ -832 +832 @@
     }
 
-    LogFlowThisFunc(("Returning rc=%Rrc\n", vrc));
+    LogFlowFuncLeaveRC(vrc);
     return vrc;
 }
@@ -868 +868 @@
     }
 
-    LogFlowThisFunc(("Returning rc=%Rrc\n", vrc));
+    LogFlowFuncLeaveRC(vrc);
     return vrc;
 }
@@ -904 +904 @@
 
     GuestWaitEvent *pEvent = NULL;
-    std::list < VBoxEventType_T > eventTypes;
+    GuestEventTypes eventTypes;
     try
     {
@@ -948 +948 @@
     unregisterWaitEvent(pEvent);
 
-    LogFlowThisFunc(("Returning rc=%Rrc\n", vrc));
+    LogFlowFuncLeaveRC(vrc);
     return vrc;
 }
@@ -1041 +1041 @@
 
     GuestWaitEvent *pEvent = NULL;
-    std::list < VBoxEventType_T > eventTypes;
+    GuestEventTypes eventTypes;
     try
     {
@@ -1168 +1168 @@
     unregisterWaitEvent(pEvent);
 
-    LogFlowThisFunc(("Returning rc=%Rrc\n", vrc));
+    LogFlowFuncLeaveRC(vrc);
     return vrc;
 }
@@ -1200 +1200 @@
     }
 
-    LogFlowThisFunc(("Returning rc=%Rrc\n", vrc));
+    LogFlowFuncLeaveRC(vrc);
     return vrc;
 }
@@ -1250 +1250 @@
     {
         GuestWaitEvent *pEvent = NULL;
-        std::list < VBoxEventType_T > eventTypes;
+        GuestEventTypes eventTypes;
         try
         {
@@ -1279 +1279 @@
     }
 
-    LogFlowThisFunc(("Returning rc=%Rrc\n", vrc));
+    LogFlowFuncLeaveRC(vrc);
     return vrc;
 }
@@ -1285 +1285 @@
 /* static */
 ProcessWaitResult_T GuestProcess::waitFlagsToResultEx(uint32_t fWaitFlags,
-                                                      ProcessStatus_T procStatus, uint32_t uProcFlags,
-                                                      uint32_t uProtocol)
+                                                      ProcessStatus_T oldStatus, ProcessStatus_T newStatus,
+                                                      uint32_t uProcFlags, uint32_t uProtocol)
 {
     ProcessWaitResult_T waitResult = ProcessWaitResult_None;
 
-    if (   (fWaitFlags & ProcessWaitForFlag_Terminate)
-        || (fWaitFlags & ProcessWaitForFlag_StdIn)
-        || (fWaitFlags & ProcessWaitForFlag_StdOut)
-        || (fWaitFlags & ProcessWaitForFlag_StdErr))
-    {
-        switch (procStatus)
-        {
-            case ProcessStatus_TerminatedNormally:
-            case ProcessStatus_TerminatedSignal:
-            case ProcessStatus_TerminatedAbnormally:
-            case ProcessStatus_Down:
-                waitResult = ProcessWaitResult_Terminate;
-                break;
-
-            case ProcessStatus_TimedOutKilled:
-            case ProcessStatus_TimedOutAbnormally:
-                waitResult = ProcessWaitResult_Timeout;
-                break;
-
-            case ProcessStatus_Error:
-                /* Handled above. */
-                break;
-
-            case ProcessStatus_Started:
+    switch (newStatus)
+    {
+        case ProcessStatus_TerminatedNormally:
+        case ProcessStatus_TerminatedSignal:
+        case ProcessStatus_TerminatedAbnormally:
+            waitResult = ProcessWaitResult_Terminate;
+            break;
+        case ProcessStatus_Down:
+            waitResult = ProcessWaitResult_Terminate;
+            break;
+
+        case ProcessStatus_TimedOutKilled:
+            /* Fall through is intentional. */
+        case ProcessStatus_TimedOutAbnormally:
+            waitResult = ProcessWaitResult_Timeout;
+            break;
+
+        case ProcessStatus_Error:
+            waitResult = ProcessWaitResult_Error;
+            break;
+
+        case ProcessStatus_Started:
+        {
+            switch (oldStatus)
             {
-                /*
-                 * If ProcessCreateFlag_WaitForProcessStartOnly was specified on process creation the
-                 * caller is not interested in getting further process statuses -- so just don't notify
-                 * anything here anymore and return.
-                 */
-                if (uProcFlags & ProcessCreateFlag_WaitForProcessStartOnly)
-                    waitResult = ProcessWaitResult_Start;
-                break;
+                case ProcessStatus_Starting:
+                    if (fWaitFlags & ProcessWaitForFlag_Start)
+                    {
+                        waitResult = ProcessWaitResult_Start;
+                    }
+                    else
+                    {
+                        /*
+                         * If ProcessCreateFlag_WaitForProcessStartOnly was specified on process creation the
+                         * caller is not interested in getting further process statuses -- so just don't notify
+                         * anything here anymore and return.
+                         */
+                        if (uProcFlags & ProcessCreateFlag_WaitForProcessStartOnly)
+                            waitResult = ProcessWaitResult_Start;
+                    }
+                    break;
+
+                default:
+                    /* No result available (yet). */
+                    break;
             }
-
-            case ProcessStatus_Undefined:
-            case ProcessStatus_Starting:
-                /* No result available yet. */
-                break;
-
-            default:
-                AssertMsgFailed(("Unhandled process status %ld\n", procStatus));
-                break;
-        }
-    }
-    else if (fWaitFlags & ProcessWaitForFlag_Start)
-    {
-        switch (procStatus)
-        {
-            case ProcessStatus_Started:
-            case ProcessStatus_Paused:
-            case ProcessStatus_Terminating:
-            case ProcessStatus_TerminatedNormally:
-            case ProcessStatus_TerminatedSignal:
-            case ProcessStatus_TerminatedAbnormally:
-            case ProcessStatus_Down:
-                waitResult = ProcessWaitResult_Start;
-                break;
-
-            case ProcessStatus_Error:
-                waitResult = ProcessWaitResult_Error;
-                break;
-
-            case ProcessStatus_TimedOutKilled:
-            case ProcessStatus_TimedOutAbnormally:
-                waitResult = ProcessWaitResult_Timeout;
-                break;
-
-            case ProcessStatus_Undefined:
-            case ProcessStatus_Starting:
-                /* No result available yet. */
-                break;
-
-            default:
-                AssertMsgFailed(("Unhandled process status %ld\n", procStatus));
-                break;
-        }
-    }
-
-    /* Filter out waits which are *not* supported using
-     * older guest control Guest Additions.
-     *
-     ** @todo ProcessWaitForFlag_Std* flags are not implemented yet.
-     */
-    if (uProtocol < 99) /* See @todo above. */
-    {
-        if (   waitResult == ProcessWaitResult_None
-            /* We don't support waiting for stdin, out + err,
-             * just skip waiting then. */
-            && (   (fWaitFlags & ProcessWaitForFlag_StdIn)
-                || (fWaitFlags & ProcessWaitForFlag_StdOut)
-                || (fWaitFlags & ProcessWaitForFlag_StdErr)
+            break;
+        }
+
+        case ProcessStatus_Undefined:
+        case ProcessStatus_Starting:
+            /* No result available yet. */
+            break;
+
+        default:
+            AssertMsgFailed(("Unhandled process status %ld\n", newStatus));
+            break;
+    }
+
+    if (newStatus == ProcessStatus_Started)
+    {
+        /* Filter out waits which are *not* supported using
+         * older guest control Guest Additions.
+         *
+         ** @todo ProcessWaitForFlag_Std* flags are not implemented yet.
+         */
+        if (uProtocol < 99) /* See @todo above. */
+        {
+            if (   waitResult == ProcessWaitResult_None
+                /* We don't support waiting for stdin, out + err,
+                 * just skip waiting then. */
+                && (   (fWaitFlags & ProcessWaitForFlag_StdIn)
+                    || (fWaitFlags & ProcessWaitForFlag_StdOut)
+                    || (fWaitFlags & ProcessWaitForFlag_StdErr)
+                   )
                )
-           )
-        {
-            /* Use _WaitFlagNotSupported because we don't know what to tell the caller. */
-            waitResult = ProcessWaitResult_WaitFlagNotSupported;
-        }
-    }
-
+            {
+                /* Use _WaitFlagNotSupported because we don't know what to tell the caller. */
+                waitResult = ProcessWaitResult_WaitFlagNotSupported;
+            }
+        }
+    }
+
+#ifdef DEBUG
+    LogFlowFunc(("oldStatus=%ld, newStatus=%ld, fWaitFlags=0x%x, waitResult=%ld\n",
+                 oldStatus, newStatus, fWaitFlags, waitResult));
+#endif
     return waitResult;
 }
@@ -1396 +1383 @@
 {
     AssertPtr(mSession);
-    return GuestProcess::waitFlagsToResultEx(fWaitFlags, mData.mStatus, mData.mProcess.mFlags,
-                                             mSession->getProtocolVersion());
-}
-
-int GuestProcess::waitFor(uint32_t fWaitFlags, ULONG uTimeoutMS, ProcessWaitResult_T &waitResult, int *pGuestRc)
+    return GuestProcess::waitFlagsToResultEx(fWaitFlags,
+                                             mData.mStatus /* curStatus */, mData.mStatus /* newStatus */,
+                                             mData.mProcess.mFlags, mSession->getProtocolVersion());
+}
+
+int GuestProcess::waitFor(uint32_t fWaitFlags, ULONG uTimeoutMS,
+                          ProcessWaitResult_T &waitResult, int *pGuestRc)
 {
     AssertReturn(fWaitFlags, VERR_INVALID_PARAMETER);
 
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
     LogFlowThisFunc(("fWaitFlags=0x%x, uTimeoutMS=%RU32, procStatus=%RU32, procRc=%Rrc, pGuestRc=%p\n",
@@ -1410 +1399 @@
 
     /* Did some error occur before? Then skip waiting and return. */
-    if (mData.mStatus == ProcessStatus_Error)
+    ProcessStatus_T curStatus = mData.mStatus;
+    if (curStatus == ProcessStatus_Error)
     {
         waitResult = ProcessWaitResult_Error;
@@ -1420 +1410 @@
 
     waitResult = waitFlagsToResult(fWaitFlags);
-    LogFlowThisFunc(("waitFlagToResult=%ld\n", waitResult));
 
     /* No waiting needed? Return immediately using the last set error. */
@@ -1435 +1424 @@
 
     GuestWaitEvent *pEvent = NULL;
-    std::list < VBoxEventType_T > eventTypes;
+    GuestEventTypes eventTypes;
     try
     {
@@ -1453 +1442 @@
      * Do the actual waiting.
      */
-    ProcessStatus_T processStatus = ProcessStatus_Undefined;
+    ProcessStatus_T newStatus = ProcessStatus_Undefined;
     uint64_t u64StartMS = RTTimeMilliTS();
     for (;;)
@@ -1468 +1457 @@
                                     uTimeoutMS == RT_INDEFINITE_WAIT
                                   ? RT_INDEFINITE_WAIT : uTimeoutMS - (uint32_t)u64ElapsedMS,
-                                  &processStatus, pGuestRc);
+                                  &newStatus, pGuestRc);
         if (RT_SUCCESS(vrc))
         {
             alock.acquire();
 
-            waitResult = waitFlagsToResultEx(fWaitFlags, processStatus,
+            waitResult = waitFlagsToResultEx(fWaitFlags, curStatus, newStatus,
                                              mData.mProcess.mFlags, mSession->getProtocolVersion());
-            LogFlowThisFunc(("Got new status change: waitResult=%ld, processStatus=%ld\n",
-                             waitResult, processStatus));
+#ifdef DEBUG
+            LogFlowThisFunc(("Got new status change: fWaitFlags=0x%x, newStatus=%ld, waitResult=%ld\n",
+                             fWaitFlags, newStatus, waitResult));
+#endif
             if (ProcessWaitResult_None != waitResult) /* We got a waiting result. */
                 break;
@@ -1488 +1479 @@
     unregisterWaitEvent(pEvent);
 
-    LogFlowThisFunc(("Returned waitResult=%ld, processStatus=%ld, rc=%Rrc\n",
-                     waitResult, processStatus, vrc));
+    LogFlowThisFunc(("Returned waitResult=%ld, newStatus=%ld, rc=%Rrc\n",
+                     waitResult, newStatus, vrc));
     return vrc;
 }
@@ -1501 +1492 @@
     ComPtr<IEvent> pIEvent;
     int vrc = waitForEvent(pEvent, uTimeoutMS,
-                           &evtType, pIEvent.asOutParam());
+                                 &evtType, pIEvent.asOutParam());
     if (RT_SUCCESS(vrc))
     {
@@ -1547 +1538 @@
     {
         vrc = waitForEvent(pEvent, uTimeoutMS,
-                           &evtType, pIEvent.asOutParam());
+                                 &evtType, pIEvent.asOutParam());
         if (RT_SUCCESS(vrc))
         {
-#ifdef DEBUG_andy
-            LogFlowThisFunc(("pEvent=%p, evtType=%ld\n", pEvent, evtType));
-#endif
             if (evtType == VBoxEventType_OnGuestProcessOutput)
             {
@@ -1560 +1548 @@
                 ULONG uHandleEvent;
                 HRESULT hr = pProcessEvent->COMGETTER(Handle)(&uHandleEvent);
-                LogFlowThisFunc(("Received output, uHandle=%RU32\n", uHandleEvent));
                 if (   SUCCEEDED(hr)
                     && uHandleEvent == uHandle)
@@ -1579 +1566 @@
                             else
                                 vrc = VERR_BUFFER_OVERFLOW;
+
+                            LogFlowThisFunc(("Read %zu bytes (uHandle=%RU32), rc=%Rrc\n",
+                                             cbRead, uHandleEvent, vrc));
                         }
                     }
@@ -1608 +1598 @@
     }
 
-    LogFlowThisFunc(("Returning rc=%Rrc\n", vrc));
+    LogFlowFuncLeaveRC(vrc);
     return vrc;
 }
@@ -1629 +1619 @@
         Assert(!pProcessEvent.isNull());
 
-        HRESULT hr;
+        ProcessStatus_T procStatus;
+        HRESULT hr = pProcessEvent->COMGETTER(Status)(&procStatus);
+        ComAssertComRC(hr);
         if (pProcessStatus)
-        {
-            hr = pProcessEvent->COMGETTER(Status)(pProcessStatus);
-            ComAssertComRC(hr);
-        }
+            *pProcessStatus = procStatus;
 
         ComPtr<IVirtualBoxErrorInfo> errorInfo;
@@ -1644 +1633 @@
         ComAssertComRC(hr);
 
-        LogFlowThisFunc(("resultDetail=%RI32 (rc=%Rrc)\n",
-                         lGuestRc, lGuestRc));
+        LogFlowThisFunc(("procStatus=%RU32, resultDetail=%RI32 (rc=%Rrc)\n",
+                         procStatus, lGuestRc, lGuestRc));
 
         if (RT_FAILURE((int)lGuestRc))
@@ -1654 +1643 @@
     }
 
-    LogFlowThisFunc(("Returning rc=%Rrc\n", vrc));
+    LogFlowFuncLeaveRC(vrc);
     return vrc;
 }
@@ -1710 +1699 @@
 
     GuestWaitEvent *pEvent = NULL;
-    std::list < VBoxEventType_T > eventTypes;
+    GuestEventTypes eventTypes;
     try
     {
@@ -1814 +1803 @@
     LogFlowThisFunc(("rc=%Rrc, cbRead=%RU32\n", vrc, cbRead));
 
-    LogFlowThisFunc(("Returning rc=%Rrc\n", vrc));
+    LogFlowFuncLeaveRC(vrc);
     return hr;
 #endif /* VBOX_WITH_GUEST_CONTROL */
@@ -1861 +1850 @@
     mSession->processRemoveFromList(this);
 
-    LogFlowThisFunc(("Returning rc=%Rrc\n", vrc));
+    LogFlowFuncLeaveRC(vrc);
     return hr;
 #endif /* VBOX_WITH_GUEST_CONTROL */
@@ -1909 +1898 @@
     }
 
-    LogFlowThisFunc(("Returning rc=%Rrc\n", vrc));
+    LogFlowFuncLeaveRC(vrc);
     return hr;
 #endif /* VBOX_WITH_GUEST_CONTROL */
@@ -1978 +1967 @@
     *aWritten = (ULONG)cbWritten;
 
-    LogFlowThisFunc(("Returning rc=%Rrc\n", vrc));
+    LogFlowFuncLeaveRC(vrc);
     return hr;
 #endif /* VBOX_WITH_GUEST_CONTROL */
@@ -2029 +2018 @@
     AssertPtrReturn(pGuestSession, VERR_INVALID_POINTER);
 
-    pSession     = pGuestSession;
+    pSession = pGuestSession;
     mStartupInfo = startupInfo;
 
@@ -2050 +2039 @@
     }
 
-    LogFlowThisFunc(("Returning rc=%Rrc\n", vrc));
+    LogFlowFuncLeaveRC(vrc);
     return vrc;
 }
@@ -2097 +2086 @@
 }
 
+/* static */
+int GuestProcessTool::Run(      GuestSession            *pGuestSession,
+                          const GuestProcessStartupInfo &startupInfo,
+                                int                     *pGuestRc)
+{
+    return RunEx(pGuestSession, startupInfo,
+                 NULL /* pStrmOutObjects */, 0 /* cStrmOutObjects */,
+                 pGuestRc);
+}
+
+/* static */
+int GuestProcessTool::RunEx(      GuestSession            *pGuestSession,
+                            const GuestProcessStartupInfo &startupInfo,
+                                  GuestCtrlStreamObjects  *pStrmOutObjects,
+                                  uint32_t                 cStrmOutObjects,
+                                  int                     *pGuestRc)
+{
+    GuestProcessTool procTool; int guestRc;
+    int vrc = procTool.Init(pGuestSession, startupInfo, false /* Async */, &guestRc);
+    if (RT_SUCCESS(vrc))
+    {
+        while (cStrmOutObjects--)
+        {
+            try
+            {
+                GuestProcessStreamBlock strmBlk;
+                vrc = procTool.WaitEx(  pStrmOutObjects
+                                      ? GUESTPROCESSTOOL_FLAG_STDOUT_BLOCK
+                                      : GUESTPROCESSTOOL_FLAG_NONE, &strmBlk, &guestRc);
+                if (pStrmOutObjects)
+                    pStrmOutObjects->push_back(strmBlk);
+            }
+            catch (std::bad_alloc)
+            {
+                vrc = VERR_NO_MEMORY;
+            }
+        }
+    }
+
+    if (RT_SUCCESS(vrc))
+    {
+        /* Make sure the process runs until completion. */
+        vrc = procTool.Wait(GUESTPROCESSTOOL_FLAG_NONE, &guestRc);
+
+        Assert(RT_SUCCESS(guestRc));
+        guestRc = procTool.TerminatedOk(NULL /* Exit code */);
+        if (pGuestRc)
+            *pGuestRc = guestRc;
+    }
+    else if (vrc == VERR_GSTCTL_GUEST_ERROR)
+    {
+        if (pGuestRc)
+            *pGuestRc = guestRc;
+    }
+
+    LogFlowFunc(("Returned rc=%Rrc, guestRc=%Rrc\n", vrc, guestRc));
+    return vrc;
+}
+
 int GuestProcessTool::TerminatedOk(LONG *pExitCode)
 {
@@ -2102 +2150 @@
     /* pExitCode is optional. */
 
+    int vrc;
     if (!IsRunning())
     {
@@ -2111 +2160 @@
             *pExitCode = exitCode;
 
-        if (exitCode != 0)
-            return VERR_NOT_EQUAL; /** @todo Special guest control rc needed! */
-        return VINF_SUCCESS;
-    }
-
-    return VERR_INVALID_STATE; /** @todo Special guest control rc needed! */
+        vrc = (exitCode != 0)
+              /** @todo Special guest control rc needed! */
+            ? VERR_NOT_EQUAL : VINF_SUCCESS;
+    }
+    else
+        vrc = VERR_INVALID_STATE; /** @todo Special guest control rc needed! */
+
+    LogFlowFuncLeaveRC(vrc);
+    return vrc;
 }
 
 int GuestProcessTool::Wait(uint32_t fFlags, int *pGuestRc)
 {
-    return WaitEx(fFlags, NULL /* pStreamBlock */, pGuestRc);
-}
-
-int GuestProcessTool::WaitEx(uint32_t fFlags, GuestProcessStreamBlock *pStreamBlock, int *pGuestRc)
-{
-    LogFlowThisFunc(("pSession=%p, fFlags=0x%x, pStreamBlock=%p, pGuestRc=%p\n",
-                     pSession, fFlags, pStreamBlock, pGuestRc));
-
-    AssertPtrReturn(pSession, VERR_INVALID_POINTER);
-    Assert(!pProcess.isNull());
-    /* Other parameters are optional. */
+    return WaitEx(fFlags, NULL /* pStrmBlkOut */, pGuestRc);
+}
+
+int GuestProcessTool::WaitEx(uint32_t fFlags, GuestProcessStreamBlock *pStrmBlkOut, int *pGuestRc)
+{
+    LogFlowThisFunc(("fFlags=0x%x, pStreamBlock=%p, pGuestRc=%p\n",
+                     fFlags, pStrmBlkOut, pGuestRc));
 
     /* Can we parse the next block without waiting? */
@@ -2137 +2185 @@
     if (fFlags & GUESTPROCESSTOOL_FLAG_STDOUT_BLOCK)
     {
-        AssertPtr(pStreamBlock);
-        vrc = GetCurrentBlock(OUTPUT_HANDLE_ID_STDOUT, *pStreamBlock);
+        AssertPtr(pStrmBlkOut);
+        vrc = GetCurrentBlock(OUTPUT_HANDLE_ID_STDOUT, *pStrmBlkOut);
         if (RT_SUCCESS(vrc))
             return vrc;
@@ -2151 +2199 @@
         fWaitFlags |= ProcessWaitForFlag_StdErr;
 
-    LogFlowThisFunc(("waitFlags=0x%x\n", fWaitFlags));
-
     /** @todo Decrease timeout while running. */
+    uint64_t u64StartMS = RTTimeMilliTS();
     uint32_t uTimeoutMS = mStartupInfo.mTimeoutMS;
 
@@ -2165 +2212 @@
     bool fHandleStdErr = false;
 
+    /**
+     * Updates the elapsed time and checks if a
+     * timeout happened, then breaking out of the loop.
+     */
+#define UPDATE_AND_CHECK_ELAPSED_TIME()          \
+    u64ElapsedMS = RTTimeMilliTS() - u64StartMS; \
+    if (   uTimeoutMS   != RT_INDEFINITE_WAIT    \
+        && u64ElapsedMS >= uTimeoutMS)           \
+    {                                            \
+        vrc = VERR_TIMEOUT;                      \
+        break;                                   \
+    }
+
+    /**
+     * Returns the remaining time (in ms).
+     */
+#define GET_REMAINING_TIME                                     \
+      uTimeoutMS == RT_INDEFINITE_WAIT                         \
+    ? RT_INDEFINITE_WAIT : uTimeoutMS - (uint32_t)u64ElapsedMS \
+
     ProcessWaitResult_T waitRes;
     do
     {
-        vrc = pProcess->waitFor(fWaitFlags,
-                                uTimeoutMS, waitRes, &guestRc);
+        uint64_t u64ElapsedMS;
+        UPDATE_AND_CHECK_ELAPSED_TIME();
+
+        vrc = pProcess->waitFor(fWaitFlags, GET_REMAINING_TIME,
+                                waitRes, &guestRc);
         if (RT_FAILURE(vrc))
             break;
@@ -2219 +2289 @@
         }
 
+        if (RT_FAILURE(vrc))
+            break;
+
         if (fHandleStdOut)
         {
+            UPDATE_AND_CHECK_ELAPSED_TIME();
+
             cbRead = 0;
             vrc = pProcess->readData(OUTPUT_HANDLE_ID_STDOUT, sizeof(byBuf),
-                                     uTimeoutMS, byBuf, sizeof(byBuf),
+                                     GET_REMAINING_TIME,
+                                     byBuf, sizeof(byBuf),
                                      &cbRead, &guestRc);
-            if (RT_FAILURE(vrc))
+            if (   RT_FAILURE(vrc)
+                || vrc == VWRN_GSTCTL_OBJECTSTATE_CHANGED)
                 break;
 
@@ -2236 +2313 @@
                     && (fFlags & GUESTPROCESSTOOL_FLAG_STDOUT_BLOCK))
                 {
-                    AssertPtr(pStreamBlock);
-                    vrc = GetCurrentBlock(OUTPUT_HANDLE_ID_STDOUT, *pStreamBlock);
+                    AssertPtr(pStrmBlkOut);
+                    vrc = GetCurrentBlock(OUTPUT_HANDLE_ID_STDOUT, *pStrmBlkOut);
+
+                    /* When successful, break out of the loop because we're done
+                     * with reading the first stream block. */
                     if (RT_SUCCESS(vrc))
                         fDone = true;
@@ -2248 +2328 @@
         if (fHandleStdErr)
         {
+            UPDATE_AND_CHECK_ELAPSED_TIME();
+
             cbRead = 0;
             vrc = pProcess->readData(OUTPUT_HANDLE_ID_STDERR, sizeof(byBuf),
-                                     uTimeoutMS, byBuf, sizeof(byBuf),
+                                     GET_REMAINING_TIME,
+                                     byBuf, sizeof(byBuf),
                                      &cbRead, &guestRc);
-            if (RT_FAILURE(vrc))
+            if (   RT_FAILURE(vrc)
+                || vrc == VWRN_GSTCTL_OBJECTSTATE_CHANGED)
                 break;
 
@@ -2266 +2350 @@
     } while (!fDone && RT_SUCCESS(vrc));
 
+#undef UPDATE_AND_CHECK_ELAPSED_TIME
+#undef GET_REMAINING_TIME
+
     LogFlowThisFunc(("Loop ended with rc=%Rrc, guestRc=%Rrc, waitRes=%ld\n",
                      vrc, guestRc, waitRes));
@@ -2271 +2358 @@
         *pGuestRc = guestRc;
 
-    LogFlowThisFunc(("Returning rc=%Rrc\n", vrc));
+    LogFlowFuncLeaveRC(vrc);
     return vrc;
 }

trunk/src/VBox/Main/src-client/GuestSessionImpl.cpp

@@ -114 +114 @@
             {
                 Assert(!mSession.isNull());
-                int rc2 = mSession->signalWaitEvents(aType, aEvent);
+                int rc2 = mSession->signalWaitEvent(aType, aEvent);
 #ifdef DEBUG_andy
                 LogFlowFunc(("Signalling events of type=%ld, session=%p resulted in rc=%Rrc\n",
@@ -289 +289 @@
          itDirs != mData.mDirectories.end(); ++itDirs)
     {
-        (*itDirs)->Release();
+        itDirs->second->Release();
     }
     mData.mDirectories.clear();
@@ -665 +665 @@
 
     GuestWaitEvent *pEvent = NULL;
-    std::list < VBoxEventType_T > eventTypes;
+    GuestEventTypes eventTypes;
     try
     {
@@ -702 +702 @@
 }
 
+int GuestSession::directoryCreateInternal(const Utf8Str &strPath, uint32_t uMode,
+                                          uint32_t uFlags, int *pGuestRc)
+{
+    LogFlowThisFunc(("strPath=%s, uMode=%x, uFlags=%x\n",
+                     strPath.c_str(), uMode, uFlags));
+
+    int vrc = VINF_SUCCESS;
+
+    GuestProcessStartupInfo procInfo;
+    procInfo.mCommand = Utf8Str(VBOXSERVICE_TOOL_MKDIR);
+    procInfo.mFlags   = ProcessCreateFlag_Hidden;
+
+    try
+    {
+        /* Construct arguments. */
+        if (uFlags & DirectoryCreateFlag_Parents)
+            procInfo.mArguments.push_back(Utf8Str("--parents")); /* We also want to create the parent directories. */
+        if (uMode)
+        {
+            procInfo.mArguments.push_back(Utf8Str("--mode")); /* Set the creation mode. */
+
+            char szMode[16];
+            if (RTStrPrintf(szMode, sizeof(szMode), "%o", uMode))
+            {
+                procInfo.mArguments.push_back(Utf8Str(szMode));
+            }
+            else
+                vrc = VERR_BUFFER_OVERFLOW;
+        }
+        procInfo.mArguments.push_back(strPath); /* The directory we want to create. */
+    }
+    catch (std::bad_alloc)
+    {
+        vrc = VERR_NO_MEMORY;
+    }
+
+    if (RT_SUCCESS(vrc))
+        vrc = GuestProcessTool::Run(this, procInfo, pGuestRc);
+
+    LogFlowFuncLeaveRC(vrc);
+    return vrc;
+}
+
+inline bool GuestSession::directoryExists(uint32_t uDirID, ComObjPtr<GuestDirectory> *pDir)
+{
+    SessionDirectories::const_iterator it = mData.mDirectories.find(uDirID);
+    if (it != mData.mDirectories.end())
+    {
+        if (pDir)
+            *pDir = it->second;
+        return true;
+    }
+    return false;
+}
+
+int GuestSession::directoryQueryInfoInternal(const Utf8Str &strPath, GuestFsObjData &objData, int *pGuestRc)
+{
+    LogFlowThisFunc(("strPath=%s\n", strPath.c_str()));
+
+    int vrc = fsQueryInfoInternal(strPath, objData, pGuestRc);
+    if (RT_SUCCESS(vrc))
+    {
+        vrc = objData.mType == FsObjType_Directory
+            ? VINF_SUCCESS : VERR_NOT_A_DIRECTORY;
+    }
+
+    LogFlowFuncLeaveRC(vrc);
+    return vrc;
+}
+
 int GuestSession::directoryRemoveFromList(GuestDirectory *pDirectory)
 {
@@ -709 +779 @@
          itDirs != mData.mDirectories.end(); ++itDirs)
     {
-        if (pDirectory == (*itDirs))
+        if (pDirectory == itDirs->second)
         {
             Bstr strName;
-            HRESULT hr = (*itDirs)->COMGETTER(DirectoryName)(strName.asOutParam());
+            HRESULT hr = itDirs->second->COMGETTER(DirectoryName)(strName.asOutParam());
             ComAssertComRC(hr);
 
@@ -727 +797 @@
 }
 
-int GuestSession::directoryCreateInternal(const Utf8Str &strPath, uint32_t uMode, uint32_t uFlags, int *pGuestRc)
-{
-    /* pGuestRc is optional. */
-
-    LogFlowThisFunc(("strPath=%s, uMode=%x, uFlags=%x\n",
-                     strPath.c_str(), uMode, uFlags));
-
-    GuestProcessStartupInfo procInfo;
-    procInfo.mCommand = Utf8Str(VBOXSERVICE_TOOL_MKDIR);
-    procInfo.mFlags   = ProcessCreateFlag_Hidden;
-
-    int vrc = VINF_SUCCESS;
-
-    /* Construct arguments. */
-    if (uFlags & DirectoryCreateFlag_Parents)
-        procInfo.mArguments.push_back(Utf8Str("--parents")); /* We also want to create the parent directories. */
-    if (uMode)
-    {
-        procInfo.mArguments.push_back(Utf8Str("--mode")); /* Set the creation mode. */
-
-        char szMode[16];
-        if (RTStrPrintf(szMode, sizeof(szMode), "%o", uMode))
-        {
-            procInfo.mArguments.push_back(Utf8Str(szMode));
-        }
-        else
-            vrc = VERR_BUFFER_OVERFLOW;
-    }
-    procInfo.mArguments.push_back(strPath); /* The directory we want to create. */
-
+int GuestSession::directoryRemoveInternal(const Utf8Str &strPath, uint32_t uFlags,
+                                          int *pGuestRc)
+{
+    AssertReturn(!(uFlags & ~DIRREMOVE_FLAG_VALID_MASK), VERR_INVALID_PARAMETER);
+
+    LogFlowThisFunc(("strPath=%s, uFlags=0x%x\n", strPath.c_str(), uFlags));
+
+    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    GuestWaitEvent *pEvent = NULL;
+    int vrc = registerWaitEvent(mData.mSession.mID, 0 /* Object ID */,
+                                &pEvent);
+    if (RT_FAILURE(vrc))
+        return vrc;
+
+    /* Prepare HGCM call. */
+    VBOXHGCMSVCPARM paParms[8];
+    int i = 0;
+    paParms[i++].setUInt32(pEvent->ContextID());
+    paParms[i++].setPointer((void*)strPath.c_str(),
+                            (ULONG)strPath.length() + 1);
+    paParms[i++].setUInt32(uFlags);
+
+    alock.release(); /* Drop write lock before sending. */
+
+    vrc = sendCommand(HOST_DIR_REMOVE, i, paParms);
     if (RT_SUCCESS(vrc))
     {
-        int guestRc;
-        GuestProcessTool procTool;
-        vrc = procTool.Init(this, procInfo, false /* Async */, &guestRc);
-        if (RT_SUCCESS(vrc))
-        {
-            if (RT_SUCCESS(guestRc))
-                vrc = procTool.Wait(GUESTPROCESSTOOL_FLAG_NONE, &guestRc);
-        }
-
-        if (RT_SUCCESS(vrc))
-        {
-            if (RT_SUCCESS(guestRc))
-                guestRc = procTool.TerminatedOk(NULL /* Exit code */);
-        }
-
+        vrc = pEvent->Wait(30 * 1000);
         if (   vrc == VERR_GSTCTL_GUEST_ERROR
             && pGuestRc)
-        {
-            *pGuestRc = guestRc;
-        }
-    }
+            *pGuestRc = pEvent->GuestResult();
+    }
+
+    unregisterWaitEvent(pEvent);
 
     LogFlowFuncLeaveRC(vrc);
@@ -785 +837 @@
 }
 
-int GuestSession::directoryQueryInfoInternal(const Utf8Str &strPath, GuestFsObjData &objData, int *pGuestRc)
-{
-    LogFlowThisFunc(("strPath=%s\n", strPath.c_str()));
-
-    int vrc = fsQueryInfoInternal(strPath, objData, pGuestRc);
-    if (RT_SUCCESS(vrc))
-    {
-        vrc = objData.mType == FsObjType_Directory
-            ? VINF_SUCCESS : VERR_NOT_A_DIRECTORY;
-    }
-
-    LogFlowFuncLeaveRC(vrc);
-    return vrc;
-}
-
 int GuestSession::objectCreateTempInternal(const Utf8Str &strTemplate, const Utf8Str &strPath,
                                            bool fDirectory, const Utf8Str &strName, int *pGuestRc)
 {
+    LogFlowThisFunc(("strTemplate=%s, strPath=%s, fDirectory=%RTbool, strName=%s\n",
+                     strTemplate.c_str(), strPath.c_str(), fDirectory, strName.c_str()));
+
+    int vrc = VINF_SUCCESS;
+
     GuestProcessStartupInfo procInfo;
     procInfo.mCommand = Utf8Str(VBOXSERVICE_TOOL_MKTEMP);
     procInfo.mFlags   = ProcessCreateFlag_WaitForStdOut;
-    procInfo.mArguments.push_back(Utf8Str("--machinereadable"));
-    if (fDirectory)
-        procInfo.mArguments.push_back(Utf8Str("-d"));
-    if (strPath.length()) /* Otherwise use /tmp or equivalent. */
-    {
-        procInfo.mArguments.push_back(Utf8Str("-t"));
-        procInfo.mArguments.push_back(strPath);
-    }
-    procInfo.mArguments.push_back(strTemplate);
-
-    GuestProcessTool procTool; int guestRc;
-    int vrc = procTool.Init(this, procInfo, false /* Async */, &guestRc);
+
+    try
+    {
+        procInfo.mArguments.push_back(Utf8Str("--machinereadable"));
+        if (fDirectory)
+            procInfo.mArguments.push_back(Utf8Str("-d"));
+        if (strPath.length()) /* Otherwise use /tmp or equivalent. */
+        {
+            procInfo.mArguments.push_back(Utf8Str("-t"));
+            procInfo.mArguments.push_back(strPath);
+        }
+        procInfo.mArguments.push_back(strTemplate);
+    }
+    catch (std::bad_alloc)
+    {
+        vrc = VERR_NO_MEMORY;
+    }
+
     if (RT_SUCCESS(vrc))
-    {
-        if (RT_SUCCESS(guestRc))
-            vrc = procTool.Wait(GUESTPROCESSTOOL_FLAG_NONE, &guestRc);
-    }
-
-    if (RT_SUCCESS(vrc))
-    {
-        if (RT_SUCCESS(guestRc))
-            guestRc = procTool.TerminatedOk(NULL /* Exit code */);
-    }
-
-    if (   vrc == VERR_GSTCTL_GUEST_ERROR
-        && pGuestRc)
-    {
-        *pGuestRc = guestRc;
-    }
+        vrc = GuestProcessTool::Run(this, procInfo, pGuestRc);
 
     LogFlowFuncLeaveRC(vrc);
@@ -840 +873 @@
 }
 
-int GuestSession::directoryOpenInternal(const Utf8Str &strPath, const Utf8Str &strFilter,
-                                        uint32_t uFlags, ComObjPtr<GuestDirectory> &pDirectory)
+int GuestSession::directoryOpenInternal(const GuestDirectoryOpenInfo &openInfo,
+                                        ComObjPtr<GuestDirectory> &pDirectory, int *pGuestRc)
 {
     LogFlowThisFunc(("strPath=%s, strPath=%s, uFlags=%x\n",
-                     strPath.c_str(), strFilter.c_str(), uFlags));
+                     openInfo.mPath.c_str(), openInfo.mFilter.c_str(), openInfo.mFlags));
 
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    int rc = VERR_MAX_PROCS_REACHED;
+    if (mData.mNumObjects >= VBOX_GUESTCTRL_MAX_OBJECTS)
+        return rc;
+
+    /* Create a new (host-based) directory ID and assign it. */
+    uint32_t uNewDirID = 0;
+    ULONG uTries = 0;
+
+    for (;;)
+    {
+        /* Is the directory ID already used? */
+        if (!directoryExists(uNewDirID, NULL /* pDirectory */))
+        {
+            /* Callback with context ID was not found. This means
+             * we can use this context ID for our new callback we want
+             * to add below. */
+            rc = VINF_SUCCESS;
+            break;
+        }
+        uNewDirID++;
+        if (uNewDirID == VBOX_GUESTCTRL_MAX_OBJECTS)
+            uNewDirID = 0;
+
+        if (++uTries == UINT32_MAX)
+            break; /* Don't try too hard. */
+    }
+
+    if (RT_FAILURE(rc))
+        return rc;
 
     /* Create the directory object. */
@@ -853 +916 @@
         return VERR_COM_UNEXPECTED;
 
-    int vrc = pDirectory->init(this /* Parent */,
-                               strPath, strFilter, uFlags);
+    Console *pConsole = mParent->getConsole();
+    AssertPtr(pConsole);
+
+    int vrc = pDirectory->init(pConsole, this /* Parent */,
+                               uNewDirID, openInfo);
     if (RT_FAILURE(vrc))
         return vrc;
 
-    /* Add the created directory to our vector. */
-    mData.mDirectories.push_back(pDirectory);
-
-    LogFlowFunc(("Added new directory \"%s\" (Session: %RU32)\n",
-                 strPath.c_str(), mData.mSession.mID));
+    /*
+     * Since this is a synchronous guest call we have to
+     * register the file object first, releasing the session's
+     * lock and then proceed with the actual opening command
+     * -- otherwise the file's opening callback would hang
+     * because the session's lock still is in place.
+     */
+    try
+    {
+        /* Add the created directory to our map. */
+        mData.mDirectories[uNewDirID] = pDirectory;
+        mData.mNumObjects++;
+        Assert(mData.mNumObjects <= VBOX_GUESTCTRL_MAX_OBJECTS);
+
+        LogFlowFunc(("Added new guest directory \"%s\" (Session: %RU32) (now total %ld dirs, %ld objects)\n",
+                     openInfo.mPath.c_str(), mData.mSession.mID, mData.mFiles.size(), mData.mNumObjects));
+
+        alock.release(); /* Release lock before firing off event. */
+
+        /** @todo Fire off a VBoxEventType_OnGuestDirectoryRegistered event? */
+    }
+    catch (std::bad_alloc &)
+    {
+        rc = VERR_NO_MEMORY;
+    }
+
+    if (RT_SUCCESS(rc))
+    {
+        /* Nothing further to do here yet. */
+        if (pGuestRc)
+            *pGuestRc = VINF_SUCCESS;
+    }
 
     LogFlowFuncLeaveRC(vrc);
     return vrc;
+}
+
+int GuestSession::dispatchToDirectory(PVBOXGUESTCTRLHOSTCBCTX pCtxCb, PVBOXGUESTCTRLHOSTCALLBACK pSvcCb)
+{
+    LogFlowFunc(("pCtxCb=%p, pSvcCb=%p\n", pCtxCb, pSvcCb));
+
+    AssertPtrReturn(pCtxCb, VERR_INVALID_POINTER);
+    AssertPtrReturn(pSvcCb, VERR_INVALID_POINTER);
+
+    if (pSvcCb->mParms < 3)
+        return VERR_INVALID_PARAMETER;
+
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    uint32_t uDirID = VBOX_GUESTCTRL_CONTEXTID_GET_OBJECT(pCtxCb->uContextID);
+#ifdef DEBUG
+    LogFlowFunc(("uDirID=%RU32 (%RU32 total)\n",
+                 uDirID, mData.mFiles.size()));
+#endif
+    int rc;
+    SessionDirectories::const_iterator itDir
+        = mData.mDirectories.find(uDirID);
+    if (itDir != mData.mDirectories.end())
+    {
+        ComObjPtr<GuestDirectory> pDirectory(itDir->second);
+        Assert(!pDirectory.isNull());
+
+        alock.release();
+
+        rc = pDirectory->callbackDispatcher(pCtxCb, pSvcCb);
+    }
+    else
+        rc = VERR_NOT_FOUND;
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
 }
 
@@ -901 +1030 @@
 }
 
+int GuestSession::dispatchToObject(PVBOXGUESTCTRLHOSTCBCTX pCtxCb, PVBOXGUESTCTRLHOSTCALLBACK pSvcCb)
+{
+    LogFlowFunc(("pCtxCb=%p, pSvcCb=%p\n", pCtxCb, pSvcCb));
+
+    AssertPtrReturn(pCtxCb, VERR_INVALID_POINTER);
+    AssertPtrReturn(pSvcCb, VERR_INVALID_POINTER);
+
+    int rc;
+    uint32_t uObjectID = VBOX_GUESTCTRL_CONTEXTID_GET_OBJECT(pCtxCb->uContextID);
+
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    /* Since we don't know which type the object is, we need to through all
+     * all objects. */
+    /** @todo Speed this up by adding an object type to the callback context! */
+    SessionProcesses::const_iterator itProc = mData.mProcesses.find(uObjectID);
+    if (itProc == mData.mProcesses.end())
+    {
+        SessionFiles::const_iterator itFile = mData.mFiles.find(uObjectID);
+        if (itFile != mData.mFiles.end())
+        {
+            alock.release();
+
+            rc = dispatchToFile(pCtxCb, pSvcCb);
+        }
+        else
+        {
+            SessionDirectories::const_iterator itDir = mData.mDirectories.find(uObjectID);
+            if (itDir != mData.mDirectories.end())
+            {
+                alock.release();
+
+                rc = dispatchToDirectory(pCtxCb, pSvcCb);
+            }
+            else
+                rc = VERR_NOT_FOUND;
+        }
+    }
+    else
+    {
+        alock.release();
+
+        rc = dispatchToProcess(pCtxCb, pSvcCb);
+    }
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
+}
+
 int GuestSession::dispatchToProcess(PVBOXGUESTCTRLHOSTCBCTX pCtxCb, PVBOXGUESTCTRLHOSTCALLBACK pSvcCb)
 {
@@ -949 +1127 @@
 #endif
 
-    int rc = VINF_SUCCESS;
+    int rc;
     switch (pCbCtx->uFunction)
     {
@@ -956 +1134 @@
             break;
 
-        case GUEST_SESSION_NOTIFY:
+        case GUEST_SESSION_NOTIFY: /* Guest Additions >= 4.3.0. */
         {
             rc = onSessionStatusChange(pCbCtx, pSvcCb);
@@ -1024 +1202 @@
 int GuestSession::fileRemoveInternal(const Utf8Str &strPath, int *pGuestRc)
 {
+    LogFlowThisFunc(("strPath=%s\n", strPath.c_str()));
+
+    int vrc = VINF_SUCCESS;
+
     GuestProcessStartupInfo procInfo;
     GuestProcessStream      streamOut;
@@ -1029 +1211 @@
     procInfo.mCommand = Utf8Str(VBOXSERVICE_TOOL_RM);
     procInfo.mFlags   = ProcessCreateFlag_WaitForStdOut;
-    procInfo.mArguments.push_back(Utf8Str("--machinereadable"));
-    procInfo.mArguments.push_back(strPath); /* The file we want to remove. */
-
-    GuestProcessTool procTool; int guestRc;
-    int vrc = procTool.Init(this, procInfo, false /* Async */, &guestRc);
+
+    try
+    {
+        procInfo.mArguments.push_back(Utf8Str("--machinereadable"));
+        procInfo.mArguments.push_back(strPath); /* The file we want to remove. */
+    }
+    catch (std::bad_alloc)
+    {
+        vrc = VERR_NO_MEMORY;
+    }
+
     if (RT_SUCCESS(vrc))
-        vrc = procTool.Wait(GUESTPROCESSTOOL_FLAG_NONE, &guestRc);
-
-    if (RT_SUCCESS(vrc))
-    {
-        if (RT_SUCCESS(guestRc))
-            guestRc = procTool.TerminatedOk(NULL /* Exit code */);
-    }
-
-    if (   vrc == VERR_GSTCTL_GUEST_ERROR
-        && pGuestRc)
-    {
-        *pGuestRc = guestRc;
-    }
+        vrc = GuestProcessTool::Run(this, procInfo, pGuestRc);
 
     LogFlowFuncLeaveRC(vrc);
@@ -1053 +1229 @@
 }
 
-int GuestSession::fileOpenInternal(const GuestFileOpenInfo &openInfo, ComObjPtr<GuestFile> &pFile, int *pGuestRc)
+int GuestSession::fileOpenInternal(const GuestFileOpenInfo &openInfo,
+                                   ComObjPtr<GuestFile> &pFile, int *pGuestRc)
 {
     LogFlowThisFunc(("strPath=%s, strOpenMode=%s, strDisposition=%s, uCreationMode=%x, uOffset=%RU64\n",
@@ -1080 +1257 @@
     {
         /* Is the file ID already used? */
-        if (!fileExists(uNewFileID, NULL /* pProgress */))
+        if (!fileExists(uNewFileID, NULL /* pFile */))
         {
             /* Callback with context ID was not found. This means
@@ -1185 +1362 @@
     LogFlowThisFunc(("strPath=%s\n", strPath.c_str()));
 
+    int vrc = VINF_SUCCESS;
+
     /** @todo Merge this with IGuestFile::queryInfo(). */
     GuestProcessStartupInfo procInfo;
@@ -1190 +1369 @@
     procInfo.mFlags   = ProcessCreateFlag_WaitForStdOut;
 
-    /* Construct arguments. */
-    procInfo.mArguments.push_back(Utf8Str("--machinereadable"));
-    procInfo.mArguments.push_back(strPath);
-
-    GuestProcessTool procTool; int guestRc;
-    int vrc = procTool.Init(this, procInfo, false /* Async */, &guestRc);
+    try
+    {
+        /* Construct arguments. */
+        procInfo.mArguments.push_back(Utf8Str("--machinereadable"));
+        procInfo.mArguments.push_back(strPath);
+    }
+    catch (std::bad_alloc)
+    {
+        vrc = VERR_NO_MEMORY;
+    }
+
+    int guestRc; GuestCtrlStreamObjects stdOut;
     if (RT_SUCCESS(vrc))
-        vrc = procTool.Wait(GUESTPROCESSTOOL_FLAG_NONE, &guestRc);
-    if (RT_SUCCESS(vrc))
-    {
-        guestRc = procTool.TerminatedOk(NULL /* Exit code */);
-        if (RT_SUCCESS(guestRc))
-        {
-            GuestProcessStreamBlock curBlock;
-            vrc = procTool.GetCurrentBlock(OUTPUT_HANDLE_ID_STDOUT,  curBlock);
-            /** @todo Check for more / validate blocks! */
-            if (RT_SUCCESS(vrc))
-                vrc = objData.FromStat(curBlock);
-        }
-    }
-
-    if (   vrc == VERR_GSTCTL_GUEST_ERROR
-        && pGuestRc)
-    {
-        *pGuestRc = guestRc;
+        vrc = GuestProcessTool::RunEx(this, procInfo,
+                                      &stdOut, 1 /* cStrmOutObjects */,
+                                      &guestRc);
+    if (   RT_SUCCESS(vrc)
+        && RT_SUCCESS(guestRc))
+    {
+        if (!stdOut.empty())
+            vrc = objData.FromStat(stdOut.at(0));
+        else
+            vrc = VERR_NO_DATA;
     }
 
@@ -1403 +1580 @@
     /* Set current session status. */
     mData.mStatus = GuestSessionStatus_Starting;
+    mData.mRC = VINF_SUCCESS; /* Clear previous error, if any. */
 
     int vrc;
 
     GuestWaitEvent *pEvent = NULL;
-    std::list < VBoxEventType_T > eventTypes;
+    GuestEventTypes eventTypes;
     try
     {
@@ -1440 +1618 @@
     vrc = sendCommand(HOST_SESSION_CREATE, i, paParms);
     if (RT_SUCCESS(vrc))
+    {
         vrc = waitForStatusChange(pEvent, GuestSessionWaitForFlag_Start,
                                   30 * 1000 /* 30s timeout */,
                                   NULL /* Session status */, pGuestRc);
+    }
+    else
+    {
+        /*
+         * Unable to start guest session - update its current state.
+         * Since there is no (official API) way to recover a failed guest session
+         * this also marks the end state. Internally just calling this
+         * same function again will work though.
+         */
+        mData.mStatus = GuestSessionStatus_Error;
+        mData.mRC = vrc;
+    }
 
     unregisterWaitEvent(pEvent);
@@ -1498 +1689 @@
     int vrc = pSession->startSessionInternal(NULL /* Guest rc, ignored */);
     /* Nothing to do here anymore. */
+
+    LogFlowFuncLeaveRC(vrc);
+    return vrc;
+}
+
+int GuestSession::pathRenameInternal(const Utf8Str &strSource, const Utf8Str &strDest,
+                                     uint32_t uFlags, int *pGuestRc)
+{
+    AssertReturn(!(uFlags & ~PATHRENAME_FLAG_VALID_MASK), VERR_INVALID_PARAMETER);
+
+    LogFlowThisFunc(("strSource=%s, strDest=%s, uFlags=0x%x\n",
+                     strSource.c_str(), strDest.c_str(), uFlags));
+
+    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    GuestWaitEvent *pEvent = NULL;
+    int vrc = registerWaitEvent(mData.mSession.mID, 0 /* Object ID */,
+                                &pEvent);
+    if (RT_FAILURE(vrc))
+        return vrc;
+
+    /* Prepare HGCM call. */
+    VBOXHGCMSVCPARM paParms[8];
+    int i = 0;
+    paParms[i++].setUInt32(pEvent->ContextID());
+    paParms[i++].setPointer((void*)strSource.c_str(),
+                            (ULONG)strSource.length() + 1);
+    paParms[i++].setPointer((void*)strDest.c_str(),
+                            (ULONG)strDest.length() + 1);
+    paParms[i++].setUInt32(uFlags);
+
+    alock.release(); /* Drop write lock before sending. */
+
+    vrc = sendCommand(HOST_PATH_RENAME, i, paParms);
+    if (RT_SUCCESS(vrc))
+    {
+        vrc = pEvent->Wait(30 * 1000);
+        if (   vrc == VERR_GSTCTL_GUEST_ERROR
+            && pGuestRc)
+            *pGuestRc = pEvent->GuestResult();
+    }
+
+    unregisterWaitEvent(pEvent);
 
     LogFlowFuncLeaveRC(vrc);
@@ -1625 +1859 @@
     {
         /* Is the context ID already used? */
-        if (!processExists(uNewProcessID, NULL /* pProgress */))
+        if (!processExists(uNewProcessID, NULL /* pProcess */))
         {
             /* Callback with context ID was not found. This means
@@ -1988 +2222 @@
 
     GuestWaitEvent *pEvent = NULL;
-    std::list < VBoxEventType_T > eventTypes;
+    GuestEventTypes eventTypes;
     try
     {
@@ -2110 +2344 @@
     /* Remove ourselves from the session list. */
     int rc2 = mParent->sessionRemove(this);
+    if (rc2 == VERR_NOT_FOUND) /* Not finding the session anymore isn't critical. */
+        rc2 = VINF_SUCCESS;
+
     if (RT_SUCCESS(rc))
         rc = rc2;
@@ -2418 +2655 @@
     HRESULT hr = S_OK;
 
-    ComObjPtr <GuestDirectory> pDirectory;
-    int rc = directoryOpenInternal(Utf8Str(aPath), Utf8Str(aFilter), fFlags, pDirectory);
+    GuestDirectoryOpenInfo openInfo;
+    openInfo.mPath = Utf8Str(aPath);
+    openInfo.mFilter = Utf8Str(aFilter);
+    openInfo.mFlags = fFlags;
+
+    ComObjPtr <GuestDirectory> pDirectory; int guestRc;
+    int rc = directoryOpenInternal(openInfo, pDirectory, &guestRc);
     if (RT_SUCCESS(rc))
     {
@@ -2433 +2675 @@
                                                    Utf8Str(aPath).c_str()));
                break;
+
+            case VERR_GSTCTL_GUEST_ERROR:
+                hr = GuestDirectory::setErrorExternal(this, guestRc);
+                break;
 
             default:
@@ -2511 +2757 @@
     LogFlowThisFuncEnter();
 
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    ReturnComNotImplemented();
+    if (RT_UNLIKELY((aPath) == NULL || *(aPath) == '\0'))
+        return setError(E_INVALIDARG, tr("No directory to remove specified"));
+
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    HRESULT hr = isReadyExternal();
+    if (FAILED(hr))
+        return hr;
+
+    /* No flags; only remove the directory when empty. */
+    uint32_t uFlags = 0;
+
+    int guestRc;
+    int vrc = directoryRemoveInternal(Utf8Str(aPath), uFlags, &guestRc);
+    if (RT_FAILURE(vrc))
+    {
+        switch (vrc)
+        {
+            case VERR_NOT_SUPPORTED:
+                hr = setError(VBOX_E_IPRT_ERROR,
+                              tr("Handling removing guest directories not supported by installed Guest Additions"));
+                break;
+
+            case VERR_GSTCTL_GUEST_ERROR:
+                hr = GuestDirectory::setErrorExternal(this, guestRc);
+                break;
+
+            default:
+                hr = setError(VBOX_E_IPRT_ERROR, tr("Removing guest directory \"%s\" failed: %Rrc"),
+                              Utf8Str(aPath).c_str(), vrc);
+                break;
+        }
+    }
+
+    return hr;
 #endif /* VBOX_WITH_GUEST_CONTROL */
 }
@@ -2525 +2803 @@
     LogFlowThisFuncEnter();
 
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    ReturnComNotImplemented();
+    if (RT_UNLIKELY((aPath) == NULL || *(aPath) == '\0'))
+        return setError(E_INVALIDARG, tr("No directory to remove recursively specified"));
+
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    HRESULT hr = isReadyExternal();
+    if (FAILED(hr))
+        return hr;
+
+    ComObjPtr<Progress> pProgress;
+    hr = pProgress.createObject();
+    if (SUCCEEDED(hr))
+        hr = pProgress->init(static_cast<IGuestSession *>(this),
+                             Bstr(tr("Removing guest directory")).raw(),
+                             TRUE /*aCancelable*/);
+    if (FAILED(hr))
+        return hr;
+
+    /* Note: At the moment we don't supply progress information while
+     *       deleting a guest directory recursively. So just complete
+     *       the progress object right now. */
+     /** @todo Implement progress reporting on guest directory deletion! */
+    hr = pProgress->notifyComplete(S_OK);
+    if (FAILED(hr))
+        return hr;
+
+    /* Remove the directory + all its contents. */
+    uint32_t uFlags = DIRREMOVE_FLAG_RECURSIVE
+                    | DIRREMOVE_FLAG_CONTENT_AND_DIR;
+    int guestRc;
+    int vrc = directoryRemoveInternal(Utf8Str(aPath), uFlags, &guestRc);
+    if (RT_FAILURE(vrc))
+    {
+        switch (vrc)
+        {
+            case VERR_NOT_SUPPORTED:
+                hr = setError(VBOX_E_IPRT_ERROR,
+                              tr("Handling removing guest directories recursively not supported by installed Guest Additions"));
+                break;
+
+            case VERR_GSTCTL_GUEST_ERROR:
+                hr = GuestFile::setErrorExternal(this, guestRc);
+                break;
+
+            default:
+                hr = setError(VBOX_E_IPRT_ERROR, tr("Recursively removing guest directory \"%s\" failed: %Rrc"),
+                              Utf8Str(aPath).c_str(), vrc);
+                break;
+        }
+    }
+    else
+    {
+        pProgress.queryInterfaceTo(aProgress);
+    }
+
+    return hr;
 #endif /* VBOX_WITH_GUEST_CONTROL */
 }
@@ -2539 +2870 @@
     LogFlowThisFuncEnter();
 
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    ReturnComNotImplemented();
+    if (RT_UNLIKELY((aSource) == NULL || *(aSource) == '\0'))
+        return setError(E_INVALIDARG, tr("No source directory to rename specified"));
+
+    if (RT_UNLIKELY((aDest) == NULL || *(aDest) == '\0'))
+        return setError(E_INVALIDARG, tr("No destination directory to rename the source to specified"));
+
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    HRESULT hr = isReadyExternal();
+    if (FAILED(hr))
+        return hr;
+
+    /* No flags; only remove the directory when empty. */
+    uint32_t uFlags = 0;
+
+    int guestRc;
+    int vrc = pathRenameInternal(Utf8Str(aSource), Utf8Str(aDest), uFlags, &guestRc);
+    if (RT_FAILURE(vrc))
+    {
+        switch (vrc)
+        {
+            case VERR_NOT_SUPPORTED:
+                hr = setError(VBOX_E_IPRT_ERROR,
+                              tr("Handling renaming guest directories not supported by installed Guest Additions"));
+                break;
+
+            case VERR_GSTCTL_GUEST_ERROR:
+                hr = setError(VBOX_E_IPRT_ERROR,
+                              tr("Renaming guest directory failed: %Rrc"), guestRc);
+                break;
+
+            default:
+                hr = setError(VBOX_E_IPRT_ERROR, tr("Renaming guest directory \"%s\" failed: %Rrc"),
+                              Utf8Str(aSource).c_str(), vrc);
+                break;
+        }
+    }
+
+    return hr;
 #endif /* VBOX_WITH_GUEST_CONTROL */
 }
@@ -2930 +3297 @@
     LogFlowThisFuncEnter();
 
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    ReturnComNotImplemented();
+    if (RT_UNLIKELY((aSource) == NULL || *(aSource) == '\0'))
+        return setError(E_INVALIDARG, tr("No source file to rename specified"));
+
+    if (RT_UNLIKELY((aDest) == NULL || *(aDest) == '\0'))
+        return setError(E_INVALIDARG, tr("No destination file to rename the source to specified"));
+
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    HRESULT hr = isReadyExternal();
+    if (FAILED(hr))
+        return hr;
+
+    /* No flags; only remove the directory when empty. */
+    uint32_t uFlags = 0;
+
+    int guestRc;
+    int vrc = pathRenameInternal(Utf8Str(aSource), Utf8Str(aDest), uFlags, &guestRc);
+    if (RT_FAILURE(vrc))
+    {
+        switch (vrc)
+        {
+            case VERR_NOT_SUPPORTED:
+                hr = setError(VBOX_E_IPRT_ERROR,
+                              tr("Handling renaming guest files not supported by installed Guest Additions"));
+                break;
+
+            case VERR_GSTCTL_GUEST_ERROR:
+                /** @todo Proper guestRc to text translation needed. */
+                hr = setError(VBOX_E_IPRT_ERROR,
+                              tr("Renaming guest file failed: %Rrc"), guestRc);
+                break;
+
+            default:
+                hr = setError(VBOX_E_IPRT_ERROR, tr("Renaming guest file \"%s\" failed: %Rrc"),
+                              Utf8Str(aSource).c_str(), vrc);
+                break;
+        }
+    }
+
+    return hr;
 #endif /* VBOX_WITH_GUEST_CONTROL */
 }

trunk/src/VBox/Main/src-client/GuestSessionImplTasks.cpp

@@ -627 +627 @@
         {
             GuestProcessStartupInfo procInfo;
-            procInfo.mName    = Utf8StrFmt(GuestSession::tr("Copying file \"%s\" from guest to the host to \"%s\" (%RI64 bytes)"),
-                                                            mSource.c_str(), mDest.c_str(), objData.mObjectSize);
+            procInfo.mName      = Utf8StrFmt(GuestSession::tr("Copying file \"%s\" from guest to the host to \"%s\" (%RI64 bytes)"),
+                                                              mSource.c_str(), mDest.c_str(), objData.mObjectSize);
             procInfo.mCommand   = Utf8Str(VBOXSERVICE_TOOL_CAT);
             procInfo.mFlags     = ProcessCreateFlag_Hidden | ProcessCreateFlag_WaitForStdOut;