- Timestamp:
- Jan 24, 2023 12:39:34 PM (21 months ago)
- File:
-
- 1 edited
Legend:
- Unmodified
- Added
- Removed
-
trunk/src/VBox/Main/src-server/VirtualBoxImpl.cpp
r98264 r98285 482 482 BaseFinalConstruct(); 483 483 484 HRESULT rc = init();484 HRESULT hrc = init(); 485 485 486 486 LogRelFlowThisFuncLeave(); 487 487 LogRel(("VirtualBox: object created\n")); 488 488 489 return rc;489 return hrc; 490 490 } 491 491 … … 556 556 * unhelpful ones which cause us a lot of grief with troubleshooting. */ 557 557 558 HRESULT rc = S_OK;558 HRESULT hrc = S_OK; 559 559 bool fCreate = false; 560 560 try 561 561 { 562 562 /* Create the event source early as we may fire async event during settings loading (media). */ 563 rc = unconst(m->pEventSource).createObject();564 if (FAILED( rc)) throwrc;565 rc = m->pEventSource->init();566 if (FAILED( rc)) throwrc;563 hrc = unconst(m->pEventSource).createObject(); 564 if (FAILED(hrc)) throw hrc; 565 hrc = m->pEventSource->init(); 566 if (FAILED(hrc)) throw hrc; 567 567 568 568 … … 620 620 /* create the performance collector object BEFORE host */ 621 621 unconst(m->pPerformanceCollector).createObject(); 622 rc = m->pPerformanceCollector->init();623 ComAssertComRCThrowRC( rc);622 hrc = m->pPerformanceCollector->init(); 623 ComAssertComRCThrowRC(hrc); 624 624 #endif /* VBOX_WITH_RESOURCE_USAGE_API */ 625 625 626 626 /* create the host object early, machines will need it */ 627 627 unconst(m->pHost).createObject(); 628 rc = m->pHost->init(this);629 ComAssertComRCThrowRC( rc);630 631 rc = m->pHost->i_loadSettings(m->pMainConfigFile->host);632 if (FAILED( rc)) throwrc;628 hrc = m->pHost->init(this); 629 ComAssertComRCThrowRC(hrc); 630 631 hrc = m->pHost->i_loadSettings(m->pMainConfigFile->host); 632 if (FAILED(hrc)) throw hrc; 633 633 634 634 /* … … 639 639 640 640 /* create the system properties object, someone may need it too */ 641 rc = unconst(m->pSystemProperties).createObject();642 if (SUCCEEDED( rc))643 rc = m->pSystemProperties->init(this);644 ComAssertComRCThrowRC( rc);645 646 rc = m->pSystemProperties->i_loadSettings(m->pMainConfigFile->systemProperties);647 if (FAILED( rc)) throwrc;641 hrc = unconst(m->pSystemProperties).createObject(); 642 if (SUCCEEDED(hrc)) 643 hrc = m->pSystemProperties->init(this); 644 ComAssertComRCThrowRC(hrc); 645 646 hrc = m->pSystemProperties->i_loadSettings(m->pMainConfigFile->systemProperties); 647 if (FAILED(hrc)) throw hrc; 648 648 #ifdef VBOX_WITH_MAIN_NLS 649 649 m->pVBoxTranslator = VirtualBoxTranslator::instance(); … … 664 664 { 665 665 com::Utf8Str strLocale; 666 HRESULT hrc = m->pSystemProperties->getLanguageId(strLocale);667 if (SUCCEEDED(hrc ))666 HRESULT hrc2 = m->pSystemProperties->getLanguageId(strLocale); 667 if (SUCCEEDED(hrc2)) 668 668 { 669 669 vrc = m->pVBoxTranslator->i_loadLanguage(strLocale.c_str()); 670 670 if (RT_FAILURE(vrc)) 671 671 { 672 hrc = Global::vboxStatusCodeToCOM(vrc);673 LogRel(("Load language failed (%Rhrc).\n", hrc ));672 hrc2 = Global::vboxStatusCodeToCOM(vrc); 673 LogRel(("Load language failed (%Rhrc).\n", hrc2)); 674 674 } 675 675 } 676 676 else 677 677 { 678 LogRel(("Getting language settings failed (%Rhrc).\n", hrc ));678 LogRel(("Getting language settings failed (%Rhrc).\n", hrc2)); 679 679 m->pVBoxTranslator->release(); 680 680 m->pVBoxTranslator = NULL; … … 684 684 else 685 685 { 686 HRESULT hrc = Global::vboxStatusCodeToCOM(vrc);687 LogRel(("Register translation failed (%Rhrc).\n", hrc ));686 HRESULT hrc2 = Global::vboxStatusCodeToCOM(vrc); 687 LogRel(("Register translation failed (%Rhrc).\n", hrc2)); 688 688 m->pVBoxTranslator->release(); 689 689 m->pVBoxTranslator = NULL; … … 693 693 else 694 694 { 695 HRESULT hrc = Global::vboxStatusCodeToCOM(vrc);696 LogRel(("Path constructing failed (%Rhrc).\n", hrc ));695 HRESULT hrc2 = Global::vboxStatusCodeToCOM(vrc); 696 LogRel(("Path constructing failed (%Rhrc).\n", hrc2)); 697 697 m->pVBoxTranslator->release(); 698 698 m->pVBoxTranslator = NULL; … … 709 709 * it is required for the VD plugins. 710 710 */ 711 rc = unconst(m->ptrExtPackManager).createObject();712 if (SUCCEEDED( rc))713 rc = m->ptrExtPackManager->initExtPackManager(this, VBOXEXTPACKCTX_PER_USER_DAEMON);714 if (FAILED( rc))715 throw rc;711 hrc = unconst(m->ptrExtPackManager).createObject(); 712 if (SUCCEEDED(hrc)) 713 hrc = m->ptrExtPackManager->initExtPackManager(this, VBOXEXTPACKCTX_PER_USER_DAEMON); 714 if (FAILED(hrc)) 715 throw hrc; 716 716 #endif 717 717 /* guest OS type objects, needed by machines */ … … 719 719 { 720 720 ComObjPtr<GuestOSType> guestOSTypeObj; 721 rc = guestOSTypeObj.createObject();722 if (SUCCEEDED( rc))721 hrc = guestOSTypeObj.createObject(); 722 if (SUCCEEDED(hrc)) 723 723 { 724 rc = guestOSTypeObj->init(Global::sOSTypes[i]);725 if (SUCCEEDED( rc))724 hrc = guestOSTypeObj->init(Global::sOSTypes[i]); 725 if (SUCCEEDED(hrc)) 726 726 m->allGuestOSTypes.addChild(guestOSTypeObj); 727 727 } 728 ComAssertComRCThrowRC( rc);728 ComAssertComRCThrowRC(hrc); 729 729 } 730 730 731 731 /* all registered media, needed by machines */ 732 if (FAILED( rc = initMedia(m->uuidMediaRegistry,732 if (FAILED(hrc = initMedia(m->uuidMediaRegistry, 733 733 m->pMainConfigFile->mediaRegistry, 734 734 Utf8Str::Empty))) // const Utf8Str &machineFolder 735 throw rc;735 throw hrc; 736 736 737 737 /* machines */ 738 if (FAILED( rc = initMachines()))739 throw rc;738 if (FAILED(hrc = initMachines())) 739 throw hrc; 740 740 741 741 #ifdef DEBUG … … 752 752 753 753 ComObjPtr<DHCPServer> pDhcpServer; 754 if (SUCCEEDED( rc = pDhcpServer.createObject()))755 rc = pDhcpServer->init(this, data);756 if (FAILED( rc)) throwrc;757 758 rc = i_registerDHCPServer(pDhcpServer, false /* aSaveRegistry */);759 if (FAILED( rc)) throwrc;754 if (SUCCEEDED(hrc = pDhcpServer.createObject())) 755 hrc = pDhcpServer->init(this, data); 756 if (FAILED(hrc)) throw hrc; 757 758 hrc = i_registerDHCPServer(pDhcpServer, false /* aSaveRegistry */); 759 if (FAILED(hrc)) throw hrc; 760 760 } 761 761 … … 768 768 769 769 ComObjPtr<NATNetwork> pNATNetwork; 770 rc = pNATNetwork.createObject();771 AssertComRCThrowRC( rc);772 rc = pNATNetwork->init(this, "");773 AssertComRCThrowRC( rc);774 rc = pNATNetwork->i_loadSettings(net);775 AssertComRCThrowRC( rc);776 rc = i_registerNATNetwork(pNATNetwork, false /* aSaveRegistry */);777 AssertComRCThrowRC( rc);770 hrc = pNATNetwork.createObject(); 771 AssertComRCThrowRC(hrc); 772 hrc = pNATNetwork->init(this, ""); 773 AssertComRCThrowRC(hrc); 774 hrc = pNATNetwork->i_loadSettings(net); 775 AssertComRCThrowRC(hrc); 776 hrc = i_registerNATNetwork(pNATNetwork, false /* aSaveRegistry */); 777 AssertComRCThrowRC(hrc); 778 778 } 779 779 … … 785 785 { 786 786 ComObjPtr<HostOnlyNetwork> pHostOnlyNetwork; 787 rc = pHostOnlyNetwork.createObject();788 AssertComRCThrowRC( rc);789 rc = pHostOnlyNetwork->init(this, "TODO???");790 AssertComRCThrowRC( rc);791 rc = pHostOnlyNetwork->i_loadSettings(*it);792 AssertComRCThrowRC( rc);787 hrc = pHostOnlyNetwork.createObject(); 788 AssertComRCThrowRC(hrc); 789 hrc = pHostOnlyNetwork->init(this, "TODO???"); 790 AssertComRCThrowRC(hrc); 791 hrc = pHostOnlyNetwork->i_loadSettings(*it); 792 AssertComRCThrowRC(hrc); 793 793 m->allHostOnlyNetworks.addChild(pHostOnlyNetwork); 794 AssertComRCThrowRC( rc);794 AssertComRCThrowRC(hrc); 795 795 } 796 796 #endif /* VBOX_WITH_VMNET */ … … 803 803 { 804 804 ComObjPtr<CloudNetwork> pCloudNetwork; 805 rc = pCloudNetwork.createObject();806 AssertComRCThrowRC( rc);807 rc = pCloudNetwork->init(this, "");808 AssertComRCThrowRC( rc);809 rc = pCloudNetwork->i_loadSettings(*it);810 AssertComRCThrowRC( rc);805 hrc = pCloudNetwork.createObject(); 806 AssertComRCThrowRC(hrc); 807 hrc = pCloudNetwork->init(this, ""); 808 AssertComRCThrowRC(hrc); 809 hrc = pCloudNetwork->i_loadSettings(*it); 810 AssertComRCThrowRC(hrc); 811 811 m->allCloudNetworks.addChild(pCloudNetwork); 812 AssertComRCThrowRC( rc);812 AssertComRCThrowRC(hrc); 813 813 } 814 814 #endif /* VBOX_WITH_CLOUD_NET */ 815 815 816 816 /* cloud provider manager */ 817 rc = unconst(m->pCloudProviderManager).createObject();818 if (SUCCEEDED( rc))819 rc = m->pCloudProviderManager->init(this);820 ComAssertComRCThrowRC( rc);821 if (FAILED( rc)) throwrc;817 hrc = unconst(m->pCloudProviderManager).createObject(); 818 if (SUCCEEDED(hrc)) 819 hrc = m->pCloudProviderManager->init(this); 820 ComAssertComRCThrowRC(hrc); 821 if (FAILED(hrc)) throw hrc; 822 822 } 823 823 catch (HRESULT err) 824 824 { 825 825 /* we assume that error info is set by the thrower */ 826 rc = err;826 hrc = err; 827 827 } 828 828 catch (...) 829 829 { 830 rc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);831 } 832 833 if (SUCCEEDED( rc))830 hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS); 831 } 832 833 if (SUCCEEDED(hrc)) 834 834 { 835 835 /* set up client monitoring */ … … 841 841 delete m->pClientWatcher; 842 842 unconst(m->pClientWatcher) = NULL; 843 rc = E_FAIL;843 hrc = E_FAIL; 844 844 } 845 845 } 846 846 catch (std::bad_alloc &) 847 847 { 848 rc = E_OUTOFMEMORY;849 } 850 } 851 852 if (SUCCEEDED( rc))848 hrc = E_OUTOFMEMORY; 849 } 850 } 851 852 if (SUCCEEDED(hrc)) 853 853 { 854 854 try … … 870 870 catch (HRESULT aRC) 871 871 { 872 rc = aRC;872 hrc = aRC; 873 873 } 874 874 } … … 876 876 #ifdef VBOX_WITH_EXTPACK 877 877 /* Let the extension packs have a go at things. */ 878 if (SUCCEEDED( rc))878 if (SUCCEEDED(hrc)) 879 879 { 880 880 lock.release(); … … 885 885 /* Confirm a successful initialization when it's the case. Must be last, 886 886 * as on failure it will uninitialize the object. */ 887 if (SUCCEEDED( rc))887 if (SUCCEEDED(hrc)) 888 888 autoInitSpan.setSucceeded(); 889 889 else 890 autoInitSpan.setFailed( rc);891 892 LogFlowThisFunc((" rc=%Rhrc\n",rc));890 autoInitSpan.setFailed(hrc); 891 892 LogFlowThisFunc(("hrc=%Rhrc\n", hrc)); 893 893 LogFlowThisFuncLeave(); 894 894 LogFlow(("===========================================================\n")); … … 904 904 ++it) 905 905 { 906 HRESULT rc = S_OK;906 HRESULT hrc = S_OK; 907 907 const settings::MachineRegistryEntry &xmlMachine = *it; 908 908 Guid uuid = xmlMachine.uuid; … … 917 917 ComObjPtr<Machine> pMachine; 918 918 com::Utf8Str strPassword; 919 if (SUCCEEDED(rc = pMachine.createObject())) 920 { 921 rc = pMachine->initFromSettings(this, 922 xmlMachine.strSettingsFile, 923 &uuid, 924 strPassword); 925 if (SUCCEEDED(rc)) 926 rc = i_registerMachine(pMachine); 927 if (FAILED(rc)) 928 return rc; 919 if (SUCCEEDED(hrc = pMachine.createObject())) 920 { 921 hrc = pMachine->initFromSettings(this, xmlMachine.strSettingsFile, &uuid, strPassword); 922 if (SUCCEEDED(hrc)) 923 hrc = i_registerMachine(pMachine); 924 if (FAILED(hrc)) 925 return hrc; 929 926 } 930 927 } … … 969 966 std::list<std::pair<Guid, DeviceType_T> > uIdsForNotify; 970 967 971 HRESULT rc = S_OK;968 HRESULT hrc = S_OK; 972 969 settings::MediaList::const_iterator it; 973 970 for (it = mediaRegistry.llHardDisks.begin(); … … 977 974 const settings::Medium &xmlHD = *it; 978 975 979 rc = Medium::initFromSettings(this,980 DeviceType_HardDisk,981 uuidRegistry,982 strMachineFolder,983 xmlHD,984 treeLock,985 uIdsForNotify);986 if (FAILED( rc)) returnrc;976 hrc = Medium::initFromSettings(this, 977 DeviceType_HardDisk, 978 uuidRegistry, 979 strMachineFolder, 980 xmlHD, 981 treeLock, 982 uIdsForNotify); 983 if (FAILED(hrc)) return hrc; 987 984 } 988 985 … … 993 990 const settings::Medium &xmlDvd = *it; 994 991 995 rc = Medium::initFromSettings(this,996 DeviceType_DVD,997 uuidRegistry,998 strMachineFolder,999 xmlDvd,1000 treeLock,1001 uIdsForNotify);1002 if (FAILED( rc)) returnrc;992 hrc = Medium::initFromSettings(this, 993 DeviceType_DVD, 994 uuidRegistry, 995 strMachineFolder, 996 xmlDvd, 997 treeLock, 998 uIdsForNotify); 999 if (FAILED(hrc)) return hrc; 1003 1000 } 1004 1001 … … 1009 1006 const settings::Medium &xmlFloppy = *it; 1010 1007 1011 rc = Medium::initFromSettings(this,1012 DeviceType_Floppy,1013 uuidRegistry,1014 strMachineFolder,1015 xmlFloppy,1016 treeLock,1017 uIdsForNotify);1018 if (FAILED( rc)) returnrc;1008 hrc = Medium::initFromSettings(this, 1009 DeviceType_Floppy, 1010 uuidRegistry, 1011 strMachineFolder, 1012 xmlFloppy, 1013 treeLock, 1014 uIdsForNotify); 1015 if (FAILED(hrc)) return hrc; 1019 1016 } 1020 1017 … … 1449 1446 ComObjPtr<HostOnlyNetwork> HostOnlyNetwork; 1450 1447 HostOnlyNetwork.createObject(); 1451 HRESULT rc = HostOnlyNetwork->init(this, aNetworkName);1452 if (FAILED( rc)) returnrc;1448 HRESULT hrc = HostOnlyNetwork->init(this, aNetworkName); 1449 if (FAILED(hrc)) return hrc; 1453 1450 1454 1451 m->allHostOnlyNetworks.addChild(HostOnlyNetwork); … … 1456 1453 { 1457 1454 AutoWriteLock vboxLock(this COMMA_LOCKVAL_SRC_POS); 1458 rc = i_saveSettings();1455 hrc = i_saveSettings(); 1459 1456 vboxLock.release(); 1460 1457 1461 if (FAILED( rc))1458 if (FAILED(hrc)) 1462 1459 m->allHostOnlyNetworks.removeChild(HostOnlyNetwork); 1463 1460 else … … 1465 1462 } 1466 1463 1467 return rc;1464 return hrc; 1468 1465 #else /* !VBOX_WITH_VMNET */ 1469 1466 NOREF(aNetworkName); … … 1536 1533 #ifdef VBOX_WITH_VMNET 1537 1534 Bstr name; 1538 HRESULT rc = aNetwork->COMGETTER(NetworkName)(name.asOutParam());1539 if (FAILED( rc))1540 return rc;1535 HRESULT hrc = aNetwork->COMGETTER(NetworkName)(name.asOutParam()); 1536 if (FAILED(hrc)) 1537 return hrc; 1541 1538 IHostOnlyNetwork *p = aNetwork; 1542 1539 HostOnlyNetwork *network = static_cast<HostOnlyNetwork *>(p); … … 1552 1549 { 1553 1550 AutoWriteLock vboxLock(this COMMA_LOCKVAL_SRC_POS); 1554 rc = i_saveSettings();1551 hrc = i_saveSettings(); 1555 1552 vboxLock.release(); 1556 1553 1557 if (FAILED( rc))1554 if (FAILED(hrc)) 1558 1555 m->allHostOnlyNetworks.addChild(network); 1559 1556 } 1560 return rc;1557 return hrc; 1561 1558 #else /* !VBOX_WITH_VMNET */ 1562 1559 NOREF(aNetwork); … … 1607 1604 { 1608 1605 ComPtr<INetworkAdapter> pNet; 1609 HRESULT rc = pMachine->GetNetworkAdapter(i, pNet.asOutParam());1610 if (FAILED( rc) || pNet.isNull())1606 HRESULT hrc = pMachine->GetNetworkAdapter(i, pNet.asOutParam()); 1607 if (FAILED(hrc) || pNet.isNull()) 1611 1608 continue; 1612 1609 Bstr strInternalNetwork; 1613 rc = pNet->COMGETTER(InternalNetwork)(strInternalNetwork.asOutParam());1614 if (FAILED( rc) || strInternalNetwork.isEmpty())1610 hrc = pNet->COMGETTER(InternalNetwork)(strInternalNetwork.asOutParam()); 1611 if (FAILED(hrc) || strInternalNetwork.isEmpty()) 1615 1612 continue; 1616 1613 … … 1658 1655 { 1659 1656 ComPtr<INetworkAdapter> pNet; 1660 HRESULT rc = pMachine->GetNetworkAdapter(i, pNet.asOutParam());1661 if (FAILED( rc) || pNet.isNull())1657 HRESULT hrc = pMachine->GetNetworkAdapter(i, pNet.asOutParam()); 1658 if (FAILED(hrc) || pNet.isNull()) 1662 1659 continue; 1663 1660 Bstr strGenericNetworkDriver; 1664 rc = pNet->COMGETTER(GenericDriver)(strGenericNetworkDriver.asOutParam());1665 if (FAILED( rc) || strGenericNetworkDriver.isEmpty())1661 hrc = pNet->COMGETTER(GenericDriver)(strGenericNetworkDriver.asOutParam()); 1662 if (FAILED(hrc) || strGenericNetworkDriver.isEmpty()) 1666 1663 continue; 1667 1664 … … 1690 1687 ComObjPtr<CloudNetwork> *aNetwork) 1691 1688 { 1692 HRESULT rc = VBOX_E_OBJECT_NOT_FOUND;1693 1689 ComPtr<CloudNetwork> found; 1694 1690 Bstr bstrNameToFind(aNetworkName); … … 1707 1703 { 1708 1704 *aNetwork = *it; 1709 rc = S_OK; 1710 break; 1711 } 1712 } 1713 return rc; 1705 return S_OK; 1706 } 1707 } 1708 return VBOX_E_OBJECT_NOT_FOUND; 1714 1709 } 1715 1710 #endif /* VBOX_WITH_CLOUD_NET */ … … 1721 1716 ComObjPtr<CloudNetwork> cloudNetwork; 1722 1717 cloudNetwork.createObject(); 1723 HRESULT rc = cloudNetwork->init(this, aNetworkName);1724 if (FAILED( rc)) returnrc;1718 HRESULT hrc = cloudNetwork->init(this, aNetworkName); 1719 if (FAILED(hrc)) return hrc; 1725 1720 1726 1721 m->allCloudNetworks.addChild(cloudNetwork); … … 1728 1723 { 1729 1724 AutoWriteLock vboxLock(this COMMA_LOCKVAL_SRC_POS); 1730 rc = i_saveSettings();1725 hrc = i_saveSettings(); 1731 1726 vboxLock.release(); 1732 1727 1733 if (FAILED( rc))1728 if (FAILED(hrc)) 1734 1729 m->allCloudNetworks.removeChild(cloudNetwork); 1735 1730 else … … 1737 1732 } 1738 1733 1739 return rc;1734 return hrc; 1740 1735 #else /* !VBOX_WITH_CLOUD_NET */ 1741 1736 NOREF(aNetworkName); … … 1765 1760 #ifdef VBOX_WITH_CLOUD_NET 1766 1761 Bstr name; 1767 HRESULT rc = aNetwork->COMGETTER(NetworkName)(name.asOutParam());1768 if (FAILED( rc))1769 return rc;1762 HRESULT hrc = aNetwork->COMGETTER(NetworkName)(name.asOutParam()); 1763 if (FAILED(hrc)) 1764 return hrc; 1770 1765 ICloudNetwork *p = aNetwork; 1771 1766 CloudNetwork *network = static_cast<CloudNetwork *>(p); … … 1781 1776 { 1782 1777 AutoWriteLock vboxLock(this COMMA_LOCKVAL_SRC_POS); 1783 rc = i_saveSettings();1778 hrc = i_saveSettings(); 1784 1779 vboxLock.release(); 1785 1780 1786 if (FAILED( rc))1781 if (FAILED(hrc)) 1787 1782 m->allCloudNetworks.addChild(network); 1788 1783 } 1789 return rc;1784 return hrc; 1790 1785 #else /* !VBOX_WITH_CLOUD_NET */ 1791 1786 NOREF(aNetwork); … … 1868 1863 Utf8Str fullName; 1869 1864 Utf8StrFmt shortName("Firmware%c%s", RTPATH_DELIMITER, firmwareDesc[i].pszFileName); 1870 int rc = i_calculateFullPath(shortName, fullName);1871 AssertRCReturn( rc, VBOX_E_IPRT_ERROR);1865 int vrc = i_calculateFullPath(shortName, fullName); 1866 AssertRCReturn(vrc, VBOX_E_IPRT_ERROR); 1872 1867 if (RTFileExists(fullName.c_str())) 1873 1868 { … … 1878 1873 1879 1874 char szVBoxPath[RTPATH_MAX]; 1880 rc = RTPathExecDir(szVBoxPath, RTPATH_MAX); 1881 AssertRCReturn(rc, VBOX_E_IPRT_ERROR); 1882 rc = RTPathAppend(szVBoxPath, sizeof(szVBoxPath), firmwareDesc[i].pszFileName); 1875 vrc = RTPathExecDir(szVBoxPath, RTPATH_MAX); 1876 AssertRCReturn(vrc, VBOX_E_IPRT_ERROR); 1877 vrc = RTPathAppend(szVBoxPath, sizeof(szVBoxPath), firmwareDesc[i].pszFileName); 1878 AssertRCReturn(vrc, VBOX_E_IPRT_ERROR); 1883 1879 if (RTFileExists(szVBoxPath)) 1884 1880 { … … 1947 1943 if (strGroup.isEmpty()) 1948 1944 strGroup = "/"; 1949 HRESULT rc = i_validateMachineGroup(strGroup, true);1950 if (FAILED( rc))1951 return rc;1945 HRESULT hrc = i_validateMachineGroup(strGroup, true); 1946 if (FAILED(hrc)) 1947 return hrc; 1952 1948 1953 1949 /* Compose the settings file name using the following scheme: … … 2105 2101 2106 2102 StringsList llGroups; 2107 HRESULT rc = i_convertMachineGroups(aGroups, &llGroups);2108 if (FAILED( rc))2109 return rc;2103 HRESULT hrc = i_convertMachineGroups(aGroups, &llGroups); 2104 if (FAILED(hrc)) 2105 return hrc; 2110 2106 2111 2107 /** @todo r=bird: Would be goot to rewrite this parsing using offset into … … 2156 2152 { 2157 2153 /* do something else */ 2158 return setError(E_INVALIDARG, 2159 tr("'%s' is not a valid Guid"), 2160 id.toStringCurly().c_str()); 2154 return setError(E_INVALIDARG, tr("'%s' is not a valid Guid"), id.toStringCurly().c_str()); 2161 2155 } 2162 2156 … … 2170 2164 2171 2165 com::Utf8Str blstr; 2172 rc = composeMachineFilename(aName,2173 llGroups.front(),2174 strNewCreateFlags,2175 blstr /* aBaseFolder */,2176 strSettingsFile);2177 if (FAILED( rc)) returnrc;2166 hrc = composeMachineFilename(aName, 2167 llGroups.front(), 2168 strNewCreateFlags, 2169 blstr /* aBaseFolder */, 2170 strSettingsFile); 2171 if (FAILED(hrc)) return hrc; 2178 2172 } 2179 2173 2180 2174 /* create a new object */ 2181 2175 ComObjPtr<Machine> machine; 2182 rc = machine.createObject();2183 if (FAILED( rc)) returnrc;2176 hrc = machine.createObject(); 2177 if (FAILED(hrc)) return hrc; 2184 2178 2185 2179 ComObjPtr<GuestOSType> osType; … … 2188 2182 2189 2183 /* initialize the machine object */ 2190 rc = machine->init(this,2191 strSettingsFile,2192 aName,2193 llGroups,2194 aOsTypeId,2195 osType,2196 id,2197 fForceOverwrite,2198 fDirectoryIncludesUUID,2199 aCipher,2200 aPasswordId,2201 aPassword);2202 if (SUCCEEDED( rc))2184 hrc = machine->init(this, 2185 strSettingsFile, 2186 aName, 2187 llGroups, 2188 aOsTypeId, 2189 osType, 2190 id, 2191 fForceOverwrite, 2192 fDirectoryIncludesUUID, 2193 aCipher, 2194 aPasswordId, 2195 aPassword); 2196 if (SUCCEEDED(hrc)) 2203 2197 { 2204 2198 /* set the return value */ 2205 2199 machine.queryInterfaceTo(aMachine.asOutParam()); 2206 AssertComRC( rc);2200 AssertComRC(hrc); 2207 2201 2208 2202 #ifdef VBOX_WITH_EXTPACK … … 2214 2208 LogFlowThisFuncLeave(); 2215 2209 2216 return rc;2210 return hrc; 2217 2211 } 2218 2212 … … 2221 2215 ComPtr<IMachine> &aMachine) 2222 2216 { 2223 HRESULT rc = E_FAIL;2224 2225 2217 /* create a new object */ 2226 2218 ComObjPtr<Machine> machine; 2227 rc = machine.createObject();2228 if (SUCCEEDED( rc))2219 HRESULT hrc = machine.createObject(); 2220 if (SUCCEEDED(hrc)) 2229 2221 { 2230 2222 /* initialize the machine object */ 2231 rc = machine->initFromSettings(this, 2232 aSettingsFile, 2233 NULL, /* const Guid *aId */ 2234 aPassword); 2235 if (SUCCEEDED(rc)) 2223 hrc = machine->initFromSettings(this, aSettingsFile, NULL /* const Guid *aId */, aPassword); 2224 if (SUCCEEDED(hrc)) 2236 2225 { 2237 2226 /* set the return value */ 2238 2227 machine.queryInterfaceTo(aMachine.asOutParam()); 2239 ComAssertComRC( rc);2240 } 2241 } 2242 2243 return rc;2228 ComAssertComRC(hrc); 2229 } 2230 } 2231 2232 return hrc; 2244 2233 } 2245 2234 … … 2247 2236 HRESULT VirtualBox::registerMachine(const ComPtr<IMachine> &aMachine) 2248 2237 { 2249 HRESULT rc;2250 2251 2238 Bstr name; 2252 rc = aMachine->COMGETTER(Name)(name.asOutParam());2253 if (FAILED( rc)) returnrc;2239 HRESULT hrc = aMachine->COMGETTER(Name)(name.asOutParam()); 2240 if (FAILED(hrc)) return hrc; 2254 2241 2255 2242 /* We can safely cast child to Machine * here because only Machine … … 2261 2248 ComAssertComRCRetRC(machCaller.hrc()); 2262 2249 2263 rc = i_registerMachine(pMachine);2250 hrc = i_registerMachine(pMachine); 2264 2251 /* fire an event */ 2265 if (SUCCEEDED( rc))2252 if (SUCCEEDED(hrc)) 2266 2253 i_onMachineRegistered(pMachine->i_getId(), TRUE); 2267 2254 2268 return rc;2255 return hrc; 2269 2256 } 2270 2257 … … 2277 2264 2278 2265 /* start with not found */ 2279 HRESULT rc = S_OK;2266 HRESULT hrc = S_OK; 2280 2267 ComObjPtr<Machine> pMachineFound; 2281 2268 … … 2283 2270 Utf8Str strFile(aSettingsFile); 2284 2271 if (id.isValid() && !id.isZero()) 2285 2286 rc = i_findMachine(id, 2287 true /* fPermitInaccessible */, 2288 true /* setError */, 2289 &pMachineFound); 2272 hrc = i_findMachine(id, 2273 true /* fPermitInaccessible */, 2274 true /* setError */, 2275 &pMachineFound); 2290 2276 // returns VBOX_E_OBJECT_NOT_FOUND if not found and sets error 2291 2277 else 2292 2278 { 2293 rc = i_findMachineByName(strFile,2294 true /* setError */,2295 &pMachineFound);2279 hrc = i_findMachineByName(strFile, 2280 true /* setError */, 2281 &pMachineFound); 2296 2282 // returns VBOX_E_OBJECT_NOT_FOUND if not found and sets error 2297 2283 } … … 2300 2286 pMachineFound.queryInterfaceTo(aMachine.asOutParam()); 2301 2287 2302 LogFlowThisFunc(("aName=\"%s\", aMachine=%p, rc=%08X\n", aSettingsFile.c_str(), &aMachine,rc));2288 LogFlowThisFunc(("aName=\"%s\", aMachine=%p, hrc=%08X\n", aSettingsFile.c_str(), &aMachine, hrc)); 2303 2289 LogFlowThisFuncLeave(); 2304 2290 2305 return rc;2291 return hrc; 2306 2292 } 2307 2293 … … 2310 2296 { 2311 2297 StringsList llGroups; 2312 HRESULT rc = i_convertMachineGroups(aGroups, &llGroups);2313 if (FAILED( rc))2314 return rc;2298 HRESULT hrc = i_convertMachineGroups(aGroups, &llGroups); 2299 if (FAILED(hrc)) 2300 return hrc; 2315 2301 2316 2302 /* we want to rely on sorted groups during compare, to save time */ … … 2384 2370 if (!pMachine.isNull()) 2385 2371 { 2386 HRESULT rc = pMachine->COMGETTER(State)(&state);2387 if ( rc == E_ACCESSDENIED)2388 rc = S_OK;2389 AssertComRC( rc);2372 HRESULT hrc = pMachine->COMGETTER(State)(&state); 2373 if (hrc == E_ACCESSDENIED) 2374 hrc = S_OK; 2375 AssertComRC(hrc); 2390 2376 } 2391 2377 aStates[i] = state; … … 2421 2407 NOREF(aAccessMode); /**< @todo r=klaus make use of access mode */ 2422 2408 2423 HRESULT rc = S_OK;2409 HRESULT hrc = S_OK; 2424 2410 2425 2411 ComObjPtr<Medium> medium; … … 2436 2422 i_getDefaultHardDiskFormat(format); 2437 2423 2438 rc = medium->init(this, 2439 format, 2440 aLocation, 2441 Guid::Empty /* media registry: none yet */, 2442 aDeviceType); 2443 } 2444 break; 2445 2446 case DeviceType_DVD: 2447 case DeviceType_Floppy: 2448 { 2449 2450 if (format.isEmpty()) 2451 return setError(E_INVALIDARG, tr("Format must be Valid Type%s"), format.c_str()); 2452 2453 // enforce read-only for DVDs even if caller specified ReadWrite 2454 if (aDeviceType == DeviceType_DVD) 2455 aAccessMode = AccessMode_ReadOnly; 2456 2457 rc = medium->init(this, 2424 hrc = medium->init(this, 2458 2425 format, 2459 2426 aLocation, 2460 2427 Guid::Empty /* media registry: none yet */, 2461 2428 aDeviceType); 2429 } 2430 break; 2431 2432 case DeviceType_DVD: 2433 case DeviceType_Floppy: 2434 { 2435 2436 if (format.isEmpty()) 2437 return setError(E_INVALIDARG, tr("Format must be Valid Type%s"), format.c_str()); 2438 2439 // enforce read-only for DVDs even if caller specified ReadWrite 2440 if (aDeviceType == DeviceType_DVD) 2441 aAccessMode = AccessMode_ReadOnly; 2442 2443 hrc = medium->init(this, 2444 format, 2445 aLocation, 2446 Guid::Empty /* media registry: none yet */, 2447 aDeviceType); 2462 2448 2463 2449 } … … 2468 2454 } 2469 2455 2470 if (SUCCEEDED( rc))2456 if (SUCCEEDED(hrc)) 2471 2457 { 2472 2458 medium.queryInterfaceTo(aMedium.asOutParam()); … … 2476 2462 } 2477 2463 2478 return rc;2464 return hrc; 2479 2465 } 2480 2466 … … 2485 2471 ComPtr<IMedium> &aMedium) 2486 2472 { 2487 HRESULT rc = S_OK;2473 HRESULT hrc = S_OK; 2488 2474 Guid id(aLocation); 2489 2475 ComObjPtr<Medium> pMedium; … … 2500 2486 case DeviceType_HardDisk: 2501 2487 if (id.isValid() && !id.isZero()) 2502 rc = i_findHardDiskById(id, false /* setError */, &pMedium);2488 hrc = i_findHardDiskById(id, false /* setError */, &pMedium); 2503 2489 else 2504 rc = i_findHardDiskByLocation(aLocation, 2505 false, /* aSetError */ 2506 &pMedium); 2490 hrc = i_findHardDiskByLocation(aLocation, false, /* aSetError */ &pMedium); 2507 2491 break; 2508 2492 … … 2510 2494 case DeviceType_DVD: 2511 2495 if (id.isValid() && !id.isZero()) 2512 rc = i_findDVDOrFloppyImage(aDeviceType, &id, Utf8Str::Empty, 2513 false /* setError */, &pMedium); 2496 hrc = i_findDVDOrFloppyImage(aDeviceType, &id, Utf8Str::Empty, false /* setError */, &pMedium); 2514 2497 else 2515 rc = i_findDVDOrFloppyImage(aDeviceType, NULL, aLocation, 2516 false /* setError */, &pMedium); 2498 hrc = i_findDVDOrFloppyImage(aDeviceType, NULL, aLocation, false /* setError */, &pMedium); 2517 2499 2518 2500 // enforce read-only for DVDs even if caller specified ReadWrite … … 2530 2512 pMedium.createObject(); 2531 2513 treeLock.release(); 2532 rc = pMedium->init(this,2533 aLocation,2534 (aAccessMode == AccessMode_ReadWrite) ? Medium::OpenReadWrite : Medium::OpenReadOnly,2535 !!aForceNewUuid,2536 aDeviceType);2514 hrc = pMedium->init(this, 2515 aLocation, 2516 (aAccessMode == AccessMode_ReadWrite) ? Medium::OpenReadWrite : Medium::OpenReadOnly, 2517 !!aForceNewUuid, 2518 aDeviceType); 2537 2519 treeLock.acquire(); 2538 2520 2539 if (SUCCEEDED( rc))2540 { 2541 rc = i_registerMedium(pMedium, &pMedium, treeLock);2521 if (SUCCEEDED(hrc)) 2522 { 2523 hrc = i_registerMedium(pMedium, &pMedium, treeLock); 2542 2524 2543 2525 treeLock.release(); … … 2547 2529 * with the parent and this association needs to be broken. */ 2548 2530 2549 if (FAILED( rc))2531 if (FAILED(hrc)) 2550 2532 { 2551 2533 pMedium->uninit(); 2552 rc = VBOX_E_OBJECT_NOT_FOUND;2534 hrc = VBOX_E_OBJECT_NOT_FOUND; 2553 2535 } 2554 2536 else 2555 {2556 2537 fMediumRegistered = true; 2557 } 2558 } 2559 else 2560 { 2561 if (rc != VBOX_E_INVALID_OBJECT_STATE) 2562 rc = VBOX_E_OBJECT_NOT_FOUND; 2563 } 2564 } 2565 2566 if (SUCCEEDED(rc)) 2538 } 2539 else if (hrc != VBOX_E_INVALID_OBJECT_STATE) 2540 hrc = VBOX_E_OBJECT_NOT_FOUND; 2541 } 2542 2543 if (SUCCEEDED(hrc)) 2567 2544 { 2568 2545 pMedium.queryInterfaceTo(aMedium.asOutParam()); … … 2571 2548 } 2572 2549 2573 return rc;2550 return hrc; 2574 2551 } 2575 2552 … … 2580 2557 { 2581 2558 ComObjPtr<GuestOSType> pType; 2582 HRESULT rc = i_findGuestOSType(aId, pType);2559 HRESULT hrc = i_findGuestOSType(aId, pType); 2583 2560 pType.queryInterfaceTo(aType.asOutParam()); 2584 return rc;2561 return hrc; 2585 2562 } 2586 2563 … … 2649 2626 Utf8Str strValue(aValue); 2650 2627 Utf8Str strOldValue; // empty 2651 HRESULT rc = S_OK;2628 HRESULT hrc = S_OK; 2652 2629 2653 2630 /* Because control characters in aKey have caused problems in the settings … … 2709 2686 2710 2687 /* save settings on success */ 2711 rc = i_saveSettings();2712 if (FAILED( rc)) returnrc;2688 hrc = i_saveSettings(); 2689 if (FAILED(hrc)) return hrc; 2713 2690 } 2714 2691 … … 2717 2694 i_onExtraDataChanged(Guid::Empty, Bstr(aKey).raw(), Bstr(aValue).raw()); 2718 2695 2719 return rc;2696 return hrc; 2720 2697 } 2721 2698 … … 2738 2715 { 2739 2716 Utf8Str strPlaintext; 2740 int rc = i_decryptSetting(&strPlaintext, bstrCipher);2741 if (RT_SUCCESS( rc))2717 int vrc = i_decryptSetting(&strPlaintext, bstrCipher); 2718 if (RT_SUCCESS(vrc)) 2742 2719 pMedium->i_setPropertyDirect("InitiatorSecret", strPlaintext); 2743 2720 else 2744 return rc;2721 return vrc; 2745 2722 } 2746 2723 return VINF_SUCCESS; … … 2795 2772 char szCipherBase64[128]; 2796 2773 size_t cchCipherBase64; 2797 int rc = i_encryptSettingBytes((uint8_t*)aPlaintext.c_str(), abCiphertext, 2798 aPlaintext.length()+1, sizeof(abCiphertext)); 2799 if (RT_SUCCESS(rc)) 2800 { 2801 rc = RTBase64Encode(abCiphertext, sizeof(abCiphertext), 2802 szCipherBase64, sizeof(szCipherBase64), 2803 &cchCipherBase64); 2804 if (RT_SUCCESS(rc)) 2774 int vrc = i_encryptSettingBytes((uint8_t*)aPlaintext.c_str(), abCiphertext, aPlaintext.length()+1, sizeof(abCiphertext)); 2775 if (RT_SUCCESS(vrc)) 2776 { 2777 vrc = RTBase64Encode(abCiphertext, sizeof(abCiphertext), szCipherBase64, sizeof(szCipherBase64), &cchCipherBase64); 2778 if (RT_SUCCESS(vrc)) 2805 2779 *aCiphertext = szCipherBase64; 2806 2780 } 2807 return rc;2781 return vrc; 2808 2782 } 2809 2783 … … 2819 2793 uint8_t abCiphertext[64]; 2820 2794 size_t cbCiphertext; 2821 int rc = RTBase64Decode(aCiphertext.c_str(),2822 abCiphertext, sizeof(abCiphertext),2823 &cbCiphertext, NULL);2824 if (RT_SUCCESS( rc))2825 { 2826 rc = i_decryptSettingBytes(abPlaintext, abCiphertext, cbCiphertext);2827 if (RT_SUCCESS( rc))2795 int vrc = RTBase64Decode(aCiphertext.c_str(), 2796 abCiphertext, sizeof(abCiphertext), 2797 &cbCiphertext, NULL); 2798 if (RT_SUCCESS(vrc)) 2799 { 2800 vrc = i_decryptSettingBytes(abPlaintext, abCiphertext, cbCiphertext); 2801 if (RT_SUCCESS(vrc)) 2828 2802 { 2829 2803 for (unsigned i = 0; i < cbCiphertext; i++) … … 2840 2814 } 2841 2815 } 2842 rc = VERR_INVALID_MAGIC;2843 } 2844 } 2845 return rc;2816 vrc = VERR_INVALID_MAGIC; 2817 } 2818 } 2819 return vrc; 2846 2820 } 2847 2821 … … 2990 2964 AssertReturn(event, E_FAIL); 2991 2965 2992 HRESULT rc;2966 HRESULT hrc; 2993 2967 AutoCaller autoCaller(this); 2994 if (SUCCEEDED(( rc = autoCaller.hrc())))2968 if (SUCCEEDED((hrc = autoCaller.hrc()))) 2995 2969 { 2996 2970 if (getObjectState().getState() != ObjectState::Ready) … … 3003 2977 return S_OK; 3004 2978 else 3005 rc = E_FAIL;2979 hrc = E_FAIL; 3006 2980 } 3007 2981 … … 3009 2983 // the caller has allocated the object using new() 3010 2984 delete event; 3011 return rc;2985 return hrc; 3012 2986 } 3013 2987 … … 3028 3002 3029 3003 Bstr id; 3030 HRESULT rc = aProgress->COMGETTER(Id)(id.asOutParam());3031 AssertComRCReturnRC( rc);3004 HRESULT hrc = aProgress->COMGETTER(Id)(id.asOutParam()); 3005 AssertComRCReturnRC(hrc); 3032 3006 3033 3007 /* protect mProgressOperations */ … … 3193 3167 /* create the i_SVCHelperClientThreadTask() argument */ 3194 3168 3195 HRESULT hr = S_OK;3169 HRESULT hrc = S_OK; 3196 3170 StartSVCHelperClientData *pTask = NULL; 3197 3171 try … … 3209 3183 3210 3184 //this function delete pTask in case of exceptions, so there is no need in the call of delete operator 3211 hr = pTask->createThreadWithType(RTTHREADTYPE_MAIN_WORKER);3185 hrc = pTask->createThreadWithType(RTTHREADTYPE_MAIN_WORKER); 3212 3186 3213 3187 } 3214 3188 catch(std::bad_alloc &) 3215 3189 { 3216 hr = setError(E_OUTOFMEMORY);3190 hrc = setError(E_OUTOFMEMORY); 3217 3191 } 3218 3192 catch(...) 3219 3193 { 3220 3194 LogRel(("Could not create thread for StartSVCHelperClientData \n")); 3221 hr = E_FAIL;3222 } 3223 3224 return hr ;3195 hrc = E_FAIL; 3196 } 3197 3198 return hrc; 3225 3199 } 3226 3200 … … 3232 3206 { 3233 3207 LogFlowFuncEnter(); 3234 HRESULT rc = S_OK;3208 HRESULT hrc = S_OK; 3235 3209 bool userFuncCalled = false; 3236 3210 3237 3211 do 3238 3212 { 3239 AssertBreakStmt(pTask, rc = E_POINTER);3213 AssertBreakStmt(pTask, hrc = E_POINTER); 3240 3214 AssertReturnVoid(!pTask->progress.isNull()); 3241 3215 … … 3245 3219 { 3246 3220 /* it's too late */ 3247 rc = autoCaller.hrc();3221 hrc = autoCaller.hrc(); 3248 3222 break; 3249 3223 } … … 3258 3232 if (RT_FAILURE(vrc)) 3259 3233 { 3260 rc = pTask->that->setErrorBoth(E_FAIL, vrc, tr("Could not create the communication channel (%Rrc)"), vrc);3234 hrc = pTask->that->setErrorBoth(E_FAIL, vrc, tr("Could not create the communication channel (%Rrc)"), vrc); 3261 3235 break; 3262 3236 } … … 3267 3241 if (!exePath) 3268 3242 { 3269 rc = pTask->that->setError(E_FAIL, tr("Cannot get executable name"));3243 hrc = pTask->that->setError(E_FAIL, tr("Cannot get executable name")); 3270 3244 break; 3271 3245 } … … 3303 3277 * (pressing the Cancel button to close the Run As dialog) */ 3304 3278 if (vrc2 == VERR_CANCELLED) 3305 rc = pTask->that->setErrorBoth(E_FAIL, vrc, tr("Operation canceled by the user"));3279 hrc = pTask->that->setErrorBoth(E_FAIL, vrc, tr("Operation canceled by the user")); 3306 3280 else 3307 rc = pTask->that->setErrorBoth(E_FAIL, vrc, tr("Could not launch a privileged process '%s' (%Rrc)"), exePath, vrc2);3281 hrc = pTask->that->setErrorBoth(E_FAIL, vrc, tr("Could not launch a privileged process '%s' (%Rrc)"), exePath, vrc2); 3308 3282 break; 3309 3283 } … … 3315 3289 if (RT_FAILURE(vrc)) 3316 3290 { 3317 rc = pTask->that->setErrorBoth(E_FAIL, vrc, tr("Could not launch a process '%s' (%Rrc)"), exePath, vrc);3291 hrc = pTask->that->setErrorBoth(E_FAIL, vrc, tr("Could not launch a process '%s' (%Rrc)"), exePath, vrc); 3318 3292 break; 3319 3293 } … … 3325 3299 { 3326 3300 /* start the user supplied function */ 3327 rc = pTask->func(&client, pTask->progress, pTask->user, &vrc);3301 hrc = pTask->func(&client, pTask->progress, pTask->user, &vrc); 3328 3302 userFuncCalled = true; 3329 3303 } … … 3336 3310 } 3337 3311 3338 if (SUCCEEDED( rc) && RT_FAILURE(vrc))3339 { 3340 rc = pTask->that->setErrorBoth(E_FAIL, vrc, tr("Could not operate the communication channel (%Rrc)"), vrc);3312 if (SUCCEEDED(hrc) && RT_FAILURE(vrc)) 3313 { 3314 hrc = pTask->that->setErrorBoth(E_FAIL, vrc, tr("Could not operate the communication channel (%Rrc)"), vrc); 3341 3315 break; 3342 3316 } … … 3344 3318 while (0); 3345 3319 3346 if (FAILED( rc) && !userFuncCalled)3320 if (FAILED(hrc) && !userFuncCalled) 3347 3321 { 3348 3322 /* call the user function in the "cleanup only" mode … … 3351 3325 } 3352 3326 3353 pTask->progress->i_notifyComplete( rc);3327 pTask->progress->i_notifyComplete(hrc); 3354 3328 3355 3329 LogFlowFuncLeave(); … … 3674 3648 { 3675 3649 ComPtr<INATNetwork> nat; 3676 HRESULT rc = findNATNetworkByName(aNetworkName, nat);3677 if (FAILED( rc)) return -1;3678 3679 rc = nat->Start();3680 if (SUCCEEDED( rc))3650 HRESULT hrc = findNATNetworkByName(aNetworkName, nat); 3651 if (FAILED(hrc)) return -1; 3652 3653 hrc = nat->Start(); 3654 if (SUCCEEDED(hrc)) 3681 3655 LogRel(("Started NAT network '%s'\n", aNetworkName.c_str())); 3682 3656 else 3683 LogRel(("Error %Rhrc starting NAT network '%s'\n", rc, aNetworkName.c_str()));3684 AssertComRCReturn( rc, -1);3657 LogRel(("Error %Rhrc starting NAT network '%s'\n", hrc, aNetworkName.c_str())); 3658 AssertComRCReturn(hrc, -1); 3685 3659 } 3686 3660 … … 3703 3677 { 3704 3678 ComPtr<INATNetwork> nat; 3705 HRESULT rc = findNATNetworkByName(aNetworkName, nat);3706 if (FAILED( rc)) return -1;3707 3708 rc = nat->Stop();3709 if (SUCCEEDED( rc))3679 HRESULT hrc = findNATNetworkByName(aNetworkName, nat); 3680 if (FAILED(hrc)) return -1; 3681 3682 hrc = nat->Stop(); 3683 if (SUCCEEDED(hrc)) 3710 3684 LogRel(("Stopped NAT network '%s'\n", aNetworkName.c_str())); 3711 3685 else 3712 LogRel(("Error %Rhrc stopping NAT network '%s'\n", rc, aNetworkName.c_str()));3713 AssertComRCReturn( rc, -1);3686 LogRel(("Error %Rhrc stopping NAT network '%s'\n", hrc, aNetworkName.c_str())); 3687 AssertComRCReturn(hrc, -1); 3714 3688 } 3715 3689 … … 3902 3876 ComObjPtr<Machine> *aMachine /* = NULL */) 3903 3877 { 3904 HRESULT rc = VBOX_E_OBJECT_NOT_FOUND;3878 HRESULT hrc = VBOX_E_OBJECT_NOT_FOUND; 3905 3879 3906 3880 AutoCaller autoCaller(this); … … 3926 3900 if (pMachine->i_getId() == aId) 3927 3901 { 3928 rc = S_OK;3902 hrc = S_OK; 3929 3903 if (aMachine) 3930 3904 *aMachine = pMachine; … … 3934 3908 } 3935 3909 3936 if (aSetError && FAILED(rc)) 3937 rc = setError(rc, 3938 tr("Could not find a registered machine with UUID {%RTuuid}"), 3939 aId.raw()); 3940 3941 return rc; 3910 if (aSetError && FAILED(hrc)) 3911 hrc = setError(hrc, tr("Could not find a registered machine with UUID {%RTuuid}"), aId.raw()); 3912 3913 return hrc; 3942 3914 } 3943 3915 … … 3955 3927 ComObjPtr<Machine> *aMachine /* = NULL */) 3956 3928 { 3957 HRESULT rc = VBOX_E_OBJECT_NOT_FOUND;3929 HRESULT hrc = VBOX_E_OBJECT_NOT_FOUND; 3958 3930 3959 3931 AutoReadLock al(m->allMachines.getLockHandle() COMMA_LOCKVAL_SRC_POS); … … 3970 3942 if (pMachine->i_getName() == aName) 3971 3943 { 3972 rc = S_OK;3944 hrc = S_OK; 3973 3945 if (aMachine) 3974 3946 *aMachine = pMachine; … … 3977 3949 if (!RTPathCompare(pMachine->i_getSettingsFileFull().c_str(), aName.c_str())) 3978 3950 { 3979 rc = S_OK;3951 hrc = S_OK; 3980 3952 if (aMachine) 3981 3953 *aMachine = pMachine; … … 3984 3956 } 3985 3957 3986 if (aSetError && FAILED(rc)) 3987 rc = setError(rc, 3988 tr("Could not find a registered machine named '%s'"), aName.c_str()); 3989 3990 return rc; 3958 if (aSetError && FAILED(hrc)) 3959 hrc = setError(hrc, tr("Could not find a registered machine named '%s'"), aName.c_str()); 3960 3961 return hrc; 3991 3962 } 3992 3963 … … 4027 3998 if (fPrimary) 4028 3999 { 4029 HRESULT rc = pVirtualBox->i_findMachineByName(tmp, 4030 false /* aSetError */); 4031 if (SUCCEEDED(rc)) 4000 HRESULT hrc = pVirtualBox->i_findMachineByName(tmp, false /* aSetError */); 4001 if (SUCCEEDED(hrc)) 4032 4002 return VBOX_E_VM_ERROR; 4033 4003 } … … 4059 4029 HRESULT VirtualBox::i_validateMachineGroup(const Utf8Str &aGroup, bool fPrimary) 4060 4030 { 4061 HRESULT rc = i_validateMachineGroupHelper(aGroup, fPrimary, this); 4062 if (FAILED(rc)) 4063 { 4064 if (rc == VBOX_E_VM_ERROR) 4065 rc = setError(E_INVALIDARG, 4066 tr("Machine group '%s' conflicts with a virtual machine name"), 4067 aGroup.c_str()); 4031 HRESULT hrc = i_validateMachineGroupHelper(aGroup, fPrimary, this); 4032 if (FAILED(hrc)) 4033 { 4034 if (hrc == VBOX_E_VM_ERROR) 4035 hrc = setError(E_INVALIDARG, tr("Machine group '%s' conflicts with a virtual machine name"), aGroup.c_str()); 4068 4036 else 4069 rc = setError(rc, 4070 tr("Invalid machine group '%s'"), 4071 aGroup.c_str()); 4072 } 4073 return rc; 4037 hrc = setError(hrc, tr("Invalid machine group '%s'"), aGroup.c_str()); 4038 } 4039 return hrc; 4074 4040 } 4075 4041 … … 4093 4059 group = "/"; 4094 4060 4095 HRESULT rc = i_validateMachineGroup(group, i == 0);4096 if (FAILED( rc))4097 return rc;4061 HRESULT hrc = i_validateMachineGroup(group, i == 0); 4062 if (FAILED(hrc)) 4063 return hrc; 4098 4064 4099 4065 /* no duplicates please */ … … 4290 4256 } 4291 4257 4292 HRESULT rc = found ? S_OK : VBOX_E_OBJECT_NOT_FOUND;4258 HRESULT hrc = found ? S_OK : VBOX_E_OBJECT_NOT_FOUND; 4293 4259 4294 4260 if (aSetError && !found) 4295 4261 { 4296 4262 if (aId) 4297 setError( rc,4263 setError(hrc, 4298 4264 tr("Could not find an image file with UUID {%RTuuid} in the media registry ('%s')"), 4299 4265 aId->raw(), 4300 4266 m->strSettingsFilePath.c_str()); 4301 4267 else 4302 setError( rc,4268 setError(hrc, 4303 4269 tr("Could not find an image file with location '%s' in the media registry ('%s')"), 4304 4270 aLocation.c_str(), … … 4306 4272 } 4307 4273 4308 return rc;4274 return hrc; 4309 4275 } 4310 4276 … … 4351 4317 4352 4318 // first search for host drive with that UUID 4353 HRESULT rc = m->pHost->i_findHostDriveById(mediumType, 4354 uuid, 4355 fRefresh, 4356 pMedium); 4357 if (rc == VBOX_E_OBJECT_NOT_FOUND) 4319 HRESULT hrc = m->pHost->i_findHostDriveById(mediumType, uuid, fRefresh, pMedium); 4320 if (hrc == VBOX_E_OBJECT_NOT_FOUND) 4358 4321 // then search for an image with that UUID 4359 rc = i_findDVDOrFloppyImage(mediumType, &uuid, Utf8Str::Empty, aSetError, &pMedium);4360 4361 return rc;4322 hrc = i_findDVDOrFloppyImage(mediumType, &uuid, Utf8Str::Empty, aSetError, &pMedium); 4323 4324 return hrc; 4362 4325 } 4363 4326 … … 4563 4526 AutoReadLock alock(i_getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS); 4564 4527 4565 HRESULT rc = S_OK;4528 HRESULT hrc = S_OK; 4566 4529 4567 4530 ComObjPtr<Medium> pMediumFound; … … 4569 4532 4570 4533 if (aId.isValid() && !aId.isZero()) 4571 rc = i_findHardDiskById(aId, false /* aSetError */, &pMediumFound);4572 if (FAILED( rc) && !aLocation.isEmpty())4573 rc = i_findHardDiskByLocation(aLocation, false /* aSetError */, &pMediumFound);4574 if (SUCCEEDED( rc))4534 hrc = i_findHardDiskById(aId, false /* aSetError */, &pMediumFound); 4535 if (FAILED(hrc) && !aLocation.isEmpty()) 4536 hrc = i_findHardDiskByLocation(aLocation, false /* aSetError */, &pMediumFound); 4537 if (SUCCEEDED(hrc)) 4575 4538 pcszType = tr("hard disk"); 4576 4539 4577 4540 if (!pcszType) 4578 4541 { 4579 rc = i_findDVDOrFloppyImage(DeviceType_DVD, &aId, aLocation, false /* aSetError */, &pMediumFound);4580 if (SUCCEEDED( rc))4542 hrc = i_findDVDOrFloppyImage(DeviceType_DVD, &aId, aLocation, false /* aSetError */, &pMediumFound); 4543 if (SUCCEEDED(hrc)) 4581 4544 pcszType = tr("CD/DVD image"); 4582 4545 } … … 4584 4547 if (!pcszType) 4585 4548 { 4586 rc = i_findDVDOrFloppyImage(DeviceType_Floppy, &aId, aLocation, false /* aSetError */, &pMediumFound);4587 if (SUCCEEDED( rc))4549 hrc = i_findDVDOrFloppyImage(DeviceType_Floppy, &aId, aLocation, false /* aSetError */, &pMediumFound); 4550 if (SUCCEEDED(hrc)) 4588 4551 pcszType = tr("floppy image"); 4589 4552 } … … 4628 4591 AutoReadLock alock(i_getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS); 4629 4592 4630 HRESULT rc = S_OK;4631 4593 bool fInUse = false; 4632 4594 4633 4595 ComObjPtr<Medium> pMediumFound; 4634 4596 4597 HRESULT hrc; 4635 4598 switch (deviceType) 4636 4599 { 4637 4600 case DeviceType_HardDisk: 4638 rc = i_findHardDiskById(aId, false /* aSetError */, &pMediumFound);4601 hrc = i_findHardDiskById(aId, false /* aSetError */, &pMediumFound); 4639 4602 break; 4640 4603 case DeviceType_DVD: 4641 rc = i_findDVDOrFloppyImage(DeviceType_DVD, &aId, Utf8Str::Empty, false /* aSetError */, &pMediumFound);4604 hrc = i_findDVDOrFloppyImage(DeviceType_DVD, &aId, Utf8Str::Empty, false /* aSetError */, &pMediumFound); 4642 4605 break; 4643 4606 case DeviceType_Floppy: 4644 rc = i_findDVDOrFloppyImage(DeviceType_Floppy, &aId, Utf8Str::Empty, false /* aSetError */, &pMediumFound);4607 hrc = i_findDVDOrFloppyImage(DeviceType_Floppy, &aId, Utf8Str::Empty, false /* aSetError */, &pMediumFound); 4645 4608 break; 4646 4609 default: 4647 4610 AssertMsgFailed(("Invalid device type %d\n", deviceType)); 4648 } 4649 4650 if (SUCCEEDED(rc) && pMediumFound) 4611 hrc = S_OK; 4612 break; 4613 } 4614 4615 if (SUCCEEDED(hrc) && pMediumFound) 4651 4616 fInUse = true; 4652 4617 … … 4800 4765 { 4801 4766 const Data::PendingMachineRename &pmr = *it2; 4802 HRESULT rc = pMedium->i_updatePath(pmr.strConfigDirOld, 4803 pmr.strConfigDirNew); 4804 if (SUCCEEDED(rc)) 4767 HRESULT hrc = pMedium->i_updatePath(pmr.strConfigDirOld, pmr.strConfigDirNew); 4768 if (SUCCEEDED(hrc)) 4805 4769 { 4806 4770 // Remember which medium objects has been changed, 4807 4771 // to trigger saving their registries later. 4808 4772 pDesc->llMedia.push_back(pMedium); 4809 } else if ( rc == VBOX_E_FILE_ERROR)4773 } else if (hrc == VBOX_E_FILE_ERROR) 4810 4774 /* nothing */; 4811 4775 else 4812 AssertComRC( rc);4776 AssertComRC(hrc); 4813 4777 } 4814 4778 } … … 4827 4791 //so there is no need to use delete operator for pDesc 4828 4792 //after calling this function 4829 HRESULT hr = pDesc->createThread();4793 HRESULT hrc = pDesc->createThread(); 4830 4794 pDesc = NULL; 4831 4795 4832 if (FAILED(hr ))4796 if (FAILED(hrc)) 4833 4797 { 4834 4798 // failure means that settings aren't saved, but there isn't 4835 4799 // much we can do besides avoiding memory leaks 4836 LogRelFunc(("Failed to create thread for saving media registries (%Rhr)\n", hr ));4800 LogRelFunc(("Failed to create thread for saving media registries (%Rhr)\n", hrc)); 4837 4801 } 4838 4802 } … … 4854 4818 }; 4855 4819 4856 HRESULT rc;4857 4858 4820 for (size_t i = 0; i < RT_ELEMENTS(s); ++i) 4859 4821 { … … 4873 4835 { 4874 4836 llTarget.push_back(settings::Medium::Empty); 4875 rc = pMedium->i_saveSettings(llTarget.back(), strMachineFolder);// this recurses into child hard disks4876 if (FAILED( rc))4837 HRESULT hrc = pMedium->i_saveSettings(llTarget.back(), strMachineFolder); // this recurses into child hard disks 4838 if (FAILED(hrc)) 4877 4839 { 4878 4840 llTarget.pop_back(); 4879 throw rc;4841 throw hrc; 4880 4842 } 4881 4843 } … … 4903 4865 i_unmarkRegistryModified(i_getGlobalRegistryId()); 4904 4866 4905 HRESULT rc = S_OK;4867 HRESULT hrc = S_OK; 4906 4868 4907 4869 try … … 4918 4880 // save actual machine registry entry 4919 4881 settings::MachineRegistryEntry mre; 4920 rc = pMachine->i_saveRegistryEntry(mre);4882 hrc = pMachine->i_saveRegistryEntry(mre); 4921 4883 m->pMainConfigFile->llMachines.push_back(mre); 4922 4884 } … … 4935 4897 { 4936 4898 settings::DHCPServer d; 4937 rc = (*it)->i_saveSettings(d);4938 if (FAILED( rc)) throwrc;4899 hrc = (*it)->i_saveSettings(d); 4900 if (FAILED(hrc)) throw hrc; 4939 4901 m->pMainConfigFile->llDhcpServers.push_back(d); 4940 4902 } … … 4951 4913 { 4952 4914 settings::NATNetwork n; 4953 rc = (*it)->i_saveSettings(n);4954 if (FAILED( rc)) throwrc;4915 hrc = (*it)->i_saveSettings(n); 4916 if (FAILED(hrc)) throw hrc; 4955 4917 m->pMainConfigFile->llNATNetworks.push_back(n); 4956 4918 } … … 4967 4929 { 4968 4930 settings::HostOnlyNetwork n; 4969 rc = (*it)->i_saveSettings(n);4970 if (FAILED( rc)) throwrc;4931 hrc = (*it)->i_saveSettings(n); 4932 if (FAILED(hrc)) throw hrc; 4971 4933 m->pMainConfigFile->llHostOnlyNetworks.push_back(n); 4972 4934 } … … 4983 4945 { 4984 4946 settings::CloudNetwork n; 4985 rc = (*it)->i_saveSettings(n);4986 if (FAILED( rc)) throwrc;4947 hrc = (*it)->i_saveSettings(n); 4948 if (FAILED(hrc)) throw hrc; 4987 4949 m->pMainConfigFile->llCloudNetworks.push_back(n); 4988 4950 } … … 4992 4954 4993 4955 // host data (USB filters) 4994 rc = m->pHost->i_saveSettings(m->pMainConfigFile->host);4995 if (FAILED( rc)) throwrc;4996 4997 rc = m->pSystemProperties->i_saveSettings(m->pMainConfigFile->systemProperties);4998 if (FAILED( rc)) throwrc;4956 hrc = m->pHost->i_saveSettings(m->pMainConfigFile->host); 4957 if (FAILED(hrc)) throw hrc; 4958 4959 hrc = m->pSystemProperties->i_saveSettings(m->pMainConfigFile->systemProperties); 4960 if (FAILED(hrc)) throw hrc; 4999 4961 5000 4962 // and write out the XML, still under the lock 5001 4963 m->pMainConfigFile->write(m->strSettingsFilePath); 5002 4964 } 5003 catch (HRESULT err)4965 catch (HRESULT hrcXcpt) 5004 4966 { 5005 4967 /* we assume that error info is set by the thrower */ 5006 rc = err;4968 hrc = hrcXcpt; 5007 4969 } 5008 4970 catch (...) 5009 4971 { 5010 rc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);5011 } 5012 5013 return rc;4972 hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS); 4973 } 4974 4975 return hrc; 5014 4976 } 5015 4977 … … 5036 4998 if (FAILED(autoCaller.hrc())) return autoCaller.hrc(); 5037 4999 5038 HRESULT rc = S_OK;5000 HRESULT hrc = S_OK; 5039 5001 5040 5002 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS); … … 5042 5004 { 5043 5005 ComObjPtr<Machine> pMachine; 5044 rc = i_findMachine(aMachine->i_getId(),5045 true /* fPermitInaccessible */,5046 false /* aDoSetError */,5047 &pMachine);5048 if (SUCCEEDED( rc))5006 hrc = i_findMachine(aMachine->i_getId(), 5007 true /* fPermitInaccessible */, 5008 false /* aDoSetError */, 5009 &pMachine); 5010 if (SUCCEEDED(hrc)) 5049 5011 { 5050 5012 /* sanity */ … … 5058 5020 } 5059 5021 5060 ComAssertRet( rc == VBOX_E_OBJECT_NOT_FOUND,rc);5061 rc = S_OK;5022 ComAssertRet(hrc == VBOX_E_OBJECT_NOT_FOUND, hrc); 5023 hrc = S_OK; 5062 5024 } 5063 5025 5064 5026 if (getObjectState().getState() != ObjectState::InInit) 5065 5027 { 5066 rc = aMachine->i_prepareRegister();5067 if (FAILED( rc)) returnrc;5028 hrc = aMachine->i_prepareRegister(); 5029 if (FAILED(hrc)) return hrc; 5068 5030 } 5069 5031 … … 5072 5034 5073 5035 if (getObjectState().getState() != ObjectState::InInit) 5074 rc = i_saveSettings();5075 5076 return rc;5036 hrc = i_saveSettings(); 5037 5038 return hrc; 5077 5039 } 5078 5040 … … 5150 5112 } 5151 5113 5152 HRESULT rc;5114 HRESULT hrc; 5153 5115 5154 5116 Utf8Str strConflict; 5155 5117 ComObjPtr<Medium> pDupMedium; 5156 rc = i_checkMediaForConflicts(id, 5157 strLocationFull, 5158 strConflict, 5159 &pDupMedium); 5160 if (FAILED(rc)) return rc; 5118 hrc = i_checkMediaForConflicts(id, strLocationFull, strConflict, &pDupMedium); 5119 if (FAILED(hrc)) return hrc; 5161 5120 5162 5121 if (pDupMedium.isNull()) … … 5210 5169 mediaTreeLock.acquire(); 5211 5170 5212 return rc;5171 return hrc; 5213 5172 } 5214 5173 … … 5376 5335 m->allMachines.removeChild(pMachine); 5377 5336 // save the global registry 5378 HRESULT rc = i_saveSettings();5337 HRESULT hrc = i_saveSettings(); 5379 5338 alock.release(); 5380 5339 … … 5437 5396 i_onMachineRegistered(id, FALSE); 5438 5397 5439 return rc;5398 return hrc; 5440 5399 } 5441 5400 … … 5453 5412 { 5454 5413 ComObjPtr<Machine> pMachine; 5455 HRESULT rc = i_findMachine(uuid, 5456 false /* fPermitInaccessible */, 5457 false /* aSetError */, 5458 &pMachine); 5459 if (SUCCEEDED(rc)) 5414 HRESULT hrc = i_findMachine(uuid, false /* fPermitInaccessible */, false /* aSetError */, &pMachine); 5415 if (SUCCEEDED(hrc)) 5460 5416 { 5461 5417 AutoCaller machineCaller(pMachine); … … 5490 5446 { 5491 5447 ComObjPtr<Machine> pMachine; 5492 HRESULT rc = i_findMachine(uuid, 5493 false /* fPermitInaccessible */, 5494 false /* aSetError */, 5495 &pMachine); 5496 if (SUCCEEDED(rc)) 5448 HRESULT hrc = i_findMachine(uuid, false /* fPermitInaccessible */, false /* aSetError */, &pMachine); 5449 if (SUCCEEDED(hrc)) 5497 5450 { 5498 5451 AutoCaller machineCaller(pMachine); … … 5524 5477 void VirtualBox::i_saveModifiedRegistries() 5525 5478 { 5526 HRESULT rc = S_OK;5479 HRESULT hrc = S_OK; 5527 5480 bool fNeedsGlobalSettings = false; 5528 5481 uint64_t uOld; … … 5554 5507 continue; 5555 5508 AutoWriteLock mlock(pMachine COMMA_LOCKVAL_SRC_POS); 5556 rc = pMachine->i_saveSettings(&fNeedsGlobalSettings, mlock,5557 Machine::SaveS_Force); // caller said save, so stop arguing5509 hrc = pMachine->i_saveSettings(&fNeedsGlobalSettings, mlock, 5510 Machine::SaveS_Force); // caller said save, so stop arguing 5558 5511 } 5559 5512 } … … 5572 5525 { 5573 5526 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS); 5574 rc = i_saveSettings();5575 } 5576 NOREF( rc); /* XXX */5527 hrc = i_saveSettings(); 5528 } 5529 NOREF(hrc); /* XXX */ 5577 5530 } 5578 5531 … … 5661 5614 AssertReturn(pvUser, VERR_INVALID_POINTER); 5662 5615 5663 HRESULT hr = com::Initialize();5664 if (FAILED(hr ))5616 HRESULT hrc = com::Initialize(); 5617 if (FAILED(hrc)) 5665 5618 return VERR_COM_UNEXPECTED; 5666 5619 5667 int rc = VINF_SUCCESS;5620 int vrc = VINF_SUCCESS; 5668 5621 5669 5622 try … … 5687 5640 for (;;) 5688 5641 { 5689 rc = pEventQueue->processEventQueue(RT_INDEFINITE_WAIT);5690 if ( rc == VERR_INTERRUPTED)5642 vrc = pEventQueue->processEventQueue(RT_INDEFINITE_WAIT); 5643 if (vrc == VERR_INTERRUPTED) 5691 5644 { 5692 LogFlow(("Event queue processing ended with rc=%Rrc\n",rc));5693 rc = VINF_SUCCESS; /* Set success when exiting. */5645 LogFlow(("Event queue processing ended with vrc=%Rrc\n", vrc)); 5646 vrc = VINF_SUCCESS; /* Set success when exiting. */ 5694 5647 break; 5695 5648 } … … 5700 5653 catch (std::bad_alloc &ba) 5701 5654 { 5702 rc = VERR_NO_MEMORY;5655 vrc = VERR_NO_MEMORY; 5703 5656 NOREF(ba); 5704 5657 } … … 5706 5659 com::Shutdown(); 5707 5660 5708 LogFlowFuncLeaveRC( rc);5709 return rc;5661 LogFlowFuncLeaveRC(vrc); 5662 return vrc; 5710 5663 } 5711 5664 … … 5782 5735 ComObjPtr<DHCPServer> dhcpServer; 5783 5736 dhcpServer.createObject(); 5784 HRESULT rc = dhcpServer->init(this, aName);5785 if (FAILED( rc)) returnrc;5786 5787 rc = i_registerDHCPServer(dhcpServer, true);5788 if (FAILED( rc)) returnrc;5737 HRESULT hrc = dhcpServer->init(this, aName); 5738 if (FAILED(hrc)) return hrc; 5739 5740 hrc = i_registerDHCPServer(dhcpServer, true); 5741 if (FAILED(hrc)) return hrc; 5789 5742 5790 5743 dhcpServer.queryInterfaceTo(aServer.asOutParam()); 5791 5744 5792 return rc;5745 return hrc; 5793 5746 } 5794 5747 … … 5796 5749 ComPtr<IDHCPServer> &aServer) 5797 5750 { 5798 HRESULT rc = S_OK;5799 5751 ComPtr<DHCPServer> found; 5800 5752 … … 5806 5758 { 5807 5759 Bstr bstrNetworkName; 5808 rc = (*it)->COMGETTER(NetworkName)(bstrNetworkName.asOutParam());5809 if (FAILED( rc)) returnrc;5760 HRESULT hrc = (*it)->COMGETTER(NetworkName)(bstrNetworkName.asOutParam()); 5761 if (FAILED(hrc)) return hrc; 5810 5762 5811 5763 if (Utf8Str(bstrNetworkName) == aName) … … 5818 5770 if (!found) 5819 5771 return E_INVALIDARG; 5820 5821 rc = found.queryInterfaceTo(aServer.asOutParam()); 5822 5823 return rc; 5772 return found.queryInterfaceTo(aServer.asOutParam()); 5824 5773 } 5825 5774 … … 5827 5776 { 5828 5777 IDHCPServer *aP = aServer; 5829 5830 HRESULT rc = i_unregisterDHCPServer(static_cast<DHCPServer *>(aP)); 5831 5832 return rc; 5778 return i_unregisterDHCPServer(static_cast<DHCPServer *>(aP)); 5833 5779 } 5834 5780 … … 5868 5814 5869 5815 Bstr bstrNetworkName; 5870 HRESULT rc = S_OK; 5871 rc = aDHCPServer->COMGETTER(NetworkName)(bstrNetworkName.asOutParam()); 5872 if (FAILED(rc)) return rc; 5816 HRESULT hrc = aDHCPServer->COMGETTER(NetworkName)(bstrNetworkName.asOutParam()); 5817 if (FAILED(hrc)) return hrc; 5873 5818 5874 5819 ComPtr<IDHCPServer> existing; 5875 rc = findDHCPServerByNetworkName(Utf8Str(bstrNetworkName), existing);5876 if (SUCCEEDED( rc))5820 hrc = findDHCPServerByNetworkName(Utf8Str(bstrNetworkName), existing); 5821 if (SUCCEEDED(hrc)) 5877 5822 return E_INVALIDARG; 5878 rc = S_OK;5823 hrc = S_OK; 5879 5824 5880 5825 m->allDHCPServers.addChild(aDHCPServer); … … 5886 5831 { 5887 5832 // we acquired the lock on 'this' earlier to avoid lock order issues 5888 rc = i_saveSettings();5889 5890 if (FAILED( rc))5833 hrc = i_saveSettings(); 5834 5835 if (FAILED(hrc)) 5891 5836 { 5892 5837 alock.acquire(); … … 5895 5840 } 5896 5841 5897 return rc;5842 return hrc; 5898 5843 } 5899 5844 … … 5926 5871 alock.release(); 5927 5872 5928 HRESULT rc = i_saveSettings();5873 HRESULT hrc = i_saveSettings(); 5929 5874 5930 5875 // undo the changes if we failed to save them 5931 if (FAILED( rc))5876 if (FAILED(hrc)) 5932 5877 { 5933 5878 alock.acquire(); … … 5935 5880 } 5936 5881 5937 return rc;5882 return hrc; 5938 5883 } 5939 5884 … … 5948 5893 ComObjPtr<NATNetwork> natNetwork; 5949 5894 natNetwork.createObject(); 5950 HRESULT rc = natNetwork->init(this, aNetworkName);5951 if (FAILED( rc)) returnrc;5952 5953 rc = i_registerNATNetwork(natNetwork, true);5954 if (FAILED( rc)) returnrc;5895 HRESULT hrc = natNetwork->init(this, aNetworkName); 5896 if (FAILED(hrc)) return hrc; 5897 5898 hrc = i_registerNATNetwork(natNetwork, true); 5899 if (FAILED(hrc)) return hrc; 5955 5900 5956 5901 natNetwork.queryInterfaceTo(aNetwork.asOutParam()); … … 5958 5903 ::FireNATNetworkCreationDeletionEvent(m->pEventSource, aNetworkName, TRUE); 5959 5904 5960 return rc;5905 return hrc; 5961 5906 #else 5962 5907 NOREF(aNetworkName); … … 5971 5916 #ifdef VBOX_WITH_NAT_SERVICE 5972 5917 5973 HRESULT rc = S_OK;5918 HRESULT hrc = S_OK; 5974 5919 ComPtr<NATNetwork> found; 5975 5920 … … 5981 5926 { 5982 5927 Bstr bstrNATNetworkName; 5983 rc = (*it)->COMGETTER(NetworkName)(bstrNATNetworkName.asOutParam());5984 if (FAILED( rc)) returnrc;5928 hrc = (*it)->COMGETTER(NetworkName)(bstrNATNetworkName.asOutParam()); 5929 if (FAILED(hrc)) return hrc; 5985 5930 5986 5931 if (Utf8Str(bstrNATNetworkName) == aNetworkName) … … 5994 5939 return E_INVALIDARG; 5995 5940 found.queryInterfaceTo(aNetwork.asOutParam()); 5996 return rc;5941 return hrc; 5997 5942 #else 5998 5943 NOREF(aNetworkName); … … 6006 5951 #ifdef VBOX_WITH_NAT_SERVICE 6007 5952 Bstr name; 6008 HRESULT rc = aNetwork->COMGETTER(NetworkName)(name.asOutParam());6009 if (FAILED( rc))6010 return rc;5953 HRESULT hrc = aNetwork->COMGETTER(NetworkName)(name.asOutParam()); 5954 if (FAILED(hrc)) 5955 return hrc; 6011 5956 INATNetwork *p = aNetwork; 6012 5957 NATNetwork *network = static_cast<NATNetwork *>(p); 6013 rc = i_unregisterNATNetwork(network, true);5958 hrc = i_unregisterNATNetwork(network, true); 6014 5959 ::FireNATNetworkCreationDeletionEvent(m->pEventSource, name.raw(), FALSE); 6015 return rc;5960 return hrc; 6016 5961 #else 6017 5962 NOREF(aNetwork); … … 6042 5987 6043 5988 Bstr name; 6044 HRESULT rc;6045 rc = aNATNetwork->COMGETTER(NetworkName)(name.asOutParam());6046 AssertComRCReturnRC( rc);5989 HRESULT hrc; 5990 hrc = aNATNetwork->COMGETTER(NetworkName)(name.asOutParam()); 5991 AssertComRCReturnRC(hrc); 6047 5992 6048 5993 /* returned value isn't 0 and aSaveSettings is true … … 6053 5998 AssertComRCReturnRC(E_INVALIDARG); 6054 5999 6055 rc = S_OK;6000 hrc = S_OK; 6056 6001 6057 6002 sNatNetworkNameToRefCount[name] = 0; … … 6062 6007 { 6063 6008 AutoWriteLock vboxLock(this COMMA_LOCKVAL_SRC_POS); 6064 rc = i_saveSettings();6009 hrc = i_saveSettings(); 6065 6010 vboxLock.release(); 6066 6011 6067 if (FAILED( rc))6012 if (FAILED(hrc)) 6068 6013 i_unregisterNATNetwork(aNATNetwork, false /* aSaveSettings */); 6069 6014 } 6070 6015 6071 return rc;6016 return hrc; 6072 6017 #else 6073 6018 NOREF(aNATNetwork); … … 6103 6048 6104 6049 Bstr name; 6105 HRESULT rc = aNATNetwork->COMGETTER(NetworkName)(name.asOutParam());6050 HRESULT hrc = aNATNetwork->COMGETTER(NetworkName)(name.asOutParam()); 6106 6051 /* Hm, there're still running clients. */ 6107 if (FAILED( rc) || sNatNetworkNameToRefCount[name])6052 if (FAILED(hrc) || sNatNetworkNameToRefCount[name]) 6108 6053 AssertComRCReturnRC(E_INVALIDARG); 6109 6054 … … 6113 6058 { 6114 6059 AutoWriteLock vboxLock(this COMMA_LOCKVAL_SRC_POS); 6115 rc = i_saveSettings();6060 hrc = i_saveSettings(); 6116 6061 vboxLock.release(); 6117 6062 6118 if (FAILED( rc))6063 if (FAILED(hrc)) 6119 6064 i_registerNATNetwork(aNATNetwork, false /* aSaveSettings */); 6120 6065 } 6121 6066 6122 return rc;6067 return hrc; 6123 6068 #else 6124 6069 NOREF(aNATNetwork); … … 6328 6273 err = GetLastError(); 6329 6274 hrc = HRESULT_FROM_WIN32(err); 6330 AssertLogRelMsgFailed(("GetWindowsDirectory failed, hr =%Rhrc (0x%x) err=%u\n",6275 AssertLogRelMsgFailed(("GetWindowsDirectory failed, hrc=%Rhrc (0x%x) err=%u\n", 6331 6276 hrc, hrc, err)); 6332 6277 break; … … 6345 6290 err = GetLastError(); 6346 6291 hrc = HRESULT_FROM_WIN32(err); 6347 AssertLogRelMsgFailed(("GetWindowsDirectory failed, hr =%Rhrc (0x%x) err=%u\n",6292 AssertLogRelMsgFailed(("GetWindowsDirectory failed, hrc=%Rhrc (0x%x) err=%u\n", 6348 6293 hrc, hrc, err)); 6349 6294 break; … … 6359 6304 err = GetLastError(); 6360 6305 hrc = HRESULT_FROM_WIN32(err); 6361 AssertLogRelMsgFailed(("EnumDeviceDrivers failed, hr =%Rhrc (0x%x) err=%u\n",6306 AssertLogRelMsgFailed(("EnumDeviceDrivers failed, hrc=%Rhrc (0x%x) err=%u\n", 6362 6307 hrc, hrc, err)); 6363 6308 break;
Note:
See TracChangeset
for help on using the changeset viewer.

