Changeset 37375 in vbox for trunk/src/VBox/Main

Timestamp:

Jun 8, 2011 10:51:26 AM (14 years ago)

Author:

vboxsync

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

72150

Message:

GuestCtrl: Added APIs for guest directory enumeration, guest file existence and copy from guest support, some API renaming/cleanup (work in progress).

Location:

trunk/src/VBox/Main

Files:

• idl/VirtualBox.xidl (modified) (13 diffs)
• include/GuestImpl.h (modified) (4 diffs)
• src-client/GuestCtrlImpl.cpp (modified) (27 diffs)

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

@@ -8114 +8114 @@
       <desc>No flag set.</desc>
     </const>
-
     <const name="WaitForProcessStartOnly" value="1">
       <desc>Only use the specified timeout value to wait for starting the guest process - the guest
         process itself then uses an infinite timeout.</desc>
     </const>
-
     <const name="IgnoreOrphanedProcesses" value="2">
       <desc>Do not report an error when executed processes are still alive when VBoxService or the guest OS is shutting down.</desc>
     </const>
-
     <const name="Hidden"                  value="4">
       <desc>Don't show the started process according to the guest OS guidelines.</desc>
@@ -8136 +8133 @@
       Guest process execution status.
     </desc>
-
     <const name="Undefined"               value="0">
       <desc>Process is in an undefined state.</desc>
@@ -8144 +8140 @@
       <desc>Process has been started.</desc>
     </const>
-
     <const name="TerminatedNormally"      value="2">
       <desc>Process terminated normally.</desc>
     </const>
-
     <const name="TerminatedSignal"        value="3">
       <desc>Process terminated via signal.</desc>
     </const>
-
     <const name="TerminatedAbnormally"    value="4">
       <desc>Process terminated abnormally.</desc>
     </const>
-
      <const name="TimedOutKilled"         value="5">
       <desc>Process timed out and was killed.</desc>
     </const>
-
     <const name="TimedOutAbnormally"      value="6">
       <desc>Process timed out and was not killed successfully.</desc>
     </const>
-
     <const name="Down"                    value="7">
       <desc>Service/OS is stopping, process was killed.</desc>
     </const>
-
     <const name="Error"                   value="8">
       <desc>Something went wrong (error code in flags).</desc>
@@ -8181 +8170 @@
       Guest process input flags.
     </desc>
-
     <const name="None"                    value="0">
       <desc>No flag set.</desc>
     </const>
-
     <const name="EndOfFile"               value="1">
       <desc>End of file (input) reached.</desc>
@@ -8199 +8186 @@
       type of output to retrieve.
     </desc>
-
     <const name="None"                     value="0">
       <desc>No flags set. Get output from stdout.</desc>
     </const>
-
     <const name="StdErr"                   value="1">
       <desc>Get output from stderr.</desc>
@@ -8217 +8202 @@
       are implemented.
     </desc>
-
     <const name="None"                    value="0">
       <desc>No flag set.</desc>
     </const>
-
     <const name="Recursive"               value="1">
       <desc>Copy directories recursively.</desc>
     </const>
-
     <const name="Update"                  value="2">
       <desc>Only copy when the source file is newer than the destination file or when the destination file is missing.</desc>
     </const>
-
     <const name="FollowLinks"             value="4">
       <desc>Follow symbolic links.</desc>
@@ -8236 +8217 @@
 
   <enum
-    name="CreateDirectoryFlag"
-    uuid="26ff5bdd-c81f-4304-857b-b8be5e3f9cd6"
-  >
+    name="DirectoryCreateFlag"
+    uuid="bd721b0e-ced5-4f79-b368-249897c32a36"
+    >
     <desc>
       Directory creation flags.
     </desc>
-
     <const name="None"                    value="0">
       <desc>No flag set.</desc>
     </const>
-
     <const name="Parents"                 value="1">
       <desc>No error if existing, make parent directories as needed.</desc>
@@ -8252 +8231 @@
   </enum>
 
+  <enum
+    name="DirectoryOpenFlag"
+    uuid="fc8f6203-0072-4f34-bd08-0b35e50bf071"
+    >
+    <desc>
+      Directory open flags.
+    </desc>
+    <const name="None"                    value="0">
+      <desc>No flag set.</desc>
+    </const>
+  </enum>
+
+  <enum
+    name="GuestDirEntryType"
+    uuid="6d19d924-1b77-4fc8-b369-a3b2c85c8241"
+    >
+    <desc>
+      Guest directory entry type.
+    </desc>
+    <const name="Unknown"                 value="0">
+      <desc>Unknown.</desc>
+    </const>
+    <const name="Directory"               value="4">
+      <desc>Regular file.</desc>
+    </const>
+    <const name="File"                    value="10">
+      <desc>Regular file.</desc>
+    </const>
+    <const name="Symlink"                 value="12">
+      <desc>Symbolic link.</desc>
+    </const>
+  </enum>
+
+  <interface
+    name="IGuestDirEntry" extends="$unknown"
+    uuid="20a66efc-c2f6-4438-826f-38454c04369e"
+    wsmap="struct"
+    >
+    <desc>
+      Structure representing a directory entry on the guest OS.
+    </desc>
+    <attribute name="nodeId" type="long long" readonly="yes">
+      <desc>The unique identifier (within the guest's file system) of this file system object.</desc>
+    </attribute>
+    <attribute name="name" type="wstring" readonly="yes">
+      <desc>The filename.</desc>
+    </attribute>
+    <attribute name="type" type="GuestDirEntryType" readonly="yes">
+      <desc>The entry type.</desc>
+    </attribute>
+  </interface>
+
   <interface
     name="IGuest" extends="$unknown"
-    uuid="4e78f7dd-8ca1-47e5-a344-5207f793df71"
+    uuid="44637074-a613-48cd-9b5d-77117f971529"
     wsmap="managed"
     >
@@ -8507 +8538 @@
         </desc>
       </param>
-      <param name="data" type="octet" dir="return" safearray="yes">
+      <param name="data" type="octet" safearray="yes" dir="return">
         <desc>
           Buffer for retrieving the actual output. A data size of 0 means end of file
@@ -8549 +8580 @@
     </method>
 
+    <method name="copyFromGuest">
+      <desc>
+        Copies files/directories from guest to the host.
+
+        <result name="VBOX_E_IPRT_ERROR">
+          Error while copying.
+        </result>
+
+      </desc>
+      <param name="source" type="wstring" dir="in">
+        <desc>
+          Source file on the guest to copy.
+        </desc>
+      </param>
+      <param name="dest" type="wstring" dir="in">
+        <desc>
+          Destination path on the host.
+        </desc>
+      </param>
+      <param name="userName" type="wstring" dir="in">
+        <desc>
+          User name under which the copy command will be executed; the
+          user has to exist and have the appropriate rights to read from
+          the source path.
+        </desc>
+      </param>
+      <param name="password" type="wstring" dir="in">
+        <desc>
+          Password of the user account specified.
+        </desc>
+      </param>
+      <param name="flags" type="unsigned long" dir="in">
+        <desc>
+          <link to="CopyFileFlag"/> flags. Not used at the moment and should be set to 0.
+        </desc>
+      </param>
+      <param name="progress" type="IProgress" dir="return">
+        <desc>Progress object to track the operation completion.</desc>
+      </param>
+    </method>
+
     <method name="copyToGuest">
       <desc>
@@ -8590 +8662 @@
     </method>
 
-    <method name="createDirectory">
+    <method name="directoryClose">
+      <desc>
+        Closes a formerly opened guest directory.
+
+        <result name="VBOX_E_IPRT_ERROR">
+          Error while closing directory.
+        </result>
+
+      </desc>
+      <param name="handle" type="unsigned long" dir="in">
+        <desc>
+          Handle of opened directory to close.
+        </desc>
+      </param>
+    </method>
+
+    <method name="directoryCreate">
       <desc>
         Creates a directory on the guest.
@@ -8623 +8711 @@
       <param name="flags" type="unsigned long" dir="in">
         <desc>
-          <link to="CreateDirectoryFlag"/> flags.
-        </desc>
-      </param>
-      <param name="progress" type="IProgress" dir="return">
-        <desc>Progress object to track the operation completion.</desc>
+          <link to="DirectoryCreateFlag"/> flags.
+        </desc>
+      </param>
+    </method>
+
+    <method name="directoryOpen">
+      <desc>
+        Opens a directory on the guest.
+
+        <result name="VBOX_E_IPRT_ERROR">
+          Error while opening / reading directory.
+        </result>
+
+      </desc>
+      <param name="directory" type="wstring" dir="in">
+        <desc>
+          Directory to read.
+        </desc>
+      </param>
+      <param name="filter" type="wstring" dir="in">
+        <desc>
+          Directory filter (DOS style wildcards). Set to empty
+          string if no filter required.
+        </desc>
+      </param>
+      <param name="flags" type="unsigned long" dir="in">
+        <desc>
+          <link to="DirectoryOpenFlag"/> flags.
+        </desc>
+      </param>
+      <param name="userName" type="wstring" dir="in">
+        <desc>
+          User name under which the directory reading 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="handle" type="unsigned long" dir="out">
+        <desc>
+          Handle of opened directory returned by openDirectory.
+        </desc>
+      </param>
+    </method>
+
+    <method name="directoryRead">
+      <desc>
+        Reads the next directory entry of an opened guest directory.
+
+        <result name="VBOX_E_IPRT_ERROR">
+          Error while opening / reading directory.
+        </result>
+
+      </desc>
+      <param name="handle" type="unsigned long" dir="in">
+        <desc>
+          Handle of opened directory returned by openDirectory.
+        </desc>
+      </param>
+      <param name="entry" type="IGuestDirEntry" dir="out">
+        <desc>
+          Information about next directory entry on success.
+        </desc>
+      </param>
+    </method>
+
+    <method name="fileExists">
+      <desc>
+        Checks if the specified file name exists and is a regular file.
+
+        <result name="VBOX_E_IPRT_ERROR">
+          Error while looking up information.
+        </result>
+
+      </desc>
+      <param name="file" type="wstring" dir="in">
+        <desc>
+          Full path of file 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="out">
+        <desc>
+          True if it's a regular file, false if it isn't (or doesn't exist).
+        </desc>
       </param>
     </method>
@@ -8905 +9088 @@
          this progress. This means sub-operation number, description, percent
          and so on.
-         
+
          You have to take care on setting up at least the same count on
          sub-operations in this progress object like there are in the other
-         progress object. 
+         progress object.
 
          If the other progress object supports cancel and this object gets any

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

@@ -88 +88 @@
     STDMETHOD(SetCredentials)(IN_BSTR aUserName, IN_BSTR aPassword,
                               IN_BSTR aDomain, BOOL aAllowInteractiveLogon);
+    // Process execution
     STDMETHOD(ExecuteProcess)(IN_BSTR aCommand, ULONG aFlags,
                               ComSafeArrayIn(IN_BSTR, aArguments), ComSafeArrayIn(IN_BSTR, aEnvironment),
@@ -95 +96 @@
     STDMETHOD(SetProcessInput)(ULONG aPID, ULONG aFlags, ULONG aTimeoutMS, ComSafeArrayIn(BYTE, aData), ULONG *aBytesWritten);
     STDMETHOD(GetProcessStatus)(ULONG aPID, ULONG *aExitCode, ULONG *aFlags, ExecuteProcessStatus_T *aStatus);
+    // File copying
+    STDMETHOD(CopyFromGuest)(IN_BSTR aSource, IN_BSTR aDest, IN_BSTR aUserName, IN_BSTR aPassword, ULONG aFlags, IProgress **aProgress);
     STDMETHOD(CopyToGuest)(IN_BSTR aSource, IN_BSTR aDest, IN_BSTR aUserName, IN_BSTR aPassword, ULONG aFlags, IProgress **aProgress);
-    STDMETHOD(CreateDirectory)(IN_BSTR aDirectory, IN_BSTR aUserName, IN_BSTR aPassword, ULONG aMode, ULONG aFlags, IProgress **aProgress);
+    // Directory handling
+    STDMETHOD(DirectoryClose)(ULONG aHandle);
+    STDMETHOD(DirectoryCreate)(IN_BSTR aDirectory, IN_BSTR aUserName, IN_BSTR aPassword, ULONG aMode, ULONG aFlags);
+    STDMETHOD(DirectoryOpen)(IN_BSTR aDirectory, IN_BSTR aFilter,
+                             ULONG aFlags, IN_BSTR aUserName, IN_BSTR aPassword, ULONG *aHandle);
+    STDMETHOD(DirectoryRead)(ULONG aHandle, IGuestDirEntry **aDirEntry);
+    // File handling
+    STDMETHOD(FileExists)(IN_BSTR aFile, IN_BSTR aUserName, IN_BSTR aPassword, BOOL *aExists);
+    // Misc stuff
     STDMETHOD(InternalGetStatistics)(ULONG *aCpuUser, ULONG *aCpuKernel, ULONG *aCpuIdle,
                                      ULONG *aMemTotal, ULONG *aMemFree, ULONG *aMemBalloon, ULONG *aMemShared, ULONG *aMemCache,
@@ -107 +118 @@
                                    IN_BSTR aUserName, IN_BSTR aPassword,
                                    ULONG aTimeoutMS, ULONG *aPID, IProgress **aProgress, int *pRC);
-    HRESULT createDirectoryInternal(IN_BSTR aDirectory, IN_BSTR aUserName, IN_BSTR aPassword,
-                                    ULONG aMode, ULONG aFlags, IProgress **aProgress, int *pRC);
+    HRESULT directoryCreateInternal(IN_BSTR aDirectory, IN_BSTR aUserName, IN_BSTR aPassword,
+                                    ULONG aMode, ULONG aFlags, int *pRC);
     void setAdditionsInfo(Bstr aInterfaceVersion, VBOXOSTYPE aOsType);
     void setAdditionsInfo2(Bstr aAdditionsVersion, Bstr aVersionName, Bstr aRevision);
@@ -131 +142 @@
     // Internal tasks.
     struct TaskGuest; /* Worker thread helper. */
-    HRESULT taskCopyFile(TaskGuest *aTask);
+    HRESULT taskCopyFileToGuest(TaskGuest *aTask);
+    HRESULT taskCopyFileFromGuest(TaskGuest *aTask);
     HRESULT taskUpdateGuestAdditions(TaskGuest *aTask);
 

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

@@ -45 +45 @@
     enum TaskType
     {
-        /** Copies a file to the guest. */
-        CopyFile = 50,
+        /** Copies a file from host to the guest. */
+        CopyFileToGuest   = 50,
+        /** Copies a file from guest to the host. */
+        CopyFileFromGuest = 55,
 
         /** Update Guest Additions by directly copying the required installer
@@ -60 +62 @@
           rc(S_OK)
     {}
-    ~TaskGuest() {}
+    virtual ~TaskGuest() {}
 
     int startThread();
@@ -110 +112 @@
     {
 #ifdef VBOX_WITH_GUEST_CONTROL
-        case TaskGuest::CopyFile:
-        {
-            rc = pGuest->taskCopyFile(task.get());
+        case TaskGuest::CopyFileToGuest:
+        {
+            rc = pGuest->taskCopyFileToGuest(task.get());
+            break;
+        }
+        case TaskGuest::CopyFileFromGuest:
+        {
+            rc = pGuest->taskCopyFileFromGuest(task.get());
             break;
         }
@@ -182 +189 @@
 
 #ifdef VBOX_WITH_GUEST_CONTROL
-HRESULT Guest::taskCopyFile(TaskGuest *aTask)
+HRESULT Guest::taskCopyFileToGuest(TaskGuest *aTask)
 {
     LogFlowFuncEnter();
@@ -458 +465 @@
 }
 
+HRESULT Guest::taskCopyFileFromGuest(TaskGuest *aTask)
+{
+    LogFlowFuncEnter();
+
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    /*
+     * Do *not* take a write lock here since we don't (and won't)
+     * touch any class-specific data (of IGuest) here - only the member functions
+     * which get called here can do that.
+     */
+
+    HRESULT rc = S_OK;
+
+    try
+    {
+        Guest *pGuest = aTask->pGuest;
+        AssertPtr(pGuest);
+
+
+
+#if 0
+        /* Does our source file exist? */
+        if (!RTFileExists(aTask->strSource.c_str()))
+        {
+            rc = TaskGuest::setProgressErrorInfo(VBOX_E_IPRT_ERROR, aTask->progress,
+                                                 Guest::tr("Source file \"%s\" does not exist, or is not a file"),
+                                                 aTask->strSource.c_str());
+        }
+        else
+        {
+            RTFILE fileSource;
+            int vrc = RTFileOpen(&fileSource, aTask->strSource.c_str(),
+                                 RTFILE_O_OPEN | RTFILE_O_READ | RTFILE_O_DENY_WRITE);
+            if (RT_FAILURE(vrc))
+            {
+                rc = TaskGuest::setProgressErrorInfo(VBOX_E_IPRT_ERROR, aTask->progress,
+                                                     Guest::tr("Could not open source file \"%s\" for reading (%Rrc)"),
+                                                     aTask->strSource.c_str(),  vrc);
+            }
+            else
+            {
+                uint64_t cbSize;
+                vrc = RTFileGetSize(fileSource, &cbSize);
+                if (RT_FAILURE(vrc))
+                {
+                    rc = TaskGuest::setProgressErrorInfo(VBOX_E_IPRT_ERROR, aTask->progress,
+                                                         Guest::tr("Could not query file size of \"%s\" (%Rrc)"),
+                                                         aTask->strSource.c_str(), vrc);
+                }
+                else
+                {
+                    com::SafeArray<IN_BSTR> args;
+                    com::SafeArray<IN_BSTR> env;
+
+                    /*
+                     * Prepare tool command line.
+                     */
+                    char szOutput[RTPATH_MAX];
+                    if (RTStrPrintf(szOutput, sizeof(szOutput), "--output=%s", aTask->strDest.c_str()) <= sizeof(szOutput) - 1)
+                    {
+                        /*
+                         * Normalize path slashes, based on the detected guest.
+                         */
+                        Utf8Str osType = mData.mOSTypeId;
+                        if (   osType.contains("Microsoft", Utf8Str::CaseInsensitive)
+                            || osType.contains("Windows", Utf8Str::CaseInsensitive))
+                        {
+                            /* We have a Windows guest. */
+                            RTPathChangeToDosSlashes(szOutput, true /* Force conversion. */);
+                        }
+                        else /* ... or something which isn't from Redmond ... */
+                        {
+                            RTPathChangeToUnixSlashes(szOutput, true /* Force conversion. */);
+                        }
+
+                        args.push_back(Bstr(szOutput).raw());             /* We want to write a file ... */
+                    }
+                    else
+                    {
+                        rc = TaskGuest::setProgressErrorInfo(VBOX_E_IPRT_ERROR, aTask->progress,
+                                                             Guest::tr("Error preparing command line"));
+                    }
+
+                    ComPtr<IProgress> execProgress;
+                    ULONG uPID;
+                    if (SUCCEEDED(rc))
+                    {
+                        LogRel(("Copying file \"%s\" to guest \"%s\" (%u bytes) ...\n",
+                                aTask->strSource.c_str(), aTask->strDest.c_str(), cbSize));
+                        /*
+                         * Okay, since we gathered all stuff we need until now to start the
+                         * actual copying, start the guest part now.
+                         */
+                        rc = pGuest->ExecuteProcess(Bstr(VBOXSERVICE_TOOL_CAT).raw(),
+                                                      ExecuteProcessFlag_Hidden
+                                                    | ExecuteProcessFlag_WaitForProcessStartOnly,
+                                                    ComSafeArrayAsInParam(args),
+                                                    ComSafeArrayAsInParam(env),
+                                                    Bstr(aTask->strUserName).raw(),
+                                                    Bstr(aTask->strPassword).raw(),
+                                                    5 * 1000 /* Wait 5s for getting the process started. */,
+                                                    &uPID, execProgress.asOutParam());
+                        if (FAILED(rc))
+                            rc = TaskGuest::setProgressErrorInfo(rc, aTask->progress, pGuest);
+                    }
+
+                    if (SUCCEEDED(rc))
+                    {
+                        BOOL fCompleted = FALSE;
+                        BOOL fCanceled = FALSE;
+
+                        size_t cbToRead = cbSize;
+                        size_t cbTransfered = 0;
+                        size_t cbRead;
+                        SafeArray<BYTE> aInputData(_64K);
+                        while (   SUCCEEDED(execProgress->COMGETTER(Completed(&fCompleted)))
+                               && !fCompleted)
+                        {
+                            if (!cbToRead)
+                                cbRead = 0;
+                            else
+                            {
+                                vrc = RTFileRead(fileSource, (uint8_t*)aInputData.raw(),
+                                                 RT_MIN(cbToRead, _64K), &cbRead);
+                                /*
+                                 * Some other error occured? There might be a chance that RTFileRead
+                                 * could not resolve/map the native error code to an IPRT code, so just
+                                 * print a generic error.
+                                 */
+                                if (RT_FAILURE(vrc))
+                                {
+                                    rc = TaskGuest::setProgressErrorInfo(VBOX_E_IPRT_ERROR, aTask->progress,
+                                                                         Guest::tr("Could not read from file \"%s\" (%Rrc)"),
+                                                                         aTask->strSource.c_str(), vrc);
+                                    break;
+                                }
+                            }
+
+                            /* Resize buffer to reflect amount we just have read.
+                             * Size 0 is allowed! */
+                            aInputData.resize(cbRead);
+
+                            ULONG uFlags = ProcessInputFlag_None;
+                            /* Did we reach the end of the content we want to transfer (last chunk)? */
+                            if (   (cbRead < _64K)
+                                /* Did we reach the last block which is exactly _64K? */
+                                || (cbToRead - cbRead == 0)
+                                /* ... or does the user want to cancel? */
+                                || (   SUCCEEDED(aTask->progress->COMGETTER(Canceled(&fCanceled)))
+                                    && fCanceled)
+                               )
+                            {
+                                uFlags |= ProcessInputFlag_EndOfFile;
+                            }
+
+                            /* Transfer the current chunk ... */
+                            ULONG uBytesWritten;
+                            rc = pGuest->SetProcessInput(uPID, uFlags,
+                                                         10 * 1000 /* Wait 10s for getting the input data transfered. */,
+                                                         ComSafeArrayAsInParam(aInputData), &uBytesWritten);
+                            if (FAILED(rc))
+                            {
+                                rc = TaskGuest::setProgressErrorInfo(rc, aTask->progress, pGuest);
+                                break;
+                            }
+
+                            Assert(cbRead <= cbToRead);
+                            Assert(cbToRead >= cbRead);
+                            cbToRead -= cbRead;
+
+                            cbTransfered += uBytesWritten;
+                            Assert(cbTransfered <= cbSize);
+                            aTask->progress->SetCurrentOperationProgress(cbTransfered / (cbSize / 100.0));
+
+                            /* End of file reached? */
+                            if (cbToRead == 0)
+                                break;
+
+                            /* Did the user cancel the operation above? */
+                            if (fCanceled)
+                                break;
+
+                            /* Progress canceled by Main API? */
+                            if (   SUCCEEDED(execProgress->COMGETTER(Canceled(&fCanceled)))
+                                && fCanceled)
+                            {
+                                rc = TaskGuest::setProgressErrorInfo(VBOX_E_IPRT_ERROR, aTask->progress,
+                                                                     Guest::tr("Copy operation of file \"%s\" was canceled on guest side"),
+                                                                     aTask->strSource.c_str());
+                                break;
+                            }
+                        }
+
+                        if (SUCCEEDED(rc))
+                        {
+                            /*
+                             * If we got here this means the started process either was completed,
+                             * canceled or we simply got all stuff transferred.
+                             */
+                            ExecuteProcessStatus_T retStatus;
+                            ULONG uRetExitCode;
+                            rc = pGuest->waitForProcessStatusChange(uPID, &retStatus, &uRetExitCode, 10 * 1000 /* 10s timeout. */);
+                            if (FAILED(rc))
+                            {
+                                rc = TaskGuest::setProgressErrorInfo(rc, aTask->progress, pGuest);
+                            }
+                            else
+                            {
+                                if (   uRetExitCode != 0
+                                    || retStatus    != ExecuteProcessStatus_TerminatedNormally)
+                                {
+                                    rc = TaskGuest::setProgressErrorInfo(VBOX_E_IPRT_ERROR, aTask->progress,
+                                                                         Guest::tr("Guest reported error %u while copying file \"%s\" to \"%s\""),
+                                                                         uRetExitCode, aTask->strSource.c_str(), aTask->strDest.c_str());
+                                }
+                            }
+                        }
+
+                        if (SUCCEEDED(rc))
+                        {
+                            if (fCanceled)
+                            {
+                                /*
+                                 * In order to make the progress object to behave nicely, we also have to
+                                 * notify the object with a complete event when it's canceled.
+                                 */
+                                aTask->progress->notifyComplete(VBOX_E_IPRT_ERROR,
+                                                                COM_IIDOF(IGuest),
+                                                                Guest::getStaticComponentName(),
+                                                                Guest::tr("Copying file \"%s\" canceled"), aTask->strSource.c_str());
+                            }
+                            else
+                            {
+                                /*
+                                 * Even if we succeeded until here make sure to check whether we really transfered
+                                 * everything.
+                                 */
+                                if (   cbSize > 0
+                                    && cbTransfered == 0)
+                                {
+                                    /* If nothing was transfered but the file size was > 0 then "vbox_cat" wasn't able to write
+                                     * to the destination -> access denied. */
+                                    rc = TaskGuest::setProgressErrorInfo(VBOX_E_IPRT_ERROR, aTask->progress,
+                                                                         Guest::tr("Access denied when copying file \"%s\" to \"%s\""),
+                                                                         aTask->strSource.c_str(), aTask->strDest.c_str());
+                                }
+                                else if (cbTransfered < cbSize)
+                                {
+                                    /* If we did not copy all let the user know. */
+                                    rc = TaskGuest::setProgressErrorInfo(VBOX_E_IPRT_ERROR, aTask->progress,
+                                                                         Guest::tr("Copying file \"%s\" failed (%u/%u bytes transfered)"),
+                                                                         aTask->strSource.c_str(), cbTransfered, cbSize);
+                                }
+                                else /* Yay, all went fine! */
+                                    aTask->progress->notifyComplete(S_OK);
+                            }
+                        }
+                    }
+                }
+                RTFileClose(fileSource);
+            }
+        }
+#endif
+    }
+    catch (HRESULT aRC)
+    {
+        rc = aRC;
+    }
+
+    /* Clean up */
+    aTask->rc = rc;
+
+    LogFlowFunc(("rc=%Rhrc\n", rc));
+    LogFlowFuncLeave();
+
+    return VINF_SUCCESS;
+}
+
 HRESULT Guest::taskUpdateGuestAdditions(TaskGuest *aTask)
 {
@@ -945 +1232 @@
             AssertPtr(pCBData);
             AssertReturn(sizeof(CALLBACKDATACLIENTDISCONNECTED) == cbParms, VERR_INVALID_PARAMETER);
-            AssertReturn(CALLBACKDATAMAGICCLIENTDISCONNECTED == pCBData->hdr.u32Magic, VERR_INVALID_PARAMETER);
+            AssertReturn(CALLBACKDATAMAGIC_CLIENT_DISCONNECTED == pCBData->hdr.u32Magic, VERR_INVALID_PARAMETER);
 
             rc = pGuest->notifyCtrlClientDisconnected(u32Function, pCBData);
@@ -958 +1245 @@
             AssertPtr(pCBData);
             AssertReturn(sizeof(CALLBACKDATAEXECSTATUS) == cbParms, VERR_INVALID_PARAMETER);
-            AssertReturn(CALLBACKDATAMAGICEXECSTATUS == pCBData->hdr.u32Magic, VERR_INVALID_PARAMETER);
+            AssertReturn(CALLBACKDATAMAGIC_EXEC_STATUS == pCBData->hdr.u32Magic, VERR_INVALID_PARAMETER);
 
             rc = pGuest->notifyCtrlExecStatus(u32Function, pCBData);
@@ -971 +1258 @@
             AssertPtr(pCBData);
             AssertReturn(sizeof(CALLBACKDATAEXECOUT) == cbParms, VERR_INVALID_PARAMETER);
-            AssertReturn(CALLBACKDATAMAGICEXECOUT == pCBData->hdr.u32Magic, VERR_INVALID_PARAMETER);
+            AssertReturn(CALLBACKDATAMAGIC_EXEC_OUT == pCBData->hdr.u32Magic, VERR_INVALID_PARAMETER);
 
             rc = pGuest->notifyCtrlExecOut(u32Function, pCBData);
@@ -984 +1271 @@
             AssertPtr(pCBData);
             AssertReturn(sizeof(CALLBACKDATAEXECINSTATUS) == cbParms, VERR_INVALID_PARAMETER);
-            AssertReturn(CALLBACKDATAMAGICEXECINSTATUS == pCBData->hdr.u32Magic, VERR_INVALID_PARAMETER);
+            AssertReturn(CALLBACKDATAMAGIC_EXEC_IN_STATUS == pCBData->hdr.u32Magic, VERR_INVALID_PARAMETER);
 
             rc = pGuest->notifyCtrlExecInStatus(u32Function, pCBData);
@@ -1636 +1923 @@
                         paParms[i++].setUInt32(aTimeoutMS);
 
-                    VMMDev *vmmDev;
+                    VMMDev *pVMMDev = NULL;
                     {
                         /* Make sure mParent is valid, so set the read lock while using.
@@ -1645 +1932 @@
                         /* Forward the information to the VMM device. */
                         AssertPtr(mParent);
-                        vmmDev = mParent->getVMMDev();
+                        pVMMDev = mParent->getVMMDev();
                     }
 
-                    if (vmmDev)
+                    if (pVMMDev)
                     {
                         LogFlowFunc(("hgcmHostCall numParms=%d\n", i));
-                        vrc = vmmDev->hgcmHostCall("VBoxGuestControlSvc", HOST_EXEC_CMD,
+                        vrc = pVMMDev->hgcmHostCall("VBoxGuestControlSvc", HOST_EXEC_CMD,
                                                    i, paParms);
                     }
@@ -1917 +2204 @@
 
             {
-                VMMDev *vmmDev;
+                VMMDev *pVMMDev = NULL;
                 {
                     /* Make sure mParent is valid, so set the read lock while using.
@@ -1926 +2213 @@
                     /* Forward the information to the VMM device. */
                     AssertPtr(mParent);
-                    vmmDev = mParent->getVMMDev();
+                    pVMMDev = mParent->getVMMDev();
                 }
 
-                if (vmmDev)
+                if (pVMMDev)
                 {
                     LogFlowFunc(("hgcmHostCall numParms=%d\n", i));
-                    vrc = vmmDev->hgcmHostCall("VBoxGuestControlSvc", HOST_EXEC_SET_INPUT,
+                    vrc = pVMMDev->hgcmHostCall("VBoxGuestControlSvc", HOST_EXEC_SET_INPUT,
                                                i, paParms);
                 }
@@ -2093 +2380 @@
 
         {
-            VMMDev *vmmDev;
+            VMMDev *pVMMDev = NULL;
             {
                 /* Make sure mParent is valid, so set the read lock while using.
@@ -2102 +2389 @@
                 /* Forward the information to the VMM device. */
                 AssertPtr(mParent);
-                vmmDev = mParent->getVMMDev();
+                pVMMDev = mParent->getVMMDev();
             }
 
-            if (vmmDev)
+            if (pVMMDev)
             {
                 LogFlowFunc(("hgcmHostCall numParms=%d\n", i));
-                vrc = vmmDev->hgcmHostCall("VBoxGuestControlSvc", HOST_EXEC_GET_OUTPUT,
+                vrc = pVMMDev->hgcmHostCall("VBoxGuestControlSvc", HOST_EXEC_GET_OUTPUT,
                                            i, paParms);
             }
@@ -2268 +2555 @@
 }
 
-STDMETHODIMP Guest::CopyToGuest(IN_BSTR aSource, IN_BSTR aDest,
-                                IN_BSTR aUserName, IN_BSTR aPassword,
-                                ULONG aFlags, IProgress **aProgress)
+STDMETHODIMP Guest::CopyFromGuest(IN_BSTR aSource, IN_BSTR aDest,
+                                  IN_BSTR aUserName, IN_BSTR aPassword,
+                                  ULONG aFlags, IProgress **aProgress)
 {
 #ifndef VBOX_WITH_GUEST_CONTROL
@@ -2306 +2593 @@
 
         rc = progress->init(static_cast<IGuest*>(this),
-                            Bstr(tr("Copying file")).raw(),
+                            Bstr(tr("Copying file from guest to host")).raw(),
                             TRUE /* aCancelable */);
         if (FAILED(rc)) throw rc;
 
         /* Initialize our worker task. */
-        TaskGuest *pTask = new TaskGuest(TaskGuest::CopyFile, this, progress);
+        TaskGuest *pTask = new TaskGuest(TaskGuest::CopyFileFromGuest, this, progress);
+        AssertPtr(pTask);
+        std::auto_ptr<TaskGuest> task(pTask);
+
+        /* Assign data - aSource is the source file on the guest,
+         * aDest reflects the full path on the host. */
+        task->strSource   = (Utf8Str(aSource));
+        task->strDest     = (Utf8Str(aDest));
+        task->strUserName = (Utf8Str(aUserName));
+        task->strPassword = (Utf8Str(aPassword));
+        task->uFlags      = aFlags;
+
+        rc = task->startThread();
+        if (FAILED(rc)) throw rc;
+
+        /* Don't destruct on success. */
+        task.release();
+    }
+    catch (HRESULT aRC)
+    {
+        rc = aRC;
+    }
+
+    if (SUCCEEDED(rc))
+    {
+        /* Return progress to the caller. */
+        progress.queryInterfaceTo(aProgress);
+    }
+    return rc;
+#endif /* VBOX_WITH_GUEST_CONTROL */
+}
+
+STDMETHODIMP Guest::CopyToGuest(IN_BSTR aSource, IN_BSTR aDest,
+                                IN_BSTR aUserName, IN_BSTR aPassword,
+                                ULONG aFlags, IProgress **aProgress)
+{
+#ifndef VBOX_WITH_GUEST_CONTROL
+    ReturnComNotImplemented();
+#else /* VBOX_WITH_GUEST_CONTROL */
+    CheckComArgStrNotEmptyOrNull(aSource);
+    CheckComArgStrNotEmptyOrNull(aDest);
+    CheckComArgStrNotEmptyOrNull(aUserName);
+    CheckComArgStrNotEmptyOrNull(aPassword);
+    CheckComArgOutPointerValid(aProgress);
+
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    /* Validate flags. */
+    if (aFlags != CopyFileFlag_None)
+    {
+        if (   !(aFlags & CopyFileFlag_Recursive)
+            && !(aFlags & CopyFileFlag_Update)
+            && !(aFlags & CopyFileFlag_FollowLinks))
+        {
+            return setError(E_INVALIDARG, tr("Unknown flags (%#x)"), aFlags);
+        }
+    }
+
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    HRESULT rc = S_OK;
+
+    ComObjPtr<Progress> progress;
+    try
+    {
+        /* Create the progress object. */
+        progress.createObject();
+
+        rc = progress->init(static_cast<IGuest*>(this),
+                            Bstr(tr("Copying file from host to guest")).raw(),
+                            TRUE /* aCancelable */);
+        if (FAILED(rc)) throw rc;
+
+        /* Initialize our worker task. */
+        TaskGuest *pTask = new TaskGuest(TaskGuest::CopyFileToGuest, this, progress);
         AssertPtr(pTask);
         std::auto_ptr<TaskGuest> task(pTask);
@@ -2343 +2705 @@
 }
 
-STDMETHODIMP Guest::CreateDirectory(IN_BSTR aDirectory,
+STDMETHODIMP Guest::DirectoryClose(ULONG aHandle)
+{
+#ifndef VBOX_WITH_GUEST_CONTROL
+    ReturnComNotImplemented();
+#else /* VBOX_WITH_GUEST_CONTROL */
+    using namespace guestControl;
+
+    return VBOX_E_NOT_SUPPORTED;
+#endif
+}
+
+STDMETHODIMP Guest::DirectoryCreate(IN_BSTR aDirectory,
                                     IN_BSTR aUserName, IN_BSTR aPassword,
-                                    ULONG aMode, ULONG aFlags,
-                                    IProgress **aProgress)
+                                    ULONG aMode, ULONG aFlags)
 {
 #ifndef VBOX_WITH_GUEST_CONTROL
@@ -2362 +2734 @@
             Utf8Str(aDirectory).c_str(), Utf8Str(aUserName).c_str()));
 
-    return createDirectoryInternal(aDirectory,
+    return directoryCreateInternal(aDirectory,
                                    aUserName, aPassword,
-                                   aMode, aFlags, aProgress, NULL /* rc */);
+                                   aMode, aFlags, NULL /* rc */);
 #endif
 }
 
-HRESULT Guest::createDirectoryInternal(IN_BSTR aDirectory,
+HRESULT Guest::directoryCreateInternal(IN_BSTR aDirectory,
                                        IN_BSTR aUserName, IN_BSTR aPassword,
-                                       ULONG aMode, ULONG aFlags,
-                                       IProgress **aProgress, int *pRC)
+                                       ULONG aMode, ULONG aFlags, int *pRC)
 {
 #ifndef VBOX_WITH_GUEST_CONTROL
@@ -2379 +2750 @@
 
     CheckComArgStrNotEmptyOrNull(aDirectory);
-    CheckComArgOutPointerValid(aProgress);
 
     AutoCaller autoCaller(this);
@@ -2385 +2755 @@
 
     /* Validate flags. */
-    if (aFlags != CreateDirectoryFlag_None)
-    {
-        if (!(aFlags & CreateDirectoryFlag_Parents))
+    if (aFlags != DirectoryCreateFlag_None)
+    {
+        if (!(aFlags & DirectoryCreateFlag_Parents))
         {
             return setError(E_INVALIDARG, tr("Unknown flags (%#x)"), aFlags);
         }
     }
-
-    /**
-     * @todo We return a progress object because we maybe later want to
-     *       process more than one directory (or somewhat lengthly operations)
-     *       that require having a progress object provided to the caller.
-     */
 
     HRESULT rc = S_OK;
@@ -2412 +2776 @@
          * Prepare tool command line.
          */
-        if (aFlags & CreateDirectoryFlag_Parents)
+        if (aFlags & DirectoryCreateFlag_Parents)
             args.push_back(Bstr("--parents").raw());        /* We also want to create the parent directories. */
         if (aMode > 0)
@@ -2444 +2808 @@
         {
             /* Wait for process to exit ... */
+            rc = progressExec->WaitForCompletion(-1);
+            if (FAILED(rc)) return rc;
+
             BOOL fCompleted = FALSE;
             BOOL fCanceled = FALSE;
-
-            while (   SUCCEEDED(progressExec->COMGETTER(Completed(&fCompleted)))
-                   && !fCompleted)
-            {
-                /* Progress canceled by Main API? */
-                if (   SUCCEEDED(progressExec->COMGETTER(Canceled(&fCanceled)))
-                    && fCanceled)
-                {
-                    break;
-                }
-            }
-
-            ComObjPtr<Progress> progressCreate;
-            rc = progressCreate.createObject();
-            if (SUCCEEDED(rc))
-            {
-                rc = progressCreate->init(static_cast<IGuest*>(this),
-                                          Bstr(tr("Creating directory")).raw(),
-                                          TRUE);
-            }
-            if (FAILED(rc)) return rc;
+            progressExec->COMGETTER(Completed)(&fCompleted);
+            if (!fCompleted)
+                progressExec->COMGETTER(Canceled)(&fCanceled);
 
             if (fCompleted)
@@ -2478 +2827 @@
                     {
                         rc = setError(VBOX_E_IPRT_ERROR,
-                                      tr("Error %u while creating directory"), uRetExitCode);
+                                      tr("Error %u while creating guest directory"), uRetExitCode);
                     }
                 }
@@ -2484 +2833 @@
             else if (fCanceled)
                 rc = setError(VBOX_E_IPRT_ERROR,
-                                      tr("Directory creation was aborted"));
+                              tr("Guest directory creation was aborted"));
             else
-                AssertReleaseMsgFailed(("Directory creation neither completed nor canceled!?"));
-
-            if (SUCCEEDED(rc))
-                progressCreate->notifyComplete(S_OK);
-            else
-                progressCreate->notifyComplete(VBOX_E_IPRT_ERROR,
-                                               COM_IIDOF(IGuest),
-                                               Guest::getStaticComponentName(),
-                                               Guest::tr("Error while executing creation command"));
-
-            /* Return the progress to the caller. */
-            progressCreate.queryInterfaceTo(aProgress);
+                AssertReleaseMsgFailed(("Guest directory creation neither completed nor canceled!?"));
         }
     }
@@ -2506 +2844 @@
     return rc;
 #endif /* VBOX_WITH_GUEST_CONTROL */
+}
+
+STDMETHODIMP Guest::DirectoryOpen(IN_BSTR aDirectory, IN_BSTR aFilter,
+                                  ULONG aFlags, IN_BSTR aUserName, IN_BSTR aPassword,
+                                  ULONG *aHandle)
+{
+#ifndef VBOX_WITH_GUEST_CONTROL
+    ReturnComNotImplemented();
+#else /* VBOX_WITH_GUEST_CONTROL */
+    using namespace guestControl;
+
+    CheckComArgStrNotEmptyOrNull(aDirectory);
+    CheckComArgStrNotEmptyOrNull(aUserName);
+    CheckComArgStrNotEmptyOrNull(aPassword);
+    CheckComArgNotNull(aHandle);
+
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    /* Validate flags. */
+    if (aFlags != DirectoryOpenFlag_None)
+        return setError(E_INVALIDARG, tr("Unknown flags (%#x)"), aFlags);
+
+    HRESULT rc = S_OK;
+    try
+    {
+        Utf8Str Utf8Dir(aDirectory);
+        Utf8Str UtfFilter(aFilter);
+        Utf8Str Utf8UserName(aUserName);
+        Utf8Str Utf8Password(aPassword);
+
+        /*
+         * Create progress object.
+         * This progress object, compared to the one in executeProgress() above
+         * is only local and is used to determine whether the operation finished
+         * or got canceled.
+         */
+        ComObjPtr <Progress> progress;
+        rc = progress.createObject();
+        if (SUCCEEDED(rc))
+        {
+            rc = progress->init(static_cast<IGuest*>(this),
+                                Bstr(tr("Getting output of process")).raw(),
+                                TRUE /* Cancelable */);
+        }
+        if (FAILED(rc)) return rc;
+
+        PCALLBACKDATADIROPEN pData = (PCALLBACKDATADIROPEN)RTMemAlloc(sizeof(CALLBACKDATADIROPEN));
+        AssertReturn(pData, VBOX_E_IPRT_ERROR);
+        RT_ZERO(*pData);
+        uint32_t uContextID = addCtrlCallbackContext(VBOXGUESTCTRLCALLBACKTYPE_EXEC_START,
+                                                     pData, sizeof(CALLBACKDATADIROPEN), progress);
+        Assert(uContextID > 0);
+
+        VBOXHGCMSVCPARM paParms[8];
+        int i = 0;
+        paParms[i++].setUInt32(uContextID);
+        paParms[i++].setPointer((void*)Utf8Dir.c_str(), (uint32_t)Utf8Dir.length() + 1);
+        paParms[i++].setPointer((void*)UtfFilter.c_str(), (uint32_t)UtfFilter.length() + 1);
+        paParms[i++].setUInt32(0 /* Flags, none set yet */);
+        paParms[i++].setPointer((void*)Utf8UserName.c_str(), (uint32_t)Utf8UserName.length() + 1);
+        paParms[i++].setPointer((void*)Utf8Password.c_str(), (uint32_t)Utf8Password.length() + 1);
+
+        int vrc = VINF_SUCCESS;
+        {
+            VMMDev *pVMMDev = NULL;
+            {
+                /* Make sure mParent is valid, so set the read lock while using.
+                 * Do not keep this lock while doing the actual call, because in the meanwhile
+                 * another thread could request a write lock which would be a bad idea ... */
+                AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+                /* Forward the information to the VMM device. */
+                AssertPtr(mParent);
+                pVMMDev = mParent->getVMMDev();
+            }
+
+            if (pVMMDev)
+            {
+                LogFlowFunc(("hgcmHostCall numParms=%d\n", i));
+                vrc = pVMMDev->hgcmHostCall("VBoxGuestControlSvc", HOST_DIR_OPEN,
+                                            i, paParms);
+            }
+        }
+
+        if (RT_SUCCESS(vrc))
+        {
+            /*
+             * Wait for the HGCM low level callback until the process
+             * has been started (or something went wrong). This is necessary to
+             * get the PID.
+             */
+            CallbackMapIter it = getCtrlCallbackContextByID(uContextID);
+            Assert(it != mCallbackMap.end());
+            ComAssert(!it->second.pProgress.isNull());
+
+            BOOL fCanceled = FALSE;
+
+            /* Wait until operation completed. */
+            rc = it->second.pProgress->WaitForCompletion(10 * 1000);
+            if (FAILED(rc)) throw rc;
+
+            /* Was the operation canceled by one of the parties? */
+            rc = it->second.pProgress->COMGETTER(Canceled)(&fCanceled);
+            if (FAILED(rc)) throw rc;
+
+            if (!fCanceled)
+            {
+                BOOL fCompleted;
+                if (   SUCCEEDED(it->second.pProgress->COMGETTER(Completed)(&fCompleted))
+                    && fCompleted)
+                {
+                    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+                    /* Did we get some output? */
+                    pData = (PCALLBACKDATADIROPEN)it->second.pvData;
+                    Assert(it->second.cbData == sizeof(PCALLBACKDATADIROPEN));
+                    AssertPtr(pData);
+                }
+                else /* If callback not called within time ... well, that's a timeout! */
+                    vrc = VERR_TIMEOUT;
+            }
+            else /* Operation was canceled. */
+            {
+                vrc = VERR_CANCELLED;
+            }
+
+            if (RT_FAILURE(vrc))
+            {
+                if (vrc == VERR_NO_DATA)
+                {
+                    /* If there was no output data then this is no error we want
+                     * to report to COM. The caller just gets back a size of 0 (zero). */
+                    rc = S_OK;
+                }
+                else if (vrc == VERR_TIMEOUT)
+                {
+                    rc = setError(VBOX_E_IPRT_ERROR,
+                                  tr("The guest did not output within time"));
+                }
+                else if (vrc == VERR_CANCELLED)
+                {
+                    rc = setError(VBOX_E_IPRT_ERROR,
+                                  tr("The output operation was canceled"));
+                }
+                else
+                {
+                    rc = setError(E_UNEXPECTED,
+                                  tr("The service call failed with error %Rrc"), vrc);
+                }
+            }
+
+            {
+                AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+                /* Destroy locally used progress object. */
+                destroyCtrlCallbackContext(it);
+            }
+        }
+        else /* HGCM operation failed. */
+            rc = setError(E_UNEXPECTED,
+                          tr("The HGCM call failed with error %Rrc"), vrc);
+
+        /* Cleanup. */
+        progress->uninit();
+        progress.setNull();
+    }
+    catch (std::bad_alloc &)
+    {
+        rc = E_OUTOFMEMORY;
+    }
+    return rc;
+#endif
+}
+
+STDMETHODIMP Guest::DirectoryRead(ULONG aHandle, IGuestDirEntry **aDirEntry)
+{
+#ifndef VBOX_WITH_GUEST_CONTROL
+    ReturnComNotImplemented();
+#else /* VBOX_WITH_GUEST_CONTROL */
+    using namespace guestControl;
+
+    return VBOX_E_NOT_SUPPORTED;
+#endif
+}
+
+STDMETHODIMP Guest::FileExists(IN_BSTR aFile, IN_BSTR aUserName, IN_BSTR aPassword, BOOL *aExists)
+{
+#ifndef VBOX_WITH_GUEST_CONTROL
+    ReturnComNotImplemented();
+#else /* VBOX_WITH_GUEST_CONTROL */
+    using namespace guestControl;
+
+    return VBOX_E_NOT_SUPPORTED;
+#endif
 }
 
@@ -2570 +3102 @@
 #endif /* VBOX_WITH_GUEST_CONTROL */
 }
+