Changeset 38395 in vbox for trunk/src

Timestamp:

Aug 10, 2011 11:48:29 AM (14 years ago)

Author:

vboxsync

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

73430

Message:

GuestCtrl: Update.

Location:

trunk/src/VBox

Files:

• Additions/common/VBoxService/VBoxServiceControlExec.cpp (modified) (2 diffs)
• Frontends/VBoxManage/VBoxManageGuestCtrl.cpp (modified) (8 diffs)
• Main/idl/VirtualBox.xidl (modified) (2 diffs)
• Main/include/GuestCtrlImplPrivate.h (modified) (4 diffs)
• Main/include/GuestImpl.h (modified) (7 diffs)
• Main/src-client/GuestCtrlIO.cpp (modified) (6 diffs)
• Main/src-client/GuestCtrlImpl.cpp (modified) (20 diffs)
• Main/src-client/GuestCtrlImplDir.cpp (modified) (10 diffs)
• Main/src-client/GuestCtrlImplFile.cpp (modified) (4 diffs)
• Main/src-client/GuestDirEntryImpl.cpp (modified) (1 diff)
• Main/testcase/tstGuestCtrlParseBuffer.cpp (modified) (9 diffs)

trunk/src/VBox/Additions/common/VBoxService/VBoxServiceControlExec.cpp

@@ -1359 +1359 @@
     Assert(uStatus > INPUT_STS_UNDEFINED);
 
-    VBoxServiceVerbose(3, "ControlExec: [PID %u]: Input processed, uStatus=%u, uFlags=0x%x, cbWritten=%u\n",
-                       uPID, uStatus, uFlags, cbWritten);
+    VBoxServiceVerbose(3, "ControlExec: [PID %u]: Input processed, CID=%u, uStatus=%u, uFlags=0x%x, cbWritten=%u\n",
+                       uPID, uContextID, uStatus, uFlags, cbWritten);
 
     /* Note: Since the context ID is unique the request *has* to be completed here,
@@ -1401 +1401 @@
                                                        pBuf, _64K /* cbSize */, &cbRead);
             if (RT_SUCCESS(rc))
-                VBoxServiceVerbose(3, "ControlExec: [PID %u]: Got output, cbRead=%u, uHandle=%u, uFlags=%u\n",
-                                   uPID, cbRead, uHandleID, uFlags);
+                VBoxServiceVerbose(3, "ControlExec: [PID %u]: Got output, CID=%u, cbRead=%u, uHandle=%u, uFlags=%u\n",
+                                   uPID, uContextID, cbRead, uHandleID, uFlags);
             else
-                VBoxServiceError("ControlExec: [PID %u]: Failed to retrieve output, uHandle=%u, rc=%Rrc\n",
-                                 uPID, uHandleID, rc);
+                VBoxServiceError("ControlExec: [PID %u]: Failed to retrieve output, CID=%u, uHandle=%u, rc=%Rrc\n",
+                                 uPID, uContextID, uHandleID, rc);
 
             /* Note: Since the context ID is unique the request *has* to be completed here,

trunk/src/VBox/Frontends/VBoxManage/VBoxManageGuestCtrl.cpp

@@ -79 +79 @@
 
 /**
- * An entry for a source element, including an optional filter.
+ * An entry for a source element, including an optional DOS-like wildcard (*,?).
  */
 typedef struct SOURCEFILEENTRY
@@ -93 +93 @@
         {
             /* No file and no directory -- maybe a filter? */
-            if (NULL != strpbrk(RTPathFilename(pszSource), "*?"))
+            char *pszFilename = RTPathFilename(pszSource);
+            if (   pszFilename
+                && strpbrk(pszFilename, "*?"))
             {
                 /* Yep, get the actual filter part. */
@@ -938 +940 @@
     {
         BOOL fDirExists = FALSE;
-        HRESULT hr = pContext->pGuest->FileExists(Bstr(pszDir).raw(),
-                                                  Bstr(pContext->pszUsername).raw(),
-                                                  Bstr(pContext->pszPassword).raw(), &fDirExists);
+        HRESULT hr = pContext->pGuest->DirectoryExists(Bstr(pszDir).raw(),
+                                                       Bstr(pContext->pszUsername).raw(),
+                                                       Bstr(pContext->pszPassword).raw(), &fDirExists);
         if (FAILED(hr))
             rc = ctrlPrintError(pContext->pGuest, COM_IIDOF(IGuest));
@@ -1271 +1273 @@
                 case GuestDirEntryType_File:
                 {
-                    const char *pszName = Utf8Str(strName).c_str();
+                    Utf8Str strFile(strName);
                     if (   !pszFilter
-                        || RTStrSimplePatternMatch(pszFilter, pszName))
+                        || RTStrSimplePatternMatch(pszFilter, strFile.c_str()))
                     {
                         if (!fDirCreated)
@@ -1291 +1293 @@
                         if (RT_SUCCESS(rc))
                         {
-                            Utf8Str strDir(strName);
                             char *pszFileSource;
                             if (RTStrAPrintf(&pszFileSource, "%s/%s",
-                                             szCurDir, strDir.c_str()))
+                                             szCurDir, strFile.c_str()))
                             {
                                 char *pszFileDest;
@@ -1307 +1308 @@
                                 RTStrFree(pszFileSource);
                             }
+                            else
+                                rc = VERR_NO_MEMORY;
                         }
                     }
@@ -1315 +1318 @@
                     break;
             }
-        }
-
-        hr = pContext->pGuest->DirectoryClose(uDirHandle);
-        if (FAILED(rc))
-            rc = ctrlPrintError(pContext->pGuest, COM_IIDOF(IGuest));
+
+            if (RT_FAILURE(rc))
+                break;
+        }
+
+        if (FAILED(hr))
+        {
+            if (hr != E_ABORT)
+                rc = ctrlPrintError(pContext->pGuest, COM_IIDOF(IGuest));
+        }
+
+        HRESULT hr2 = pContext->pGuest->DirectoryClose(uDirHandle);
+        if (FAILED(hr2))
+        {
+            int rc2 = ctrlPrintError(pContext->pGuest, COM_IIDOF(IGuest));
+            if (RT_SUCCESS(rc))
+                rc = rc2;
+        }
+        else if (SUCCEEDED(hr))
+            hr = hr2;
     }
 
@@ -1549 +1567 @@
                 RTPrintf("Source: %s\n", pszSource);
 
-            /* @todo Files with filter?? */
+            /** @todo Files with filter?? */
             bool fExists;
             vrc = ctrlCopyFileExistsOnSource(pContext, pszSource, &fExists);

trunk/src/VBox/Main/idl/VirtualBox.xidl

@@ -8566 +8566 @@
   <interface
     name="IGuest" extends="$unknown"
-    uuid="ed109b6e-0578-4b17-8ace-52646789f1a0"
+    uuid="35f75ed7-df96-4988-b246-2c103555c95d"
     wsmap="managed"
     >
@@ -9009 +9009 @@
         <desc>
           <link to="DirectoryCreateFlag"/> flags.
+        </desc>
+      </param>
+    </method>
+
+    <method name="directoryExists">
+      <desc>
+        Checks if the specified directory exists and is a directory.
+
+        <result name="VBOX_E_IPRT_ERROR">
+          Error while looking up information.
+        </result>
+
+      </desc>
+      <param name="directory" type="wstring" dir="in">
+        <desc>
+          Full path of directory to check.
+        </desc>
+      </param>
+      <param name="userName" type="wstring" dir="in">
+        <desc>
+          User name under which the lookup will be performed; the
+          user has to exist and have the appropriate rights to access / read the
+          desired directory.
+        </desc>
+      </param>
+      <param name="password" type="wstring" dir="in">
+        <desc>
+          Password of the user account specified.
+        </desc>
+      </param>
+      <param name="exists" type="boolean" dir="return">
+        <desc>
+          True if it's a directory, false if it isn't (or doesn't exist).
         </desc>
       </param>

trunk/src/VBox/Main/include/GuestCtrlImplPrivate.h

@@ -39 +39 @@
 typedef struct VBOXGUESTCTRL_STREAMPAIR
 {
-    char *pszValue;
+    VBOXGUESTCTRL_STREAMPAIR(const char *pszValue)
+        : mValue(pszValue) {}
+
+    Utf8Str mValue;
 } VBOXGUESTCTRL_STREAMPAIR, *PVBOXGUESTCTRL_STREAM_PAIR;
 
@@ -58 +61 @@
     GuestProcessStreamBlock();
 
+    //GuestProcessStreamBlock(GuestProcessStreamBlock &);
+
     virtual ~GuestProcessStreamBlock();
 
 public:
-
-    int AddKey(const char *pszKey);
 
     void Clear();
@@ -85 +88 @@
 };
 
-/** Vector containing multiple stream pair objects. */
-typedef std::vector< GuestProcessStreamBlock > GuestCtrlStreamObjects;
+/** Vector containing multiple allocated stream pair objects. */
+typedef std::vector< GuestProcessStreamBlock* > GuestCtrlStreamObjects;
+typedef std::vector< GuestProcessStreamBlock* >::iterator GuestCtrlStreamObjectsIter;
+typedef std::vector< GuestProcessStreamBlock* >::const_iterator GuestCtrlStreamObjectsIterConst;
 
 /**
@@ -110 +115 @@
 
     int ParseBlock(GuestProcessStreamBlock &streamBlock);
+
+public:
+
+    static void FreeBlock(GuestProcessStreamBlock *pStreamBlock);
 
 protected:

trunk/src/VBox/Main/include/GuestImpl.h

@@ -27 +27 @@
 #include "HGCM.h"
 #ifdef VBOX_WITH_GUEST_CONTROL
+# include <iprt/fs.h>
 # include <VBox/HostServices/GuestControlSvc.h>
 using namespace guestControl;
@@ -103 +104 @@
     STDMETHOD(DirectoryClose)(ULONG aHandle);
     STDMETHOD(DirectoryCreate)(IN_BSTR aDirectory, IN_BSTR aUsername, IN_BSTR aPassword, ULONG aMode, ULONG aFlags);
+    STDMETHOD(DirectoryExists)(IN_BSTR aDirectory, IN_BSTR aUsername, IN_BSTR aPassword, BOOL *aExists);
     STDMETHOD(DirectoryOpen)(IN_BSTR aDirectory, IN_BSTR aFilter,
                              ULONG aFlags, IN_BSTR aUsername, IN_BSTR aPassword, ULONG *aHandle);
@@ -131 +133 @@
 
 # ifdef VBOX_WITH_GUEST_CONTROL
+    // Internal guest directory functions
+    int directoryCreateHandle(ULONG *puHandle, ULONG uPID, IN_BSTR aDirectory, IN_BSTR aFilter, ULONG uFlags);
     HRESULT directoryCreateInternal(IN_BSTR aDirectory, IN_BSTR aUsername, IN_BSTR aPassword,
                                     ULONG aMode, ULONG aFlags, int *pRC);
+    void directoryDestroyHandle(uint32_t uHandle);
+    HRESULT directoryExistsInternal(IN_BSTR aDirectory, IN_BSTR aUsername, IN_BSTR aPassword, BOOL *aExists);
+    uint32_t directoryGetPID(uint32_t uHandle);
+    int directoryGetNextEntry(uint32_t uHandle, GuestProcessStreamBlock &streamBlock);
+    bool directoryHandleExists(uint32_t uHandle);
     HRESULT directoryOpenInternal(IN_BSTR aDirectory, IN_BSTR aFilter,
                                   ULONG aFlags,
                                   IN_BSTR aUsername, IN_BSTR aPassword,
                                   ULONG *aHandle, int *pRC);
+    HRESULT directoryQueryInfoInternal(IN_BSTR aDirectory, IN_BSTR aUsername, IN_BSTR aPassword, PRTFSOBJINFO aObjInfo, RTFSOBJATTRADD enmAddAttribs, int *pRC);
+    // Internal guest execution functions
     HRESULT executeAndWaitForTool(IN_BSTR aTool, IN_BSTR aDescription,
                                   ComSafeArrayIn(IN_BSTR, aArguments), ComSafeArrayIn(IN_BSTR, aEnvironment),
@@ -146 +157 @@
                                    ULONG aTimeoutMS, ULONG *aPID, IProgress **aProgress, int *pRC);
     HRESULT executeProcessResult(const char *pszCommand, const char *pszUser, ULONG ulTimeout, PCALLBACKDATAEXECSTATUS pExecStatus, ULONG *puPID);
-    HRESULT executeStreamCollectBlock(ULONG aPID,
-                                      GuestProcessStream &stream, GuestProcessStreamBlock &streamBlock);
-    HRESULT executeStreamCollectOutput(ULONG aPID, GuestCtrlStreamObjects &streamObjects);
+    HRESULT executeStreamQueryFsObjInfo(IN_BSTR aObjName,GuestProcessStreamBlock *pStreamBlock, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttribs);
+    int     executeStreamDrain(ULONG aPID, GuestProcessStream &stream);
+    void    executeStreamFree(GuestCtrlStreamObjects &streamObjects);
+    void    executeStreamFreeBlock(GuestProcessStreamBlock *pBlock);
+    int     executeStreamGetNextBlock(ULONG aPID, GuestProcessStream &stream, GuestProcessStreamBlock &streamBlock);
+    HRESULT executeStreamParse(ULONG aPID, GuestCtrlStreamObjects &streamObjects);
     HRESULT executeWaitForStatusChange(ULONG uPID, ULONG uTimeoutMS, ExecuteProcessStatus_T *pRetStatus, ULONG *puRetExitCode);
-    HRESULT fileExistsInternal(IN_BSTR aFile, IN_BSTR aUsername, IN_BSTR aPassword, BOOL *aExists, int *pRC);
-    HRESULT fileQuerySizeInternal(IN_BSTR aFile, IN_BSTR aUsername, IN_BSTR aPassword, LONG64 *aSize, int *pRC);
+    // Internal guest file functions
+    HRESULT fileExistsInternal(IN_BSTR aFile, IN_BSTR aUsername, IN_BSTR aPassword, BOOL *aExists);
+    HRESULT fileQueryInfoInternal(IN_BSTR aFile, IN_BSTR aUsername, IN_BSTR aPassword, PRTFSOBJINFO aObjInfo, RTFSOBJATTRADD enmAddAttribs, int *pRC);
+    HRESULT fileQuerySizeInternal(IN_BSTR aFile, IN_BSTR aUsername, IN_BSTR aPassword, LONG64 *aSize);
 
     // Guest control dispatcher.
@@ -188 +204 @@
     int callbackGetUserData(uint32_t uContextID, eVBoxGuestCtrlCallbackType *pEnmType, void **ppvData, size_t *pcbData);
     void* callbackGetUserDataMutableRaw(uint32_t uContextID, size_t *pcbData);
+    int callbackInit(PVBOXGUESTCTRL_CALLBACK pCallback, eVBoxGuestCtrlCallbackType enmType, ComPtr<Progress> pProgress);
     bool callbackIsCanceled(uint32_t uContextID);
     bool callbackIsComplete(uint32_t uContextID);
@@ -219 +236 @@
     typedef struct VBOXGUESTCTRL_DIRECTORY
     {
-        char                       *mpszDirectory;
-        char                       *mpszFilter;
+        Bstr                        mDirectory;
+        Bstr                        mFilter;
         ULONG                       mFlags;
         /** Associated PID of started vbox_ls tool. */
-        uint32_t                    mPID;
+        ULONG                       mPID;
         GuestProcessStream          mStream;
 #if 0
@@ -237 +254 @@
     typedef std::map< uint32_t, VBOXGUESTCTRL_DIRECTORY >::const_iterator GuestDirectoryMapIterConst;
 
-    int directoryCreateHandle(ULONG *puHandle, ULONG uPID, const char *pszDirectory, const char *pszFilter, ULONG uFlags);
-    void directoryDestroyHandle(uint32_t uHandle);
-    uint32_t directoryGetPID(uint32_t uHandle);
-    int directoryGetNextEntry(uint32_t uHandle, GuestProcessStreamBlock &streamBlock);
-    bool directoryHandleExists(uint32_t uHandle);
-
     // Utility functions.
     int prepareExecuteEnv(const char *pszEnv, void **ppvList, uint32_t *pcbList, uint32_t *pcEnv);

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

@@ -35 +35 @@
 }
 
+/*
+GuestProcessStreamBlock::GuestProcessStreamBlock(const GuestProcessStreamBlock &otherBlock)
+{
+    for (GuestCtrlStreamPairsIter it = otherBlock.m_mapPairs.begin();
+         it != otherBlock.end(); it++)
+    {
+        m_mapPairs[it->first] = new
+        if (it->second.pszValue)
+        {
+            RTMemFree(it->second.pszValue);
+            it->second.pszValue = NULL;
+        }
+    }
+}*/
+
 GuestProcessStreamBlock::~GuestProcessStreamBlock()
 {
@@ -41 +56 @@
 
 /**
- * Adds a key (if not existing yet).
+ * Destroys the currently stored stream pairs.
  *
  * @return  IPRT status code.
- * @param   pszKey              Key name to add.
- */
-int GuestProcessStreamBlock::AddKey(const char *pszKey)
-{
-    AssertPtrReturn(pszKey, VERR_INVALID_POINTER);
-    /** @todo Add check for already existing keys! (VERR_ALREADY_EXISTS). */
-    m_mapPairs[Utf8Str(pszKey)].pszValue = NULL;
-
-    return VINF_SUCCESS;
-}
-
-/**
- * Destroys the currently stored stream pairs.
- *
- * @return  IPRT status code.
  */
 void GuestProcessStreamBlock::Clear()
 {
-    for (GuestCtrlStreamPairsIter it = m_mapPairs.begin(); it != m_mapPairs.end(); it++)
-    {
-        if (it->second.pszValue)
-            RTMemFree(it->second.pszValue);
-    }
-
     m_mapPairs.clear();
 }
@@ -115 +109 @@
 }
 
-
 /**
  * Returns a string value of a specified key.
@@ -130 +123 @@
         GuestCtrlStreamPairsIterConst itPairs = m_mapPairs.find(Utf8Str(pszKey));
         if (itPairs != m_mapPairs.end())
-            return itPairs->second.pszValue;
+            return itPairs->second.mValue.c_str();
     }
     catch (const std::exception &ex)
@@ -185 +178 @@
 
     int rc = VINF_SUCCESS;
-    if (pszValue)
-    {
-        char *pszVal = RTStrDup(pszValue);
-        if (pszVal)
-            m_mapPairs[pszKey].pszValue = pszVal;
-        else
-            rc = VERR_NO_MEMORY;
-    }
-    else
-    {
-        GuestCtrlStreamPairsIter it = m_mapPairs.find(pszKey);
-        if (it != m_mapPairs.end())
-        {
-            if (it->second.pszValue)
-            {
-                RTMemFree(it->second.pszValue);
-                it->second.pszValue = NULL;
-            }
-            m_mapPairs.erase(it);
-        }
+    try
+    {
+        Utf8Str Utf8Key(pszKey);
+
+        /* Take a shortcut and prevent crashes on some funny versions
+         * of STL if map is empty initially. */
+        if (!m_mapPairs.empty())
+        {
+            GuestCtrlStreamPairsIter it = m_mapPairs.find(Utf8Key);
+            if (it != m_mapPairs.end())
+                 m_mapPairs.erase(it);
+        }
+
+        if (pszValue)
+        {
+            m_mapPairs.insert(
+                std::pair<Utf8Str, VBOXGUESTCTRL_STREAMPAIR>(Utf8Key, VBOXGUESTCTRL_STREAMPAIR(pszValue)));
+        }
+    }
+    catch (const std::exception &ex)
+    {
+        NOREF(ex);
     }
     return rc;
@@ -324 +319 @@
 
 /**
- * Try to parse the next upcoming pair block within the internal
- * buffer. Old pairs from a previously parsed block will be removed first!
- *
- * @return  IPRT status code.
+ * Tries to parse the next upcoming pair block within the internal
+ * buffer.
+ *
+ * Returns VERR_NO_DATA is no data is in internal buffer or buffer has been
+ * completely parsed already.
+ *
+ * Returns VERR_MORE_DATA if current block was parsed (with zero or more pairs
+ * stored in stream block) but still contains incomplete (unterminated)
+ * data.
+ *
+ * Returns VINF_SUCCESS if current block was parsed until the next upcoming
+ * block (with zero or more pairs stored in stream block).
+ *
+ * @return IPRT status code.
+ * @param streamBlock               Reference to guest stream block to fill.
+ *
  */
 int GuestProcessStream::ParseBlock(GuestProcessStreamBlock &streamBlock)
 {
-    AssertPtrReturn(m_pbBuffer, VINF_SUCCESS);
-    AssertReturn(m_cbSize, VINF_SUCCESS);
+    if (   !m_pbBuffer
+        || !m_cbSize)
+    {
+        return VERR_NO_DATA;
+    }
+
     AssertReturn(m_cbOffset <= m_cbSize, VERR_INVALID_PARAMETER);
+    if (m_cbOffset == m_cbSize)
+        return VERR_NO_DATA;
 
     int rc = VINF_SUCCESS;
 
-    size_t uCur = m_cbOffset;
-    for (;uCur < m_cbSize;)
-    {
-        const char *pszStart = (char*)&m_pbBuffer[uCur];
-        const char *pszEnd = pszStart;
-
-        /* Search end of current pair (key=value\0). */
-        while (uCur++ < m_cbSize)
-        {
-            if (*pszEnd == '\0')
+    char *pszOff   = (char*)&m_pbBuffer[m_cbOffset];
+    char *pszStart = pszOff;
+    while (*pszStart)
+    {
+        size_t pairLen = strlen(pszStart);
+        if ((pszStart - pszOff) + pairLen + 1 >= m_cbSize)
+        {
+            rc = VERR_MORE_DATA;
+            break;
+        }
+        else
+        {
+            char *pszSep = strchr(pszStart, '=');
+            char *pszVal = NULL;
+            if (pszSep)
+                pszVal = pszSep + 1;
+            if (!pszSep || !pszVal)
+            {
+                rc = VERR_MORE_DATA;
                 break;
-            pszEnd++;
-        }
-
-        size_t uPairLen = pszEnd - pszStart;
-        if (uPairLen)
-        {
-            const char *pszSep = pszStart;
-            while (   *pszSep != '='
-                   &&  pszSep != pszEnd)
-            {
-                pszSep++;
             }
 
-            /* No separator found (or incomplete key=value pair)? */
-            if (   pszSep == pszStart
-                || pszSep == pszEnd)
-            {
-                m_cbOffset =  uCur - uPairLen - 1;
-                rc = VERR_MORE_DATA;
-            }
-
+            /* Terminate the separator so that we can
+             * use pszStart as our key from now on. */
+            *pszSep = '\0';
+
+            rc = streamBlock.SetValue(pszStart, pszVal);
             if (RT_FAILURE(rc))
-                break;
-
-            size_t uKeyLen = pszSep - pszStart;
-            size_t uValLen = pszEnd - (pszSep + 1);
-
-            /* Get key (if present). */
-            if (uKeyLen)
-            {
-                Assert(pszSep > pszStart);
-                char *pszKey = (char*)RTMemAllocZ(uKeyLen + 1);
-                if (!pszKey)
-                {
-                    rc = VERR_NO_MEMORY;
-                    break;
-                }
-                memcpy(pszKey, pszStart, uKeyLen);
-
-                streamBlock.AddKey(pszKey);
-
-                /* Get value (if present). */
-                if (uValLen)
-                {
-                    Assert(pszEnd > pszSep);
-                    char *pszVal = (char*)RTMemAllocZ(uValLen + 1);
-                    if (!pszVal)
-                    {
-                        rc = VERR_NO_MEMORY;
-                        break;
-                    }
-                    memcpy(pszVal, pszSep + 1, uValLen);
-
-                    streamBlock.SetValue(pszKey, pszVal);
-                    RTMemFree(pszVal);
-                }
-
-                RTMemFree(pszKey);
-
-                m_cbOffset += uCur - m_cbOffset;
-            }
-        }
-        else /* No pair detected, check for a new block. */
-        {
-            do
-            {
-                if (*pszEnd == '\0')
-                {
-                    m_cbOffset = uCur;
-                    rc = VERR_MORE_DATA;
-                    break;
-                }
-                pszEnd++;
-            } while (++uCur < m_cbSize);
-        }
-
-        if (RT_FAILURE(rc))
-            break;
-    }
-
-    RT_CLAMP(m_cbOffset, 0, m_cbSize);
+                return rc;
+        }
+
+        /* Next pair. */
+        pszStart += pairLen + 1;
+    }
+
+    /* If we did not do any movement but we have stuff left
+     * in our buffer just skip the current termination so that
+     * we can try next time. */
+    uint32_t uDistance = (pszStart - pszOff);
+    if (   !uDistance
+        && *pszStart == '\0'
+        && m_cbOffset < m_cbSize)
+    {
+        uDistance++;
+    }
+    m_cbOffset += uDistance;
 
     return rc;
 }
 
+void GuestProcessStream::FreeBlock(GuestProcessStreamBlock *pStreamBlock)
+{
+    if (pStreamBlock)
+    {
+        pStreamBlock->Clear();
+        delete pStreamBlock;
+        pStreamBlock = NULL;
+    }
+}
+

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

@@ -108 +108 @@
  *
  * @return  IPRT status code.
+ * @param   pCallback
  * @param   puContextID
- * @param   pCallbackData
  */
-int Guest::callbackAdd(const PVBOXGUESTCTRL_CALLBACK pCallbackData, uint32_t *puContextID)
-{
-    AssertPtrReturn(pCallbackData, VERR_INVALID_PARAMETER);
-    AssertPtrReturn(puContextID, VERR_INVALID_PARAMETER);
+int Guest::callbackAdd(const PVBOXGUESTCTRL_CALLBACK pCallback, uint32_t *puContextID)
+{
+    AssertPtrReturn(pCallback, VERR_INVALID_PARAMETER);
+    /* puContextID is optional. */
 
     int rc;
@@ -142 +142 @@
 
         /* Add callback with new context ID to our callback map. */
-        mCallbackMap[uNewContextID] = *pCallbackData;
+        mCallbackMap[uNewContextID] = *pCallback;
         Assert(mCallbackMap.size());
 
         /* Report back new context ID. */
-        *puContextID = uNewContextID;
+        if (puContextID)
+            *puContextID = uNewContextID;
     }
 
@@ -247 +248 @@
 
     return NULL;
+}
+
+int Guest::callbackInit(PVBOXGUESTCTRL_CALLBACK pCallback, eVBoxGuestCtrlCallbackType enmType,
+                        ComPtr<Progress> pProgress)
+{
+    AssertPtrReturn(pCallback, VERR_INVALID_POINTER);
+    /* Everything else is optional. */
+
+    int rc = VINF_SUCCESS;
+    switch (enmType)
+    {
+        case VBOXGUESTCTRLCALLBACKTYPE_EXEC_START:
+        {
+            PCALLBACKDATAEXECSTATUS pData = (PCALLBACKDATAEXECSTATUS)RTMemAlloc(sizeof(CALLBACKDATAEXECSTATUS));
+            AssertPtrReturn(pData, VERR_NO_MEMORY);
+            RT_BZERO(pData, sizeof(CALLBACKDATAEXECSTATUS));
+            pCallback->cbData = sizeof(CALLBACKDATAEXECSTATUS);
+            pCallback->pvData = pData;
+            break;
+        }
+
+        case VBOXGUESTCTRLCALLBACKTYPE_EXEC_OUTPUT:
+        {
+            break;
+        }
+
+        case VBOXGUESTCTRLCALLBACKTYPE_EXEC_INPUT_STATUS:
+        {
+
+            break;
+        }
+
+        default:
+            rc = VERR_INVALID_PARAMETER;
+            break;
+    }
+
+    if (RT_SUCCESS(rc))
+    {
+        /* Init/set common stuff. */
+        pCallback->mType  = enmType;
+        pCallback->pProgress = pProgress;
+    }
+
+    return rc;
 }
 
@@ -475 +521 @@
 }
 
+/**
+ * Waits for a callback (using its context ID) to complete.
+ *
+ * @return  IPRT status code.
+ * @param   uContextID              Context ID to wait for.
+ * @param   lStage                  Stage to wait for. Specify -1 if no staging is present/required.
+ *                                  Specifying a stage is only needed if there's a multi operation progress
+ *                                  object to wait for.
+ * @param   lTimeout                Timeout (in ms) to wait for.
+ */
 int Guest::callbackWaitForCompletion(uint32_t uContextID, LONG lStage, LONG lTimeout)
 {
@@ -615 +671 @@
 
     uint32_t uContextID = pData->hdr.u32ContextID;
+    Assert(uContextID);
 
     /* Scope write locks as much as possible. */
@@ -630 +687 @@
         }
         else
-            AssertReleaseMsgFailed(("Process status (PID=%u) does not have allocated callback data!\n",
-                                    pData->u32PID));
+            AssertReleaseMsgFailed(("Process status (PID=%u, CID=%u) does not have allocated callback data!\n",
+                                    pData->u32PID, uContextID));
     }
 
@@ -813 +870 @@
         }
         else
-            AssertReleaseMsgFailed(("Process output status (PID=%u) does not have allocated callback data!\n",
-                                    pData->u32PID));
+            AssertReleaseMsgFailed(("Process output status (PID=%u, CID=%u) does not have allocated callback data!\n",
+                                    pData->u32PID, uContextID));
     }
 
@@ -854 +911 @@
         }
         else
-            AssertReleaseMsgFailed(("Process input status (PID=%u) does not have allocated callback data!\n",
-                                    pData->u32PID));
+            AssertReleaseMsgFailed(("Process input status (PID=%u, CID=%u) does not have allocated callback data!\n",
+                                    pData->u32PID, uContextID));
     }
 
@@ -1025 +1082 @@
     ULONG uPID;
 
-    HRESULT rc = this->ExecuteProcess(aTool,
-                                      ExecuteProcessFlag_Hidden,
-                                      ComSafeArrayInArg(aArguments),
-                                      ComSafeArrayInArg(aEnvironment),
-                                      aUsername, aPassword,
-                                      5 * 1000 /* Wait 5s for getting the process started. */,
-                                      &uPID, progressTool.asOutParam());
+    HRESULT rc = ExecuteProcess(aTool,
+                                ExecuteProcessFlag_Hidden,
+                                ComSafeArrayInArg(aArguments),
+                                ComSafeArrayInArg(aEnvironment),
+                                aUsername, aPassword,
+                                5 * 1000 /* Wait 5s for getting the process started. */,
+                                &uPID, progressTool.asOutParam());
     if (SUCCEEDED(rc))
     {
@@ -1053 +1110 @@
                 if (SUCCEEDED(rc))
                 {
-                    if (!uRetExitCode)
+                    if (uRetExitCode != 0) /* Not equal 0 means some error occured. */
                     {
+                        /** @todo IPRT exit code to string! */
                         rc = setError(VBOX_E_IPRT_ERROR,
-                                      tr("Error %u occurred while %s"),
-                                      uRetExitCode, Utf8Str(aDescription).c_str());
+                                      tr("%s: Error %u occured"),
+                                      Utf8Str(aDescription).c_str(), uRetExitCode);
                     }
-                    else
+                    else /* Return code 0, success. */
                     {
                         if (aProgress)
@@ -1078 +1136 @@
         }
         else
-            AssertReleaseMsgFailed(("Operation \"%s\" neither completed nor canceled!?\n",
+            AssertReleaseMsgFailed(("%s: Operation neither completed nor canceled!?\n",
                                     Utf8Str(aDescription).c_str()));
     }
@@ -1171 +1229 @@
 
 /**
- * Gets the next stream block from a formerly processed guest stream. Will return
- * E_UNEXPECTED if not enough guest stream data was read yet, otherwise S_OK or an appropriate
- * error.
+ * TODO
  *
  * @return  HRESULT
- * @param   aPID                    PID of process to get the next stream block from.
- * @param   stream                  Reference to an already filled guest process stream.
- * @param   streamBlock             Reference to a stream block which receives the parsed data.
+ * @param   aObjName
+ * @param   pStreamBlock
+ * @param   pObjInfo
+ * @param   enmAddAttribs
  */
-HRESULT Guest::executeStreamCollectBlock(ULONG aPID,
-                                         GuestProcessStream &stream, GuestProcessStreamBlock &streamBlock)
-{
+HRESULT Guest::executeStreamQueryFsObjInfo(IN_BSTR aObjName,
+                                           GuestProcessStreamBlock *pStreamBlock,
+                                           PRTFSOBJINFO pObjInfo,
+                                           RTFSOBJATTRADD enmAddAttribs)
+{
+    AssertPtrReturn(pStreamBlock, E_INVALIDARG);
+
     HRESULT rc = S_OK;
-
-    SafeArray<BYTE> aOutputData;
-    ULONG cbOutputData = 0;
-    int vrc;
+    Utf8Str Utf8ObjName(aObjName);
+
+    int64_t iVal;
+    int vrc = pStreamBlock->GetInt64Ex("st_size", &iVal);
+    if (RT_SUCCESS(vrc))
+        pObjInfo->cbObject = iVal;
+    else
+        rc = setError(VBOX_E_IPRT_ERROR,
+                      tr("Unable to retrieve size for \"%s\" (%Rrc)"),
+                      Utf8ObjName.c_str(), vrc);
+    /** @todo Add more stuff! */
+    return rc;
+}
+
+/**
+ * Tries to drain the guest's output (from stdout) and fill it into
+ * a guest process stream object for later usage.
+ *
+ * @return  IPRT status code.
+ * @param   aPID                    PID of process to get the output from.
+ * @param   stream                  Reference to guest process stream to fill.
+ */
+int Guest::executeStreamDrain(ULONG aPID, GuestProcessStream &stream)
+{
+    AssertReturn(aPID, VERR_INVALID_PARAMETER);
+
+    /** @todo Should we try to drain the stream harder? */
+
+    int rc = VINF_SUCCESS;
     for (;;)
     {
-        rc = this->GetProcessOutput(aPID, ProcessOutputFlag_None,
-                                    10 * 1000 /* Timeout in ms */,
-                                    _64K, ComSafeArrayAsOutParam(aOutputData));
-        if (   SUCCEEDED(rc)
+        SafeArray<BYTE> aOutputData;
+        HRESULT hr = GetProcessOutput(aPID, ProcessOutputFlag_None /* Stdout */,
+                                      10 * 1000 /* Timeout in ms */,
+                                      _64K, ComSafeArrayAsOutParam(aOutputData));
+        if (   SUCCEEDED(hr)
             && aOutputData.size())
         {
-            vrc = stream.AddData(aOutputData.raw(), aOutputData.size());
-            if (RT_UNLIKELY(RT_FAILURE(vrc)))
-            {
-                rc = setError(VBOX_E_IPRT_ERROR,
-                              tr("Error while adding guest output to stream buffer (%Rrc)"), vrc);
+            rc = stream.AddData(aOutputData.raw(), aOutputData.size());
+            if (RT_UNLIKELY(RT_FAILURE(rc)))
                 break;
-            }
-            else
-            {
-                /* Try to parse the stream output we gathered until now. If we still need more
-                 * data the parsing routine will tell us and we just do another poll round. */
-                vrc = stream.ParseBlock(streamBlock);
-                if (RT_SUCCESS(vrc))
-                {
-                    /* Yay, we're done! */
-                    break;
-                }
-                else if (vrc == VERR_MORE_DATA)
-                {
-                    /* We need another poll round. */
-                    continue;
-                }
-                else
-                    rc = setError(VBOX_E_IPRT_ERROR,
-                                  tr("Error while parsing guest output (%Rrc)"), vrc);
-            }
-        }
-        else /* No more output! */
-        {
-            if (vrc == VERR_MORE_DATA)
-                rc = E_UNEXPECTED; /** @todo Find a better rc! */
+        }
+        else /* No more output and/or error! */
             break;
-        }
-    }
+    }
+
+    return rc;
+}
+
+/**
+ * Frees a guest stream objects vector.
+ *
+ * @param   streamObjects           Vector to free.
+ */
+void Guest::executeStreamFree(GuestCtrlStreamObjects &streamObjects)
+{
+    for (GuestCtrlStreamObjectsIter it = streamObjects.begin();
+         it != streamObjects.end(); it++)
+    {
+        executeStreamFreeBlock(*it);
+    }
+    streamObjects.clear();
+}
+
+/**
+ * Frees a guest stream block. Pure convenience function for
+ * GuestProcessStream::FreeBlock().
+ *
+ * @return  IPRT status code.
+ * @param   pBlock
+ */
+void Guest::executeStreamFreeBlock(GuestProcessStreamBlock *pBlock)
+{
+    GuestProcessStream::FreeBlock(pBlock);
+}
+
+/**
+ * Tries to get the next upcoming value block from a started guest process
+ * by first draining its output and then processing the received guest stream.
+ *
+ * @return  IPRT status code.
+ * @param   aPID                    PID of process to get/parse the output from.
+ * @param   stream                  Reference to process stream object to use.
+ * @param   streamBlock             Reference that receives the next stream block data.
+ *
+ */
+int Guest::executeStreamGetNextBlock(ULONG aPID, GuestProcessStream &stream,
+                                     GuestProcessStreamBlock &streamBlock)
+{
+    int rc = executeStreamDrain(aPID, stream);
+    if (RT_SUCCESS(rc))
+        rc = stream.ParseBlock(streamBlock);
 
     return rc;
@@ -1244 +1351 @@
  *                                  storing the parsed data.
  */
-HRESULT Guest::executeStreamCollectOutput(ULONG aPID, GuestCtrlStreamObjects &streamObjects)
-{
-    HRESULT rc = S_OK;
-
-    SafeArray<BYTE> aOutputData;
-    ULONG cbOutputData = 0;
+HRESULT Guest::executeStreamParse(ULONG aPID, GuestCtrlStreamObjects &streamObjects)
+{
     GuestProcessStream guestStream;
-
-    for (;;)
-    {
-        rc = this->GetProcessOutput(aPID, ProcessOutputFlag_None,
-                                    10 * 1000 /* Timeout in ms */,
-                                    _64K, ComSafeArrayAsOutParam(aOutputData));
-        if (   SUCCEEDED(rc)
-            && aOutputData.size())
-        {
-            int vrc = guestStream.AddData(aOutputData.raw(), aOutputData.size());
-            if (RT_UNLIKELY(RT_FAILURE(vrc)))
-            {
-                rc = setError(VBOX_E_IPRT_ERROR,
-                              tr("Error while adding guest output to stream buffer (%Rrc)"), vrc);
+    HRESULT hr = executeStreamDrain(aPID, guestStream);
+    if (SUCCEEDED(hr))
+    {
+        for (;;)
+        {
+            /* Try to parse the stream output we gathered until now. If we still need more
+             * data the parsing routine will tell us and we just do another poll round. */
+            GuestProcessStreamBlock *pCurBlock = (GuestProcessStreamBlock*)
+                                            RTMemAlloc(sizeof(GuestProcessStreamBlock));
+            if (!pCurBlock)
+            {
+                hr = setError(VBOX_E_IPRT_ERROR,
+                              tr("No memory for allocating stream block"));
                 break;
             }
-        }
-        else /* No more output! */
-            break;
-    }
-
-    if (SUCCEEDED(rc))
-    {
-        for (;;)
-        {
-            GuestProcessStreamBlock curBlock;
-            rc = executeStreamCollectBlock(aPID,
-                                           guestStream, curBlock);
-            if (SUCCEEDED(rc))
-
-            {
-                if (curBlock.GetCount())
-                    streamObjects.push_back(curBlock);
+            int vrc = guestStream.ParseBlock(*pCurBlock);
+            if (RT_SUCCESS(vrc))
+            {
+                if (pCurBlock->GetCount())
+                {
+                    streamObjects.push_back(pCurBlock);
+                }
                 else
+                {
+                    GuestProcessStream::FreeBlock(pCurBlock);
                     break; /* No more data. */
-            }
-            else
-            {
-                rc = setError(VBOX_E_IPRT_ERROR,
-                              tr("Error while parsing guest stream block"));
-                break;
-            }
-        }
-    }
-
-    return rc;
+                }
+            }
+            else /* Everything else would be an error! */
+                hr = setError(VBOX_E_IPRT_ERROR,
+                              tr("Error while parsing guest output (%Rrc)"), vrc);
+        }
+    }
+
+    /** @todo Add check if there now are any sream objects at all! */
+
+    return hr;
 }
 
@@ -1471 +1565 @@
                 if (RT_SUCCESS(vrc))
                 {
-                    /* Allocate payload. */
-                    PCALLBACKDATAEXECSTATUS pStatus = (PCALLBACKDATAEXECSTATUS)RTMemAlloc(sizeof(CALLBACKDATAEXECSTATUS));
-                    AssertReturn(pStatus, VBOX_E_IPRT_ERROR);
-                    RT_ZERO(*pStatus);
-
-                    /* Create callback. */
                     VBOXGUESTCTRL_CALLBACK callback;
-                    callback.mType  = VBOXGUESTCTRLCALLBACKTYPE_EXEC_START;
-                    callback.cbData = sizeof(CALLBACKDATAEXECSTATUS);
-                    callback.pvData = pStatus;
-                    callback.pProgress = pProgress;
-
-                    vrc = callbackAdd(&callback, &uContextID);
+                    vrc = callbackInit(&callback, VBOXGUESTCTRLCALLBACKTYPE_EXEC_START, pProgress);
+                    if (RT_SUCCESS(vrc))
+                    {
+                        /* Allocate and assign payload. */
+                        callback.cbData = sizeof(CALLBACKDATAEXECSTATUS);
+                        PCALLBACKDATAEXECSTATUS pData = (PCALLBACKDATAEXECSTATUS)RTMemAlloc(callback.cbData);
+                        AssertReturn(pData, E_OUTOFMEMORY);
+                        RT_BZERO(pData, callback.cbData);
+                        callback.pvData = pData;
+                    }
+
+                    if (RT_SUCCESS(vrc))
+                        vrc = callbackAdd(&callback, &uContextID);
+
                     if (RT_SUCCESS(vrc))
                     {
@@ -1669 +1765 @@
                 aTimeoutMS = UINT32_MAX;
 
-            /* Construct callback data. */
             VBOXGUESTCTRL_CALLBACK callback;
-            callback.mType  = VBOXGUESTCTRLCALLBACKTYPE_EXEC_INPUT_STATUS;
-            callback.cbData = sizeof(CALLBACKDATAEXECINSTATUS);
-
-            PCALLBACKDATAEXECINSTATUS pStatus = (PCALLBACKDATAEXECINSTATUS)RTMemAlloc(callback.cbData);
-            AssertReturn(pStatus, VBOX_E_IPRT_ERROR);
-            RT_ZERO(*pStatus);
-
-            /* Save PID + output flags for later use. */
-            pStatus->u32PID = aPID;
-            pStatus->u32Flags = aFlags;
-
-            callback.pvData = pStatus;
-            callback.pProgress = pProgress;
-
-            /* Add the callback. */
-            vrc = callbackAdd(&callback, &uContextID);
+            vrc = callbackInit(&callback, VBOXGUESTCTRLCALLBACKTYPE_EXEC_INPUT_STATUS, pProgress);
+            if (RT_SUCCESS(vrc))
+            {
+                callback.cbData = sizeof(CALLBACKDATAEXECINSTATUS);
+                PCALLBACKDATAEXECINSTATUS pData = (PCALLBACKDATAEXECINSTATUS)RTMemAlloc(callback.cbData);
+                AssertReturn(pData, E_OUTOFMEMORY);
+                RT_BZERO(pData, callback.cbData);
+                callback.pvData = pData;
+
+                /* Save PID + output flags for later use. */
+                pData->u32PID = aPID;
+                pData->u32Flags = aFlags;
+            }
+
+            if (RT_SUCCESS(vrc))
+                vrc = callbackAdd(&callback, &uContextID);
+
             if (RT_SUCCESS(vrc))
             {
@@ -1825 +1921 @@
         if (RT_FAILURE(vrc))
             rc = setError(VBOX_E_IPRT_ERROR,
-                          Guest::tr("Cannot get output from non-existent process (PID %u)"), aPID);
+                          Guest::tr("Cannot get output from non-existent guest process (PID %u)"), aPID);
 
         if (SUCCEEDED(rc))
@@ -1842 +1938 @@
             {
                 rc = pProgress->init(static_cast<IGuest*>(this),
-                                     Bstr(tr("Setting input for process")).raw(),
+                                     Bstr(tr("Getting output for guest process")).raw(),
                                      TRUE /* Cancelable */);
             }
@@ -1857 +1953 @@
                 uHandleID = OUTPUT_HANDLE_ID_STDERR;
 
-            /* Construct callback data. */
             VBOXGUESTCTRL_CALLBACK callback;
-            callback.mType  = VBOXGUESTCTRLCALLBACKTYPE_EXEC_OUTPUT;
-            callback.cbData = sizeof(CALLBACKDATAEXECOUT);
-
-            PCALLBACKDATAEXECOUT pStatus = (PCALLBACKDATAEXECOUT)RTMemAlloc(callback.cbData);
-            AssertReturn(pStatus, VBOX_E_IPRT_ERROR);
-            RT_ZERO(*pStatus);
-
-            /* Save PID + output flags for later use. */
-            pStatus->u32PID = aPID;
-            pStatus->u32Flags = aFlags;
-
-            callback.pvData = pStatus;
-            callback.pProgress = pProgress;
-
-            /* Add the callback. */
-            vrc = callbackAdd(&callback, &uContextID);
+            vrc = callbackInit(&callback, VBOXGUESTCTRLCALLBACKTYPE_EXEC_OUTPUT, pProgress);
+            if (RT_SUCCESS(vrc))
+            {
+                callback.cbData = sizeof(CALLBACKDATAEXECOUT);
+                PCALLBACKDATAEXECOUT pData = (PCALLBACKDATAEXECOUT)RTMemAlloc(callback.cbData);
+                AssertReturn(pData, E_OUTOFMEMORY);
+                RT_BZERO(pData, callback.cbData);
+                callback.pvData = pData;
+
+                /* Save PID + output flags for later use. */
+                pData->u32PID = aPID;
+                pData->u32Flags = aFlags;
+            }
+
+            if (RT_SUCCESS(vrc))
+                vrc = callbackAdd(&callback, &uContextID);
+
             if (RT_SUCCESS(vrc))
             {
@@ -1916 +2012 @@
                 PCALLBACKDATAEXECOUT pExecOut = NULL;
 
-                 /*
-                 * Wait for the first stage (=0) to complete (that is starting the process).
+                /*
+                 * Wait for the first output callback notification to arrive.
                  */
-                vrc = callbackWaitForCompletion(uContextID, 0 /* Stage */, aTimeoutMS);
+                vrc = callbackWaitForCompletion(uContextID, -1 /* No staging */, aTimeoutMS);
                 if (RT_SUCCESS(vrc))
                 {
@@ -1961 +2057 @@
                 rc = handleErrorHGCM(vrc);
 
-            if (SUCCEEDED(rc))
-            {
-
-            }
-
             /* The callback isn't needed anymore -- just was kept locally. */
             callbackDestroy(uContextID);

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

@@ -138 +138 @@
  *
  * @return IPRT status code.
- * @param puHandle             Pointer where the handle gets stored to.
+ * @param puHandle             Pointer where the handle gets stored to. Optional.
  * @param uPID                 PID of guest process running the associated "vbox_ls".
- * @param pszDirectory         Directory the handle is assigned to.
- * @param pszFilter            Directory filter.  Optional.
+ * @param aDirectory           Directory the handle is assigned to.
+ * @param aFilter              Directory filter.  Optional.
  * @param uFlags               Directory open flags.
  *
  */
 int Guest::directoryCreateHandle(ULONG *puHandle, ULONG uPID,
-                                 const char *pszDirectory, const char *pszFilter, ULONG uFlags)
-{
-    AssertPtrReturn(puHandle, VERR_INVALID_POINTER);
-    AssertPtrReturn(pszDirectory, VERR_INVALID_POINTER);
-    /* pszFilter is optional. */
+                                 IN_BSTR aDirectory, IN_BSTR aFilter, ULONG uFlags)
+{
+    AssertReturn(uPID, VERR_INVALID_PARAMETER);
+    CheckComArgStrNotEmptyOrNull(aDirectory);
+    /* aFilter is optional. */
+    /* uFlags are optional. */
 
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
@@ -160 +161 @@
         uint32_t uHandleTry = ASMAtomicIncU32(&mNextDirectoryID);
         GuestDirectoryMapIter it = mGuestDirectoryMap.find(uHandleTry);
-        if (it == mGuestDirectoryMap.end())
-        {
+        if (it == mGuestDirectoryMap.end()) /* We found a free slot ... */
+        {
+            mGuestDirectoryMap[uHandleTry].mDirectory = aDirectory;
+            mGuestDirectoryMap[uHandleTry].mFilter = aFilter;
+            mGuestDirectoryMap[uHandleTry].mPID = uPID;
+            mGuestDirectoryMap[uHandleTry].mFlags = uFlags;
+            Assert(mGuestDirectoryMap.size());
+
             rc = VINF_SUCCESS;
-            if (!RTStrAPrintf(&mGuestDirectoryMap[uHandleTry].mpszDirectory, pszDirectory))
-                rc = VERR_NO_MEMORY;
-            else
-            {
-                /* Filter is optional. */
-                if (pszFilter)
-                {
-                    if (!RTStrAPrintf(&mGuestDirectoryMap[uHandleTry].mpszFilter, pszFilter))
-                        rc = VERR_NO_MEMORY;
-                }
-
-                if (RT_SUCCESS(rc))
-                {
-                    mGuestDirectoryMap[uHandleTry].mPID = uPID;
-                    mGuestDirectoryMap[uHandleTry].mFlags = uFlags;
-                    *puHandle = uHandleTry;
-
-                    break;
-                }
-            }
-
-            if (RT_FAILURE(rc))
-                break;
-
-            Assert(mGuestDirectoryMap.size());
+
+            if (puHandle)
+                *puHandle = uHandleTry;
+            break;
         }
     }
@@ -208 +194 @@
     if (it != mGuestDirectoryMap.end())
     {
-        RTStrFree(it->second.mpszDirectory);
-        RTStrFree(it->second.mpszFilter);
-
         /* Destroy raw guest stream buffer - not used
          * anymore. */
@@ -220 +203 @@
 }
 
+STDMETHODIMP Guest::DirectoryExists(IN_BSTR aDirectory, IN_BSTR aUsername, IN_BSTR aPassword, BOOL *aExists)
+{
+#ifndef VBOX_WITH_GUEST_CONTROL
+    ReturnComNotImplemented();
+#else /* VBOX_WITH_GUEST_CONTROL */
+    using namespace guestControl;
+
+    CheckComArgStrNotEmptyOrNull(aDirectory);
+
+    /* Do not allow anonymous executions (with system rights). */
+    if (RT_UNLIKELY((aUsername) == NULL || *(aUsername) == '\0'))
+        return setError(E_INVALIDARG, tr("No user name specified"));
+
+    return directoryExistsInternal(aDirectory,
+                                   aUsername, aPassword, aExists);
+#endif
+}
+
+#ifdef VBOX_WITH_GUEST_CONTROL
+HRESULT Guest::directoryExistsInternal(IN_BSTR aDirectory, IN_BSTR aUsername, IN_BSTR aPassword, BOOL *aExists)
+{
+    using namespace guestControl;
+
+    CheckComArgStrNotEmptyOrNull(aDirectory);
+
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    RTFSOBJINFO objInfo;
+    int rc;
+    HRESULT hr = directoryQueryInfoInternal(aDirectory,
+                                            aUsername, aPassword,
+                                            &objInfo, RTFSOBJATTRADD_NOTHING, &rc);
+    if (SUCCEEDED(hr))
+    {
+        switch (rc)
+        {
+            case VINF_SUCCESS:
+                *aExists = TRUE;
+                break;
+
+            case VERR_FILE_NOT_FOUND:
+                *aExists = FALSE;
+                break;
+
+            case VERR_NOT_FOUND:
+                rc = setError(VBOX_E_IPRT_ERROR,
+                              Guest::tr("Unable to query directory existence"));
+                break;
+
+            default:
+                AssertReleaseMsgFailed(("directoryExistsInternal: Unknown return value (%Rrc)\n", rc));
+                break;
+        }
+    }
+    return hr;
+}
+#endif
+
 /**
  * Gets the associated PID from a directory handle.
  *
- * @return  uint32_t            Associated PID, 0 if handle not found/invalid.
- * @param   uHandle             Directory handle to get PID for.
+ * @return  uint32_t                Associated PID, 0 if handle not found/invalid.
+ * @param   uHandle                 Directory handle to get PID for.
  */
 uint32_t Guest::directoryGetPID(uint32_t uHandle)
@@ -237 +279 @@
 }
 
+/**
+ * Returns the next directory entry of an open guest directory.
+ * Returns VERR_NO_MORE_FILES if no more entries available.
+ *
+ * @return  IPRT status code.
+ * @param   uHandle                 Directory handle to get entry for.
+ * @param   streamBlock             Reference that receives the next stream block data.
+ */
 int Guest::directoryGetNextEntry(uint32_t uHandle, GuestProcessStreamBlock &streamBlock)
 {
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+    // LOCK DOES NOT WORK HERE!?
+    //AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
     GuestDirectoryMapIter it = mGuestDirectoryMap.find(uHandle);
     if (it != mGuestDirectoryMap.end())
     {
-        HRESULT hr = executeStreamCollectBlock(it->second.mPID,
-                                               it->second.mStream, streamBlock);
-        if (FAILED(hr))
-            return VERR_INVALID_PARAMETER; /** @todo Find better rc! */
-
-        return VINF_SUCCESS;
+        return executeStreamGetNextBlock(it->second.mPID,
+                                         it->second.mStream, streamBlock);
     }
 
@@ -259 +306 @@
  * or not.
  *
- * @return  bool                True if handle exists, false if not.
- * @param   uHandle             Directory handle to check.
+ * @return  bool                    True if handle exists, false if not.
+ * @param   uHandle                 Directory handle to check.
  */
 bool Guest::directoryHandleExists(uint32_t uHandle)
@@ -315 +362 @@
         return setError(E_INVALIDARG, tr("Unknown flags (%#x)"), aFlags);
 
-    HRESULT rc = S_OK;
+    HRESULT hr = S_OK;
     try
     {
@@ -354 +401 @@
 
         ULONG uPID;
-        rc = executeAndWaitForTool(Bstr(VBOXSERVICE_TOOL_LS).raw(), Bstr("Opening directory").raw(),
+        /** @todo Don't wait for tool to finish! Might take a lot of time! */
+        hr = executeAndWaitForTool(Bstr(VBOXSERVICE_TOOL_LS).raw(), Bstr("Opening directory").raw(),
                                    ComSafeArrayAsInParam(args),
                                    ComSafeArrayAsInParam(env),
                                    aUsername, aPassword,
                                    NULL /* Progress */, &uPID);
-        if (SUCCEEDED(rc))
+        if (SUCCEEDED(hr))
         {
             /* Assign new directory handle ID. */
-            int vrc = directoryCreateHandle(aHandle, uPID,
-                                            Utf8Directory.c_str(),
-                                            Utf8Filter.isEmpty() ? NULL : Utf8Filter.c_str(),
-                                            aFlags);
-            if (RT_FAILURE(vrc))
-                rc = setError(VBOX_E_IPRT_ERROR,
+            ULONG uHandleNew;
+            int vrc = directoryCreateHandle(&uHandleNew, uPID,
+                                            aDirectory, aFilter, aFlags);
+            if (RT_SUCCESS(vrc))
+            {
+                *aHandle = uHandleNew;
+            }
+            else
+                hr = setError(VBOX_E_IPRT_ERROR,
                               tr("Unable to create guest directory handle (%Rrc)"), vrc);
         }
@@ -373 +424 @@
     catch (std::bad_alloc &)
     {
-        rc = E_OUTOFMEMORY;
-    }
-    return rc;
+        hr = E_OUTOFMEMORY;
+    }
+    return hr;
+}
+
+HRESULT Guest::directoryQueryInfoInternal(IN_BSTR aDirectory,
+                                          IN_BSTR aUsername, IN_BSTR aPassword,
+                                          PRTFSOBJINFO aObjInfo, RTFSOBJATTRADD enmAddAttribs,
+                                          int *pRC)
+{
+    using namespace guestControl;
+
+    /** @todo Search directory cache first? */
+
+    CheckComArgStrNotEmptyOrNull(aDirectory);
+    /* aUsername is optional. */
+    /* aPassword is optional. */
+    /* aObjInfo is optional. */
+
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    HRESULT hr = S_OK;
+    try
+    {
+        Utf8Str Utf8Dir(aDirectory);
+        Utf8Str Utf8Username(aUsername);
+        Utf8Str Utf8Password(aPassword);
+
+        com::SafeArray<IN_BSTR> args;
+        com::SafeArray<IN_BSTR> env;
+
+        /*
+         * Prepare tool command line.
+         */
+
+        /* We need to get output which is machine-readable in form
+         * of "key=value\0..key=value\0\0". */
+        args.push_back(Bstr("--machinereadable").raw());
+
+        /* Only the actual file name to chekc is needed for now. */
+        args.push_back(Bstr(Utf8Dir).raw());
+
+        /*
+         * Execute guest process.
+         */
+        ULONG uPID;
+        hr = executeAndWaitForTool(Bstr(VBOXSERVICE_TOOL_STAT).raw(), Bstr("Querying directory information").raw(),
+                                   ComSafeArrayAsInParam(args),
+                                   ComSafeArrayAsInParam(env),
+                                   aUsername, aPassword,
+                                   NULL /* Progress */, &uPID);
+        if (SUCCEEDED(hr))
+        {
+            GuestCtrlStreamObjects streamObjs;
+            hr = executeStreamParse(uPID, streamObjs);
+            if (SUCCEEDED(hr))
+            {
+                int rc = VINF_SUCCESS;
+
+                GuestProcessStreamBlock *pBlock = streamObjs[0];
+                AssertPtr(pBlock);
+                const char *pszFsType = pBlock->GetString("ftype");
+                if (!pszFsType) /* Attribute missing? */
+                     rc = VERR_NOT_FOUND;
+                if (   RT_SUCCESS(rc)
+                    && strcmp(pszFsType, "d")) /* Directory? */
+                {
+                     rc = VERR_FILE_NOT_FOUND;
+                }
+                if (   RT_SUCCESS(rc)
+                    && aObjInfo) /* Do we want object details? */
+                {
+                    hr = executeStreamQueryFsObjInfo(aDirectory, pBlock,
+                                                     aObjInfo, enmAddAttribs);
+                }
+
+                executeStreamFree(streamObjs);
+
+                if (pRC)
+                    *pRC = rc;
+            }
+        }
+    }
+    catch (std::bad_alloc &)
+    {
+        hr = E_OUTOFMEMORY;
+    }
+    return hr;
 }
 #endif /* VBOX_WITH_GUEST_CONTROL */
@@ -391 +528 @@
     if (FAILED(autoCaller.rc())) return autoCaller.rc();
 
-    HRESULT rc = S_OK;
+    HRESULT hr = S_OK;
     try
     {
         GuestProcessStreamBlock streamBlock;
-        int vrc = directoryGetNextEntry(aHandle, streamBlock);
-        if (RT_SUCCESS(vrc))
+        int rc = directoryGetNextEntry(aHandle, streamBlock);
+        if (RT_SUCCESS(rc))
         {
             ComObjPtr <GuestDirEntry> pDirEntry;
-            rc = pDirEntry.createObject();
-            ComAssertComRC(rc);
-
-            rc = pDirEntry->init(this, streamBlock);
-            if (SUCCEEDED(rc))
+            hr = pDirEntry.createObject();
+            ComAssertComRC(hr);
+
+            hr = pDirEntry->init(this, streamBlock);
+            if (SUCCEEDED(hr))
             {
                 pDirEntry.queryInterfaceTo(aDirEntry);
             }
             else
-                rc = setError(VBOX_E_IPRT_ERROR,
+                hr = setError(VBOX_E_IPRT_ERROR,
                               Guest::tr("Unable to init guest directory entry"));
         }
+        else if (rc == VERR_NO_MORE_FILES)
+        {
+            /* No more directory entries to read. */
+            hr = E_ABORT; /** @todo Find/define a better rc! */
+        }
         else
-            rc = setError(VBOX_E_IPRT_ERROR,
-                          Guest::tr("Directory handle is invalid"));
+            hr = setError(VBOX_E_IPRT_ERROR,
+                          Guest::tr("Failed getting next directory entry (%Rrc)"), rc);
     }
     catch (std::bad_alloc &)
     {
-        rc = E_OUTOFMEMORY;
-    }
-    return rc;
-#endif
-}
-
+        hr = E_OUTOFMEMORY;
+    }
+    return hr;
+#endif
+}
+

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

@@ -47 +47 @@
 
     return fileExistsInternal(aFile,
-                              aUsername, aPassword, aExists,
-                              NULL /* rc */);
+                              aUsername, aPassword, aExists);
 #endif
 }
 
 #ifdef VBOX_WITH_GUEST_CONTROL
-HRESULT Guest::fileExistsInternal(IN_BSTR aFile, IN_BSTR aUsername, IN_BSTR aPassword, BOOL *aExists, int *pRC)
+HRESULT Guest::fileExistsInternal(IN_BSTR aFile, IN_BSTR aUsername, IN_BSTR aPassword, BOOL *aExists)
 {
     using namespace guestControl;
@@ -62 +61 @@
     if (FAILED(autoCaller.rc())) return autoCaller.rc();
 
-    HRESULT rc = S_OK;
+    RTFSOBJINFO objInfo;
+    int rc;
+    HRESULT hr = fileQueryInfoInternal(aFile,
+                                       aUsername, aPassword,
+                                       &objInfo, RTFSOBJATTRADD_NOTHING, &rc);
+    if (SUCCEEDED(hr))
+    {
+        switch (rc)
+        {
+            case VINF_SUCCESS:
+                *aExists = TRUE;
+                break;
+
+            case VERR_FILE_NOT_FOUND:
+                *aExists = FALSE;
+                break;
+
+            case VERR_NOT_FOUND:
+                rc = setError(VBOX_E_IPRT_ERROR,
+                              Guest::tr("Unable to query file existence"));
+                break;
+
+            default:
+                AssertReleaseMsgFailed(("fileExistsInternal: Unknown return value (%Rrc)\n", rc));
+                break;
+        }
+    }
+    return hr;
+}
+
+HRESULT Guest::fileQueryInfoInternal(IN_BSTR aFile,
+                                     IN_BSTR aUsername, IN_BSTR aPassword,
+                                     PRTFSOBJINFO aObjInfo, RTFSOBJATTRADD enmAddAttribs,
+                                     int *pRC)
+{
+    using namespace guestControl;
+
+    /* aUsername is optional. */
+    /* aPassword is optional. */
+    /* aObjInfo is optional. */
+
+    HRESULT hr;
     try
     {
@@ -86 +126 @@
          * Execute guest process.
          */
-        rc = executeAndWaitForTool(Bstr(VBOXSERVICE_TOOL_STAT).raw(), Bstr("Checking for file existence").raw(),
+        ULONG uPID;
+        hr = executeAndWaitForTool(Bstr(VBOXSERVICE_TOOL_STAT).raw(), Bstr("Querying file information").raw(),
                                    ComSafeArrayAsInParam(args),
                                    ComSafeArrayAsInParam(env),
                                    aUsername, aPassword,
-                                   NULL /* Progress */, NULL /* PID */);
-
-        /* If the call succeeded the file exists, otherwise it does not. */
-        *aExists = SUCCEEDED(rc) ? TRUE : FALSE;
+                                   NULL /* Progress */, &uPID);
+        if (SUCCEEDED(hr))
+        {
+            GuestCtrlStreamObjects streamObjs;
+            hr = executeStreamParse(uPID, streamObjs);
+            if (SUCCEEDED(hr))
+            {
+                int rc = VINF_SUCCESS;
+
+                GuestProcessStreamBlock *pBlock = streamObjs[0];
+                AssertPtr(pBlock);
+                const char *pszFsType = pBlock->GetString("ftype");
+                if (!pszFsType) /* Attribute missing? */
+                     rc = VERR_NOT_FOUND;
+                if (   RT_SUCCESS(rc)
+                    && strcmp(pszFsType, "-")) /* Regular file? */
+                {
+                     rc = VERR_FILE_NOT_FOUND;
+                }
+                if (   RT_SUCCESS(rc)
+                    && aObjInfo) /* Do we want object details? */
+                {
+                    hr = executeStreamQueryFsObjInfo(aFile, pBlock,
+                                                     aObjInfo, enmAddAttribs);
+                }
+
+                executeStreamFree(streamObjs);
+
+                if (pRC)
+                    *pRC = rc;
+            }
+        }
     }
     catch (std::bad_alloc &)
     {
-        rc = E_OUTOFMEMORY;
-    }
-    return rc;
+        hr = E_OUTOFMEMORY;
+    }
+
+    return hr;
 }
 #endif /* VBOX_WITH_GUEST_CONTROL */
@@ -116 +186 @@
         return setError(E_INVALIDARG, tr("No user name specified"));
 
-    return fileQuerySizeInternal(aFile,
-                                 aUsername, aPassword, aSize,
-                                 NULL /* rc */);
-#endif
-}
-
-#ifdef VBOX_WITH_GUEST_CONTROL
-HRESULT Guest::fileQuerySizeInternal(IN_BSTR aFile, IN_BSTR aUsername, IN_BSTR aPassword, LONG64 *aSize, int *pRC)
-{
-    using namespace guestControl;
-
-    CheckComArgStrNotEmptyOrNull(aFile);
-
     AutoCaller autoCaller(this);
     if (FAILED(autoCaller.rc())) return autoCaller.rc();
 
-    HRESULT rc = S_OK;
-    try
-    {
-        Utf8Str Utf8File(aFile);
-        Utf8Str Utf8Username(aUsername);
-        Utf8Str Utf8Password(aPassword);
-
-        com::SafeArray<IN_BSTR> args;
-        com::SafeArray<IN_BSTR> env;
-
-        /*
-         * Prepare tool command line.
-         */
-
-        /* We need to get output which is machine-readable in form
-         * of "key=value\0..key=value\0\0". */
-        args.push_back(Bstr("--machinereadable").raw());
-
-        /* Only the actual file name to chekc is needed for now. */
-        args.push_back(Bstr(Utf8File).raw());
-
-        /*
-         * Execute guest process.
-         */
-        ComPtr<IProgress> progressFileSize;
-        ULONG uPID;
-
-        rc = executeAndWaitForTool(Bstr(VBOXSERVICE_TOOL_STAT).raw(), Bstr("Querying file size").raw(),
-                                   ComSafeArrayAsInParam(args),
-                                   ComSafeArrayAsInParam(env),
-                                   aUsername, aPassword,
-                                   progressFileSize.asOutParam(), &uPID);
-        if (SUCCEEDED(rc))
+    return fileQuerySizeInternal(aFile,
+                                 aUsername, aPassword, aSize);
+#endif
+}
+
+#ifdef VBOX_WITH_GUEST_CONTROL
+HRESULT Guest::fileQuerySizeInternal(IN_BSTR aFile, IN_BSTR aUsername, IN_BSTR aPassword, LONG64 *aSize)
+{
+    using namespace guestControl;
+
+    CheckComArgStrNotEmptyOrNull(aFile);
+
+    int rc;
+    RTFSOBJINFO objInfo;
+    HRESULT hr = fileQueryInfoInternal(aFile,
+                                       aUsername, aPassword,
+                                       &objInfo, RTFSOBJATTRADD_NOTHING, &rc);
+    if (SUCCEEDED(hr))
+    {
+        switch (rc)
         {
-            GuestCtrlStreamObjects streamObjs;
-            rc = executeStreamCollectOutput(uPID, streamObjs);
-            if (SUCCEEDED(rc))
-            {
-                /** @todo */
-                #if 0
-                                                    int64_t iVal;
-                                    vrc = guestStream.GetInt64Ex("st_size", &iVal);
-                                    if (RT_SUCCESS(vrc))
-                                        *aSize = iVal;
-                                    else
-                                        rc = setError(VBOX_E_IPRT_ERROR,
-                                                      tr("Query file size: Unable to retrieve file size for file \"%s\" (%Rrc)"),
-                                                      Utf8File.c_str(), vrc);
-              #endif
-            }
+            case VINF_SUCCESS:
+                *aSize = objInfo.cbObject;
+                break;
+
+            case VERR_FILE_NOT_FOUND:
+                rc = setError(VBOX_E_IPRT_ERROR,
+                              Guest::tr("File not found"));
+                break;
+
+            case VERR_NOT_FOUND:
+                rc = setError(VBOX_E_IPRT_ERROR,
+                              Guest::tr("Unable to query file size"));
+                break;
+
+            default:
+                AssertReleaseMsgFailed(("fileExistsInternal: Unknown return value (%Rrc)\n", rc));
+                break;
         }
     }
-    catch (std::bad_alloc &)
-    {
-        rc = E_OUTOFMEMORY;
-    }
     return rc;
 }

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

@@ -59 +59 @@
 
     mData.mNodeId = streamBlock.GetInt64("node_id");
-    mData.mName =  BstrFmt("%s", streamBlock.GetString("name"));
+    const char *pszName = streamBlock.GetString("name");
+    if (pszName)
+        mData.mName =  BstrFmt("%s", pszName);
     mData.mType = GuestDirEntry::fileTypeToEntryType(streamBlock.GetString("ftype"));
 

trunk/src/VBox/Main/testcase/tstGuestCtrlParseBuffer.cpp

@@ -58 +58 @@
 } aTests[] =
 {
+    /*
+     * Single object parsing.
+     * An object is represented by one or multiple key=value pairs which are
+     * separated by a single "\0". If this termination is missing it will be assumed
+     * that we need to collect more data to do a successful parsing.
+     */
+
     /* Invalid stuff. */
     { NULL,                             0,                                                 0,  0,                                         0, VERR_INVALID_POINTER },
@@ -66 +73 @@
     { "foo=bar2",                       0,                                                 50, 50,                                        0, VERR_INVALID_PARAMETER },
     /* Empty buffers. */
-    { "",                               1,                                                 0,  1,                                         0, VERR_MORE_DATA },
-    { "\0",                             1,                                                 0,  1,                                         0, VERR_MORE_DATA },
-    /* Incomplete buffer (missing components). */
-    { szUnterm1,                        5,                                                 0,  0,                                         0, VERR_MORE_DATA },
-    { "foo1",                           sizeof("foo1"),                                    0,  0,                                         0, VERR_MORE_DATA },
-    { "=bar\0",                         sizeof("=bar"),                                    0,  0,                                         0, VERR_MORE_DATA },
-    /* Last sequence is incomplete -- new offset should point to it. */
-    { "hug=sub\0incomplete",            sizeof("hug=sub\0incomplete"),                     0,  sizeof("hug=sub"),                         1, VERR_MORE_DATA },
-    { "boo=hoo\0baz=boo\0qwer",         sizeof("boo=hoo\0baz=boo\0qwer"),                  0,  sizeof("boo=hoo\0baz=boo"),                2, VERR_MORE_DATA },
-    /* Parsing good stuff. */
-    { "novalue=",                       sizeof("novalue="),                                0,  sizeof("novalue="),                        1, VINF_SUCCESS },
-    { szUnterm2,                        8,                                                 0,  sizeof(szUnterm2),                         1, VINF_SUCCESS },
-    { "foo2=",                          sizeof("foo2="),                                   0,  sizeof("foo2="),                           1, VINF_SUCCESS },
-    { "har=hor",                        sizeof("har=hor"),                                 0,  sizeof("har=hor"),                         1, VINF_SUCCESS },
-    { "foo=bar\0baz=boo",               sizeof("foo=bar\0baz=boo"),                        0,  sizeof("foo=bar\0baz=boo"),                2, VINF_SUCCESS },
-    /* Parsing until a different block (two terminations, returning offset to next block). */
-    { "off=rab\0a=b\0\0\0\0",           sizeof("off=rab\0a=b\0\0\0"),                      0,  13,                                        2, VERR_MORE_DATA },
-    { "off=rab\0\0zab=oob",             sizeof("off=rab\0\0zab=oob"),                      0,  9,                                         1, VERR_MORE_DATA },
-    { "\0\0\0\0off=rab\0zab=oob\0\0",   sizeof("\0\0\0\0off=rab\0zab=oob\0\0"),            0,  1,                                         0, VERR_MORE_DATA },
-    { "o2=r2\0z3=o3\0\0f3=g3",          sizeof("o2=r2\0z3=o3\0\0f3=g3"),                   0,  13,                                        2, VERR_MORE_DATA }
+    { "",                               1,                                                 0,  1,                                         0, VINF_SUCCESS },
+    { "\0",                             1,                                                 0,  1,                                         0, VINF_SUCCESS },
+    /* Unterminated values (missing "\0"). */
+    { "test1",                          sizeof("test1"),                                   0,  0,                                         0, VERR_MORE_DATA },
+    { "test2=",                         sizeof("test2="),                                  0,  0,                                         0, VERR_MORE_DATA },
+    { "test3=test3",                    sizeof("test3=test3"),                             0,  0,                                         0, VERR_MORE_DATA },
+    { "test4=test4\0t41",               sizeof("test4=test4\0t41"),                        0,  sizeof("test4=test4\0") - 1,               1, VERR_MORE_DATA },
+    { "test5=test5\0t51=t51",           sizeof("test5=test5\0t51=t51"),                    0,  sizeof("test5=test5\0") - 1,               1, VERR_MORE_DATA },
+    /* Next block unterminated. */
+    { "t51=t51\0t52=t52\0\0t53=t53",    sizeof("t51=t51\0t52=t52\0\0t53=t53"),             0,  sizeof("t51=t51\0t52=t52\0") - 1,          2, VINF_SUCCESS },
+    { "test6=test6\0\0t61=t61",         sizeof("test6=test6\0\0t61=t61"),                  0,  sizeof("test6=test6\0") - 1,               1, VINF_SUCCESS },
+    /* Good stuff. */
+    { "test61=\0test611=test611\0",     sizeof("test61=\0test611=test611\0"),              0,  sizeof("test61=\0test611=test611\0") - 1,  2, VINF_SUCCESS },
+    { "test7=test7\0\0",                sizeof("test7=test7\0\0"),                         0,  sizeof("test7=test7\0") - 1,               1, VINF_SUCCESS },
+    { "test8=test8\0t81=t81\0\0",       sizeof("test8=test8\0t81=t81\0\0"),                0,  sizeof("test8=test8\0t81=t81\0") - 1,      2, VINF_SUCCESS },
+    /* Good stuff, but with a second block -- should be *not* taken into account since
+     * we're only interested in parsing/handling the first object. */
+    { "t9=t9\0t91=t91\0\0t92=t92\0\0",  sizeof("t9=t9\0t91=t91\0\0t92=t92\0\0"),           0,  sizeof("t9=t9\0t91=t91\0") - 1,            2, VINF_SUCCESS }
 };
 
@@ -98 +103 @@
 } aTests2[] =
 {
-    { "\0\0\0\0",                                      sizeof("\0\0\0\0"),                                0, VINF_SUCCESS },
-    { "off=rab\0\0zab=oob",                            sizeof("off=rab\0\0zab=oob"),                      2, VINF_SUCCESS },
-    { "\0\0\0soo=foo\0goo=loo\0\0zab=oob",             sizeof("\0\0\0soo=foo\0goo=loo\0\0zab=oob"),       2, VINF_SUCCESS },
-    { "qoo=uoo\0\0\0\0asdf=\0\0",                      sizeof("qoo=uoo\0\0\0\0asdf=\0\0"),                2, VINF_SUCCESS },
-    { "foo=bar\0\0\0\0\0\0",                           sizeof("foo=bar\0\0\0\0\0\0"),                     1, VINF_SUCCESS },
-    { "qwer=cvbnr\0\0\0gui=uig\0\0\0",                 sizeof("qwer=cvbnr\0\0\0gui=uig\0\0\0"),           2, VINF_SUCCESS }
+    /* No blocks. */
+    { "\0\0\0\0",                                      sizeof("\0\0\0\0"),                                0, VERR_NO_DATA },
+    /* Good stuff. */
+    { "\0b1=b1\0\0",                                   sizeof("\0b1=b1\0\0"),                             1, VERR_NO_DATA },
+    { "b1=b1\0\0",                                     sizeof("b1=b1\0\0"),                               1, VERR_NO_DATA },
+    { "b1=b1\0b2=b2\0\0",                              sizeof("b1=b1\0b2=b2\0\0"),                        1, VERR_NO_DATA },
+    { "b1=b1\0b2=b2\0\0\0",                            sizeof("b1=b1\0b2=b2\0\0\0"),                      1, VERR_NO_DATA }
 };
 
@@ -136 +142 @@
     for (iTest; iTest < RT_ELEMENTS(aTests); iTest++)
     {
-        uint32_t uOffset = aTests[iTest].uOffsetStart;
-
         RTTestIPrintf(RTTESTLVL_DEBUG, "=> Test #%u\n", iTest);
 
@@ -144 +148 @@
         if (RT_SUCCESS(iResult))
         {
-            GuestProcessStreamBlock block;
-            iResult = stream.ParseBlock(block);
+            GuestProcessStreamBlock curBlock;
+            iResult = stream.ParseBlock(curBlock);
             if (iResult != aTests[iTest].iResult)
             {
@@ -151 +155 @@
                              iResult, aTests[iTest].iResult);
             }
-            else if (block.GetCount() != aTests[iTest].uMapElements)
-            {
-                RTTestFailed(hTest, "\tMap has %u elements, expected %u",
-                             block.GetCount(), aTests[iTest].uMapElements);
-            }
             else if (stream.GetOffset() != aTests[iTest].uOffsetAfter)
             {
@@ -163 +162 @@
             else if (iResult == VERR_MORE_DATA)
             {
-                RTTestIPrintf(RTTESTLVL_DEBUG, "\tMore data (Offset: %u)\n", uOffset);
-
-                /* There is remaining data left in the buffer (which needs to be merged
-                 * with a following buffer) -- print it. */
-                size_t uToWrite = aTests[iTest].cbData - uOffset;
-                if (uToWrite)
+                RTTestIPrintf(RTTESTLVL_DEBUG, "\tMore data (Offset: %u)\n", stream.GetOffset());
+            }
+
+            if (  (   RT_SUCCESS(iResult)
+                   || iResult == VERR_MORE_DATA))
+            {
+                if (curBlock.GetCount() != aTests[iTest].uMapElements)
                 {
-                    const char *pszRemaining = aTests[iTest].pbData;
-                    RTTestIPrintf(RTTESTLVL_DEBUG, "\tRemaining (%u):\n", uToWrite);
-                    RTStrmWriteEx(g_pStdOut, &aTests[iTest].pbData[uOffset], uToWrite - 1, NULL);
-                    RTTestIPrintf(RTTESTLVL_DEBUG, "\n");
+                    RTTestFailed(hTest, "\tMap has %u elements, expected %u",
+                                 curBlock.GetCount(), aTests[iTest].uMapElements);
                 }
+            }
+
+            /* There is remaining data left in the buffer (which needs to be merged
+             * with a following buffer) -- print it. */
+            uint32_t uOffset = stream.GetOffset();
+            size_t uToWrite = aTests[iTest].cbData - uOffset;
+            if (uToWrite)
+            {
+                const char *pszRemaining = aTests[iTest].pbData;
+                RTTestIPrintf(RTTESTLVL_DEBUG, "\tRemaining (%u):\n", uToWrite);
+                RTStrmWriteEx(g_pStdOut, &aTests[iTest].pbData[uOffset], uToWrite - 1, NULL);
             }
         }
@@ -181 +190 @@
     RTTestIPrintf(RTTESTLVL_INFO, "Doing block tests ...\n");
 
-    for (unsigned iTest = 0; iTest < RT_ELEMENTS(aTests2); iTest++)
+    iTest = 0;
+    for (iTest; iTest < RT_ELEMENTS(aTests2); iTest++)
     {
         RTTestIPrintf(RTTESTLVL_DEBUG, "=> Block test #%u\n", iTest);
@@ -190 +200 @@
         {
             uint32_t uNumBlocks = 0;
-
+            uint8_t uSafeCouunter = 0;
             do
             {
-                GuestProcessStreamBlock block;
-                iResult = stream.ParseBlock(block);
+                GuestProcessStreamBlock curBlock;
+                iResult = stream.ParseBlock(curBlock);
                 RTTestIPrintf(RTTESTLVL_DEBUG, "\tReturned with %Rrc\n", iResult);
-                if (   iResult == VINF_SUCCESS
-                        || iResult == VERR_MORE_DATA)
+                if (RT_SUCCESS(iResult))
                 {
                     /* Only count block which have at least one pair. */
-                    if (block.GetCount())
+                    if (curBlock.GetCount())
                         uNumBlocks++;
                 }
-                if (uNumBlocks > 32)
-                    break; /* Give up if unreasonable big. */
-                block.Clear();
-            } while (iResult == VERR_MORE_DATA);
+                if (uSafeCouunter++ > 32)
+                    break;
+            } while (RT_SUCCESS(iResult));
 
             if (iResult != aTests2[iTest].iResult)