Changeset 73003 in vbox for trunk/src

Timestamp:

Jul 9, 2018 11:09:32 AM (7 years ago)

Author:

vboxsync

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

123555

Message:

Main: Use setErrorBoth when we've got a VBox status code handy. (The COM status codes aren't too specfic and this may help us decode error messages and provide an alternative to strstr for API clients. setErrorBoth isn't new, btw.)

Location:

trunk/src/VBox/Main

Files:

• include/ConsoleImpl.h (modified) (1 diff)
• include/VirtualBoxImpl.h (modified) (1 diff)
• src-all/ExtPackManagerImpl.cpp (modified) (9 diffs)
• src-all/ProgressImpl.cpp (modified) (6 diffs)
• src-all/SharedFolderImpl.cpp (modified) (1 diff)
• src-client/ConsoleImpl.cpp (modified) (78 diffs)
• src-client/ConsoleImplTeleporter.cpp (modified) (11 diffs)
• src-client/ConsoleVRDPServer.cpp (modified) (1 diff)
• src-client/DisplayImpl.cpp (modified) (5 diffs)
• src-client/EmulatedUSBImpl.cpp (modified) (3 diffs)
• src-client/GuestCtrlImpl.cpp (modified) (10 diffs)
• src-client/GuestDirectoryImpl.cpp (modified) (5 diffs)
• src-client/GuestDnDSourceImpl.cpp (modified) (1 diff)
• src-client/GuestDnDTargetImpl.cpp (modified) (3 diffs)
• src-client/GuestFileImpl.cpp (modified) (9 diffs)
• src-client/GuestImpl.cpp (modified) (1 diff)
• src-client/GuestProcessImpl.cpp (modified) (5 diffs)
• src-client/GuestSessionImpl.cpp (modified) (30 diffs)
• src-client/KeyboardImpl.cpp (modified) (1 diff)
• src-client/MachineDebuggerImpl.cpp (modified) (19 diffs)
• src-client/MouseImpl.cpp (modified) (4 diffs)
• src-client/VirtualBoxClientImpl.cpp (modified) (2 diffs)
• src-server/ApplianceImplExport.cpp (modified) (3 diffs)
• src-server/ApplianceImplImport.cpp (modified) (3 diffs)
• src-server/DHCPServerImpl.cpp (modified) (7 diffs)
• src-server/HostUSBDeviceImpl.cpp (modified) (1 diff)
• src-server/HostVideoInputDeviceImpl.cpp (modified) (2 diffs)
• src-server/MachineImpl.cpp (modified) (22 diffs)
• src-server/MachineImplCloneVM.cpp (modified) (5 diffs)
• src-server/MachineImplMoveVM.cpp (modified) (17 diffs)
• src-server/MediumImpl.cpp (modified) (33 diffs)
• src-server/SystemPropertiesImpl.cpp (modified) (3 diffs)
• src-server/USBProxyService.cpp (modified) (1 diff)
• src-server/VFSExplorerImpl.cpp (modified) (2 diffs)
• src-server/VirtualBoxImpl.cpp (modified) (6 diffs)

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

@@ -257 +257 @@
 
     static HRESULT i_setErrorStatic(HRESULT aResultCode, const char *pcsz, ...);
+    static HRESULT i_setErrorStaticBoth(HRESULT aResultCode, int vrc, const char *pcsz, ...);
     HRESULT i_setInvalidMachineStateError();
 

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

@@ -352 +352 @@
                                  BOOL *aResult);
 
-    static HRESULT i_setErrorStatic(HRESULT aResultCode,
-                                    const Utf8Str &aText)
+    static HRESULT i_setErrorStaticBoth(HRESULT aResultCode, int vrc, const Utf8Str &aText)
     {
-        return setErrorInternal(aResultCode, getStaticClassIID(), getStaticComponentName(), aText, false, true);
+        return setErrorInternal(aResultCode, getStaticClassIID(), getStaticComponentName(), aText, false, true, vrc);
     }
 

trunk/src/VBox/Main/src-all/ExtPackManagerImpl.cpp

@@ -572 +572 @@
                     {
                         if (vrc != VERR_EOF)
-                            hrc = setError(VBOX_E_IPRT_ERROR, tr("RTVfsFsStrmNext failed: %Rrc"), vrc);
+                            hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("RTVfsFsStrmNext failed: %Rrc"), vrc);
                         else
-                            hrc = setError(E_UNEXPECTED, tr("'%s' was found in the manifest but not in the tarball"), szName);
+                            hrc = setErrorBoth(E_UNEXPECTED, vrc, tr("'%s' was found in the manifest but not in the tarball"), szName);
                         break;
                     }
@@ -608 +608 @@
                                     }
                                     else
-                                        hrc = setError(VBOX_E_IPRT_ERROR,
-                                                       tr("The license file '%s' is empty or contains invalid UTF-8 encoding"),
-                                                       szName);
+                                        hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
+                                                           tr("The license file '%s' is empty or contains invalid UTF-8 encoding"),
+                                                           szName);
                                 }
                                 else
-                                    hrc = setError(VBOX_E_IPRT_ERROR, tr("Failed to read '%s': %Rrc"), szName, vrc);
+                                    hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Failed to read '%s': %Rrc"), szName, vrc);
                                 RTMemFree(pvFile);
                             }
@@ -620 +620 @@
                         }
                         else
-                            hrc = setError(VBOX_E_IPRT_ERROR, tr("RTVfsIoStrmQueryInfo on '%s': %Rrc"), szName, vrc);
+                            hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("RTVfsIoStrmQueryInfo on '%s': %Rrc"), szName, vrc);
                         RTVfsIoStrmRelease(hVfsIos);
-                            break;
+                        break;
                     }
 
@@ -634 +634 @@
                 hrc = setError(VBOX_E_OBJECT_NOT_FOUND, tr("%s"), szError);
         }
-            else
+        else
             hrc = setError(VBOX_E_OBJECT_NOT_FOUND, tr("The license file '%s' was not found in '%s'"),
-                               szName, m->strExtPackFile.c_str());
+                           szName, m->strExtPackFile.c_str());
     }
     return hrc;
@@ -872 +872 @@
                 LogRel(("ExtPack pfnUninstall returned %Rrc for %s\n", vrc, m->Desc.strName.c_str()));
                 if (!a_fForcedRemoval)
-                    hrc = setError(E_FAIL, tr("pfnUninstall returned %Rrc"), vrc);
+                    hrc = setErrorBoth(E_FAIL, vrc, tr("pfnUninstall returned %Rrc"), vrc);
             }
         }
@@ -1870 +1870 @@
             }
             else if (vrc == VERR_FILE_NOT_FOUND || vrc == VERR_PATH_NOT_FOUND)
-                hrc = setError(VBOX_E_OBJECT_NOT_FOUND, tr("The license file '%s' was not found in extension pack '%s'"),
-                               szName, m->Desc.strName.c_str());
+                hrc = setErrorBoth(VBOX_E_OBJECT_NOT_FOUND, vrc, tr("The license file '%s' was not found in extension pack '%s'"),
+                                   szName, m->Desc.strName.c_str());
             else
-                hrc = setError(VBOX_E_FILE_ERROR, tr("Failed to open the license file '%s': %Rrc"), szPath, vrc);
+                hrc = setErrorBoth(VBOX_E_FILE_ERROR, vrc, tr("Failed to open the license file '%s': %Rrc"), szPath, vrc);
         }
         else
-            hrc = setError(VBOX_E_IPRT_ERROR, tr("RTPathJoin failed: %Rrc"), vrc);
+            hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("RTPathJoin failed: %Rrc"), vrc);
     }
     return hrc;
@@ -2132 +2132 @@
             else
                 hrc = setError(VBOX_E_IPRT_ERROR,
-                              tr("Starting thread for an extension pack uninstallation failed with %Rrc"), hrc);
+                               tr("Starting thread for an extension pack uninstallation failed with %Rrc"), hrc);
         }
         else
-            hrc = setError(VBOX_E_IPRT_ERROR,
-                          tr("Looks like creating a progress object for ExtraPackUninstallTask object failed"));
+            hrc = setError(hrc, tr("Looks like creating a progress object for ExtraPackUninstallTask object failed"));
     }
     catch (std::bad_alloc &)
@@ -2415 +2414 @@
     }
     else
-        hrc = setError(VBOX_E_IPRT_ERROR, tr("Failed to launch the helper application '%s' (%Rrc)"), szExecName, vrc);
+        hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Failed to launch the helper application '%s' (%Rrc)"), szExecName, vrc);
 
     RTPipeClose(hPipeR);
@@ -2741 +2740 @@
                                                     "--forced",
                                                     (const char *)NULL);
-                        hrc = setError(E_FAIL, tr("The installation hook failed: %Rrc - %s"),
-                                       ErrInfo.Core.rc, ErrInfo.Core.pszMsg);
+                        hrc = setErrorBoth(E_FAIL, ErrInfo.Core.rc, tr("The installation hook failed: %Rrc - %s"),
+                                           ErrInfo.Core.rc, ErrInfo.Core.pszMsg);
                     }
                 }

trunk/src/VBox/Main/src-all/ProgressImpl.cpp

@@ -708 +708 @@
 
     if (!mCompleted)
-        return setError(E_FAIL,
-                        tr("Result code is not available, operation is still in progress"));
+        return setError(E_FAIL, tr("Result code is not available, operation is still in progress"));
 
     *aResultCode = mResultCode;
@@ -721 +720 @@
 
     if (!mCompleted)
-        return setError(E_FAIL,
-                        tr("Error info is not available, operation is still in progress"));
+        return setError(E_FAIL, tr("Error info is not available, operation is still in progress"));
 
     mErrorInfo.queryInterfaceTo(aErrorInfo.asOutParam());
@@ -791 +789 @@
 
     if (!mCancelable)
-        return setError(VBOX_E_INVALID_OBJECT_STATE,
-                        tr("Operation cannot be canceled"));
+        return setError(VBOX_E_INVALID_OBJECT_STATE, tr("Operation cannot be canceled"));
     m_cMsTimeout = aTimeout;
 
@@ -915 +912 @@
 
         if (RT_FAILURE(vrc) && vrc != VERR_TIMEOUT)
-            return setError(VBOX_E_IPRT_ERROR,
-                            tr("Failed to wait for the task completion (%Rrc)"),
-                            vrc);
+            return setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Failed to wait for the task completion (%Rrc)"), vrc);
     }
 
@@ -977 +972 @@
 
         if (RT_FAILURE(vrc) && vrc != VERR_TIMEOUT)
-            return setError(E_FAIL,
-                            tr("Failed to wait for the operation completion (%Rrc)"),
-                            vrc);
+            return setErrorBoth(E_FAIL, vrc, tr("Failed to wait for the operation completion (%Rrc)"), vrc);
     }
 
@@ -1076 +1069 @@
 
     if (!mCancelable)
-        return setError(VBOX_E_INVALID_OBJECT_STATE,
-                        tr("Operation cannot be canceled"));
+        return setError(VBOX_E_INVALID_OBJECT_STATE, tr("Operation cannot be canceled"));
 
     if (!mCanceled)

trunk/src/VBox/Main/src-all/SharedFolderImpl.cpp

@@ -280 +280 @@
                               sizeof (hostPathFull));
         if (RT_FAILURE(vrc))
-            return setError(E_INVALIDARG,
-                            tr("Invalid shared folder path: '%s' (%Rrc)"),
-                            hostPath.c_str(), vrc);
+            return setErrorBoth(E_INVALIDARG, vrc, tr("Invalid shared folder path: '%s' (%Rrc)"), hostPath.c_str(), vrc);
 
         if (RTPathCompare(hostPath.c_str(), hostPathFull) != 0)
-            return setError(E_INVALIDARG,
-                            tr("Shared folder path '%s' is not absolute"),
-                            hostPath.c_str());
+            return setError(E_INVALIDARG, tr("Shared folder path '%s' is not absolute"), hostPath.c_str());
     }
 

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

@@ -1586 +1586 @@
 
     if (RT_FAILURE(vrc))
-        rc = setError(VBOX_E_FILE_ERROR,
-                      tr("The saved state file '%ls' is invalid (%Rrc). Delete the saved state and try again"),
-                      savedStateFile.raw(), vrc);
+        rc = setErrorBoth(VBOX_E_FILE_ERROR, vrc,
+                          tr("The saved state file '%ls' is invalid (%Rrc). Delete the saved state and try again"),
+                          savedStateFile.raw(), vrc);
 
     mSavedStateDataLoaded = true;
@@ -1837 +1837 @@
         Utf8Buf.jolt();
         if (parm[2].type != VBOX_HGCM_SVC_PARM_32BIT)
-            return setError(E_FAIL, tr("Internal application error"));
+            return setErrorBoth(E_FAIL, vrc, tr("Internal application error"));
         cchBuf = parm[2].u.uint32;
     }
-    if (VERR_BUFFER_OVERFLOW == vrc)
-        return setError(E_UNEXPECTED,
-                        tr("Temporary failure due to guest activity, please retry"));
+    if (vrc == VERR_BUFFER_OVERFLOW)
+        return setError(E_UNEXPECTED, tr("Temporary failure due to guest activity, please retry"));
 
     /*
@@ -2214 +2213 @@
         {
             delete task;
-            rc = setError(E_FAIL, "Could not create VMPowerDownTask object \n");
+            rc = setError(E_FAIL, "Could not create VMPowerDownTask object\n");
             break;
         }
@@ -2272 +2271 @@
     int vrc = VMR3Reset(ptrVM.rawUVM());
 
-    HRESULT rc = RT_SUCCESS(vrc) ? S_OK :
-        setError(VBOX_E_VM_ERROR,
-                 tr("Could not reset the machine (%Rrc)"),
-                 vrc);
+    HRESULT rc = RT_SUCCESS(vrc) ? S_OK : setErrorBoth(VBOX_E_VM_ERROR, vrc, tr("Could not reset the machine (%Rrc)"), vrc);
 
     LogFlowThisFunc(("mMachineState=%d, rc=%Rhrc\n", mMachineState, rc));
@@ -2388 +2384 @@
         }
         else
-           rc = setError(VBOX_E_VM_ERROR,
-                         tr("Hot-Remove failed (rc=%Rrc)"), vrc);
+           rc = setErrorBoth(VBOX_E_VM_ERROR, vrc, tr("Hot-Remove failed (rc=%Rrc)"), vrc);
     }
     else
-        rc = setError(VBOX_E_VM_ERROR,
-                      tr("Hot-Remove was aborted because the CPU may still be used by the guest"), VERR_RESOURCE_BUSY);
+        rc = setErrorBoth(VBOX_E_VM_ERROR, VERR_RESOURCE_BUSY,
+                          tr("Hot-Remove was aborted because the CPU may still be used by the guest"), VERR_RESOURCE_BUSY);
 
     LogFlowThisFunc(("mMachineState=%d, rc=%Rhrc\n", mMachineState, rc));
@@ -2499 +2494 @@
     }
     else
-        rc = setError(VBOX_E_VM_ERROR,
-                      tr("Could not add CPU to the machine (%Rrc)"),
-                      vrc);
+        rc = setErrorBoth(VBOX_E_VM_ERROR, vrc, tr("Could not add CPU to the machine (%Rrc)"), vrc);
 
     LogFlowThisFunc(("mMachineState=%d, rc=%Rhrc\n", mMachineState, rc));
@@ -2569 +2562 @@
     }
 
-    HRESULT rc = RT_SUCCESS(vrc) ? S_OK :
-        setError(VBOX_E_PDM_ERROR,
-                 tr("Controlled power off failed (%Rrc)"),
-                 vrc);
+    HRESULT rc = RT_SUCCESS(vrc) ? S_OK : setErrorBoth(VBOX_E_PDM_ERROR, vrc, tr("Controlled power off failed (%Rrc)"), vrc);
 
     LogFlowThisFunc(("rc=%Rhrc\n", rc));
@@ -2618 +2608 @@
     }
 
-    HRESULT rc = RT_SUCCESS(vrc) ? S_OK :
-        setError(VBOX_E_PDM_ERROR,
-            tr("Checking if the ACPI Power Button event was handled by the guest OS failed (%Rrc)"),
-            vrc);
+    HRESULT rc = RT_SUCCESS(vrc) ? S_OK
+               : setErrorBoth(VBOX_E_PDM_ERROR, vrc,
+                              tr("Checking if the ACPI Power Button event was handled by the guest OS failed (%Rrc)"), vrc);
 
     LogFlowThisFunc(("rc=%Rhrc\n", rc));
@@ -2641 +2630 @@
        )
         return setError(VBOX_E_INVALID_VM_STATE,
-            tr("Invalid machine state %s when checking if the guest entered the ACPI mode)"),
-            Global::stringifyMachineState(mMachineState));
+                        tr("Invalid machine state %s when checking if the guest entered the ACPI mode)"),
+                        Global::stringifyMachineState(mMachineState));
 
     /* get the VM handle. */
@@ -2704 +2693 @@
     }
 
-    HRESULT rc = RT_SUCCESS(vrc) ? S_OK :
-        setError(VBOX_E_PDM_ERROR,
-            tr("Sending sleep button event failed (%Rrc)"),
-            vrc);
+    HRESULT rc = RT_SUCCESS(vrc) ? S_OK : setErrorBoth(VBOX_E_PDM_ERROR, vrc, tr("Sending sleep button event failed (%Rrc)"), vrc);
 
     LogFlowThisFunc(("rc=%Rhrc\n", rc));
@@ -2778 +2764 @@
 
             default:
-                return setError(E_INVALIDARG,
-                    tr("Invalid device type: %d"),
-                    aType[iType]);
+                return setError(E_INVALIDARG, tr("Invalid device type: %d"), aType[iType]);
         }
 
@@ -2810 +2794 @@
         && mMachineState != MachineState_Paused)
         return setError(VBOX_E_INVALID_VM_STATE,
-            tr("Cannot attach a USB device to the machine which is not running or paused (machine state: %s)"),
-            Global::stringifyMachineState(mMachineState));
+                        tr("Cannot attach a USB device to the machine which is not running or paused (machine state: %s)"),
+                        Global::stringifyMachineState(mMachineState));
 
     /* Get the VM handle. */
@@ -2820 +2804 @@
     /* Don't proceed unless we have a USB controller. */
     if (!mfVMHasUsbController)
-        return setError(VBOX_E_PDM_ERROR,
-            tr("The virtual machine does not have a USB controller"));
+        return setError(VBOX_E_PDM_ERROR, tr("The virtual machine does not have a USB controller"));
 
     /* release the lock because the USB Proxy service may call us back
@@ -2831 +2814 @@
 
 #else   /* !VBOX_WITH_USB */
-    return setError(VBOX_E_PDM_ERROR,
-        tr("The virtual machine does not have a USB controller"));
+    return setError(VBOX_E_PDM_ERROR, tr("The virtual machine does not have a USB controller"));
 #endif  /* !VBOX_WITH_USB */
 }
@@ -2857 +2839 @@
 
     if (!pUSBDevice)
-        return setError(E_INVALIDARG,
-            tr("USB device with UUID {%RTuuid} is not attached to this machine"),
-            aId.raw());
+        return setError(E_INVALIDARG, tr("USB device with UUID {%RTuuid} is not attached to this machine"), aId.raw());
 
     /* Remove the device from the collection, it is re-added below for failures */
@@ -2896 +2876 @@
 
 #else   /* !VBOX_WITH_USB */
-    return setError(VBOX_E_PDM_ERROR,
-        tr("The virtual machine does not have a USB controller"));
+    return setError(VBOX_E_PDM_ERROR, tr("The virtual machine does not have a USB controller"));
 #endif  /* !VBOX_WITH_USB */
 }
@@ -2926 +2905 @@
     }
 
-    return setErrorNoLog(VBOX_E_OBJECT_NOT_FOUND,
-        tr("Could not find a USB device with address '%s'"),
-        aName.c_str());
+    return setErrorNoLog(VBOX_E_OBJECT_NOT_FOUND, tr("Could not find a USB device with address '%s'"), aName.c_str());
 
 #else   /* !VBOX_WITH_USB */
@@ -2960 +2937 @@
     }
 
-    return setErrorNoLog(VBOX_E_OBJECT_NOT_FOUND,
-        tr("Could not find a USB device with uuid {%RTuuid}"),
-        Guid(aId).raw());
+    return setErrorNoLog(VBOX_E_OBJECT_NOT_FOUND, tr("Could not find a USB device with uuid {%RTuuid}"), Guid(aId).raw());
 
 #else   /* !VBOX_WITH_USB */
@@ -2978 +2953 @@
     if (mMachineState == MachineState_Saved)
         return setError(VBOX_E_INVALID_VM_STATE,
-            tr("Cannot create a transient shared folder on the machine in the saved state"));
+                        tr("Cannot create a transient shared folder on the machine in the saved state"));
     if (   mMachineState != MachineState_PoweredOff
         && mMachineState != MachineState_Teleported
@@ -2986 +2961 @@
        )
         return setError(VBOX_E_INVALID_VM_STATE,
-            tr("Cannot create a transient shared folder on the machine while it is changing the state (machine state: %s)"),
-            Global::stringifyMachineState(mMachineState));
+                        tr("Cannot create a transient shared folder on the machine while it is changing the state (machine state: %s)"),
+                        Global::stringifyMachineState(mMachineState));
 
     ComObjPtr<SharedFolder> pSharedFolder;
@@ -3048 +3023 @@
     if (mMachineState == MachineState_Saved)
         return setError(VBOX_E_INVALID_VM_STATE,
-            tr("Cannot remove a transient shared folder from the machine in the saved state"));
+                        tr("Cannot remove a transient shared folder from the machine in the saved state"));
     if (   mMachineState != MachineState_PoweredOff
         && mMachineState != MachineState_Teleported
@@ -3111 +3086 @@
     const uint8_t *pbKey = (const uint8_t *)aPassword.c_str();
 
-    int rc = m_pKeyStore->addSecretKey(aId, pbKey, cbKey);
-    if (RT_SUCCESS(rc))
+    int vrc = m_pKeyStore->addSecretKey(aId, pbKey, cbKey);
+    if (RT_SUCCESS(vrc))
     {
         unsigned cDisksConfigured = 0;
@@ -3120 +3095 @@
         {
             SecretKey *pKey = NULL;
-            rc = m_pKeyStore->retainSecretKey(aId, &pKey);
-            AssertRCReturn(rc, E_FAIL);
+            vrc = m_pKeyStore->retainSecretKey(aId, &pKey);
+            AssertRCReturn(vrc, E_FAIL);
 
             pKey->setUsers(cDisksConfigured);
@@ -3137 +3112 @@
 
                 alock.release();
-                int vrc = VMR3Resume(ptrVM.rawUVM(), VMRESUMEREASON_RECONFIG);
-
-                hrc = RT_SUCCESS(vrc) ? S_OK :
-                    setError(VBOX_E_VM_ERROR,
-                             tr("Could not resume the machine execution (%Rrc)"),
-                             vrc);
+                vrc = VMR3Resume(ptrVM.rawUVM(), VMRESUMEREASON_RECONFIG);
+
+                hrc = RT_SUCCESS(vrc) ? S_OK
+                    : setErrorBoth(VBOX_E_VM_ERROR, vrc, tr("Could not resume the machine execution (%Rrc)"), vrc);
             }
         }
     }
-    else if (rc == VERR_ALREADY_EXISTS)
-        hrc = setError(VBOX_E_OBJECT_IN_USE, tr("A password with the given ID already exists"));
-    else if (rc == VERR_NO_MEMORY)
-        hrc = setError(E_FAIL, tr("Failed to allocate enough secure memory for the key"));
+    else if (vrc == VERR_ALREADY_EXISTS)
+        hrc = setErrorBoth(VBOX_E_OBJECT_IN_USE, vrc, tr("A password with the given ID already exists"));
+    else if (vrc == VERR_NO_MEMORY)
+        hrc = setErrorBoth(E_FAIL, vrc, tr("Failed to allocate enough secure memory for the key"));
     else
-        hrc = setError(E_FAIL, tr("Unknown error happened while adding a password (%Rrc)"), rc);
+        hrc = setErrorBoth(E_FAIL, vrc, tr("Unknown error happened while adding a password (%Rrc)"), vrc);
 
     return hrc;
@@ -3174 +3147 @@
     {
         SecretKey *pKey = NULL;
-        int rc = m_pKeyStore->retainSecretKey(aIds[i], &pKey);
-        if (rc != VERR_NOT_FOUND)
+        int vrc = m_pKeyStore->retainSecretKey(aIds[i], &pKey);
+        if (vrc != VERR_NOT_FOUND)
         {
             AssertPtr(pKey);
@@ -3215 +3188 @@
 
     SecretKey *pKey = NULL;
-    int rc = m_pKeyStore->retainSecretKey(aId, &pKey);
-    if (RT_SUCCESS(rc))
+    int vrc = m_pKeyStore->retainSecretKey(aId, &pKey);
+    if (RT_SUCCESS(vrc))
     {
         m_cDisksPwProvided -= pKey->getUsers();
         m_pKeyStore->releaseSecretKey(aId);
-        rc = m_pKeyStore->deleteSecretKey(aId);
-        AssertRCReturn(rc, E_FAIL);
-    }
-    else if (rc == VERR_NOT_FOUND)
-        return setError(VBOX_E_OBJECT_NOT_FOUND, tr("A password with the ID \"%s\" does not exist"),
-                                                 aId.c_str());
+        vrc = m_pKeyStore->deleteSecretKey(aId);
+        AssertRCReturn(vrc, E_FAIL);
+    }
+    else if (vrc == VERR_NOT_FOUND)
+        return setErrorBoth(VBOX_E_OBJECT_NOT_FOUND, vrc, tr("A password with the ID \"%s\" does not exist"), aId.c_str());
     else
-        return setError(E_FAIL, tr("Failed to remove password with ID \"%s\" (%Rrc)"),
-                                aId.c_str(), rc);
+        return setErrorBoth(E_FAIL, vrc, tr("Failed to remove password with ID \"%s\" (%Rrc)"), aId.c_str(), vrc);
 
     return S_OK;
@@ -3237 +3208 @@
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    int rc = m_pKeyStore->deleteAllSecretKeys(false /* fSuspend */, false /* fForce */);
-    if (rc == VERR_RESOURCE_IN_USE)
-        return setError(VBOX_E_OBJECT_IN_USE, tr("A password is still in use by the VM"));
-    else if (RT_FAILURE(rc))
-        return setError(E_FAIL, tr("Deleting all passwords failed (%Rrc)"));
+    int vrc = m_pKeyStore->deleteAllSecretKeys(false /* fSuspend */, false /* fForce */);
+    if (vrc == VERR_RESOURCE_IN_USE)
+        return setErrorBoth(VBOX_E_OBJECT_IN_USE, vrc, tr("A password is still in use by the VM"));
+    else if (RT_FAILURE(vrc))
+        return setErrorBoth(E_FAIL, vrc, tr("Deleting all passwords failed (%Rrc)"));
 
     m_cDisksPwProvided = 0;
@@ -3261 +3232 @@
                                   false /* aWarning */,
                                   true /* aLogIt */);
+    va_end(args);
+    return rc;
+}
+
+/*static*/
+HRESULT Console::i_setErrorStaticBoth(HRESULT aResultCode, int vrc, const char *pcsz, ...)
+{
+    va_list args;
+    va_start(args, pcsz);
+    HRESULT rc = setErrorInternal(aResultCode,
+                                  getStaticClassIID(),
+                                  getStaticComponentName(),
+                                  Utf8Str(pcsz, args),
+                                  false /* aWarning */,
+                                  true /* aLogIt */,
+                                  vrc);
     va_end(args);
     return rc;
@@ -3363 +3350 @@
             if (pAlock)
                 pAlock->release();
-            int rc = VMR3Suspend(pUVM, VMSUSPENDREASON_RECONFIG);
+            int vrc = VMR3Suspend(pUVM, VMSUSPENDREASON_RECONFIG);
             if (pAlock)
                 pAlock->acquire();
             mVMStateChangeCallbackDisabled = false;
-            if (RT_FAILURE(rc))
+            if (RT_FAILURE(vrc))
                 return setErrorInternal(VBOX_E_INVALID_VM_STATE,
                                         COM_IIDOF(IConsole),
                                         getStaticComponentName(),
-                                        Utf8StrFmt("Could suspend VM for medium change (%Rrc)", rc),
+                                        Utf8StrFmt("Could suspend VM for medium change (%Rrc)", vrc),
                                         false /*aWarning*/,
-                                        true /*aLogIt*/);
+                                        true /*aLogIt*/,
+                                        vrc);
             *pfResume = true;
             break;
@@ -3523 +3511 @@
 
     if (pMedium)
-        return setError(E_FAIL,
-                        tr("Could not mount the media/drive '%ls' (%Rrc)"),
-                        mediumLocation.raw(), vrc);
-
-    return setError(E_FAIL,
-                    tr("Could not unmount the currently mounted media/drive (%Rrc)"),
-                    vrc);
+        return setErrorBoth(E_FAIL, vrc, tr("Could not mount the media/drive '%ls' (%Rrc)"), mediumLocation.raw(), vrc);
+    return setErrorBoth(E_FAIL, vrc, tr("Could not unmount the currently mounted media/drive (%Rrc)"), vrc);
 }
 
@@ -3701 +3684 @@
 
     if (!pMedium)
-        return setError(E_FAIL,
-                        tr("Could not mount the media/drive '%ls' (%Rrc)"),
-                        mediumLocation.raw(), vrc);
-
-    return setError(E_FAIL,
-                    tr("Could not unmount the currently mounted media/drive (%Rrc)"),
-                    vrc);
+        return setErrorBoth(E_FAIL, vrc, tr("Could not mount the media/drive '%ls' (%Rrc)"), mediumLocation.raw(), vrc);
+    return setErrorBoth(E_FAIL, vrc, tr("Could not unmount the currently mounted media/drive (%Rrc)"), vrc);
 }
 
@@ -3876 +3854 @@
 
     if (!pMedium)
-        return setError(E_FAIL,
-                        tr("Could not mount the media/drive '%ls' (%Rrc)"),
-                        mediumLocation.raw(), vrc);
-
-    return setError(E_FAIL,
-                    tr("Could not unmount the currently mounted media/drive (%Rrc)"),
-                    vrc);
+        return setErrorBoth(E_FAIL, vrc, tr("Could not mount the media/drive '%ls' (%Rrc)"), mediumLocation.raw(), vrc);
+    return setErrorBoth(E_FAIL, vrc, tr("Could not unmount the currently mounted media/drive (%Rrc)"), vrc);
 }
 
@@ -4081 +4054 @@
                     }
                     else if (vrc == VERR_PDM_DEVICE_INSTANCE_NOT_FOUND)
-                        return setError(E_FAIL,
-                                tr("The network adapter #%u is not enabled"), ulInstance);
+                        return setErrorBoth(E_FAIL, vrc, tr("The network adapter #%u is not enabled"), ulInstance);
                     else
                         ComAssertRC(vrc);
@@ -4667 +4639 @@
             PPDMIBASE pIBase = NULL;
             PPDMIMEDIA pIMedium = NULL;
-            int rc = PDMR3QueryDriverOnLun(ptrVM.rawUVM(), pcszDevice, ulStorageCtrlInst, uLUN, "VD", &pIBase);
-            if (RT_SUCCESS(rc))
+            int vrc = PDMR3QueryDriverOnLun(ptrVM.rawUVM(), pcszDevice, ulStorageCtrlInst, uLUN, "VD", &pIBase);
+            if (RT_SUCCESS(vrc))
             {
                 if (pIBase)
@@ -4675 +4647 @@
                     if (!pIMedium)
                         return setError(E_FAIL, tr("could not query medium interface of controller"));
-                    else
+                    vrc = pIMedium->pfnSetSecKeyIf(pIMedium, mpIfSecKey, mpIfSecKeyHlp);
+                    if (vrc == VERR_VD_PASSWORD_INCORRECT)
                     {
-                        rc = pIMedium->pfnSetSecKeyIf(pIMedium, mpIfSecKey, mpIfSecKeyHlp);
-                        if (rc == VERR_VD_PASSWORD_INCORRECT)
-                        {
-                            hrc = setError(VBOX_E_PASSWORD_INCORRECT, tr("The provided password for ID \"%s\" is not correct for at least one disk using this ID"),
-                                           strId.c_str());
-                            break;
-                        }
-                        else if (RT_FAILURE(rc))
-                        {
-                            hrc = setError(E_FAIL, tr("Failed to set the encryption key (%Rrc)"), rc);
-                            break;
-                        }
-
-                        if (RT_SUCCESS(rc))
-                           cDisksConfigured++;
+                        hrc = setError(VBOX_E_PASSWORD_INCORRECT,
+                                       tr("The provided password for ID \"%s\" is not correct for at least one disk using this ID"),
+                                       strId.c_str());
+                        break;
                     }
+                    else if (RT_FAILURE(vrc))
+                    {
+                        hrc = setErrorBoth(E_FAIL, vrc, tr("Failed to set the encryption key (%Rrc)"), vrc);
+                        break;
+                    }
+
+                    if (RT_SUCCESS(vrc))
+                       cDisksConfigured++;
                 }
                 else
@@ -4795 +4765 @@
                 }
                 else
-                    hrc = setError(E_FAIL,
-                                   tr("Failed to decode the key (%Rrc)"),
-                                   rc);
+                    hrc = setErrorBoth(E_FAIL, rc, tr("Failed to decode the key (%Rrc)"), rc);
 
                 RTMemSaferFree(pbKey, cbKey);
             }
             else
-                hrc = setError(E_FAIL,
-                               tr("Failed to allocate secure memory for the key (%Rrc)"), rc);
+                hrc = setErrorBoth(E_FAIL, rc, tr("Failed to allocate secure memory for the key (%Rrc)"), rc);
         }
         else
@@ -4896 +4863 @@
         return S_OK;
 
-    return setError(E_FAIL,
-                    tr("Could not change the network adaptor attachement type (%Rrc)"), rc);
+    return setErrorBoth(E_FAIL, rc,  tr("Could not change the network adaptor attachement type (%Rrc)"), rc);
 }
 
@@ -5222 +5188 @@
                     m_aeSerialPortMode[ulSlot] = eHostMode;
                 else
-                    hrc = setError(E_FAIL,
-                                   tr("Failed to change the serial port attachment (%Rrc)"), rc);
+                    hrc = setErrorBoth(E_FAIL, rc, tr("Failed to change the serial port attachment (%Rrc)"), rc);
             }
         }
@@ -5549 +5514 @@
                             {
                                 Utf8Str errMsg = VRDPServerErrorToMsg(vrc);
-                                rc = setError(E_FAIL, errMsg.c_str());
+                                rc = setErrorBoth(E_FAIL, vrc, errMsg.c_str());
                             }
                             else
@@ -5629 +5594 @@
     }
 
-    HRESULT rc = RT_SUCCESS(vrc) ? S_OK :
-        setError(VBOX_E_PDM_ERROR,
-            tr("Sending monitor hot-plug event failed (%Rrc)"),
-            vrc);
+    HRESULT rc = RT_SUCCESS(vrc) ? S_OK
+               : setErrorBoth(VBOX_E_PDM_ERROR, vrc, tr("Sending monitor hot-plug event failed (%Rrc)"), vrc);
 
     LogFlowThisFunc(("rc=%Rhrc\n", rc));
@@ -5675 +5638 @@
                 vrc = mDisplay->i_videoRecStart();
                 if (RT_FAILURE(vrc))
-                    rc = setError(E_FAIL, tr("Unable to start video capturing (%Rrc)"), vrc);
+                    rc = setErrorBoth(E_FAIL, vrc, tr("Unable to start video capturing (%Rrc)"), vrc);
             }
             else
@@ -6120 +6083 @@
         }
         else
-            rc = setError(VBOX_E_IPRT_ERROR,
-                          tr("The VBoxGuestPropSvc service call failed with the error %Rrc"),
-                          vrc);
+            rc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("The VBoxGuestPropSvc service call failed with the error %Rrc"), vrc);
     }
     catch(std::bad_alloc & /*e*/)
@@ -6179 +6140 @@
     HRESULT hrc = S_OK;
     if (RT_FAILURE(vrc))
-        hrc = setError(VBOX_E_IPRT_ERROR, tr("The VBoxGuestPropSvc service call failed with the error %Rrc"), vrc);
+        hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("The VBoxGuestPropSvc service call failed with the error %Rrc"), vrc);
     return hrc;
 #endif /* VBOX_WITH_GUEST_PROPS */
@@ -6210 +6171 @@
     HRESULT hrc = S_OK;
     if (RT_FAILURE(vrc))
-        hrc = setError(VBOX_E_IPRT_ERROR, tr("The VBoxGuestPropSvc service call failed with the error %Rrc"), vrc);
+        hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("The VBoxGuestPropSvc service call failed with the error %Rrc"), vrc);
     return hrc;
 #endif /* VBOX_WITH_GUEST_PROPS */
@@ -6379 +6340 @@
 
     if (RT_FAILURE(vrc))
-        return setError(E_FAIL, tr("%Rrc"), vrc);
+        return setErrorBoth(E_FAIL, vrc, tr("%Rrc"), vrc);
     if (FAILED(rc))
         return rc;
@@ -6401 +6362 @@
     vrc = pIMedium->pfnMerge(pIMedium, onlineMergeMediumProgress, aProgress);
     if (RT_FAILURE(vrc))
-        return setError(E_FAIL, tr("Failed to perform an online medium merge (%Rrc)"), vrc);
+        return setErrorBoth(E_FAIL, vrc, tr("Failed to perform an online medium merge (%Rrc)"), vrc);
 
     alock.acquire();
@@ -6425 +6386 @@
 
     if (RT_FAILURE(vrc))
-        return setError(E_FAIL, tr("%Rrc"), vrc);
+        return setErrorBoth(E_FAIL, vrc, tr("%Rrc"), vrc);
     if (FAILED(rc))
         return rc;
@@ -6507 +6468 @@
                                    pAttachment, mMachineState, &rc);
         if (RT_FAILURE(vrc))
-            throw setError(E_FAIL, tr("%Rrc"), vrc);
+            throw setErrorBoth(E_FAIL, vrc, tr("%Rrc"), vrc);
         if (FAILED(rc))
             throw rc;
@@ -6602 +6563 @@
     HRESULT hrc = S_OK;
     if (RT_FAILURE(vrc))
-        hrc = setError(VBOX_E_VM_ERROR, tr("Could not suspend the machine execution (%Rrc)"), vrc);
+        hrc = setErrorBoth(VBOX_E_VM_ERROR, vrc, tr("Could not suspend the machine execution (%Rrc)"), vrc);
     else if (   aReason == Reason_HostSuspend
              || aReason == Reason_HostBatteryLow)
@@ -6695 +6656 @@
     }
 
-    HRESULT rc = RT_SUCCESS(vrc) ? S_OK :
-        setError(VBOX_E_VM_ERROR,
-                 tr("Could not resume the machine execution (%Rrc)"),
-                 vrc);
+    HRESULT rc = RT_SUCCESS(vrc) ? S_OK
+               : setErrorBoth(VBOX_E_VM_ERROR, vrc, tr("Could not resume the machine execution (%Rrc)"), vrc);
 
     LogFlowThisFunc(("rc=%Rhrc\n", rc));
@@ -6739 +6698 @@
     {
         return setError(VBOX_E_INVALID_VM_STATE,
-            tr("Cannot save the execution state as the machine is not running or paused (machine state: %s)"),
-            Global::stringifyMachineState(mMachineState));
+                        tr("Cannot save the execution state as the machine is not running or paused (machine state: %s)"),
+                        Global::stringifyMachineState(mMachineState));
     }
     bool fContinueAfterwards = mMachineState != MachineState_Saving;
@@ -6761 +6720 @@
             int vrc = RTDirCreateFullPath(dir.c_str(), 0700);
             if (RT_FAILURE(vrc))
-                return setError(VBOX_E_FILE_ERROR,
-                                tr("Could not create a directory '%s' to save the state to (%Rrc)"),
-                                dir.c_str(), vrc);
+                return setErrorBoth(VBOX_E_FILE_ERROR, vrc, tr("Could not create a directory '%s' to save the state to (%Rrc)"),
+                                    dir.c_str(), vrc);
         }
     }
@@ -6786 +6744 @@
 
         if (RT_FAILURE(vrc))
-            return setError(VBOX_E_VM_ERROR, tr("Could not suspend the machine execution (%Rrc)"), vrc);
+            return setErrorBoth(VBOX_E_VM_ERROR, vrc, tr("Could not suspend the machine execution (%Rrc)"), vrc);
         fPaused = true;
     }
@@ -6812 +6770 @@
             alock.acquire();
         }
-        return setError(E_FAIL, tr("Failed to save the machine state to '%s' (%Rrc)"),
-                        aStateFilePath.c_str(), vrc);
+        return setErrorBoth(E_FAIL, vrc, tr("Failed to save the machine state to '%s' (%Rrc)"), aStateFilePath.c_str(), vrc);
     }
     Assert(fContinueAfterwards || !aLeftPaused);
@@ -7204 +7161 @@
     {
         /* powerDown() is waiting for all callers to finish */
-        return aQuiet ? E_ACCESSDENIED : setError(E_ACCESSDENIED,
-            tr("The virtual machine is being powered down"));
+        return aQuiet ? E_ACCESSDENIED : setError(E_ACCESSDENIED, tr("The virtual machine is being powered down"));
     }
 
@@ -7213 +7169 @@
 
         /* The machine is not powered up */
-        return aQuiet ? E_ACCESSDENIED : setError(E_ACCESSDENIED,
-            tr("The virtual machine is not powered up"));
+        return aQuiet ? E_ACCESSDENIED : setError(E_ACCESSDENIED, tr("The virtual machine is not powered up"));
     }
 
@@ -7364 +7319 @@
                                     0 /* uHistoryFileSize */, RTErrInfoInitStatic(&ErrInfo));
     if (RT_FAILURE(vrc))
-        hrc = setError(E_FAIL, tr("Failed to open release log (%s, %Rrc)"), ErrInfo.Core.pszMsg, vrc);
+        hrc = setErrorBoth(E_FAIL, vrc, tr("Failed to open release log (%s, %Rrc)"), ErrInfo.Core.pszMsg, vrc);
 
     /* If we've made any directory changes, flush the directory to increase
@@ -7408 +7363 @@
     {
         if (Global::IsOnlineOrTransient(mMachineState))
-            throw setError(VBOX_E_INVALID_VM_STATE,
-                tr("The virtual machine is already running or busy (machine state: %s)"),
-                Global::stringifyMachineState(mMachineState));
+            throw setError(VBOX_E_INVALID_VM_STATE, tr("The virtual machine is already running or busy (machine state: %s)"),
+                           Global::stringifyMachineState(mMachineState));
 
         /* Set up release logging as early as possible after the check if
@@ -7472 +7426 @@
             int vrc = SSMR3ValidateFile(Utf8Str(savedStateFile).c_str(), false /* fChecksumIt */);
             if (RT_FAILURE(vrc))
-                throw setError(VBOX_E_FILE_ERROR,
-                               tr("VM cannot start because the saved state file '%ls' is invalid (%Rrc). Delete the saved state prior to starting the VM"),
-                               savedStateFile.raw(), vrc);
+                throw setErrorBoth(VBOX_E_FILE_ERROR, vrc,
+                                   tr("VM cannot start because the saved state file '%ls' is invalid (%Rrc). Delete the saved state prior to starting the VM"),
+                                   savedStateFile.raw(), vrc);
         }
 
@@ -7653 +7607 @@
                 vrc = RTDirCreateFullPath(pszDumpDir, 0700);
                 if (RT_FAILURE(vrc))
-                    throw setError(E_FAIL, "Failed to setup CoreDumper. Couldn't create dump directory '%s' (%Rrc)\n",
-                                   pszDumpDir, vrc);
+                    throw setErrorBoth(E_FAIL, vrc, "Failed to setup CoreDumper. Couldn't create dump directory '%s' (%Rrc)\n",
+                                       pszDumpDir, vrc);
             }
 
             vrc = RTCoreDumperSetup(pszDumpDir, fCoreFlags);
             if (RT_FAILURE(vrc))
-                throw setError(E_FAIL, "Failed to setup CoreDumper (%Rrc)", vrc);
-            else
-                LogRel(("CoreDumper setup successful. pszDumpDir=%s fFlags=%#x\n", pszDumpDir ? pszDumpDir : ".", fCoreFlags));
+                throw setErrorBoth(E_FAIL, vrc, "Failed to setup CoreDumper (%Rrc)", vrc);
+            LogRel(("CoreDumper setup successful. pszDumpDir=%s fFlags=%#x\n", pszDumpDir ? pszDumpDir : ".", fCoreFlags));
         }
 #endif
@@ -7771 +7724 @@
                     {
                         throw setError(VBOX_E_HOST_ERROR,
-                            tr("VM cannot start because host interface networking requires a host interface name to be set"));
+                                       tr("VM cannot start because host interface networking requires a host interface name to be set"));
                     }
                     ComPtr<IVirtualBox> pVirtualBox;
@@ -7782 +7735 @@
                     {
                         throw setError(VBOX_E_HOST_ERROR,
-                            tr("VM cannot start because the host interface '%ls' does not exist"),
-                            hostif.raw());
+                                       tr("VM cannot start because the host interface '%ls' does not exist"), hostif.raw());
                     }
                     break;
@@ -8103 +8055 @@
             mpUVM = pUVM;
             pUVM = NULL;
-            rc = setError(VBOX_E_VM_ERROR,
-                tr("Could not destroy the machine. (Error: %Rrc)"),
-                vrc);
+            rc = setErrorBoth(VBOX_E_VM_ERROR, vrc, tr("Could not destroy the machine. (Error: %Rrc)"), vrc);
         }
 
@@ -8121 +8071 @@
     }
     else
-    {
-        rc = setError(VBOX_E_VM_ERROR,
-            tr("Could not power off the machine. (Error: %Rrc)"),
-            vrc);
-    }
+        rc = setErrorBoth(VBOX_E_VM_ERROR, vrc, tr("Could not power off the machine. (Error: %Rrc)"), vrc);
 
     /*
@@ -8227 +8173 @@
 
     if (aSetError)
-        setError(VBOX_E_FILE_ERROR,
-            tr("Could not find a shared folder named '%s'."),
-            strName.c_str());
+        setError(VBOX_E_FILE_ERROR, tr("Could not find a shared folder named '%s'."), strName.c_str());
 
     return VBOX_E_FILE_ERROR;
@@ -8444 +8388 @@
     bool fMissing = false;
     if (RT_FAILURE(vrc))
-        return setError(E_INVALIDARG,
-                        tr("Invalid shared folder path: '%s' (%Rrc)"),
-                        aData.m_strHostPath.c_str(), vrc);
+        return setErrorBoth(E_INVALIDARG, vrc, tr("Invalid shared folder path: '%s' (%Rrc)"), aData.m_strHostPath.c_str(), vrc);
     if (!RTPathExists(hostPathFull))
         fMissing = true;
@@ -8506 +8448 @@
 
     if (RT_FAILURE(vrc))
-        return setError(E_FAIL,
-            tr("Could not create a shared folder '%s' mapped to '%s' (%Rrc)"),
-            strName.c_str(), aData.m_strHostPath.c_str(), vrc);
+        return setErrorBoth(E_FAIL, vrc, tr("Could not create a shared folder '%s' mapped to '%s' (%Rrc)"),
+                            strName.c_str(), aData.m_strHostPath.c_str(), vrc);
 
     if (fMissing)
@@ -8560 +8501 @@
     RTMemFree(pMapName);
     if (RT_FAILURE(vrc))
-        return setError(E_FAIL,
-                        tr("Could not remove the shared folder '%s' (%Rrc)"),
-                        strName.c_str(), vrc);
+        return setErrorBoth(E_FAIL, vrc, tr("Could not remove the shared folder '%s' (%Rrc)"), strName.c_str(), vrc);
 
     return S_OK;
@@ -9102 +9041 @@
         {
             case VERR_VUSB_NO_PORTS:
-                hrc = setError(E_FAIL, tr("Failed to attach the USB device. (No available ports on the USB controller)."));
+                hrc = setErrorBoth(E_FAIL, vrc, tr("Failed to attach the USB device. (No available ports on the USB controller)."));
                 break;
             case VERR_VUSB_USBFS_PERMISSION:
-                hrc = setError(E_FAIL, tr("Not permitted to open the USB device, check usbfs options"));
+                hrc = setErrorBoth(E_FAIL, vrc, tr("Not permitted to open the USB device, check usbfs options"));
                 break;
             default:
-                hrc = setError(E_FAIL, tr("Failed to create a proxy device for the USB device. (Error: %Rrc)"), vrc);
+                hrc = setErrorBoth(E_FAIL, vrc, tr("Failed to create a proxy device for the USB device. (Error: %Rrc)"), vrc);
                 break;
         }
@@ -9277 +9216 @@
      * Allocate a host interface device
      */
-    int rcVBox = RTFileOpen(&maTapFD[slot], "/dev/net/tun",
-                            RTFILE_O_READWRITE | RTFILE_O_OPEN | RTFILE_O_DENY_NONE | RTFILE_O_INHERIT);
-    if (RT_SUCCESS(rcVBox))
+    int vrc = RTFileOpen(&maTapFD[slot], "/dev/net/tun",
+                         RTFILE_O_READWRITE | RTFILE_O_OPEN | RTFILE_O_DENY_NONE | RTFILE_O_INHERIT);
+    if (RT_SUCCESS(vrc))
     {
         /*
@@ -9303 +9242 @@
             RTStrCopy(IfReq.ifr_name, sizeof(IfReq.ifr_name), str.c_str()); /** @todo bitch about names which are too long... */
             IfReq.ifr_flags = IFF_TAP | IFF_NO_PI;
-            rcVBox = ioctl(RTFileToNative(maTapFD[slot]), TUNSETIFF, &IfReq);
-            if (rcVBox != 0)
+            vrc = ioctl(RTFileToNative(maTapFD[slot]), TUNSETIFF, &IfReq);
+            if (vrc != 0)
             {
                 LogRel(("Failed to open the host network interface %ls\n", tapDeviceName.raw()));
-                rc = setError(E_FAIL,
-                    tr("Failed to open the host network interface %ls"),
-                    tapDeviceName.raw());
+                rc = setErrorBoth(E_FAIL, vrc, tr("Failed to open the host network interface %ls"), tapDeviceName.raw());
             }
         }
@@ -9326 +9263 @@
                  */
                 maTAPDeviceName[slot] = tapDeviceName;
-                rcVBox = VINF_SUCCESS;
+                vrc = VINF_SUCCESS;
             }
             else
@@ -9333 +9270 @@
 
                 LogRel(("Configuration error: Failed to configure /dev/net/tun non blocking. Error: %s\n", strerror(iErr)));
-                rcVBox = VERR_HOSTIF_BLOCKING;
-                rc = setError(E_FAIL,
-                    tr("could not set up the host networking device for non blocking access: %s"),
-                    strerror(errno));
+                vrc = VERR_HOSTIF_BLOCKING;
+                rc = setErrorBoth(E_FAIL, vrc, tr("could not set up the host networking device for non blocking access: %s"),
+                                  strerror(errno));
             }
         }
@@ -9342 +9278 @@
     else
     {
-        LogRel(("Configuration error: Failed to open /dev/net/tun rc=%Rrc\n", rcVBox));
-        switch (rcVBox)
+        LogRel(("Configuration error: Failed to open /dev/net/tun rc=%Rrc\n", vrc));
+        switch (vrc)
         {
             case VERR_ACCESS_DENIED:
                 /* will be handled by our caller */
-                rc = rcVBox;
+                rc = vrc;
                 break;
             default:
-                rc = setError(E_FAIL,
-                    tr("Could not set up the host networking device: %Rrc"),
-                    rcVBox);
+                rc = setErrorBoth(E_FAIL, vrc, tr("Could not set up the host networking device: %Rrc"), vrc);
                 break;
         }
@@ -9379 +9313 @@
         memcpy(szTapdev + strlen(szTapdev), str.c_str(),
                sizeof(szTapdev) - strlen(szTapdev) - 1); /** @todo bitch about names which are too long... */
-    int rcVBox = RTFileOpen(&maTapFD[slot], szTapdev,
-                            RTFILE_O_READWRITE | RTFILE_O_OPEN | RTFILE_O_DENY_NONE | RTFILE_O_INHERIT | RTFILE_O_NON_BLOCK);
-
-    if (RT_SUCCESS(rcVBox))
+    int vrc = RTFileOpen(&maTapFD[slot], szTapdev,
+                         RTFILE_O_READWRITE | RTFILE_O_OPEN | RTFILE_O_DENY_NONE | RTFILE_O_INHERIT | RTFILE_O_NON_BLOCK);
+
+    if (RT_SUCCESS(vrc))
         maTAPDeviceName[slot] = tapDeviceName;
     else
     {
-        switch (rcVBox)
+        switch (vrc)
         {
             case VERR_ACCESS_DENIED:
                 /* will be handled by our caller */
-                rc = rcVBox;
+                rc = vrc;
                 break;
             default:
-                rc = setError(E_FAIL,
-                    tr("Failed to open the host network interface %ls"),
-                    tapDeviceName.raw());
+                rc = setErrorBoth(E_FAIL, vrc, tr("Failed to open the host network interface %ls"), tapDeviceName.raw());
                 break;
         }
@@ -9403 +9335 @@
 # endif
     /* in case of failure, cleanup. */
-    if (RT_FAILURE(rcVBox) && SUCCEEDED(rc))
+    if (RT_FAILURE(vrc) && SUCCEEDED(rc))
     {
         LogRel(("General failure attaching to host interface\n"));
-        rc = setError(E_FAIL,
-            tr("General failure attaching to host interface"));
+        rc = setError(E_FAIL, vrc, tr("General failure attaching to host interface"));
     }
     LogFlowThisFunc(("rc=%Rhrc\n", rc));
@@ -9950 +9881 @@
             if (   RT_FAILURE(vrc)
                 && vrc != VERR_NET_ADDRESS_IN_USE) /* not fatal */
-                throw i_setErrorStatic(E_FAIL, errMsg.c_str());
+                throw i_setErrorStaticBoth(E_FAIL, vrc, errMsg.c_str());
         }
 
@@ -10278 +10209 @@
             /* Set the error message as the COM error.
              * Progress::notifyComplete() will pick it up later. */
-            throw i_setErrorStatic(E_FAIL, pTask->mErrorMsg.c_str());
+            throw i_setErrorStaticBoth(E_FAIL, vrc, pTask->mErrorMsg.c_str());
         }
     }

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

@@ -238 +238 @@
     int vrc = teleporterTcpReadLine(pState, szMsg, sizeof(szMsg));
     if (RT_FAILURE(vrc))
-        return setError(E_FAIL, tr("Failed reading ACK(%s): %Rrc"), pszWhich, vrc);
+        return setErrorBoth(E_FAIL, vrc, tr("Failed reading ACK(%s): %Rrc"), pszWhich, vrc);
 
     if (!strcmp(szMsg, "ACK"))
@@ -300 +300 @@
     int vrc = RTTcpSgWriteL(pState->mhSocket, 2, pszCommand, strlen(pszCommand), "\n", sizeof("\n") - 1);
     if (RT_FAILURE(vrc))
-        return setError(E_FAIL, tr("Failed writing command '%s': %Rrc"), pszCommand, vrc);
+        return setErrorBoth(E_FAIL, vrc, tr("Failed writing command '%s': %Rrc"), pszCommand, vrc);
     if (!fWaitForAck)
         return S_OK;
@@ -655 +655 @@
     int vrc = RTTcpClientConnect(pState->mstrHostname.c_str(), pState->muPort, &pState->mhSocket);
     if (RT_FAILURE(vrc))
-        return setError(E_FAIL, tr("Failed to connect to port %u on '%s': %Rrc"),
-                        pState->muPort, pState->mstrHostname.c_str(), vrc);
+        return setErrorBoth(E_FAIL, vrc, tr("Failed to connect to port %u on '%s': %Rrc"),
+                            pState->muPort, pState->mstrHostname.c_str(), vrc);
     vrc = RTTcpSetSendCoalescing(pState->mhSocket, false /*fEnable*/);
     AssertRC(vrc);
@@ -665 +665 @@
     vrc = RTTcpRead(pState->mhSocket, szLine, sizeof(g_szWelcome) - 1, NULL);
     if (RT_FAILURE(vrc))
-        return setError(E_FAIL, tr("Failed to read welcome message: %Rrc"), vrc);
+        return setErrorBoth(E_FAIL, vrc, tr("Failed to read welcome message: %Rrc"), vrc);
     if (strcmp(szLine, g_szWelcome))
         return setError(E_FAIL, tr("Unexpected welcome %.*Rhxs"), sizeof(g_szWelcome) - 1, szLine);
@@ -673 +673 @@
     vrc = RTTcpWrite(pState->mhSocket, pState->mstrPassword.c_str(), pState->mstrPassword.length());
     if (RT_FAILURE(vrc))
-        return setError(E_FAIL, tr("Failed to send password: %Rrc"), vrc);
+        return setErrorBoth(E_FAIL, vrc, tr("Failed to send password: %Rrc"), vrc);
 
     /* ACK */
@@ -708 +708 @@
                 return hrc;
         }
-        return setError(E_FAIL, tr("VMR3Teleport -> %Rrc"), vrc);
+        return setErrorBoth(E_FAIL, vrc, tr("VMR3Teleport -> %Rrc"), vrc);
     }
 
@@ -968 +968 @@
 
         default:
-            return setError(VBOX_E_INVALID_VM_STATE,
-                tr("Invalid machine state: %s (must be Running or Paused)"),
-                Global::stringifyMachineState(mMachineState));
+            return setError(VBOX_E_INVALID_VM_STATE, tr("Invalid machine state: %s (must be Running or Paused)"),
+                            Global::stringifyMachineState(mMachineState));
     }
 
@@ -1018 +1017 @@
         ptrProgress->i_setCancelCallback(NULL, NULL);
         delete pState;
-        hrc = setError(E_FAIL, tr("RTThreadCreate -> %Rrc"), vrc);
+        hrc = setErrorBoth(E_FAIL, vrc, tr("RTThreadCreate -> %Rrc"), vrc);
     }
 
@@ -1099 +1098 @@
     }
     if (RT_FAILURE(vrc))
-        return setError(E_FAIL, tr("RTTcpServerCreateEx failed with status %Rrc"), vrc);
+        return setErrorBoth(E_FAIL, vrc, tr("RTTcpServerCreateEx failed with status %Rrc"), vrc);
 
     /*
@@ -1162 +1161 @@
                     else
                     {
-                        hrc = setError(E_FAIL, tr("Unexpected RTTcpServerListen status code %Rrc"), vrc);
+                        hrc = setErrorBoth(E_FAIL, vrc, tr("Unexpected RTTcpServerListen status code %Rrc"), vrc);
                         LogRel(("Teleporter: Unexpected RTTcpServerListen rc: %Rrc\n", vrc));
                     }
@@ -1176 +1175 @@
         }
         else
-            hrc = setError(E_FAIL, "RTTimerLRStart -> %Rrc", vrc);
+            hrc = setErrorBoth(E_FAIL, vrc, "RTTimerLRStart -> %Rrc", vrc);
 
         RTTimerLRDestroy(hTimerLR);
     }
     else
-        hrc = setError(E_FAIL, "RTTimerLRCreate -> %Rrc", vrc);
+        hrc = setErrorBoth(E_FAIL, vrc, "RTTimerLRCreate -> %Rrc", vrc);
     RTTcpServerDestroy(hServer);
 

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

@@ -3201 +3201 @@
         Utf8Str filename = authLibrary;
 
-        int rc = AuthLibLoad(&mAuthLibCtx, filename.c_str());
-
-        if (RT_FAILURE(rc))
-        {
-            mConsole->setError(E_FAIL,
-                               mConsole->tr("Could not load the external authentication library '%s' (%Rrc)"),
-                               filename.c_str(),
-                               rc);
-
+        int vrc = AuthLibLoad(&mAuthLibCtx, filename.c_str());
+        if (RT_FAILURE(vrc))
+        {
+            mConsole->setErrorBoth(E_FAIL, vrc, mConsole->tr("Could not load the external authentication library '%s' (%Rrc)"),
+                                   filename.c_str(), vrc);
             return AuthResultAccessDenied;
         }

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

@@ -2344 +2344 @@
             }
             else
-            {
-                rc = setError(VBOX_E_IPRT_ERROR,
-                              tr("Could not convert screenshot to PNG (%Rrc)"), vrc);
-            }
+                rc = setErrorBoth(VBOX_E_VM_ERROR, vrc, tr("Could not convert screenshot to PNG (%Rrc)"), vrc);
             RTMemFree(pu8PNG);
         }
     }
     else if (vrc == VERR_TRY_AGAIN)
-        rc = setError(E_UNEXPECTED,
-                      tr("Screenshot is not available at this time"));
+        rc = setErrorBoth(E_UNEXPECTED, vrc, tr("Screenshot is not available at this time"));
     else if (RT_FAILURE(vrc))
-        rc = setError(VBOX_E_IPRT_ERROR,
-                      tr("Could not take a screenshot (%Rrc)"), vrc);
+        rc = setErrorBoth(VBOX_E_VM_ERROR, vrc, tr("Could not take a screenshot (%Rrc)"), vrc);
 
     return rc;
@@ -2817 +2812 @@
      * dirty conversion work.
      */
-    int rcVBox = VMR3ReqCallWaitU(ptrVM.rawUVM(), VMCPUID_ANY, (PFNRT)Display::i_drawToScreenEMT, 7,
-                                  this, aScreenId, aAddress, aX, aY, aWidth, aHeight);
+    int vrc = VMR3ReqCallWaitU(ptrVM.rawUVM(), VMCPUID_ANY, (PFNRT)Display::i_drawToScreenEMT, 7,
+                               this, aScreenId, aAddress, aX, aY, aWidth, aHeight);
 
     /*
@@ -2825 +2820 @@
      */
     HRESULT rc = S_OK;
-    if (rcVBox == VERR_NOT_SUPPORTED || rcVBox == VERR_NOT_IMPLEMENTED)
+    if (vrc == VERR_NOT_SUPPORTED || vrc == VERR_NOT_IMPLEMENTED)
     {
         /** @todo implement generic fallback for screen blitting. */
         rc = E_NOTIMPL;
     }
-    else if (RT_FAILURE(rcVBox))
-        rc = setError(VBOX_E_IPRT_ERROR,
-                      tr("Could not draw to the screen (%Rrc)"), rcVBox);
+    else if (RT_FAILURE(vrc))
+        rc = setErrorBoth(VBOX_E_VM_ERROR, vrc, tr("Could not draw to the screen (%Rrc)"), vrc);
 /// @todo
 //    else
@@ -2958 +2952 @@
     alock.release();
 
-    int rcVBox = VMR3ReqCallNoWaitU(ptrVM.rawUVM(), VMCPUID_ANY, (PFNRT)Display::i_InvalidateAndUpdateEMT,
-                                    3, this, 0, true);
+    int vrc = VMR3ReqCallNoWaitU(ptrVM.rawUVM(), VMCPUID_ANY, (PFNRT)Display::i_InvalidateAndUpdateEMT,
+                                 3, this, 0, true);
     alock.acquire();
 
-    if (RT_FAILURE(rcVBox))
-        rc = setError(VBOX_E_IPRT_ERROR,
-                      tr("Could not invalidate and update the screen (%Rrc)"), rcVBox);
+    if (RT_FAILURE(vrc))
+        rc = setErrorBoth(VBOX_E_VM_ERROR, vrc, tr("Could not invalidate and update the screen (%Rrc)"), vrc);
 
     LogRelFlowFunc(("rc=%Rhrc\n", rc));
@@ -2980 +2973 @@
         return ptrVM.rc();
 
-    int rcVBox = VMR3ReqCallNoWaitU(ptrVM.rawUVM(), VMCPUID_ANY, (PFNRT)Display::i_InvalidateAndUpdateEMT,
-                                    3, this, aScreenId, false);
-    if (RT_FAILURE(rcVBox))
-        rc = setError(VBOX_E_IPRT_ERROR,
-                      tr("Could not invalidate and update the screen %d (%Rrc)"), aScreenId, rcVBox);
+    int vrc = VMR3ReqCallNoWaitU(ptrVM.rawUVM(), VMCPUID_ANY, (PFNRT)Display::i_InvalidateAndUpdateEMT,
+                                 3, this, aScreenId, false);
+    if (RT_FAILURE(vrc))
+        rc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Could not invalidate and update the screen %d (%Rrc)"), aScreenId, vrc);
 
     LogRelFlowFunc(("rc=%Rhrc\n", rc));

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

@@ -213 +213 @@
     {
         LogFlowThisFunc(("%Rrc\n", vrc));
-        hrc = pConsole->setError(VBOX_E_IPRT_ERROR,
-                                 "Init emulated USB webcam (%Rrc)", vrc);
+        hrc = pConsole->setErrorBoth(VBOX_E_IPRT_ERROR, vrc, "Init emulated USB webcam (%Rrc)", vrc);
     }
 
@@ -313 +312 @@
     {
         LogFlowThisFunc(("%Rrc\n", vrc));
-        hrc = pConsole->setError(VBOX_E_IPRT_ERROR,
-                                 "Attach emulated USB webcam (%Rrc)", vrc);
+        hrc = pConsole->setErrorBoth(VBOX_E_VM_ERROR, vrc, "Attach emulated USB webcam (%Rrc)", vrc);
     }
 
@@ -332 +330 @@
     {
         LogFlowThisFunc(("%Rrc\n", vrc));
-        hrc = pConsole->setError(VBOX_E_IPRT_ERROR,
-                                 "Detach emulated USB webcam (%Rrc)", vrc);
+        hrc = pConsole->setErrorBoth(VBOX_E_VM_ERROR, vrc, "Detach emulated USB webcam (%Rrc)", vrc);
     }
 

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

@@ -375 +375 @@
 
     ComObjPtr<GuestSession> pSession;
-    int rc = i_sessionCreate(startupInfo, guestCreds, pSession);
-    if (RT_SUCCESS(rc))
+    int vrc = i_sessionCreate(startupInfo, guestCreds, pSession);
+    if (RT_SUCCESS(vrc))
     {
         /* Return guest session to the caller. */
         HRESULT hr2 = pSession.queryInterfaceTo(aGuestSession.asOutParam());
         if (FAILED(hr2))
-            rc = VERR_COM_OBJECT_NOT_FOUND;
-    }
-
-    if (RT_SUCCESS(rc))
+            vrc = VERR_COM_OBJECT_NOT_FOUND;
+    }
+
+    if (RT_SUCCESS(vrc))
         /* Start (fork) the session asynchronously
          * on the guest. */
-        rc = pSession->i_startSessionAsync();
+        vrc = pSession->i_startSessionAsync();
 
     HRESULT hr = S_OK;
 
-    if (RT_FAILURE(rc))
-    {
-        switch (rc)
+    if (RT_FAILURE(vrc))
+    {
+        switch (vrc)
         {
             case VERR_MAX_PROCS_REACHED:
-                hr = setError(VBOX_E_MAXIMUM_REACHED, tr("Maximum number of concurrent guest sessions (%ld) reached"),
-                              VBOX_GUESTCTRL_MAX_SESSIONS);
+                hr = setErrorBoth(VBOX_E_MAXIMUM_REACHED, vrc, tr("Maximum number of concurrent guest sessions (%d) reached"),
+                                  VBOX_GUESTCTRL_MAX_SESSIONS);
                 break;
 
@@ -403 +403 @@
 
             default:
-                hr = setError(VBOX_E_IPRT_ERROR, tr("Could not create guest session: %Rrc"), rc);
+                hr = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Could not create guest session: %Rrc"), vrc);
                 break;
         }
@@ -470 +470 @@
         return setError(E_INVALIDARG, tr("Unknown flags (%#x)"), fFlags);
 
-    int rc = VINF_SUCCESS;
+    int vrc = VINF_SUCCESS;
 
     ProcessArguments aArgs;
@@ -484 +484 @@
         catch(std::bad_alloc &)
         {
-            rc = VERR_NO_MEMORY;
+            vrc = VERR_NO_MEMORY;
         }
     }
@@ -501 +501 @@
 
     ComObjPtr<GuestSession> pSession;
-    if (RT_SUCCESS(rc))
-        rc = i_sessionCreate(startupInfo, guestCreds, pSession);
-    if (RT_FAILURE(rc))
-    {
-        switch (rc)
+    if (RT_SUCCESS(vrc))
+        vrc = i_sessionCreate(startupInfo, guestCreds, pSession);
+    if (RT_FAILURE(vrc))
+    {
+        switch (vrc)
         {
             case VERR_MAX_PROCS_REACHED:
-                hr = setError(VBOX_E_IPRT_ERROR, tr("Maximum number of concurrent guest sessions (%ld) reached"),
-                              VBOX_GUESTCTRL_MAX_SESSIONS);
+                hr = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Maximum number of concurrent guest sessions (%d) reached"),
+                                  VBOX_GUESTCTRL_MAX_SESSIONS);
                 break;
 
@@ -515 +515 @@
 
            default:
-                hr = setError(VBOX_E_IPRT_ERROR, tr("Could not create guest session: %Rrc"), rc);
+                hr = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Could not create guest session: %Rrc"), vrc);
                 break;
         }
@@ -523 +523 @@
         Assert(!pSession.isNull());
         int rcGuest;
-        rc = pSession->i_startSession(&rcGuest);
-        if (RT_FAILURE(rc))
+        vrc = pSession->i_startSession(&rcGuest);
+        if (RT_FAILURE(vrc))
         {
             /** @todo Handle rcGuest! */
 
-            hr = setError(VBOX_E_IPRT_ERROR, tr("Could not open guest session: %Rrc"), rc);
+            hr = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Could not open guest session: %Rrc"), vrc);
         }
         else
@@ -543 +543 @@
                 catch(...)
                 {
-                    hr = setError(VBOX_E_IPRT_ERROR, tr("Failed to create SessionTaskUpdateAdditions object "));
+                    hr = setError(E_OUTOFMEMORY, tr("Failed to create SessionTaskUpdateAdditions object "));
                     throw;
                 }
@@ -552 +552 @@
                 {
                     delete pTask;
-                    hr = setError(VBOX_E_IPRT_ERROR,
-                                  tr("Creating progress object for SessionTaskUpdateAdditions object failed"));
+                    hr = setError(hr, tr("Creating progress object for SessionTaskUpdateAdditions object failed"));
                     throw hr;
                 }
@@ -566 +565 @@
                 }
                 else
-                    hr = setError(VBOX_E_IPRT_ERROR,
-                                  tr("Starting thread for updating Guest Additions on the guest failed "));
+                    hr = setError(hr, tr("Starting thread for updating Guest Additions on the guest failed "));
             }
             catch(std::bad_alloc &)

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

@@ -342 +342 @@
 
     int rcGuest;
-    int rc = i_closeInternal(&rcGuest);
-    if (RT_FAILURE(rc))
-    {
-        switch (rc)
+    int vrc = i_closeInternal(&rcGuest);
+    if (RT_FAILURE(vrc))
+    {
+        switch (vrc)
         {
             case VERR_GSTCTL_GUEST_ERROR:
@@ -357 +357 @@
 
             default:
-                hr = setError(VBOX_E_IPRT_ERROR,
-                              tr("Terminating open guest directory \"%s\" failed: %Rrc"),
-                              mData.mOpenInfo.mPath.c_str(), rc);
+                hr = setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
+                                  tr("Terminating open guest directory \"%s\" failed: %Rrc"), mData.mOpenInfo.mPath.c_str(), vrc);
                 break;
         }
@@ -377 +376 @@
 
     ComObjPtr<GuestFsObjInfo> fsObjInfo; int rcGuest;
-    int rc = i_readInternal(fsObjInfo, &rcGuest);
-    if (RT_SUCCESS(rc))
-    {
+    int vrc = i_readInternal(fsObjInfo, &rcGuest);
+    if (RT_SUCCESS(vrc))
+    {
+AssertMsg(vrc != VWRN_GSTCTL_PROCESS_EXIT_CODE, ("Buggy status code handling! See futher down...\n"));
         /* Return info object to the caller. */
         hr = fsObjInfo.queryInterfaceTo(aObjInfo.asOutParam());
@@ -385 +385 @@
     else
     {
-        switch (rc)
+        switch (vrc)
         {
             case VERR_GSTCTL_GUEST_ERROR:
@@ -391 +391 @@
                 break;
 
+/** @todo r=bird: VWRN_GSTCTL_PROCESS_EXIT_CODE won't ever get here because
+ *        RT_SUCCESS(VWRN_GSTCTL_PROCESS_EXIT_CODE) -> true.
+ *
+ */
             case VWRN_GSTCTL_PROCESS_EXIT_CODE:
-                hr = setError(VBOX_E_IPRT_ERROR, tr("Reading directory \"%s\" failed: %Rrc"),
-                              mData.mOpenInfo.mPath.c_str(), mData.mProcessTool.getRc());
+                hr = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Reading directory \"%s\" failed: %Rrc"),
+                                  mData.mOpenInfo.mPath.c_str(), mData.mProcessTool.getRc());
                 break;
 
             case VERR_PATH_NOT_FOUND:
-                hr = setError(VBOX_E_IPRT_ERROR, tr("Reading directory \"%s\" failed: Path not found"),
-                              mData.mOpenInfo.mPath.c_str());
+                hr = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Reading directory \"%s\" failed: Path not found"),
+                                  mData.mOpenInfo.mPath.c_str());
                 break;
 
             case VERR_NO_MORE_FILES:
                 /* See SDK reference. */
-                hr = setError(VBOX_E_OBJECT_NOT_FOUND, tr("Reading directory \"%s\" failed: No more entries"),
-                              mData.mOpenInfo.mPath.c_str());
+                hr = setErrorBoth(VBOX_E_OBJECT_NOT_FOUND, vrc, tr("Reading directory \"%s\" failed: No more entries"),
+                                  mData.mOpenInfo.mPath.c_str());
                 break;
 
             default:
-                hr = setError(VBOX_E_IPRT_ERROR, tr("Reading directory \"%s\" returned error: %Rrc\n"),
-                              mData.mOpenInfo.mPath.c_str(), rc);
+                hr = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Reading directory \"%s\" returned error: %Rrc\n"),
+                                  mData.mOpenInfo.mPath.c_str(), vrc);
                 break;
         }
     }
 
-    LogFlowThisFunc(("Returning rc=%Rrc\n", rc));
+    LogFlowThisFunc(("Returning hr=%Rhrc / vrc=%Rrc\n", hr, vrc));
     return hr;
 }

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

@@ -400 +400 @@
     }
     else
-        hr = setError(VBOX_E_IPRT_ERROR, tr("Starting thread for GuestDnDSource::i_receiveDataThread failed (%Rhrc)"), hr);
+        hr = setError(hr, tr("Starting thread for GuestDnDSource::i_receiveDataThread failed (%Rhrc)"), hr);
     /* Note: mDataBase.mfTransferIsPending will be set to false again by i_receiveDataThread. */
 

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

@@ -514 +514 @@
         Msg.setNextUInt32(cbFormats);
 
-        int rc = GuestDnDInst()->hostCall(Msg.getType(), Msg.getCount(), Msg.getParms());
-        if (RT_SUCCESS(rc))
+        int vrc = GuestDnDInst()->hostCall(Msg.getType(), Msg.getCount(), Msg.getParms());
+        if (RT_SUCCESS(vrc))
         {
             GuestDnDResponse *pResp = GuestDnDInst()->response();
             AssertPtr(pResp);
 
-            rc = pResp->waitForGuestResponse();
-            if (RT_SUCCESS(rc))
+            vrc = pResp->waitForGuestResponse();
+            if (RT_SUCCESS(vrc))
             {
                 resAction = GuestDnD::toMainAction(pResp->defAction());
@@ -532 +532 @@
                 }
                 else
+                    /** @todo r=bird: This isn't an IPRT error, is it?   */
                     hr = setError(VBOX_E_IPRT_ERROR, tr("Guest returned invalid drop formats (%zu formats)"), lstFormats.size());
             }
             else
-                hr = setError(VBOX_E_IPRT_ERROR, tr("Waiting for response of dropped event failed (%Rrc)"), rc);
+                hr = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Waiting for response of dropped event failed (%Rrc)"), vrc);
         }
         else
-            hr = setError(VBOX_E_IPRT_ERROR, tr("Sending dropped event to guest failed (%Rrc)"), rc);
+            hr = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Sending dropped event to guest failed (%Rrc)"), vrc);
     }
     else
@@ -674 +675 @@
     }
     else
-        hr = setError(VBOX_E_IPRT_ERROR, tr("Starting thread for GuestDnDTarget::i_sendDataThread (%Rhrc)"), hr);
+        hr = setError(hr, tr("Starting thread for GuestDnDTarget::i_sendDataThread (%Rhrc)"), hr);
 
     LogFlowFunc(("Returning hr=%Rhrc\n", hr));

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

@@ -1260 +1260 @@
     /* Close file on guest. */
     int rcGuest;
-    int rc = i_closeFile(&rcGuest);
+    int vrc = i_closeFile(&rcGuest);
     /* On failure don't return here, instead do all the cleanup
      * work first and then return an error. */
 
     AssertPtr(mSession);
-    int rc2 = mSession->i_fileUnregister(this);
-    if (RT_SUCCESS(rc))
-        rc = rc2;
-
-    if (RT_FAILURE(rc))
-    {
-        if (rc == VERR_GSTCTL_GUEST_ERROR)
+    int vrc2 = mSession->i_fileUnregister(this);
+    if (RT_SUCCESS(vrc))
+        vrc = vrc2;
+
+    if (RT_FAILURE(vrc))
+    {
+        if (vrc == VERR_GSTCTL_GUEST_ERROR)
             return GuestFile::i_setErrorExternal(this, rcGuest);
-
-        return setError(VBOX_E_IPRT_ERROR,
-                        tr("Closing guest file failed with %Rrc\n"), rc);
-    }
-
-    LogFlowThisFunc(("Returning rc=%Rrc\n", rc));
+        return setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Closing guest file failed with %Rrc\n"), vrc);
+    }
+
+    LogFlowThisFunc(("Returning S_OK / vrc=%Rrc\n", vrc));
     return S_OK;
 }
@@ -1309 +1307 @@
     {
         if (GuestProcess::i_isGuestError(vrc))
-        {
             hr = GuestProcess::i_setErrorExternal(this, rcGuest);
-        }
         else
             hr = setErrorVrc(vrc, tr("Querying file information failed: %Rrc"), vrc);
@@ -1338 +1334 @@
     {
         if (GuestProcess::i_isGuestError(vrc))
-        {
             hr = GuestProcess::i_setErrorExternal(this, rcGuest);
-        }
         else
             hr = setErrorVrc(vrc, tr("Querying file size failed: %Rrc"), vrc);
@@ -1376 +1370 @@
         aData.resize(0);
 
-        switch (vrc)
-        {
-            default:
-                hr = setError(VBOX_E_IPRT_ERROR,
-                              tr("Reading from file \"%s\" failed: %Rrc"),
-                              mData.mOpenInfo.mFileName.c_str(), vrc);
-                break;
-        }
+        hr = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Reading from file \"%s\" failed: %Rrc"),
+                          mData.mOpenInfo.mFileName.c_str(), vrc);
     }
 
@@ -1416 +1404 @@
         aData.resize(0);
 
-        switch (vrc)
-        {
-            default:
-                hr = setError(VBOX_E_IPRT_ERROR,
-                              tr("Reading from file \"%s\" (at offset %RU64) failed: %Rrc"),
-                              mData.mOpenInfo.mFileName.c_str(), aOffset, vrc);
-                break;
-        }
+        hr = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Reading from file \"%s\" (at offset %RU64) failed: %Rrc"),
+                          mData.mOpenInfo.mFileName.c_str(), aOffset, vrc);
     }
 
@@ -1454 +1436 @@
         default:
             return setError(E_INVALIDARG, tr("Invalid seek type specified"));
-            break; /* Never reached. */
     }
 
@@ -1465 +1446 @@
         *aNewOffset = RT_MIN(uNewOffset, (uint64_t)INT64_MAX);
     else
-    {
-        switch (vrc)
-        {
-            default:
-                hr = setError(VBOX_E_IPRT_ERROR,
-                              tr("Seeking file \"%s\" (to offset %RI64) failed: %Rrc"),
-                              mData.mOpenInfo.mFileName.c_str(), aOffset, vrc);
-                break;
-        }
-    }
+        hr = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Seeking file \"%s\" (to offset %RI64) failed: %Rrc"),
+                          mData.mOpenInfo.mFileName.c_str(), aOffset, vrc);
 
     LogFlowFuncLeaveRC(vrc);
@@ -1505 +1478 @@
     int vrc = i_writeData(aTimeoutMS, pvData, cbData, (uint32_t*)aWritten);
     if (RT_FAILURE(vrc))
-    {
-        switch (vrc)
-        {
-            default:
-                hr = setError(VBOX_E_IPRT_ERROR,
-                              tr("Writing %zubytes to file \"%s\" failed: %Rrc"),
-                              aData.size(), mData.mOpenInfo.mFileName.c_str(), vrc);
-                break;
-        }
-    }
+        hr = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Writing %zubytes to file \"%s\" failed: %Rrc"),
+                          aData.size(), mData.mOpenInfo.mFileName.c_str(), vrc);
 
     LogFlowFuncLeaveRC(vrc);
@@ -1533 +1498 @@
     int vrc = i_writeData(aTimeoutMS, pvData, cbData, (uint32_t*)aWritten);
     if (RT_FAILURE(vrc))
-    {
-        switch (vrc)
-        {
-            default:
-                hr = setError(VBOX_E_IPRT_ERROR,
-                              tr("Writing %zubytes to file \"%s\" (at offset %RU64) failed: %Rrc"),
-                              aData.size(), mData.mOpenInfo.mFileName.c_str(), aOffset, vrc);
-                break;
-        }
-    }
+        hr = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Writing %zubytes to file \"%s\" (at offset %RU64) failed: %Rrc"),
+                          aData.size(), mData.mOpenInfo.mFileName.c_str(), aOffset, vrc);
 
     LogFlowFuncLeaveRC(vrc);

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

@@ -809 +809 @@
     if (Utf8Str(aDomain) == "@@disk")
         return mParent->i_setDiskEncryptionKeys(aPassword);
-    else if (Utf8Str(aDomain) == "@@mem")
+    if (Utf8Str(aDomain) == "@@mem")
     {
         /** @todo */
         return E_NOTIMPL;
     }
-    else
-    {
-        /* forward the information to the VMM device */
-        VMMDev *pVMMDev = mParent->i_getVMMDev();
-        if (pVMMDev)
-        {
-            PPDMIVMMDEVPORT pVMMDevPort = pVMMDev->getVMMDevPort();
-            if (pVMMDevPort)
-            {
-                uint32_t u32Flags = VMMDEV_SETCREDENTIALS_GUESTLOGON;
-                if (!aAllowInteractiveLogon)
-                    u32Flags = VMMDEV_SETCREDENTIALS_NOLOCALLOGON;
-
-                pVMMDevPort->pfnSetCredentials(pVMMDevPort,
-                                               aUserName.c_str(),
-                                               aPassword.c_str(),
-                                               aDomain.c_str(),
-                                               u32Flags);
-                return S_OK;
-            }
-        }
-    }
-
-    return setError(VBOX_E_VM_ERROR,
-                    tr("VMM device is not available (is the VM running?)"));
+
+    /* forward the information to the VMM device */
+    VMMDev *pVMMDev = mParent->i_getVMMDev();
+    if (pVMMDev)
+    {
+        PPDMIVMMDEVPORT pVMMDevPort = pVMMDev->getVMMDevPort();
+        if (pVMMDevPort)
+        {
+            uint32_t u32Flags = VMMDEV_SETCREDENTIALS_GUESTLOGON;
+            if (!aAllowInteractiveLogon)
+                u32Flags = VMMDEV_SETCREDENTIALS_NOLOCALLOGON;
+
+            pVMMDevPort->pfnSetCredentials(pVMMDevPort,
+                                           aUserName.c_str(),
+                                           aPassword.c_str(),
+                                           aDomain.c_str(),
+                                           u32Flags);
+            return S_OK;
+        }
+    }
+
+    return setError(VBOX_E_VM_ERROR, tr("VMM device is not available (is the VM running?)"));
 }
 

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

@@ -1000 +1000 @@
     AssertMsg(RT_FAILURE(rcGuest), ("Guest rc does not indicate a failure when setting error\n"));
 
-    return pInterface->setError(VBOX_E_IPRT_ERROR, GuestProcess::i_guestErrorToString(rcGuest).c_str());
+    return pInterface->setErrorBoth(VBOX_E_IPRT_ERROR, rcGuest, GuestProcess::i_guestErrorToString(rcGuest).c_str());
 }
 
@@ -1791 +1791 @@
 
             default:
-                hr = setError(VBOX_E_IPRT_ERROR,
-                              tr("Reading from process \"%s\" (PID %RU32) failed: %Rrc"),
-                              mData.mProcess.mExecutable.c_str(), mData.mPID, vrc);
+                hr = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Reading from process \"%s\" (PID %RU32) failed: %Rrc"),
+                                  mData.mProcess.mExecutable.c_str(), mData.mPID, vrc);
                 break;
         }
@@ -1824 +1823 @@
 
             case VERR_NOT_SUPPORTED:
-                hr = setError(VBOX_E_IPRT_ERROR,
-                              tr("Terminating process \"%s\" (PID %RU32) not supported by installed Guest Additions"),
-                              mData.mProcess.mExecutable.c_str(), mData.mPID);
+                hr = setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
+                                  tr("Terminating process \"%s\" (PID %RU32) not supported by installed Guest Additions"),
+                                  mData.mProcess.mExecutable.c_str(), mData.mPID);
                 break;
 
             default:
-                hr = setError(VBOX_E_IPRT_ERROR,
-                              tr("Terminating process \"%s\" (PID %RU32) failed: %Rrc"),
-                              mData.mProcess.mExecutable.c_str(), mData.mPID, vrc);
+                hr = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Terminating process \"%s\" (PID %RU32) failed: %Rrc"),
+                                  mData.mProcess.mExecutable.c_str(), mData.mPID, vrc);
                 break;
         }
@@ -1880 +1878 @@
 
             default:
-                hr = setError(VBOX_E_IPRT_ERROR,
-                              tr("Waiting for process \"%s\" (PID %RU32) failed: %Rrc"),
-                              mData.mProcess.mExecutable.c_str(), mData.mPID, vrc);
+                hr = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Waiting for process \"%s\" (PID %RU32) failed: %Rrc"),
+                                  mData.mProcess.mExecutable.c_str(), mData.mPID, vrc);
                 break;
         }
@@ -1924 +1921 @@
 
             default:
-                hr = setError(VBOX_E_IPRT_ERROR,
-                              tr("Writing to process \"%s\" (PID %RU32) failed: %Rrc"),
-                              mData.mProcess.mExecutable.c_str(), mData.mPID, vrc);
+                hr = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Writing to process \"%s\" (PID %RU32) failed: %Rrc"),
+                                  mData.mProcess.mExecutable.c_str(), mData.mPID, vrc);
                 break;
         }

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

@@ -557 +557 @@
                 {
                     case VERR_NOT_SUPPORTED:
-                        hr = setError(VBOX_E_IPRT_ERROR, tr("Getting the user's home path is not supported by installed Guest Additions"));
+                        hr = setErrorBoth(VBOX_E_IPRT_ERROR, rcGuest,
+                                          tr("Getting the user's home path is not supported by installed Guest Additions"));
                         break;
 
                     default:
-                        hr = setError(VBOX_E_IPRT_ERROR, tr("Getting the user's home path failed on the guest: %Rrc"), rcGuest);
+                        hr = setErrorBoth(VBOX_E_IPRT_ERROR, rcGuest,
+                                          tr("Getting the user's home path failed on the guest: %Rrc"), rcGuest);
                         break;
                 }
@@ -568 +570 @@
 
             default:
-                hr = setError(VBOX_E_IPRT_ERROR, tr("Getting the user's home path failed: %Rrc"), vrc);
+                hr = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Getting the user's home path failed: %Rrc"), vrc);
                 break;
         }
@@ -593 +595 @@
                 {
                     case VERR_NOT_SUPPORTED:
-                        hr = setError(VBOX_E_IPRT_ERROR, tr("Getting the user's documents path is not supported by installed Guest Additions"));
+                        hr = setErrorBoth(VBOX_E_IPRT_ERROR, rcGuest,
+                                          tr("Getting the user's documents path is not supported by installed Guest Additions"));
                         break;
 
                     default:
-                        hr = setError(VBOX_E_IPRT_ERROR, tr("Getting the user's documents path failed on the guest: %Rrc"), rcGuest);
+                        hr = setErrorBoth(VBOX_E_IPRT_ERROR, rcGuest,
+                                          tr("Getting the user's documents path failed on the guest: %Rrc"), rcGuest);
                         break;
                 }
@@ -604 +608 @@
 
             default:
-                hr = setError(VBOX_E_IPRT_ERROR, tr("Getting the user's documents path failed: %Rrc"), vrc);
+                hr = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Getting the user's documents path failed: %Rrc"), vrc);
                 break;
         }
@@ -780 +784 @@
         }
         else
-            hrc = setError(VBOX_E_IPRT_ERROR,
-                           tr("Starting thread for copying from guest to \"%s\" on the host failed"), strDestination.c_str());
+            hrc = setError(hrc, tr("Starting thread for copying from guest to \"%s\" on the host failed"), strDestination.c_str());
 
     }
@@ -852 +855 @@
         }
         else
-            hrc = setError(VBOX_E_IPRT_ERROR,
-                           tr("Starting thread for copying from host to \"%s\" on the guest failed"), strDestination.c_str());
+            hrc = setError(hrc, tr("Starting thread for copying from host to \"%s\" on the guest failed"), strDestination.c_str());
 
     }
@@ -2485 +2487 @@
     AssertMsg(RT_FAILURE(rcGuest), ("Guest rc does not indicate a failure when setting error\n"));
 
-    return pInterface->setError(VBOX_E_IPRT_ERROR, GuestSession::i_guestErrorToString(rcGuest).c_str());
+    return pInterface->setErrorBoth(VBOX_E_IPRT_ERROR, rcGuest, GuestSession::i_guestErrorToString(rcGuest).c_str());
 }
 
@@ -2804 +2806 @@
     /* Close session on guest. */
     int rcGuest = VINF_SUCCESS;
-    int rc = i_closeSession(0 /* Flags */, 30 * 1000 /* Timeout */, &rcGuest);
+    int vrc = i_closeSession(0 /* Flags */, 30 * 1000 /* Timeout */, &rcGuest);
     /* On failure don't return here, instead do all the cleanup
      * work first and then return an error. */
@@ -2810 +2812 @@
     /* Remove ourselves from the session list. */
     AssertPtr(mParent);
-    int rc2 = mParent->i_sessionRemove(mData.mSession.mID);
-    if (rc2 == VERR_NOT_FOUND) /* Not finding the session anymore isn't critical. */
-        rc2 = VINF_SUCCESS;
-
-    if (RT_SUCCESS(rc))
-        rc = rc2;
-
-    LogFlowThisFunc(("Returning rc=%Rrc, rcGuest=%Rrc\n", rc, rcGuest));
-
-    if (RT_FAILURE(rc))
-    {
-        if (rc == VERR_GSTCTL_GUEST_ERROR)
+    int vrc2 = mParent->i_sessionRemove(mData.mSession.mID);
+    if (vrc2 == VERR_NOT_FOUND) /* Not finding the session anymore isn't critical. */
+        vrc2 = VINF_SUCCESS;
+
+    if (RT_SUCCESS(vrc))
+        vrc = vrc2;
+
+    LogFlowThisFunc(("Returning rc=%Rrc, rcGuest=%Rrc\n", vrc, rcGuest));
+
+    if (RT_FAILURE(vrc))
+    {
+        if (vrc == VERR_GSTCTL_GUEST_ERROR)
             return GuestSession::i_setErrorExternal(this, rcGuest);
-
-        return setError(VBOX_E_IPRT_ERROR,
-                        tr("Closing guest session failed with %Rrc"), rc);
+        return setError(VBOX_E_IPRT_ERROR, tr("Closing guest session failed with %Rrc"), vrc);
     }
 
@@ -3087 +3087 @@
 
     ComObjPtr <GuestDirectory> pDirectory; int rcGuest;
-    int rc = i_directoryCreate(aPath, (uint32_t)aMode, fFlags, &rcGuest);
-    if (RT_FAILURE(rc))
-    {
-        if (GuestProcess::i_isGuestError(rc))
-        {
-            hrc = setError(VBOX_E_IPRT_ERROR, tr("Directory creation failed: %s"),
-                                                 GuestDirectory::i_guestErrorToString(rcGuest).c_str());
-        }
+    int vrc = i_directoryCreate(aPath, (uint32_t)aMode, fFlags, &rcGuest);
+    if (RT_FAILURE(vrc))
+    {
+        if (GuestProcess::i_isGuestError(vrc))
+            hrc = setErrorBoth(VBOX_E_IPRT_ERROR, rcGuest,
+                               tr("Directory creation failed: %s"), GuestDirectory::i_guestErrorToString(rcGuest).c_str());
         else
         {
-            switch (rc)
+            switch (vrc)
             {
                 case VERR_INVALID_PARAMETER:
-                    hrc = setError(VBOX_E_IPRT_ERROR, tr("Directory creation failed: Invalid parameters given"));
+                    hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Directory creation failed: Invalid parameters given"));
                     break;
 
                 case VERR_BROKEN_PIPE:
-                    hrc = setError(VBOX_E_IPRT_ERROR, tr("Directory creation failed: Unexpectedly aborted"));
+                    hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Directory creation failed: Unexpectedly aborted"));
                     break;
 
                 default:
-                    hrc = setError(VBOX_E_IPRT_ERROR, tr("Directory creation failed: %Rrc"), rc);
+                    hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Directory creation failed: %Rrc"), vrc);
                     break;
             }
@@ -3137 +3135 @@
 
     int rcGuest;
-    int rc = i_fsCreateTemp(aTemplateName, aPath, true /* Directory */, aDirectory, &rcGuest);
-    if (!RT_SUCCESS(rc))
-    {
-        switch (rc)
+    int vrc = i_fsCreateTemp(aTemplateName, aPath, true /* Directory */, aDirectory, &rcGuest);
+    if (!RT_SUCCESS(vrc))
+    {
+        switch (vrc)
         {
             case VERR_GSTCTL_GUEST_ERROR:
@@ -3147 +3145 @@
 
             default:
-               hrc = setError(VBOX_E_IPRT_ERROR, tr("Temporary directory creation \"%s\" with template \"%s\" failed: %Rrc"),
-                              aPath.c_str(), aTemplateName.c_str(), rc);
+               hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Temporary directory creation \"%s\" with template \"%s\" failed: %Rrc"),
+                                  aPath.c_str(), aTemplateName.c_str(), vrc);
                break;
         }
@@ -3171 +3169 @@
 
     GuestFsObjData objData; int rcGuest;
-    int rc = i_directoryQueryInfo(aPath, aFollowSymlinks != FALSE, objData, &rcGuest);
-    if (RT_SUCCESS(rc))
+    int vrc = i_directoryQueryInfo(aPath, aFollowSymlinks != FALSE, objData, &rcGuest);
+    if (RT_SUCCESS(vrc))
         *aExists = objData.mType == FsObjType_Directory;
     else
     {
-        switch (rc)
+        switch (vrc)
         {
             case VERR_GSTCTL_GUEST_ERROR:
@@ -3186 +3184 @@
                         break;
                     default:
-                        hrc = setError(VBOX_E_IPRT_ERROR, tr("Querying directory existence \"%s\" failed: %s"),
-                                                             aPath.c_str(), GuestProcess::i_guestErrorToString(rcGuest).c_str());
+                        hrc = setErrorBoth(VBOX_E_IPRT_ERROR, rcGuest, tr("Querying directory existence \"%s\" failed: %s"),
+                                           aPath.c_str(), GuestProcess::i_guestErrorToString(rcGuest).c_str());
                         break;
                 }
@@ -3194 +3192 @@
 
             default:
-               hrc = setError(VBOX_E_IPRT_ERROR, tr("Querying directory existence \"%s\" failed: %Rrc"),
-                                                    aPath.c_str(), rc);
+               hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Querying directory existence \"%s\" failed: %Rrc"),
+                                  aPath.c_str(), vrc);
                break;
         }
@@ -3236 +3234 @@
 
     ComObjPtr <GuestDirectory> pDirectory; int rcGuest;
-    int rc = i_directoryOpen(openInfo, pDirectory, &rcGuest);
-    if (RT_SUCCESS(rc))
+    int vrc = i_directoryOpen(openInfo, pDirectory, &rcGuest);
+    if (RT_SUCCESS(vrc))
     {
         /* Return directory object to the caller. */
@@ -3244 +3242 @@
     else
     {
-        switch (rc)
+        switch (vrc)
         {
             case VERR_INVALID_PARAMETER:
-               hrc = setError(VBOX_E_IPRT_ERROR, tr("Opening directory \"%s\" failed; invalid parameters given"),
-                                                    aPath.c_str());
+               hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Opening directory \"%s\" failed; invalid parameters given"),
+                                  aPath.c_str());
                break;
 
@@ -3256 +3254 @@
 
             default:
-               hrc = setError(VBOX_E_IPRT_ERROR, tr("Opening directory \"%s\" failed: %Rrc"),
-                                                    aPath.c_str(),rc);
+               hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Opening directory \"%s\" failed: %Rrc"), aPath.c_str(), vrc);
                break;
         }
@@ -3289 +3286 @@
         {
             case VERR_NOT_SUPPORTED:
-                hrc = setError(VBOX_E_IPRT_ERROR,
-                               tr("Handling removing guest directories not supported by installed Guest Additions"));
+                hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
+                                   tr("Handling removing guest directories not supported by installed Guest Additions"));
                 break;
 
@@ -3298 +3295 @@
 
             default:
-                hrc = setError(VBOX_E_IPRT_ERROR, tr("Removing guest directory \"%s\" failed: %Rrc"),
-                                                     aPath.c_str(), vrc);
+                hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Removing guest directory \"%s\" failed: %Rrc"), aPath.c_str(), vrc);
                 break;
         }
@@ -3354 +3350 @@
         {
             case VERR_NOT_SUPPORTED:
-                hrc = setError(VBOX_E_IPRT_ERROR,
-                              tr("Handling removing guest directories recursively not supported by installed Guest Additions"));
+                hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
+                                   tr("Handling removing guest directories recursively not supported by installed Guest Additions"));
                 break;
 
@@ -3363 +3359 @@
 
             default:
-                hrc = setError(VBOX_E_IPRT_ERROR, tr("Recursively removing guest directory \"%s\" failed: %Rrc"),
-                                                     aPath.c_str(), vrc);
+                hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Recursively removing guest directory \"%s\" failed: %Rrc"),
+                                   aPath.c_str(), vrc);
                 break;
         }
@@ -3550 +3546 @@
 
         default:
-            hrc = setError(VBOX_E_IPRT_ERROR, tr("Querying file information for \"%s\" failed: %Rrc"),
-                                                 aPath.c_str(), vrc);
+            hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Querying file information for \"%s\" failed: %Rrc"),
+                               aPath.c_str(), vrc);
             break;
     }
@@ -3662 +3658 @@
         {
             case VERR_NOT_SUPPORTED:
-                hrc = setError(VBOX_E_IPRT_ERROR,
-                              tr("Handling guest files not supported by installed Guest Additions"));
+                hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
+                                   tr("Handling guest files not supported by installed Guest Additions"));
                 break;
 
@@ -3671 +3667 @@
 
             default:
-                hrc = setError(VBOX_E_IPRT_ERROR, tr("Opening guest file \"%s\" failed: %Rrc"),
-                              aPath.c_str(), vrc);
+                hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Opening guest file \"%s\" failed: %Rrc"), aPath.c_str(), vrc);
                 break;
         }
@@ -3701 +3696 @@
     {
         if (GuestProcess::i_isGuestError(vrc))
-        {
             hrc = GuestProcess::i_setErrorExternal(this, rcGuest);
-        }
         else
-            hrc = setError(VBOX_E_IPRT_ERROR, tr("Querying file size failed: %Rrc"), vrc);
+            hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Querying file size failed: %Rrc"), vrc);
     }
 
@@ -3787 +3780 @@
     {
         if (GuestProcess::i_isGuestError(vrc))
-        {
             hrc = GuestProcess::i_setErrorExternal(this, rcGuest);
-        }
         else
             hrc = setErrorVrc(vrc, tr("Querying file information for \"%s\" failed: %Rrc"), aPath.c_str(), vrc);
@@ -3816 +3807 @@
     {
         if (GuestProcess::i_isGuestError(vrc))
-        {
             hrc = GuestProcess::i_setErrorExternal(this, rcGuest);
-        }
         else
-            hrc = setError(VBOX_E_IPRT_ERROR, tr("Removing file \"%s\" failed: %Rrc"), aPath.c_str(), vrc);
+            hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Removing file \"%s\" failed: %Rrc"), aPath.c_str(), vrc);
     }
 
@@ -3868 +3857 @@
         {
             case VERR_NOT_SUPPORTED:
-                hrc = setError(VBOX_E_IPRT_ERROR,
-                              tr("Handling renaming guest directories not supported by installed Guest Additions"));
+                hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
+                                   tr("Handling renaming guest directories not supported by installed Guest Additions"));
                 break;
 
             case VERR_GSTCTL_GUEST_ERROR:
-                hrc = setError(VBOX_E_IPRT_ERROR,
-                              tr("Renaming guest directory failed: %Rrc"), rcGuest);
+                hrc = setErrorBoth(VBOX_E_IPRT_ERROR, rcGuest, tr("Renaming guest directory failed: %Rrc"), rcGuest);
                 break;
 
             default:
-                hrc = setError(VBOX_E_IPRT_ERROR, tr("Renaming guest directory \"%s\" failed: %Rrc"),
-                                                     aSource.c_str(), vrc);
+                hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Renaming guest directory \"%s\" failed: %Rrc"),
+                                   aSource.c_str(), vrc);
                 break;
         }
@@ -4101 +4089 @@
             {
                 const char *pszSessionName = mData.mSession.mName.c_str();
-                hrc = setError(VBOX_E_IPRT_ERROR,
-                               tr("Waiting for guest session \"%s\" failed: %Rrc"),
-                                  pszSessionName ? pszSessionName : tr("Unnamed"), vrc);
+                hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
+                                   tr("Waiting for guest session \"%s\" failed: %Rrc"),
+                                   pszSessionName ? pszSessionName : tr("Unnamed"), vrc);
                 break;
             }

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

@@ -215 +215 @@
 
     if (RT_FAILURE(vrc))
-        return setError(VBOX_E_IPRT_ERROR,
-                        tr("Could not send all scan codes to the virtual keyboard (%Rrc)"),
-                        vrc);
+        return setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
+                            tr("Could not send all scan codes to the virtual keyboard (%Rrc)"),
+                            vrc);
 
     return S_OK;

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

@@ -215 +215 @@
                 int vrc = EMR3SetExecutionPolicy(ptrVM.rawUVM(), enmPolicy, fEnforce != FALSE);
                 if (RT_FAILURE(vrc))
-                    hrc = setError(VBOX_E_VM_ERROR, tr("EMR3SetExecutionPolicy failed with %Rrc"), vrc);
+                    hrc = setErrorBoth(VBOX_E_VM_ERROR, vrc, tr("EMR3SetExecutionPolicy failed with %Rrc"), vrc);
             }
         }
@@ -338 +338 @@
     int vrc = PATMR3AllowPatching(ptrVM.rawUVM(), RT_BOOL(aPATMEnabled));
     if (RT_FAILURE(vrc))
-        return setError(VBOX_E_VM_ERROR, tr("PATMR3AllowPatching returned %Rrc"), vrc);
+        return setErrorBoth(VBOX_E_VM_ERROR, vrc, tr("PATMR3AllowPatching returned %Rrc"), vrc);
 
 #else  /* !VBOX_WITH_RAW_MODE */
     if (aPATMEnabled)
-        return setError(VBOX_E_VM_ERROR, tr("PATM not present"), VERR_NOT_SUPPORTED);
+        return setErrorBoth(VBOX_E_VM_ERROR, VERR_RAW_MODE_NOT_SUPPORTED, tr("PATM not present"), VERR_NOT_SUPPORTED);
 #endif /* !VBOX_WITH_RAW_MODE */
     return S_OK;
@@ -395 +395 @@
     int vrc = CSAMR3SetScanningEnabled(ptrVM.rawUVM(), aCSAMEnabled != FALSE);
     if (RT_FAILURE(vrc))
-        return setError(VBOX_E_VM_ERROR, tr("CSAMR3SetScanningEnabled returned %Rrc"), vrc);
+        return setErrorBoth(VBOX_E_VM_ERROR, vrc, tr("CSAMR3SetScanningEnabled returned %Rrc"), vrc);
 
 #else  /* !VBOX_WITH_RAW_MODE */
     if (aCSAMEnabled)
-        return setError(VBOX_E_VM_ERROR, tr("CASM not present"), VERR_NOT_SUPPORTED);
+        return setErrorBoth(VBOX_E_VM_ERROR, VERR_RAW_MODE_NOT_SUPPORTED, tr("CASM not present"));
 #endif /* !VBOX_WITH_RAW_MODE */
     return S_OK;
@@ -490 +490 @@
             }
             *pstrSettings = "";
-            AssertReturn(vrc == VERR_BUFFER_OVERFLOW, setError(VBOX_E_IPRT_ERROR, tr("%s returned %Rrc"), pszLogGetStr, vrc));
+            AssertReturn(vrc == VERR_BUFFER_OVERFLOW,
+                         setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("%s returned %Rrc"), pszLogGetStr, vrc));
         }
         else
@@ -669 +670 @@
         }
         else
-            hrc = setError(VBOX_E_VM_ERROR, tr("DBGFR3OSQueryNameAndVersion failed with %Rrc"), vrc);
+            hrc = setErrorBoth(VBOX_E_VM_ERROR, vrc, tr("DBGFR3OSQueryNameAndVersion failed with %Rrc"), vrc);
     }
     return hrc;
@@ -700 +701 @@
         }
         else
-            hrc = setError(VBOX_E_VM_ERROR, tr("DBGFR3OSQueryNameAndVersion failed with %Rrc"), vrc);
+            hrc = setErrorBoth(VBOX_E_VM_ERROR, vrc, tr("DBGFR3OSQueryNameAndVersion failed with %Rrc"), vrc);
     }
     return hrc;
@@ -771 +772 @@
             int vrc = TMR3SetWarpDrive(ptrVM.rawUVM(), aVirtualTimeRate);
             if (RT_FAILURE(vrc))
-                hrc = setError(VBOX_E_VM_ERROR, tr("TMR3SetWarpDrive(, %u) failed with rc=%Rrc"), aVirtualTimeRate, vrc);
+                hrc = setErrorBoth(VBOX_E_VM_ERROR, vrc, tr("TMR3SetWarpDrive(, %u) failed with rc=%Rrc"), aVirtualTimeRate, vrc);
         }
     }
@@ -844 +845 @@
             hrc = S_OK;
         else
-            hrc = setError(E_FAIL, tr("DBGFR3CoreWrite failed with %Rrc"), vrc);
+            hrc = setErrorBoth(E_FAIL, vrc, tr("DBGFR3CoreWrite failed with %Rrc"), vrc);
     }
 
@@ -1010 +1011 @@
             }
             else
-                hrc = setError(VBOX_E_VM_ERROR, tr("DBGFR3Info failed with %Rrc"), vrc);
+                hrc = setErrorBoth(VBOX_E_VM_ERROR, vrc, tr("DBGFR3Info failed with %Rrc"), vrc);
             MachineDebuggerInfoDelete(&Hlp);
         }
@@ -1030 +1031 @@
             hrc = S_OK;
         else
-            hrc = setError(E_FAIL, tr("DBGFR3InjectNMI failed with %Rrc"), vrc);
+            hrc = setErrorBoth(E_FAIL, vrc, tr("DBGFR3InjectNMI failed with %Rrc"), vrc);
     }
     return hrc;
@@ -1047 +1048 @@
             hrc = S_OK;
         else
-            hrc = setError(E_FAIL, tr("DBGFR3LogModifyFlags failed with %Rrc"), vrc);
+            hrc = setErrorBoth(E_FAIL, vrc, tr("DBGFR3LogModifyFlags failed with %Rrc"), vrc);
     }
     return hrc;
@@ -1064 +1065 @@
             hrc = S_OK;
         else
-            hrc = setError(E_FAIL, tr("DBGFR3LogModifyGroups failed with %Rrc"), vrc);
+            hrc = setErrorBoth(E_FAIL, vrc, tr("DBGFR3LogModifyGroups failed with %Rrc"), vrc);
     }
     return hrc;
@@ -1081 +1082 @@
             hrc = S_OK;
         else
-            hrc = setError(E_FAIL, tr("DBGFR3LogModifyDestinations failed with %Rrc"), vrc);
+            hrc = setErrorBoth(E_FAIL, vrc, tr("DBGFR3LogModifyDestinations failed with %Rrc"), vrc);
     }
     return hrc;
@@ -1223 +1224 @@
         }
         else
-            hrc = setError(VBOX_E_VM_ERROR, tr("DBGFR3OSDetect failed with %Rrc"), vrc);
+            hrc = setErrorBoth(VBOX_E_VM_ERROR, vrc, tr("DBGFR3OSDetect failed with %Rrc"), vrc);
     }
     return hrc;
@@ -1327 +1328 @@
         }
         else if (vrc == VERR_DBGF_REGISTER_NOT_FOUND)
-            hrc = setError(E_FAIL, tr("Register '%s' was not found"), aName.c_str());
+            hrc = setErrorBoth(E_FAIL, vrc, tr("Register '%s' was not found"), aName.c_str());
         else if (vrc == VERR_INVALID_CPU_ID)
-            hrc = setError(E_FAIL, tr("Invalid CPU ID: %u"), aCpuId);
+            hrc = setErrorBoth(E_FAIL, vrc, tr("Invalid CPU ID: %u"), aCpuId);
         else
-            hrc = setError(VBOX_E_VM_ERROR,
-                           tr("DBGFR3RegNmQuery failed with rc=%Rrc querying register '%s' with default cpu set to %u"),
-                           vrc, aName.c_str(), aCpuId);
+            hrc = setErrorBoth(VBOX_E_VM_ERROR, vrc,
+                               tr("DBGFR3RegNmQuery failed with rc=%Rrc querying register '%s' with default cpu set to %u"),
+                               vrc, aName.c_str(), aCpuId);
     }
 
@@ -1386 +1387 @@
                 }
                 else
-                    hrc = setError(E_FAIL, tr("DBGFR3RegNmQueryAll failed with %Rrc"), vrc);
+                    hrc = setErrorBoth(E_FAIL, vrc, tr("DBGFR3RegNmQueryAll failed with %Rrc"), vrc);
 
                 RTMemFree(paRegs);
@@ -1394 +1395 @@
         }
         else
-            hrc = setError(E_FAIL, tr("DBGFR3RegNmQueryAllCount failed with %Rrc"), vrc);
+            hrc = setErrorBoth(E_FAIL, vrc, tr("DBGFR3RegNmQueryAllCount failed with %Rrc"), vrc);
     }
     return hrc;
@@ -1537 +1538 @@
             }
             else
-                hrc = setError(E_FAIL, tr("DBGFR3StackWalkBegin failed with %Rrc"), vrc);
+                hrc = setErrorBoth(E_FAIL, vrc, tr("DBGFR3StackWalkBegin failed with %Rrc"), vrc);
 
             /*
@@ -1549 +1550 @@
         }
         else
-            hrc = setError(E_FAIL, tr("Suspending the VM failed with %Rrc\n"), vrc);
+            hrc = setErrorBoth(E_FAIL, vrc, tr("Suspending the VM failed with %Rrc\n"), vrc);
     }
 

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

@@ -504 +504 @@
 
         if (RT_FAILURE(vrc))
-            return setError(VBOX_E_IPRT_ERROR,
-                            tr("Could not send the mouse event to the virtual mouse (%Rrc)"),
-                            vrc);
+            return setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
+                                tr("Could not send the mouse event to the virtual mouse (%Rrc)"),
+                                vrc);
         mfLastButtons = fButtons;
     }
@@ -547 +547 @@
                                           dw, fButtons);
         if (RT_FAILURE(vrc))
-            return setError(VBOX_E_IPRT_ERROR,
-                            tr("Could not send the mouse event to the virtual mouse (%Rrc)"),
-                            vrc);
+            return setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
+                                tr("Could not send the mouse event to the virtual mouse (%Rrc)"),
+                                vrc);
         mfLastButtons = fButtons;
 
@@ -582 +582 @@
         int vrc = pUpPort->pfnPutEventMultiTouch(pUpPort, cContacts, pau64Contacts, u32ScanTime);
         if (RT_FAILURE(vrc))
-            hrc = setError(VBOX_E_IPRT_ERROR,
-                           tr("Could not send the multi-touch event to the virtual device (%Rrc)"),
-                           vrc);
+            hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
+                               tr("Could not send the multi-touch event to the virtual device (%Rrc)"),
+                               vrc);
     }
     else
@@ -613 +613 @@
                                                    x, y);
         if (RT_FAILURE(vrc))
-            return setError(VBOX_E_IPRT_ERROR,
-                            tr("Could not send the mouse event to the virtual mouse (%Rrc)"),
-                            vrc);
+            return setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
+                                tr("Could not send the mouse event to the virtual mouse (%Rrc)"),
+                                vrc);
     }
     return S_OK;

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

@@ -145 +145 @@
         {
             mData.m_SemEvWatcher = NIL_RTSEMEVENT;
-            AssertRCStmt(vrc, throw setError(VBOX_E_IPRT_ERROR, tr("Failed to create semaphore (rc=%Rrc)"), vrc));
+            AssertRCStmt(vrc, throw setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Failed to create semaphore (rc=%Rrc)"), vrc));
         }
 
@@ -154 +154 @@
             RTSemEventDestroy(mData.m_SemEvWatcher);
             mData.m_SemEvWatcher = NIL_RTSEMEVENT;
-            AssertRCStmt(vrc, throw setError(VBOX_E_IPRT_ERROR,  tr("Failed to create watcher thread (rc=%Rrc)"), vrc));
+            AssertRCStmt(vrc, throw setErrorBoth(VBOX_E_IPRT_ERROR, vrc,  tr("Failed to create watcher thread (rc=%Rrc)"), vrc));
         }
     }

trunk/src/VBox/Main/src-server/ApplianceImplExport.cpp

@@ -490 +490 @@
                         throw setError(VBOX_E_NOT_SUPPORTED,
                                        tr("Cannot handle medium attachment: channel is %d, device is %d"), lChannel, lDevice);
-                break;
+                    break;
 
                 case StorageBus_SATA:
                     lChannelVsys = lChannel;        // should be between 0 and 29
                     lControllerVsys = lSATAControllerIndex;
-                break;
+                    break;
 
                 case StorageBus_SCSI:
@@ -501 +501 @@
                     lChannelVsys = lChannel;        // should be between 0 and 15
                     lControllerVsys = lSCSIControllerIndex;
-                break;
+                    break;
 
                 case StorageBus_Floppy:
                     lChannelVsys = 0;
                     lControllerVsys = 0;
-                break;
+                    break;
 
                 default:
@@ -512 +512 @@
                                    tr("Cannot handle medium attachment: storageBus is %d, channel is %d, device is %d"),
                                    storageBus, lChannel, lDevice);
-                break;
             }
 

trunk/src/VBox/Main/src-server/ApplianceImplImport.cpp

@@ -1843 +1843 @@
                     vrc = RTCrX509CertPathsSetTrustedStore(hCertPaths, hTrustedCerts);
                     if (RT_FAILURE(vrc))
-                        hrc2 = setError(E_FAIL, tr("RTCrX509CertPathsSetTrustedStore failed (%Rrc)"), vrc);
+                        hrc2 = setErrorBoth(E_FAIL, vrc, tr("RTCrX509CertPathsSetTrustedStore failed (%Rrc)"), vrc);
                     RTCrStoreRelease(hTrustedCerts);
                 }
                 else
-                    hrc2 = setError(E_FAIL,
-                                    tr("Failed to query trusted CAs and Certificates from the system and for the current user (%Rrc, %s)"),
-                                    vrc, StaticErrInfo.Core.pszMsg);
+                    hrc2 = setErrorBoth(E_FAIL, vrc,
+                                        tr("Failed to query trusted CAs and Certificates from the system and for the current user (%Rrc, %s)"),
+                                        vrc, StaticErrInfo.Core.pszMsg);
 
                 /* Add untrusted intermediate certificates. */
@@ -1913 +1913 @@
                         }
                         else
-                            hrc2 = setError(E_FAIL, tr("Certificate path validation failed (%Rrc, %s)"),
-                                            vrc, StaticErrInfo.Core.pszMsg);
+                            hrc2 = setErrorBoth(E_FAIL, vrc, tr("Certificate path validation failed (%Rrc, %s)"),
+                                                vrc, StaticErrInfo.Core.pszMsg);
                     }
                     else
-                        hrc2 = setError(E_FAIL, tr("Certificate path building failed (%Rrc, %s)"),
-                                        vrc, StaticErrInfo.Core.pszMsg);
+                        hrc2 = setErrorBoth(E_FAIL, vrc, tr("Certificate path building failed (%Rrc, %s)"),
+                                            vrc, StaticErrInfo.Core.pszMsg);
                 }
                 RTCrX509CertPathsRelease(hCertPaths);
@@ -2239 +2239 @@
                                              NULL /*pszAttr*/, szDigest, fType);
             if (RT_FAILURE(vrc))
-                return setError(VBOX_E_IPRT_ERROR, tr("Error fudging missing OVF digest in manifest: %Rrc"), vrc);
+                return setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Error fudging missing OVF digest in manifest: %Rrc"), vrc);
         }
 

trunk/src/VBox/Main/src-server/DHCPServerImpl.cpp

@@ -258 +258 @@
 {
     RTNETADDRIPV4 IPAddress, NetworkMask, LowerIP, UpperIP;
-    int rc;
-
-    rc = RTNetStrToIPv4Addr(aIPAddress.c_str(), &IPAddress);
-    if (RT_FAILURE(rc))
-        return mVirtualBox->setErrorBoth(E_INVALIDARG, rc,
-                   "Invalid server address");
-
-    rc = RTNetStrToIPv4Addr(aNetworkMask.c_str(), &NetworkMask);
-    if (RT_FAILURE(rc))
-        return mVirtualBox->setErrorBoth(E_INVALIDARG, rc,
-                   "Invalid netmask");
-
-    rc = RTNetStrToIPv4Addr(aLowerIP.c_str(), &LowerIP);
-    if (RT_FAILURE(rc))
-        return mVirtualBox->setErrorBoth(E_INVALIDARG, rc,
-                   "Invalid range lower address");
-
-    rc = RTNetStrToIPv4Addr(aUpperIP.c_str(), &UpperIP);
-    if (RT_FAILURE(rc))
-        return mVirtualBox->setErrorBoth(E_INVALIDARG, rc,
-                   "Invalid range upper address");
+
+    int vrc = RTNetStrToIPv4Addr(aIPAddress.c_str(), &IPAddress);
+    if (RT_FAILURE(vrc))
+        return mVirtualBox->setErrorBoth(E_INVALIDARG, vrc, "Invalid server address");
+
+    vrc = RTNetStrToIPv4Addr(aNetworkMask.c_str(), &NetworkMask);
+    if (RT_FAILURE(vrc))
+        return mVirtualBox->setErrorBoth(E_INVALIDARG, vrc, "Invalid netmask");
+
+    vrc = RTNetStrToIPv4Addr(aLowerIP.c_str(), &LowerIP);
+    if (RT_FAILURE(vrc))
+        return mVirtualBox->setErrorBoth(E_INVALIDARG, vrc, "Invalid range lower address");
+
+    vrc = RTNetStrToIPv4Addr(aUpperIP.c_str(), &UpperIP);
+    if (RT_FAILURE(vrc))
+        return mVirtualBox->setErrorBoth(E_INVALIDARG, vrc, "Invalid range upper address");
 
     /*
@@ -284 +279 @@
      * here or address/prefix for aIPAddress?
      */
-    rc = RTNetMaskToPrefixIPv4(&NetworkMask, NULL);
-    if (RT_FAILURE(rc))
-        return mVirtualBox->setErrorBoth(E_INVALIDARG, rc,
-                   "Invalid netmask");
+    vrc = RTNetMaskToPrefixIPv4(&NetworkMask, NULL);
+    if (RT_FAILURE(vrc))
+        return mVirtualBox->setErrorBoth(E_INVALIDARG, vrc, "Invalid netmask");
 
     /* It's more convenient to convert to host order once */
@@ -301 +295 @@
         || (IPAddress.u & ~NetworkMask.u) == 0
         || ((IPAddress.u & ~NetworkMask.u) | NetworkMask.u) == UINT32_C(0xffffffff))
-    {
-        return mVirtualBox->setError(E_INVALIDARG,
-                   "Invalid server address");
-    }
+        return mVirtualBox->setError(E_INVALIDARG, "Invalid server address");
 
     if (   (LowerIP.u & UINT32_C(0xe0000000)) == UINT32_C(0xe0000000)
@@ -310 +301 @@
         || (LowerIP.u & ~NetworkMask.u) == 0
         || ((LowerIP.u & ~NetworkMask.u) | NetworkMask.u) == UINT32_C(0xffffffff))
-    {
-        return mVirtualBox->setError(E_INVALIDARG,
-                   "Invalid range lower address");
-    }
+        return mVirtualBox->setError(E_INVALIDARG, "Invalid range lower address");
 
     if (   (UpperIP.u & UINT32_C(0xe0000000)) == UINT32_C(0xe0000000)
@@ -319 +307 @@
         || (UpperIP.u & ~NetworkMask.u) == 0
         || ((UpperIP.u & ~NetworkMask.u) | NetworkMask.u) == UINT32_C(0xffffffff))
-    {
-        return mVirtualBox->setError(E_INVALIDARG,
-                   "Invalid range upper address");
-    }
+        return mVirtualBox->setError(E_INVALIDARG, "Invalid range upper address");
 
     /* The range should be valid ... */
     if (LowerIP.u > UpperIP.u)
-        return mVirtualBox->setError(E_INVALIDARG,
-                   "Invalid range bounds");
+        return mVirtualBox->setError(E_INVALIDARG, "Invalid range bounds");
 
     /* ... and shouldn't contain the server's address */
     if (LowerIP.u <= IPAddress.u && IPAddress.u <= UpperIP.u)
-        return mVirtualBox->setError(E_INVALIDARG,
-                   "Server address within range bounds");
+        return mVirtualBox->setError(E_INVALIDARG, "Server address within range bounds");
 
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
@@ -416 +399 @@
     {
         uint8_t u8Code;
+        char    *pszNext;
+        int vrc = RTStrToUInt8Ex(aValue.c_str(), &pszNext, 10, &u8Code);
+        if (!RT_SUCCESS(vrc))
+            return VERR_PARSE_ERROR;
+
         uint32_t u32Enc;
-        char *pszNext;
-        int rc;
-
-        rc = RTStrToUInt8Ex(aValue.c_str(), &pszNext, 10, &u8Code);
-        if (!RT_SUCCESS(rc))
-            return VERR_PARSE_ERROR;
-
         switch (*pszNext)
         {
@@ -440 +421 @@
             case '@':
             {
-                rc = RTStrToUInt32Ex(pszNext + 1, &pszNext, 10, &u32Enc);
-                if (!RT_SUCCESS(rc))
+                vrc = RTStrToUInt32Ex(pszNext + 1, &pszNext, 10, &u32Enc);
+                if (!RT_SUCCESS(vrc))
                     return VERR_PARSE_ERROR;
                 if (*pszNext != '=')

trunk/src/VBox/Main/src-server/HostUSBDeviceImpl.cpp

@@ -474 +474 @@
     mCaptureFilename = aCaptureFilename;
     alock.release();
-    int rc = mUSBProxyBackend->captureDevice(this);
-    if (RT_FAILURE(rc))
+    int vrc = mUSBProxyBackend->captureDevice(this);
+    if (RT_FAILURE(vrc))
     {
         alock.acquire();
         i_failTransition(kHostUSBDeviceState_Invalid);
         mMachine.setNull();
-        if (rc == VERR_SHARING_VIOLATION)
-            return setError(E_FAIL,
-                            tr("USB device '%s' with UUID {%RTuuid} is in use by someone else"),
-                            mName, mId.raw());
+        if (vrc == VERR_SHARING_VIOLATION)
+            return setErrorBoth(E_FAIL, vrc,
+                                tr("USB device '%s' with UUID {%RTuuid} is in use by someone else"),
+                                mName, mId.raw());
         return E_FAIL;
     }

trunk/src/VBox/Main/src-server/HostVideoInputDeviceImpl.cpp

@@ -184 +184 @@
         PFNVBOXHOSTWEBCAMLIST pfn = NULL;
         RTLDRMOD hmod = NIL_RTLDRMOD;
-        int rc = loadHostWebcamLibrary(strLibrary.c_str(), &hmod, &pfn);
-
-        LogRel(("Load [%s] rc %Rrc\n", strLibrary.c_str(), rc));
-
-        if (RT_SUCCESS(rc))
+        int vrc = loadHostWebcamLibrary(strLibrary.c_str(), &hmod, &pfn);
+
+        LogRel(("Load [%s] vrc=%Rrc\n", strLibrary.c_str(), vrc));
+
+        if (RT_SUCCESS(vrc))
         {
             uint64_t u64Result = S_OK;
-            rc = pfn(hostWebcamAdd, pList, &u64Result);
-            Log(("VBoxHostWebcamList rc %Rrc, result 0x%08X\n", rc, u64Result));
-            if (RT_FAILURE(rc))
+            vrc = pfn(hostWebcamAdd, pList, &u64Result);
+            Log(("VBoxHostWebcamList vrc %Rrc, result 0x%08X\n", vrc, u64Result));
+            if (RT_FAILURE(vrc))
             {
                 hr = (HRESULT)u64Result;
@@ -204 +204 @@
         if (SUCCEEDED(hr))
         {
-            if (RT_FAILURE(rc))
-                hr = pVirtualBox->setError(VBOX_E_IPRT_ERROR,
-                         "Failed to get webcam list: %Rrc", rc);
+            if (RT_FAILURE(vrc))
+                hr = pVirtualBox->setErrorBoth(VBOX_E_IPRT_ERROR, vrc, "Failed to get webcam list: %Rrc", vrc);
         }
     }

trunk/src/VBox/Main/src-server/MachineImpl.cpp

@@ -641 +641 @@
     int vrc1 = mParent->i_calculateFullPath(strConfigFile, mData->m_strConfigFileFull);
     if (RT_FAILURE(vrc1))
-        return setError(VBOX_E_FILE_ERROR,
-                        tr("Invalid machine settings file name '%s' (%Rrc)"),
-                        strConfigFile.c_str(),
-                        vrc1);
+        return setErrorBoth(VBOX_E_FILE_ERROR, vrc1,
+                            tr("Invalid machine settings file name '%s' (%Rrc)"),
+                            strConfigFile.c_str(),
+                            vrc1);
 
     LogFlowThisFuncLeave();
@@ -680 +680 @@
             int vrc2 = RTFileDelete(mData->m_strConfigFileFull.c_str());
             if (RT_FAILURE(vrc2))
-                rc = setError(VBOX_E_FILE_ERROR,
-                              tr("Could not delete the existing settings file '%s' (%Rrc)"),
-                              mData->m_strConfigFileFull.c_str(), vrc2);
+                rc = setErrorBoth(VBOX_E_FILE_ERROR, vrc2,
+                                  tr("Could not delete the existing settings file '%s' (%Rrc)"),
+                                  mData->m_strConfigFileFull.c_str(), vrc2);
         }
     }
@@ -688 +688 @@
               && vrc != VERR_PATH_NOT_FOUND
             )
-        rc = setError(VBOX_E_FILE_ERROR,
-                      tr("Invalid machine settings file name '%s' (%Rrc)"),
-                      mData->m_strConfigFileFull.c_str(),
-                      vrc);
+        rc = setErrorBoth(VBOX_E_FILE_ERROR, vrc,
+                          tr("Invalid machine settings file name '%s' (%Rrc)"),
+                          mData->m_strConfigFileFull.c_str(),
+                          vrc);
     return rc;
 }
@@ -2664 +2664 @@
                                 strSnapshotFolder);
     if (RT_FAILURE(vrc))
-        return setError(E_FAIL,
-                        tr("Invalid snapshot folder '%s' (%Rrc)"),
-                        strSnapshotFolder.c_str(), vrc);
+        return setErrorBoth(E_FAIL, vrc,
+                            tr("Invalid snapshot folder '%s' (%Rrc)"),
+                            strSnapshotFolder.c_str(), vrc);
 
     i_setModified(IsModified_MachineData);
@@ -4866 +4866 @@
             case DeviceType_DVD:
             case DeviceType_Floppy:
-            break;
+                break;
 
             default:
@@ -5493 +5493 @@
             int vrc = RTFileDelete(strFile.c_str());
             if (RT_FAILURE(vrc))
-                throw setError(VBOX_E_IPRT_ERROR,
-                               tr("Could not delete file '%s' (%Rrc)"), strFile.c_str(), vrc);
+                throw setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
+                                   tr("Could not delete file '%s' (%Rrc)"), strFile.c_str(), vrc);
         }
 
@@ -6520 +6520 @@
         *aEnabled = TRUE;
 #endif
-        return setError(VBOX_E_IPRT_ERROR,
-                        tr("Saved guest size is not available (%Rrc)"),
-                        vrc);
+        return setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
+                            tr("Saved guest size is not available (%Rrc)"),
+                            vrc);
     }
 
@@ -6557 +6557 @@
 
     if (RT_FAILURE(vrc))
-        return setError(VBOX_E_IPRT_ERROR,
-                        tr("Saved thumbnail data is not available (%Rrc)"),
-                        vrc);
+        return setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
+                            tr("Saved thumbnail data is not available (%Rrc)"),
+                            vrc);
 
     HRESULT hr = S_OK;
@@ -6615 +6615 @@
             }
             else
-                hr = setError(VBOX_E_IPRT_ERROR,
-                              tr("Could not convert saved thumbnail to PNG (%Rrc)"),
-                              vrc);
+                hr = setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
+                                  tr("Could not convert saved thumbnail to PNG (%Rrc)"),
+                                  vrc);
 
             RTMemFree(pu8PNG);
@@ -6646 +6646 @@
 
     if (RT_FAILURE(vrc))
-        return setError(VBOX_E_IPRT_ERROR,
-                        tr("Saved screenshot data is not available (%Rrc)"),
-                        vrc);
+        return setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
+                            tr("Saved screenshot data is not available (%Rrc)"),
+                            vrc);
 
     *aWidth = u32Width;
@@ -6682 +6682 @@
 
     if (RT_FAILURE(vrc))
-        return setError(VBOX_E_IPRT_ERROR,
-                        tr("Saved screenshot thumbnail data is not available (%Rrc)"),
-                        vrc);
+        return setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
+                            tr("Saved screenshot thumbnail data is not available (%Rrc)"),
+                            vrc);
 
     *aWidth = u32Width;
@@ -6828 +6828 @@
             aData.resize(cbData);
         else
-            rc = setError(VBOX_E_IPRT_ERROR,
-                          tr("Could not read log file '%s' (%Rrc)"),
+            rc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
+                              tr("Could not read log file '%s' (%Rrc)"),
+                              log.c_str(), vrc);
+        RTFileClose(LogFile);
+    }
+    else
+        rc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
+                          tr("Could not open log file '%s' (%Rrc)"),
                           log.c_str(), vrc);
-        RTFileClose(LogFile);
-    }
-    else
-        rc = setError(VBOX_E_IPRT_ERROR,
-                      tr("Could not open log file '%s' (%Rrc)"),
-                      log.c_str(), vrc);
 
     if (FAILED(rc))
@@ -7950 +7950 @@
 
     if (RT_FAILURE(vrc))
-        return setError(VBOX_E_IPRT_ERROR,
-                        tr("Could not launch a process for the machine '%s' (%Rrc)"),
-                        mUserData->s.strName.c_str(), vrc);
+        return setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
+                            tr("Could not launch a process for the machine '%s' (%Rrc)"),
+                            mUserData->s.strName.c_str(), vrc);
 
     LogFlowThisFunc(("launched.pid=%d(0x%x)\n", pid, pid));
@@ -8150 +8150 @@
                           i_getName().c_str(), status.iStatus, strExtraInfo.c_str());
         else
-            rc = setError(E_FAIL,
-                          tr("The virtual machine '%s' has terminated unexpectedly during startup (%Rrc)%s"),
-                          i_getName().c_str(), vrc, strExtraInfo.c_str());
+            rc = setErrorBoth(E_FAIL, vrc,
+                              tr("The virtual machine '%s' has terminated unexpectedly during startup (%Rrc)%s"),
+                              i_getName().c_str(), vrc, strExtraInfo.c_str());
     }
 
@@ -8856 +8856 @@
         int vrc = i_calculateFullPath(stateFilePathFull, stateFilePathFull);
         if (RT_FAILURE(vrc))
-            return setError(E_FAIL,
-                            tr("Invalid saved state file path '%s' (%Rrc)"),
-                            config.strStateFile.c_str(),
-                            vrc);
+            return setErrorBoth(E_FAIL, vrc,
+                                tr("Invalid saved state file path '%s' (%Rrc)"),
+                                config.strStateFile.c_str(),
+                                vrc);
         mSSData->strStateFilePath = stateFilePathFull;
     }
@@ -8966 +8966 @@
         int vrc = i_calculateFullPath(strStateFile, strStateFile);
         if (RT_FAILURE(vrc))
-            return setError(E_FAIL,
-                            tr("Invalid saved state file path '%s' (%Rrc)"),
-                            strStateFile.c_str(),
-                            vrc);
+            return setErrorBoth(E_FAIL, vrc,
+                                tr("Invalid saved state file path '%s' (%Rrc)"),
+                                strStateFile.c_str(),
+                                vrc);
     }
 
@@ -9951 +9951 @@
                     if (RT_FAILURE(vrc))
                     {
-                        rc = setError(E_FAIL,
-                                      tr("Could not rename the directory '%s' to '%s' to save the settings file (%Rrc)"),
-                                      configDir.c_str(),
-                                      newConfigDir.c_str(),
-                                      vrc);
+                        rc = setErrorBoth(E_FAIL, vrc,
+                                          tr("Could not rename the directory '%s' to '%s' to save the settings file (%Rrc)"),
+                                          configDir.c_str(),
+                                          newConfigDir.c_str(),
+                                          vrc);
                         break;
                     }
@@ -9989 +9989 @@
                     if (RT_FAILURE(vrc))
                     {
-                        rc = setError(E_FAIL,
-                                      tr("Could not rename the settings file '%s' to '%s' (%Rrc)"),
-                                      configFile.c_str(),
-                                      newConfigFile.c_str(),
-                                      vrc);
+                        rc = setErrorBoth(E_FAIL, vrc,
+                                          tr("Could not rename the settings file '%s' to '%s' (%Rrc)"),
+                                          configFile.c_str(),
+                                          newConfigFile.c_str(),
+                                          vrc);
                         break;
                     }
@@ -10063 +10063 @@
             if (RT_FAILURE(vrc))
             {
-                return setError(E_FAIL,
-                                tr("Could not create a directory '%s' to save the settings file (%Rrc)"),
-                                path.c_str(),
-                                vrc);
+                return setErrorBoth(E_FAIL, vrc,
+                                    tr("Could not create a directory '%s' to save the settings file (%Rrc)"),
+                                    path.c_str(),
+                                    vrc);
             }
         }
@@ -10076 +10076 @@
                          RTFILE_O_READWRITE | RTFILE_O_CREATE | RTFILE_O_DENY_WRITE);
         if (RT_FAILURE(vrc))
-            return setError(E_FAIL,
-                            tr("Could not create the settings file '%s' (%Rrc)"),
-                            path.c_str(),
-                            vrc);
+            return setErrorBoth(E_FAIL, vrc,
+                                tr("Could not create the settings file '%s' (%Rrc)"),
+                                path.c_str(),
+                                vrc);
         RTFileClose(f);
     }
@@ -13274 +13274 @@
     int vrc = i_calculateFullPath(aSavedStateFile, stateFilePathFull);
     if (RT_FAILURE(vrc))
-        return setError(VBOX_E_FILE_ERROR,
-                        tr("Invalid saved state file path '%s' (%Rrc)"),
-                        aSavedStateFile.c_str(),
-                        vrc);
+        return setErrorBoth(VBOX_E_FILE_ERROR, vrc,
+                            tr("Invalid saved state file path '%s' (%Rrc)"),
+                            aSavedStateFile.c_str(),
+                            vrc);
 
     mSSData->strStateFilePath = stateFilePathFull;
@@ -13927 +13927 @@
         Utf8Str filename = authLibrary;
 
-        int rc = AuthLibLoad(&mAuthLibCtx, filename.c_str());
-        if (RT_FAILURE(rc))
-        {
-            hr = setError(E_FAIL,
-                          tr("Could not load the external authentication library '%s' (%Rrc)"),
-                          filename.c_str(), rc);
-        }
+        int vrc = AuthLibLoad(&mAuthLibCtx, filename.c_str());
+        if (RT_FAILURE(vrc))
+            hr = setErrorBoth(E_FAIL, vrc,
+                              tr("Could not load the external authentication library '%s' (%Rrc)"),
+                              filename.c_str(), vrc);
     }
 

trunk/src/VBox/Main/src-server/MachineImplCloneVM.cpp

@@ -221 +221 @@
         int vrc = RTFileQuerySize(sst.strSaveStateFile.c_str(), &cbSize);
         if (RT_FAILURE(vrc))
-            return p->setError(VBOX_E_IPRT_ERROR, p->tr("Could not query file size of '%s' (%Rrc)"),
-                               sst.strSaveStateFile.c_str(), vrc);
-        /* same rule as above: count both the data which needs to
+            return p->setErrorBoth(VBOX_E_IPRT_ERROR, vrc, p->tr("Could not query file size of '%s' (%Rrc)"),
+                                   sst.strSaveStateFile.c_str(), vrc);
+        /*  same rule as above: count both the data which needs to
          * be read and written */
         sst.uWeight = (ULONG)(2 * (cbSize + _1M - 1) / _1M);
@@ -965 +965 @@
 
         if (RT_FAILURE(vrc))
-            p->setError(VBOX_E_IPRT_ERROR, "Could not create machine clone thread (%Rrc)", vrc);
+            p->setErrorBoth(VBOX_E_IPRT_ERROR, vrc, "Could not create machine clone thread (%Rrc)", vrc);
     }
     catch (HRESULT rc2)
@@ -1393 +1393 @@
             int vrc = RTDirCreateFullPath(strTrgSnapshotFolder.c_str(), 0700);
             if (RT_FAILURE(vrc))
-                throw p->setError(VBOX_E_IPRT_ERROR,
-                                  p->tr("Could not create snapshots folder '%s' (%Rrc)"),
-                                        strTrgSnapshotFolder.c_str(), vrc);
+                throw p->setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
+                                      p->tr("Could not create snapshots folder '%s' (%Rrc)"),
+                                            strTrgSnapshotFolder.c_str(), vrc);
         }
         /* Clone all save state files. */
@@ -1414 +1414 @@
                                        MachineCloneVMPrivate::copyStateFileProgress, &d->pProgress);
                 if (RT_FAILURE(vrc))
-                    throw p->setError(VBOX_E_IPRT_ERROR,
-                                      p->tr("Could not copy state file '%s' to '%s' (%Rrc)"),
-                                            sst.strSaveStateFile.c_str(), strTrgSaveState.c_str(), vrc);
+                    throw p->setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
+                                          p->tr("Could not copy state file '%s' to '%s' (%Rrc)"),
+                                          sst.strSaveStateFile.c_str(), strTrgSaveState.c_str(), vrc);
                 newFiles.append(strTrgSaveState);
             }
@@ -1507 +1507 @@
             vrc = RTFileDelete(newFiles.at(i).c_str());
             if (RT_FAILURE(vrc))
-                mrc = p->setError(VBOX_E_IPRT_ERROR, p->tr("Could not delete file '%s' (%Rrc)"), newFiles.at(i).c_str(), vrc);
+                mrc = p->setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
+                                      p->tr("Could not delete file '%s' (%Rrc)"), newFiles.at(i).c_str(), vrc);
         }
         /* Delete all already created medias. (Reverse, cause there could be

trunk/src/VBox/Main/src-server/MachineImplMoveVM.cpp

@@ -185 +185 @@
                                  strTargetFolder.c_str());
             errorsList.push_back(ErrorInfoItem(E_FAIL, errorDesc.c_str()));
-            rc = m_pMachine->setError(E_FAIL, m_pMachine->tr(errorDesc.c_str()));
+            rc = m_pMachine->setErrorBoth(E_FAIL, vrc, m_pMachine->tr(errorDesc.c_str()));
             throw rc;
         }
@@ -204 +204 @@
                                      "the destination folder.", strTargetFolder.c_str());
                 errorsList.push_back(ErrorInfoItem(HRESULT(vrc), errorDesc.c_str()));
-                rc = m_pMachine->setError(vrc, m_pMachine->tr(errorDesc.c_str()));
-
+                rc = m_pMachine->setErrorBoth(VBOX_E_FILE_ERROR, vrc, m_pMachine->tr(errorDesc.c_str()));
             }
 
@@ -493 +492 @@
                 errorsList.push_back(ErrorInfoItem(VBOX_E_IPRT_ERROR, errorDesc.c_str()));
 
-                throw m_pMachine->setError(VBOX_E_IPRT_ERROR,m_pMachine->tr(errorDesc.c_str()));
+                throw m_pMachine->setError(VBOX_E_IPRT_ERROR, m_pMachine->tr(errorDesc.c_str()));
             }
         }
@@ -658 +657 @@
                     taskMoveVM->errorsList.push_back(ErrorInfoItem(VBOX_E_IPRT_ERROR, errorDesc.c_str()));
 
-                    throw machine->setError(VBOX_E_IPRT_ERROR,machine->tr(errorDesc.c_str()));
+                    throw machine->setErrorBoth(VBOX_E_IPRT_ERROR, vrc, machine->tr(errorDesc.c_str()));
                 }
             }
@@ -682 +681 @@
                     taskMoveVM->errorsList.push_back(ErrorInfoItem(VBOX_E_IPRT_ERROR, errorDesc.c_str()));
 
-                    throw machine->setError(VBOX_E_IPRT_ERROR,machine->tr(errorDesc.c_str()));
+                    throw machine->setErrorBoth(VBOX_E_IPRT_ERROR, vrc, machine->tr(errorDesc.c_str()));
                 }
 
@@ -731 +730 @@
                     taskMoveVM->errorsList.push_back(ErrorInfoItem(VBOX_E_IPRT_ERROR, errorDesc.c_str()));
 
-                    throw machine->setError(VBOX_E_IPRT_ERROR,machine->tr(errorDesc.c_str()));
+                    throw machine->setErrorBoth(VBOX_E_IPRT_ERROR, vrc, machine->tr(errorDesc.c_str()));
                 }
                 LogRelFunc(("Created a home machine folder %s\n", strTargetSettingsFilePath.c_str()));
@@ -755 +754 @@
                 taskMoveVM->errorsList.push_back(ErrorInfoItem(VBOX_E_IPRT_ERROR, errorDesc.c_str()));
 
-                throw machine->setError(VBOX_E_IPRT_ERROR, machine->tr(errorDesc.c_str()));
+                throw machine->setErrorBoth(VBOX_E_IPRT_ERROR, vrc, machine->tr(errorDesc.c_str()));
             }
 
@@ -789 +788 @@
                             taskMoveVM->errorsList.push_back(ErrorInfoItem(VBOX_E_IPRT_ERROR, errorDesc.c_str()));
 
-                            throw machine->setError(VBOX_E_IPRT_ERROR,machine->tr(errorDesc.c_str()));
+                            throw machine->setErrorBoth(VBOX_E_IPRT_ERROR, vrc, machine->tr(errorDesc.c_str()));
                         }
                         LogRelFunc(("Created a log machine folder %s\n", strTargetLogFolderPath.c_str()));
@@ -807 +806 @@
                         /* Move to next sub-operation. */
                         rc = taskMoveVM->m_pProgress->SetNextOperation(BstrFmt(machine->tr("Copying the log file '%s' ..."),
-                                                                RTPathFilename(strFullSourceFilePath.c_str())).raw(), 1);
+                                                                               RTPathFilename(strFullSourceFilePath.c_str())).raw(),
+                                                                       1);
                         if (FAILED(rc)) throw rc;
 
                         int vrc = RTFileCopyEx(strFullSourceFilePath.c_str(), strFullTargetFilePath.c_str(), 0,
-                                       MachineMoveVM::copyFileProgress, &taskMoveVM->m_pProgress);
+                                               MachineMoveVM::copyFileProgress, &taskMoveVM->m_pProgress);
                         if (RT_FAILURE(vrc))
                         {
@@ -820 +820 @@
                             taskMoveVM->errorsList.push_back(ErrorInfoItem(VBOX_E_IPRT_ERROR, errorDesc.c_str()));
 
-                            throw machine->setError(VBOX_E_IPRT_ERROR,machine->tr(errorDesc.c_str()));
+                            throw machine->setErrorBoth(VBOX_E_IPRT_ERROR, vrc, machine->tr(errorDesc.c_str()));
                         }
 
                         LogRelFunc(("The log file %s has been copied into the folder %s\n", strFullSourceFilePath.c_str(),
-                                         strFullTargetFilePath.stripFilename().c_str()));
+                                    strFullTargetFilePath.stripFilename().c_str()));
 
                         /* save new file in case of restoring */
@@ -1232 +1232 @@
 
         vrc = RTDirClose(hDir);
+        AssertRC(vrc);
     }
     else if (vrc == VERR_FILE_NOT_FOUND)
@@ -1238 +1239 @@
         errorsList.push_back(ErrorInfoItem(VERR_FILE_NOT_FOUND, errorDesc.c_str()));
 
-        m_pMachine->setError(VBOX_E_IPRT_ERROR, m_pMachine->tr(errorDesc.c_str()));
-        rc = vrc;
+        rc = m_pMachine->setErrorBoth(VBOX_E_IPRT_ERROR, vrc, m_pMachine->tr(errorDesc.c_str()));
     }
     else
@@ -1246 +1246 @@
         errorsList.push_back(ErrorInfoItem(VBOX_E_IPRT_ERROR, errorDesc.c_str()));
 
-        throw m_pMachine->setError(VBOX_E_IPRT_ERROR, m_pMachine->tr(errorDesc.c_str()));
+/** @todo r=bird: document this throwing business, please!  Error handling is
+ *        a bit fishy here.  See also */
+        throw m_pMachine->setErrorBoth(VBOX_E_IPRT_ERROR, vrc, m_pMachine->tr(errorDesc.c_str()));
     }
 
@@ -1270 +1272 @@
                 errorsList.push_back(ErrorInfoItem(VBOX_E_IPRT_ERROR, errorDesc.c_str()));
 
-                rc = m_pMachine->setError(VBOX_E_IPRT_ERROR, m_pMachine->tr(errorDesc.c_str()));
+                rc = m_pMachine->setErrorBoth(VBOX_E_IPRT_ERROR, vrc, m_pMachine->tr(errorDesc.c_str()));
             }
             else
@@ -1317 +1319 @@
                     errorsList.push_back(ErrorInfoItem(VBOX_E_IPRT_ERROR, errorDesc.c_str()));
 
-                    throw m_pMachine->setError(VBOX_E_IPRT_ERROR, m_pMachine->tr(errorDesc.c_str()));
+                    throw m_pMachine->setErrorBoth(VBOX_E_IPRT_ERROR, vrc, m_pMachine->tr(errorDesc.c_str()));
                 }
                 ++it;
@@ -1326 +1328 @@
         else
         {
-            Utf8StrFmt errorDesc("Could not calculate the size of folder '%s' (%Rrc)", strRootFolder.c_str(), vrc);
+/** @todo r=bird: This only happens if RTDirOpen fails.  So, I'm not sure
+ * what you're going for here... See not about throwing in getFilesList(). */
+            Utf8StrFmt errorDesc("Could not calculate the size of folder '%s'", strRootFolder.c_str());
             errorsList.push_back(ErrorInfoItem(VBOX_E_IPRT_ERROR, errorDesc.c_str()));
 
@@ -1502 +1506 @@
             errorsList.push_back(ErrorInfoItem(VBOX_E_IPRT_ERROR, errorDesc.c_str()));
 
-            return m_pMachine->setError(VBOX_E_IPRT_ERROR, m_pMachine->tr(errorDesc.c_str()));
+            return m_pMachine->setErrorBoth(VBOX_E_IPRT_ERROR, vrc, m_pMachine->tr(errorDesc.c_str()));
         }
         /* same rule as above: count both the data which needs to

trunk/src/VBox/Main/src-server/MediumImpl.cpp

@@ -3610 +3610 @@
                 int vrc = VDPluginLoadFromFilename(strPlugin.c_str());
                 if (RT_FAILURE(vrc))
-                    throw setError(VBOX_E_NOT_SUPPORTED,
-                                   tr("Retrieving encryption settings of the image failed because the encryption plugin could not be loaded (%s)"),
-                                   i_vdError(vrc).c_str());
+                    throw setErrorBoth(VBOX_E_NOT_SUPPORTED, vrc,
+                                       tr("Retrieving encryption settings of the image failed because the encryption plugin could not be loaded (%s)"),
+                                       i_vdError(vrc).c_str());
             }
             else
@@ -3633 +3633 @@
         vrc = VDFilterAdd(pDisk, "CRYPT", VD_FILTER_FLAGS_READ | VD_FILTER_FLAGS_INFO, CryptoSettings.vdFilterIfaces);
         if (RT_FAILURE(vrc))
-            throw setError(VBOX_E_INVALID_OBJECT_STATE,
-                           tr("Failed to load the encryption filter: %s"),
-                           i_vdError(vrc).c_str());
+            throw setErrorBoth(VBOX_E_INVALID_OBJECT_STATE, vrc,
+                               tr("Failed to load the encryption filter: %s"),
+                               i_vdError(vrc).c_str());
 
         it = pBase->m->mapProperties.find("CRYPT/KeyId");
@@ -3686 +3686 @@
                 int vrc = VDPluginLoadFromFilename(strPlugin.c_str());
                 if (RT_FAILURE(vrc))
-                    throw setError(VBOX_E_NOT_SUPPORTED,
-                                   tr("Retrieving encryption settings of the image failed because the encryption plugin could not be loaded (%s)"),
-                                   i_vdError(vrc).c_str());
+                    throw setErrorBoth(VBOX_E_NOT_SUPPORTED, vrc,
+                                       tr("Retrieving encryption settings of the image failed because the encryption plugin could not be loaded (%s)"),
+                                       i_vdError(vrc).c_str());
             }
             else
@@ -3713 +3713 @@
                            tr("The given password is incorrect"));
         else if (RT_FAILURE(vrc))
-            throw setError(VBOX_E_INVALID_OBJECT_STATE,
-                           tr("Failed to load the encryption filter: %s"),
-                           i_vdError(vrc).c_str());
+            throw setErrorBoth(VBOX_E_INVALID_OBJECT_STATE, vrc,
+                               tr("Failed to load the encryption filter: %s"),
+                               i_vdError(vrc).c_str());
 
         VDDestroy(pDisk);
@@ -6085 +6085 @@
         catch (int aVRC)
         {
-            rc = setError(E_FAIL,
-                          tr("Could not update medium UUID references to parent '%s' (%s)"),
-                          m->strLocationFull.c_str(),
-                          i_vdError(aVRC).c_str());
+            rc = setErrorBoth(E_FAIL, aVRC,
+                              tr("Could not update medium UUID references to parent '%s' (%s)"),
+                              m->strLocationFull.c_str(),
+                              i_vdError(aVRC).c_str());
         }
 
@@ -7425 +7425 @@
             {
                 if (vrc == VERR_ACCESS_DENIED)
-                    return setError(VBOX_E_FILE_ERROR,
-                                    tr("Permission problem accessing the file for the medium '%s' (%Rrc)"),
-                                    locationFull.c_str(), vrc);
+                    return setErrorBoth(VBOX_E_FILE_ERROR, vrc,
+                                        tr("Permission problem accessing the file for the medium '%s' (%Rrc)"),
+                                        locationFull.c_str(), vrc);
                 else if (vrc == VERR_FILE_NOT_FOUND || vrc == VERR_PATH_NOT_FOUND)
-                    return setError(VBOX_E_FILE_ERROR,
-                                    tr("Could not find file for the medium '%s' (%Rrc)"),
-                                    locationFull.c_str(), vrc);
+                    return setErrorBoth(VBOX_E_FILE_ERROR, vrc,
+                                        tr("Could not find file for the medium '%s' (%Rrc)"),
+                                        locationFull.c_str(), vrc);
                 else if (aFormat.isEmpty())
-                    return setError(VBOX_E_IPRT_ERROR,
-                                    tr("Could not get the storage format of the medium '%s' (%Rrc)"),
-                                    locationFull.c_str(), vrc);
+                    return setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
+                                        tr("Could not get the storage format of the medium '%s' (%Rrc)"),
+                                        locationFull.c_str(), vrc);
                 else
                 {
@@ -8046 +8046 @@
                     vrc = VDPluginLoadFromFilename(strPlugin.c_str());
                     if (RT_FAILURE(vrc))
-                        throw setError(VBOX_E_NOT_SUPPORTED,
-                                       tr("Retrieving encryption settings of the image failed because the encryption plugin could not be loaded (%s)"),
-                                       i_vdError(vrc).c_str());
+                        throw setErrorBoth(VBOX_E_NOT_SUPPORTED, vrc,
+                                           tr("Retrieving encryption settings of the image failed because the encryption plugin could not be loaded (%s)"),
+                                           i_vdError(vrc).c_str());
                 }
                 else
@@ -8087 +8087 @@
             pKeyStore->releaseSecretKey(itKeyId->second);
             if (vrc == VERR_VD_PASSWORD_INCORRECT)
-                throw setError(VBOX_E_PASSWORD_INCORRECT, tr("The password to decrypt the image is incorrect"));
+                throw setErrorBoth(VBOX_E_PASSWORD_INCORRECT, vrc, tr("The password to decrypt the image is incorrect"));
             if (RT_FAILURE(vrc))
-                throw setError(VBOX_E_INVALID_OBJECT_STATE, tr("Failed to load the decryption filter: %s"),
-                               i_vdError(vrc).c_str());
+                throw setErrorBoth(VBOX_E_INVALID_OBJECT_STATE, vrc, tr("Failed to load the decryption filter: %s"),
+                                   i_vdError(vrc).c_str());
         }
 
@@ -8117 +8117 @@
                          pMedium->m->vdImageIfaces);
             if (RT_FAILURE(vrc))
-                throw setError(VBOX_E_FILE_ERROR,
-                               tr("Could not open the medium storage unit '%s'%s"),
-                               pMedium->m->strLocationFull.c_str(),
-                               i_vdError(vrc).c_str());
+                throw setErrorBoth(VBOX_E_FILE_ERROR, vrc,
+                                   tr("Could not open the medium storage unit '%s'%s"),
+                                   pMedium->m->strLocationFull.c_str(),
+                                   i_vdError(vrc).c_str());
         }
 
@@ -8405 +8405 @@
                              pMedium->m->vdImageIfaces);
                 if (RT_FAILURE(vrc))
-                    throw setError(VBOX_E_FILE_ERROR,
-                                   tr("Could not open the medium storage unit '%s'%s"),
-                                   pMedium->m->strLocationFull.c_str(),
-                                   i_vdError(vrc).c_str());
+                    throw setErrorBoth(VBOX_E_FILE_ERROR, vrc,
+                                       tr("Could not open the medium storage unit '%s'%s"),
+                                       pMedium->m->strLocationFull.c_str(),
+                                       i_vdError(vrc).c_str());
             }
 
@@ -8434 +8434 @@
             {
                 if (vrc == VERR_VD_INVALID_TYPE)
-                    throw setError(VBOX_E_FILE_ERROR,
-                                   tr("Parameters for creating the differencing medium storage unit '%s' are invalid%s"),
-                                   targetLocation.c_str(), i_vdError(vrc).c_str());
+                    throw setErrorBoth(VBOX_E_FILE_ERROR, vrc,
+                                       tr("Parameters for creating the differencing medium storage unit '%s' are invalid%s"),
+                                       targetLocation.c_str(), i_vdError(vrc).c_str());
                 else
-                    throw setError(VBOX_E_FILE_ERROR,
-                                   tr("Could not create the differencing medium storage unit '%s'%s"),
-                                   targetLocation.c_str(), i_vdError(vrc).c_str());
+                    throw setErrorBoth(VBOX_E_FILE_ERROR, vrc,
+                                       tr("Could not create the differencing medium storage unit '%s'%s"),
+                                       targetLocation.c_str(), i_vdError(vrc).c_str());
             }
 
@@ -8687 +8687 @@
         catch (int aVRC)
         {
-            rcTmp = setError(VBOX_E_FILE_ERROR,
-                             tr("Could not merge the medium '%s' to '%s'%s"),
-                             m->strLocationFull.c_str(),
-                             pTarget->m->strLocationFull.c_str(),
-                             i_vdError(aVRC).c_str());
+            rcTmp = setErrorBoth(VBOX_E_FILE_ERROR, aVRC,
+                                 tr("Could not merge the medium '%s' to '%s'%s"),
+                                 m->strLocationFull.c_str(),
+                                 pTarget->m->strLocationFull.c_str(),
+                                 i_vdError(aVRC).c_str());
         }
 
@@ -8934 +8934 @@
                              pMedium->m->vdImageIfaces);
                 if (RT_FAILURE(vrc))
-                    throw setError(VBOX_E_FILE_ERROR,
-                                   tr("Could not open the medium storage unit '%s'%s"),
-                                   pMedium->m->strLocationFull.c_str(),
-                                   i_vdError(vrc).c_str());
+                    throw setErrorBoth(VBOX_E_FILE_ERROR, vrc,
+                                       tr("Could not open the medium storage unit '%s'%s"),
+                                       pMedium->m->strLocationFull.c_str(),
+                                       i_vdError(vrc).c_str());
             }
 
@@ -9004 +9004 @@
                                  pMedium->m->vdImageIfaces);
                     if (RT_FAILURE(vrc))
-                        throw setError(VBOX_E_FILE_ERROR,
-                                       tr("Could not open the medium storage unit '%s'%s"),
-                                       pMedium->m->strLocationFull.c_str(),
-                                       i_vdError(vrc).c_str());
+                        throw setErrorBoth(VBOX_E_FILE_ERROR, vrc,
+                                           tr("Could not open the medium storage unit '%s'%s"),
+                                           pMedium->m->strLocationFull.c_str(),
+                                           i_vdError(vrc).c_str());
                 }
 
@@ -9046 +9046 @@
                 }
                 if (RT_FAILURE(vrc))
-                    throw setError(VBOX_E_FILE_ERROR,
-                                   tr("Could not create the clone medium '%s'%s"),
-                                   targetLocation.c_str(), i_vdError(vrc).c_str());
+                    throw setErrorBoth(VBOX_E_FILE_ERROR, vrc,
+                                       tr("Could not create the clone medium '%s'%s"),
+                                       targetLocation.c_str(), i_vdError(vrc).c_str());
 
                 size = VDGetFileSize(targetHdd, VD_LAST_IMAGE);
@@ -9245 +9245 @@
                              pMedium->m->vdImageIfaces);
                 if (RT_FAILURE(vrc))
-                    throw setError(VBOX_E_FILE_ERROR,
-                                   tr("Could not open the medium storage unit '%s'%s"),
-                                   pMedium->m->strLocationFull.c_str(),
-                                   i_vdError(vrc).c_str());
+                    throw setErrorBoth(VBOX_E_FILE_ERROR, vrc,
+                                       tr("Could not open the medium storage unit '%s'%s"),
+                                       pMedium->m->strLocationFull.c_str(),
+                                       i_vdError(vrc).c_str());
             }
 
@@ -9291 +9291 @@
                              NULL);
                 if (RT_FAILURE(vrc))
-                    throw setError(VBOX_E_FILE_ERROR,
-                                   tr("Could not move medium '%s'%s"),
-                                   targetLocation.c_str(), i_vdError(vrc).c_str());
+                    throw setErrorBoth(VBOX_E_FILE_ERROR, vrc,
+                                       tr("Could not move medium '%s'%s"),
+                                       targetLocation.c_str(), i_vdError(vrc).c_str());
                 size = VDGetFileSize(hdd, VD_LAST_IMAGE);
                 logicalSize = VDGetSize(hdd, VD_LAST_IMAGE);
@@ -9383 +9383 @@
 
             if (RT_FAILURE(vrc) && vrc != VERR_FILE_NOT_FOUND)
-                throw setError(VBOX_E_FILE_ERROR,
-                               tr("Could not delete the medium storage unit '%s'%s"),
-                               location.c_str(), i_vdError(vrc).c_str());
+                throw setErrorBoth(VBOX_E_FILE_ERROR, vrc,
+                                   tr("Could not delete the medium storage unit '%s'%s"),
+                                   location.c_str(), i_vdError(vrc).c_str());
 
         }
@@ -9478 +9478 @@
                              pMedium->m->vdImageIfaces);
                 if (RT_FAILURE(vrc))
-                    throw setError(VBOX_E_FILE_ERROR,
-                                   tr("Could not open the medium storage unit '%s'%s"),
-                                   pMedium->m->strLocationFull.c_str(),
-                                   i_vdError(vrc).c_str());
+                    throw setErrorBoth(VBOX_E_FILE_ERROR, vrc,
+                                       tr("Could not open the medium storage unit '%s'%s"),
+                                       pMedium->m->strLocationFull.c_str(),
+                                       i_vdError(vrc).c_str());
 
                 /* Done when we hit the media which should be reset */
@@ -9491 +9491 @@
             vrc = VDClose(hdd, true /* fDelete */);
             if (RT_FAILURE(vrc))
-                throw setError(VBOX_E_FILE_ERROR,
-                               tr("Could not delete the medium storage unit '%s'%s"),
-                               location.c_str(), i_vdError(vrc).c_str());
+                throw setErrorBoth(VBOX_E_FILE_ERROR, vrc,
+                                   tr("Could not delete the medium storage unit '%s'%s"),
+                                   location.c_str(), i_vdError(vrc).c_str());
 
             /* next, create it again */
@@ -9502 +9502 @@
                          m->vdImageIfaces);
             if (RT_FAILURE(vrc))
-                throw setError(VBOX_E_FILE_ERROR,
-                               tr("Could not open the medium storage unit '%s'%s"),
-                               parentLocation.c_str(), i_vdError(vrc).c_str());
+                throw setErrorBoth(VBOX_E_FILE_ERROR, vrc,
+                                   tr("Could not open the medium storage unit '%s'%s"),
+                                   parentLocation.c_str(), i_vdError(vrc).c_str());
 
             vrc = VDCreateDiff(hdd,
@@ -9520 +9520 @@
             {
                 if (vrc == VERR_VD_INVALID_TYPE)
-                    throw setError(VBOX_E_FILE_ERROR,
-                                   tr("Parameters for creating the differencing medium storage unit '%s' are invalid%s"),
-                                   location.c_str(), i_vdError(vrc).c_str());
+                    throw setErrorBoth(VBOX_E_FILE_ERROR, vrc,
+                                       tr("Parameters for creating the differencing medium storage unit '%s' are invalid%s"),
+                                       location.c_str(), i_vdError(vrc).c_str());
                 else
-                    throw setError(VBOX_E_FILE_ERROR,
-                                   tr("Could not create the differencing medium storage unit '%s'%s"),
-                                   location.c_str(), i_vdError(vrc).c_str());
+                    throw setErrorBoth(VBOX_E_FILE_ERROR, vrc,
+                                       tr("Could not create the differencing medium storage unit '%s'%s"),
+                                       location.c_str(), i_vdError(vrc).c_str());
             }
 
@@ -9608 +9608 @@
                              pMedium->m->vdImageIfaces);
                 if (RT_FAILURE(vrc))
-                    throw setError(VBOX_E_FILE_ERROR,
-                                   tr("Could not open the medium storage unit '%s'%s"),
-                                   pMedium->m->strLocationFull.c_str(),
-                                   i_vdError(vrc).c_str());
+                    throw setErrorBoth(VBOX_E_FILE_ERROR, vrc,
+                                       tr("Could not open the medium storage unit '%s'%s"),
+                                       pMedium->m->strLocationFull.c_str(),
+                                       i_vdError(vrc).c_str());
             }
 
@@ -9625 +9625 @@
             {
                 if (vrc == VERR_NOT_SUPPORTED)
-                    throw setError(VBOX_E_NOT_SUPPORTED,
-                                   tr("Compacting is not yet supported for medium '%s'"),
-                                   location.c_str());
+                    throw setErrorBoth(VBOX_E_NOT_SUPPORTED, vrc,
+                                       tr("Compacting is not yet supported for medium '%s'"),
+                                       location.c_str());
                 else if (vrc == VERR_NOT_IMPLEMENTED)
-                    throw setError(E_NOTIMPL,
-                                   tr("Compacting is not implemented, medium '%s'"),
-                                   location.c_str());
+                    throw setErrorBoth(E_NOTIMPL, vrc,
+                                       tr("Compacting is not implemented, medium '%s'"),
+                                       location.c_str());
                 else
-                    throw setError(VBOX_E_FILE_ERROR,
-                                   tr("Could not compact medium '%s'%s"),
-                                   location.c_str(),
-                                   i_vdError(vrc).c_str());
+                    throw setErrorBoth(VBOX_E_FILE_ERROR, vrc,
+                                       tr("Could not compact medium '%s'%s"),
+                                       location.c_str(),
+                                       i_vdError(vrc).c_str());
             }
         }
@@ -9706 +9706 @@
                              pMedium->m->vdImageIfaces);
                 if (RT_FAILURE(vrc))
-                    throw setError(VBOX_E_FILE_ERROR,
-                                   tr("Could not open the medium storage unit '%s'%s"),
-                                   pMedium->m->strLocationFull.c_str(),
-                                   i_vdError(vrc).c_str());
+                    throw setErrorBoth(VBOX_E_FILE_ERROR, vrc,
+                                       tr("Could not open the medium storage unit '%s'%s"),
+                                       pMedium->m->strLocationFull.c_str(),
+                                       i_vdError(vrc).c_str());
             }
 
@@ -9724 +9724 @@
             {
                 if (vrc == VERR_NOT_SUPPORTED)
-                    throw setError(VBOX_E_NOT_SUPPORTED,
-                                   tr("Resizing to new size %llu is not yet supported for medium '%s'"),
-                                   task.mSize, location.c_str());
+                    throw setErrorBoth(VBOX_E_NOT_SUPPORTED, vrc,
+                                       tr("Resizing to new size %llu is not yet supported for medium '%s'"),
+                                       task.mSize, location.c_str());
                 else if (vrc == VERR_NOT_IMPLEMENTED)
-                    throw setError(E_NOTIMPL,
-                                   tr("Resiting is not implemented, medium '%s'"),
-                                   location.c_str());
+                    throw setErrorBoth(E_NOTIMPL, vrc,
+                                       tr("Resiting is not implemented, medium '%s'"),
+                                       location.c_str());
                 else
-                    throw setError(VBOX_E_FILE_ERROR,
-                                   tr("Could not resize medium '%s'%s"),
-                                   location.c_str(),
-                                   i_vdError(vrc).c_str());
+                    throw setErrorBoth(VBOX_E_FILE_ERROR, vrc,
+                                       tr("Could not resize medium '%s'%s"),
+                                       location.c_str(),
+                                       i_vdError(vrc).c_str());
             }
             size = VDGetFileSize(hdd, VD_LAST_IMAGE);
@@ -9828 +9828 @@
                          task.mVDImageIfaces);
             if (RT_FAILURE(vrc))
-                throw setError(VBOX_E_FILE_ERROR,
-                               tr("Could not open the medium storage unit '%s'%s"),
-                               task.mFilename.c_str(),
-                               i_vdError(vrc).c_str());
+                throw setErrorBoth(VBOX_E_FILE_ERROR, vrc,
+                                   tr("Could not open the medium storage unit '%s'%s"),
+                                   task.mFilename.c_str(),
+                                   i_vdError(vrc).c_str());
 
             Utf8Str targetFormat(m->strFormat);
@@ -9896 +9896 @@
                                  pMedium->m->vdImageIfaces);
                     if (RT_FAILURE(vrc))
-                        throw setError(VBOX_E_FILE_ERROR,
-                                       tr("Could not open the medium storage unit '%s'%s"),
-                                       pMedium->m->strLocationFull.c_str(),
-                                       i_vdError(vrc).c_str());
+                        throw setErrorBoth(VBOX_E_FILE_ERROR, vrc,
+                                           tr("Could not open the medium storage unit '%s'%s"),
+                                           pMedium->m->strLocationFull.c_str(),
+                                           i_vdError(vrc).c_str());
                 }
 
@@ -9916 +9916 @@
                              task.mVDOperationIfaces);
                 if (RT_FAILURE(vrc))
-                    throw setError(VBOX_E_FILE_ERROR,
-                                   tr("Could not create the imported medium '%s'%s"),
-                                   targetLocation.c_str(), i_vdError(vrc).c_str());
+                    throw setErrorBoth(VBOX_E_FILE_ERROR, vrc,
+                                       tr("Could not create the imported medium '%s'%s"),
+                                       targetLocation.c_str(), i_vdError(vrc).c_str());
 
                 size = VDGetFileSize(targetHdd, VD_LAST_IMAGE);
@@ -10094 +10094 @@
                 int vrc = VDPluginLoadFromFilename(strPlugin.c_str());
                 if (RT_FAILURE(vrc))
-                    throw setError(VBOX_E_NOT_SUPPORTED,
-                                   tr("Encrypting the image failed because the encryption plugin could not be loaded (%s)"),
-                                   i_vdError(vrc).c_str());
+                    throw setErrorBoth(VBOX_E_NOT_SUPPORTED, vrc,
+                                       tr("Encrypting the image failed because the encryption plugin could not be loaded (%s)"),
+                                       i_vdError(vrc).c_str());
             }
             else
@@ -10172 +10172 @@
                 vrc = VDFilterAdd(pDisk, "CRYPT", VD_FILTER_FLAGS_WRITE, CryptoSettingsWrite.vdFilterIfaces);
                 if (RT_FAILURE(vrc))
-                    throw setError(VBOX_E_INVALID_OBJECT_STATE,
-                                   tr("Failed to load the encryption filter: %s"),
-                                   i_vdError(vrc).c_str());
+                    throw setErrorBoth(VBOX_E_INVALID_OBJECT_STATE, vrc,
+                                       tr("Failed to load the encryption filter: %s"),
+                                       i_vdError(vrc).c_str());
             }
             else if (task.mstrNewPasswordId.isNotEmpty() || task.mstrNewPassword.isNotEmpty())
@@ -10207 +10207 @@
                              pMedium->m->vdImageIfaces);
                 if (RT_FAILURE(vrc))
-                    throw setError(VBOX_E_FILE_ERROR,
-                                   tr("Could not open the medium storage unit '%s'%s"),
-                                   pMedium->m->strLocationFull.c_str(),
-                                   i_vdError(vrc).c_str());
+                    throw setErrorBoth(VBOX_E_FILE_ERROR, vrc,
+                                       tr("Could not open the medium storage unit '%s'%s"),
+                                       pMedium->m->strLocationFull.c_str(),
+                                       i_vdError(vrc).c_str());
             }
 
@@ -10222 +10222 @@
             vrc = VDPrepareWithFilters(pDisk, task.mVDOperationIfaces);
             if (RT_FAILURE(vrc))
-                throw setError(VBOX_E_FILE_ERROR,
-                               tr("Could not prepare disk images for encryption (%Rrc): %s"),
-                               vrc, i_vdError(vrc).c_str());
+                throw setErrorBoth(VBOX_E_FILE_ERROR, vrc,
+                                   tr("Could not prepare disk images for encryption (%Rrc): %s"),
+                                   vrc, i_vdError(vrc).c_str());
 
             thisLock.acquire();

trunk/src/VBox/Main/src-server/SystemPropertiesImpl.cpp

@@ -1171 +1171 @@
     int vrc = RTPathUserHome(szHome, sizeof(szHome));
     if (RT_FAILURE(vrc))
-        return setError(E_FAIL,
-                        tr("Cannot determine user home directory (%Rrc)"),
-                        vrc);
+        return setErrorBoth(E_FAIL, vrc,
+                            tr("Cannot determine user home directory (%Rrc)"),
+                            vrc);
     strPath = szHome;
     return S_OK;
@@ -1287 +1287 @@
             m->strAutostartDatabasePath = aPath;
         else
-            rc = setError(E_FAIL,
-                          tr("Cannot set the autostart database path (%Rrc)"),
-                          vrc);
+            rc = setErrorBoth(E_FAIL, vrc,
+                              tr("Cannot set the autostart database path (%Rrc)"),
+                              vrc);
     }
     else
@@ -1297 +1297 @@
             m->strAutostartDatabasePath = "";
         else
-            rc = setError(E_FAIL,
-                          tr("Deleting the autostart database path failed (%Rrc)"),
-                          vrc);
+            rc = setErrorBoth(E_FAIL, vrc,
+                              tr("Deleting the autostart database path failed (%Rrc)"),
+                              vrc);
     }
 

trunk/src/VBox/Main/src-server/USBProxyService.cpp

@@ -949 +949 @@
     va_start(va, aText);
     HRESULT rc = VirtualBoxBase::setErrorInternal(aResultCode,
-                                                    COM_IIDOF(IHost),
-                                                    "USBProxyService",
-                                                    Utf8Str(aText, va),
-                                                    false /* aWarning*/,
-                                                    true /* aLogIt*/);
+                                                  COM_IIDOF(IHost),
+                                                  "USBProxyService",
+                                                  Utf8Str(aText, va),
+                                                  false /* aWarning*/,
+                                                  true /* aLogIt*/);
     va_end(va);
     return rc;

trunk/src/VBox/Main/src-server/VFSExplorerImpl.cpp

@@ -319 +319 @@
     }
     else
-        rc = setError(VBOX_E_FILE_ERROR, tr ("Can't open directory '%s' (%Rrc)"), m->strPath.c_str(), vrc);
+        rc = setErrorBoth(VBOX_E_FILE_ERROR, vrc, tr ("Can't open directory '%s' (%Rrc)"), m->strPath.c_str(), vrc);
 
     if (aTask->m_ptrProgress)
@@ -362 +362 @@
             int vrc = RTPathJoin(szPath, sizeof(szPath), m->strPath.c_str(), (*it).c_str());
             if (RT_FAILURE(vrc))
-                throw setError(E_FAIL, tr("Internal Error (%Rrc)"), vrc);
+                throw setErrorBoth(E_FAIL, vrc, tr("Internal Error (%Rrc)"), vrc);
             vrc = RTFileDelete(szPath);
             if (RT_FAILURE(vrc))
-                throw setError(VBOX_E_FILE_ERROR, tr("Can't delete file '%s' (%Rrc)"), szPath, vrc);
+                throw setErrorBoth(VBOX_E_FILE_ERROR, vrc, tr("Can't delete file '%s' (%Rrc)"), szPath, vrc);
             if (aTask->m_ptrProgress)
                 aTask->m_ptrProgress->SetCurrentOperationProgress((ULONG)(fPercentStep * (float)i));

trunk/src/VBox/Main/src-server/VirtualBoxImpl.cpp

@@ -401 +401 @@
             int vrc = com::GetVBoxUserHomeDirectory(szHomeDir, sizeof(szHomeDir));
             if (RT_FAILURE(vrc))
-                throw setError(E_FAIL,
-                               tr("Could not create the VirtualBox home directory '%s' (%Rrc)"),
-                               szHomeDir, vrc);
+                throw setErrorBoth(E_FAIL, vrc,
+                                   tr("Could not create the VirtualBox home directory '%s' (%Rrc)"),
+                                   szHomeDir, vrc);
 
             unconst(m->strHomeDir) = szHomeDir;
@@ -2628 +2628 @@
         if (RT_FAILURE(vrc))
         {
-            rc = pTask->that->setError(E_FAIL, tr("Could not create the communication channel (%Rrc)"), vrc);
+            rc = pTask->that->setErrorBoth(E_FAIL, vrc, tr("Could not create the communication channel (%Rrc)"), vrc);
             break;
         }
@@ -2673 +2673 @@
                  * (pressing the Cancel button to close the Run As dialog) */
                 if (vrc2 == VERR_CANCELLED)
-                    rc = pTask->that->setError(E_FAIL, tr("Operation canceled by the user"));
+                    rc = pTask->that->setErrorBoth(E_FAIL, vrc, tr("Operation canceled by the user"));
                 else
-                    rc = pTask->that->setError(E_FAIL, tr("Could not launch a privileged process '%s' (%Rrc)"), exePath, vrc2);
+                    rc = pTask->that->setErrorBoth(E_FAIL, vrc, tr("Could not launch a privileged process '%s' (%Rrc)"), exePath, vrc2);
                 break;
             }
@@ -2685 +2685 @@
             if (RT_FAILURE(vrc))
             {
-                rc = pTask->that->setError(E_FAIL, tr("Could not launch a process '%s' (%Rrc)"), exePath, vrc);
+                rc = pTask->that->setErrorBoth(E_FAIL, vrc, tr("Could not launch a process '%s' (%Rrc)"), exePath, vrc);
                 break;
             }
@@ -2708 +2708 @@
         if (SUCCEEDED(rc) && RT_FAILURE(vrc))
         {
-            rc = pTask->that->setError(E_FAIL, tr("Could not operate the communication channel (%Rrc)"), vrc);
+            rc = pTask->that->setErrorBoth(E_FAIL, vrc, tr("Could not operate the communication channel (%Rrc)"), vrc);
             break;
         }
@@ -4856 +4856 @@
             int vrc = RTDirCreateFullPath(strDir.c_str(), 0700);
             if (RT_FAILURE(vrc))
-                return i_setErrorStatic(VBOX_E_IPRT_ERROR,
-                                        Utf8StrFmt(tr("Could not create the directory '%s' (%Rrc)"),
-                                                   strDir.c_str(),
-                                                   vrc));
+                return i_setErrorStaticBoth(VBOX_E_IPRT_ERROR, vrc,
+                                            Utf8StrFmt(tr("Could not create the directory '%s' (%Rrc)"),
+                                                       strDir.c_str(),
+                                                       vrc));
         }
         else
-            return i_setErrorStatic(VBOX_E_IPRT_ERROR,
-                                    Utf8StrFmt(tr("Directory '%s' does not exist"),
-                                               strDir.c_str()));
+            return i_setErrorStaticBoth(VBOX_E_IPRT_ERROR, VERR_FILE_NOT_FOUND,
+                                        Utf8StrFmt(tr("Directory '%s' does not exist"), strDir.c_str()));
     }