VirtualBox

Changeset 98298 in vbox for trunk


Ignore:
Timestamp:
Jan 25, 2023 2:23:33 AM (21 months ago)
Author:
vboxsync
Message:

VBoxManage: rc -> vrc/hrc. Make scm check. bugref:10223

Location:
trunk/src/VBox/Frontends/VBoxManage
Files:
1 added
11 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/VBox/Frontends/VBoxManage/VBoxInternalManage.cpp

    r98103 r98298  
    355355 *
    356356 * @param   enmCommand      The command.
    357  * @param   rc              The RTGetOpt return code.
     357 * @param   vrc             The RTGetOpt return code.
    358358 * @param   pValueUnion     The value union.
    359359 */
    360 static RTEXITCODE errorGetOptInternal(USAGECATEGORY enmCommand, int rc, union RTGETOPTUNION const *pValueUnion)
     360static RTEXITCODE errorGetOptInternal(USAGECATEGORY enmCommand, int vrc, union RTGETOPTUNION const *pValueUnion)
    361361{
    362362    /*
    363363     * Check if it is an unhandled standard option.
    364364     */
    365     if (rc == 'V')
     365    if (vrc == 'V')
    366366    {
    367367        RTPrintf("%sr%d\n", VBOX_VERSION_STRING, RTBldCfgRevision());
     
    369369    }
    370370
    371     if (rc == 'h')
     371    if (vrc == 'h')
    372372    {
    373373        showLogo(g_pStdErr);
     
    383383    printUsageInternal(enmCommand, g_pStdErr);
    384384
    385     if (rc == VINF_GETOPT_NOT_OPTION)
     385    if (vrc == VINF_GETOPT_NOT_OPTION)
    386386        return RTMsgErrorExit(RTEXITCODE_SYNTAX, Internal::tr("Invalid parameter '%s'"), pValueUnion->psz);
    387     if (rc > 0)
    388     {
    389         if (RT_C_IS_PRINT(rc))
    390             return RTMsgErrorExit(RTEXITCODE_SYNTAX, Internal::tr("Invalid option -%c"), rc);
    391         return RTMsgErrorExit(RTEXITCODE_SYNTAX, Internal::tr("Invalid option case %i"), rc);
    392     }
    393     if (rc == VERR_GETOPT_UNKNOWN_OPTION)
     387    if (vrc > 0)
     388    {
     389        if (RT_C_IS_PRINT(vrc))
     390            return RTMsgErrorExit(RTEXITCODE_SYNTAX, Internal::tr("Invalid option -%c"), vrc);
     391        return RTMsgErrorExit(RTEXITCODE_SYNTAX, Internal::tr("Invalid option case %i"), vrc);
     392    }
     393    if (vrc == VERR_GETOPT_UNKNOWN_OPTION)
    394394        return RTMsgErrorExit(RTEXITCODE_SYNTAX, Internal::tr("Unknown option: %s"), pValueUnion->psz);
    395     if (rc == VERR_GETOPT_INVALID_ARGUMENT_FORMAT)
     395    if (vrc == VERR_GETOPT_INVALID_ARGUMENT_FORMAT)
    396396        return RTMsgErrorExit(RTEXITCODE_SYNTAX, Internal::tr("Invalid argument format: %s"), pValueUnion->psz);
    397397    if (pValueUnion->pDef)
    398         return RTMsgErrorExit(RTEXITCODE_SYNTAX, "%s: %Rrs", pValueUnion->pDef->pszLong, rc);
    399     return RTMsgErrorExit(RTEXITCODE_SYNTAX, "%Rrs", rc);
     398        return RTMsgErrorExit(RTEXITCODE_SYNTAX, "%s: %Rrs", pValueUnion->pDef->pszLong, vrc);
     399    return RTMsgErrorExit(RTEXITCODE_SYNTAX, "%Rrs", vrc);
    400400}
    401401
     
    496496
    497497    char *pszKeys;
    498     int rc = RTUtf16ToUtf8(Keys.raw(), &pszKeys);
    499     if (RT_SUCCESS(rc))
     498    int vrc = RTUtf16ToUtf8(Keys.raw(), &pszKeys);
     499    if (RT_SUCCESS(vrc))
    500500    {
    501501        /* locate it */
     
    531531    else
    532532        RTMsgError(Internal::tr("Failed to delete key '%s' from '%s',  string conversion error %Rrc!"),
    533                    pszKey,  pszKeyBase, rc);
     533                   pszKey,  pszKeyBase, vrc);
    534534
    535535    return E_FAIL;
     
    630630        int vrc = RTStrToInt64Ex(argv[2], NULL, 0, &offDelta);
    631631        if (RT_FAILURE(vrc))
    632             return errorArgument(argv[0], Internal::tr("Failed to read delta '%s', rc=%Rrc\n"), argv[2], vrc);
     632            return errorArgument(argv[0], Internal::tr("Failed to read delta '%s', vrc=%Rrc\n"), argv[2], vrc);
    633633    }
    634634
     
    642642        int vrc = RTStrToUInt64Ex(argv[4], NULL, 0, &ModuleAddress);
    643643        if (RT_FAILURE(vrc))
    644             return errorArgument(argv[0], Internal::tr("Failed to read module address '%s', rc=%Rrc\n"), argv[4], vrc);
     644            return errorArgument(argv[0], Internal::tr("Failed to read module address '%s', vrc=%Rrc\n"), argv[4], vrc);
    645645    }
    646646
     
    650650        int vrc = RTStrToUInt64Ex(argv[5], NULL, 0, &ModuleSize);
    651651        if (RT_FAILURE(vrc))
    652             return errorArgument(argv[0], Internal::tr("Failed to read module size '%s', rc=%Rrc\n"), argv[5], vrc);
     652            return errorArgument(argv[0], Internal::tr("Failed to read module size '%s', vrc=%Rrc\n"), argv[5], vrc);
    653653    }
    654654
     
    707707    int vrc = RTStrToUInt64Ex(argv[2], NULL, 0, &ModuleAddress);
    708708    if (RT_FAILURE(vrc))
    709         return errorArgument(argv[0], Internal::tr("Failed to read module address '%s', rc=%Rrc\n"), argv[2], vrc);
     709        return errorArgument(argv[0], Internal::tr("Failed to read module address '%s', vrc=%Rrc\n"), argv[2], vrc);
    710710
    711711    /* name (optional) */
     
    718718        vrc = RTStrToUInt64Ex(argv[4], NULL, 0, &offSubtrahend);
    719719        if (RT_FAILURE(vrc))
    720             return errorArgument(argv[0], Internal::tr("Failed to read subtrahend '%s', rc=%Rrc\n"), argv[4], vrc);
     720            return errorArgument(argv[0], Internal::tr("Failed to read subtrahend '%s', vrc=%Rrc\n"), argv[4], vrc);
    721721    }
    722722
     
    726726        vrc = RTStrToUInt32Ex(argv[5], NULL, 0, &iSeg);
    727727        if (RT_FAILURE(vrc))
    728             return errorArgument(argv[0], Internal::tr("Failed to read segment number '%s', rc=%Rrc\n"), argv[5], vrc);
     728            return errorArgument(argv[0], Internal::tr("Failed to read segment number '%s', vrc=%Rrc\n"), argv[5], vrc);
    729729    }
    730730
     
    749749
    750750
    751 static DECLCALLBACK(void) handleVDError(void *pvUser, int rc, RT_SRC_POS_DECL, const char *pszFormat, va_list va)
     751static DECLCALLBACK(void) handleVDError(void *pvUser, int vrc, RT_SRC_POS_DECL, const char *pszFormat, va_list va)
    752752{
    753753    RT_NOREF(pvUser);
    754754    RTMsgErrorV(pszFormat, va);
    755     RTMsgError(Internal::tr("Error code %Rrc at %s(%u) in function %s"), rc, RT_SRC_POS_ARGS);
     755    RTMsgError(Internal::tr("Error code %Rrc at %s(%u) in function %s"), vrc, RT_SRC_POS_ARGS);
    756756}
    757757
     
    801801    char *pszFormat = NULL;
    802802    VDTYPE enmType = VDTYPE_INVALID;
    803     int rc = VDGetFormat(NULL /* pVDIfsDisk */, NULL /* pVDIfsImage */,
    804                          argv[1], VDTYPE_INVALID, &pszFormat, &enmType);
    805     if (RT_FAILURE(rc))
    806         return RTMsgErrorExit(RTEXITCODE_FAILURE, Internal::tr("Format autodetect failed: %Rrc"), rc);
     803    int vrc = VDGetFormat(NULL /* pVDIfsDisk */, NULL /* pVDIfsImage */, argv[1], VDTYPE_INVALID, &pszFormat, &enmType);
     804    if (RT_FAILURE(vrc))
     805        return RTMsgErrorExit(RTEXITCODE_FAILURE, Internal::tr("Format autodetect failed: %Rrc"), vrc);
    807806
    808807    PVDISK pDisk = NULL;
     
    813812    vdInterfaceError.pfnMessage   = handleVDMessage;
    814813
    815     rc = VDInterfaceAdd(&vdInterfaceError.Core, "VBoxManage_IError", VDINTERFACETYPE_ERROR,
    816                         NULL, sizeof(VDINTERFACEERROR), &pVDIfs);
    817     AssertRC(rc);
    818 
    819     rc = VDCreate(pVDIfs, enmType, &pDisk);
    820     if (RT_FAILURE(rc))
    821         return RTMsgErrorExit(RTEXITCODE_FAILURE, Internal::tr("Cannot create the virtual disk container: %Rrc"), rc);
     814    vrc = VDInterfaceAdd(&vdInterfaceError.Core, "VBoxManage_IError", VDINTERFACETYPE_ERROR,
     815                         NULL, sizeof(VDINTERFACEERROR), &pVDIfs);
     816    AssertRC(vrc);
     817
     818    vrc = VDCreate(pVDIfs, enmType, &pDisk);
     819    if (RT_FAILURE(vrc))
     820        return RTMsgErrorExit(RTEXITCODE_FAILURE, Internal::tr("Cannot create the virtual disk container: %Rrc"), vrc);
    822821
    823822    /* Open the image */
    824     rc = VDOpen(pDisk, pszFormat, argv[1], VD_OPEN_FLAGS_NORMAL | VD_OPEN_FLAGS_INFO, NULL);
    825     if (RT_FAILURE(rc))
    826         return RTMsgErrorExit(RTEXITCODE_FAILURE, Internal::tr("Cannot open the image: %Rrc"), rc);
     823    vrc = VDOpen(pDisk, pszFormat, argv[1], VD_OPEN_FLAGS_NORMAL | VD_OPEN_FLAGS_INFO, NULL);
     824    if (RT_FAILURE(vrc))
     825        return RTMsgErrorExit(RTEXITCODE_FAILURE, Internal::tr("Cannot open the image: %Rrc"), vrc);
    827826
    828827    if (uuidType == HDUUID)
    829       rc = VDSetUuid(pDisk, VD_LAST_IMAGE, uuid.raw());
     828      vrc = VDSetUuid(pDisk, VD_LAST_IMAGE, uuid.raw());
    830829    else
    831       rc = VDSetParentUuid(pDisk, VD_LAST_IMAGE, uuid.raw());
    832     if (RT_FAILURE(rc))
    833         RTMsgError(Internal::tr("Cannot set a new UUID: %Rrc"), rc);
     830      vrc = VDSetParentUuid(pDisk, VD_LAST_IMAGE, uuid.raw());
     831    if (RT_FAILURE(vrc))
     832        RTMsgError(Internal::tr("Cannot set a new UUID: %Rrc"), vrc);
    834833    else
    835834        RTPrintf(Internal::tr("UUID changed to: %s\n"), uuid.toString().c_str());
     
    837836    VDCloseAll(pDisk);
    838837
    839     return RT_SUCCESS(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
     838    return RT_SUCCESS(vrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
    840839}
    841840
     
    854853    char *pszFormat = NULL;
    855854    VDTYPE enmType = VDTYPE_INVALID;
    856     int rc = VDGetFormat(NULL /* pVDIfsDisk */, NULL /* pVDIfsImage */,
    857                          argv[0], VDTYPE_INVALID, &pszFormat, &enmType);
    858     if (RT_FAILURE(rc))
    859         return RTMsgErrorExit(RTEXITCODE_FAILURE, Internal::tr("Format autodetect failed: %Rrc"), rc);
     855    int vrc = VDGetFormat(NULL /* pVDIfsDisk */, NULL /* pVDIfsImage */, argv[0], VDTYPE_INVALID, &pszFormat, &enmType);
     856    if (RT_FAILURE(vrc))
     857        return RTMsgErrorExit(RTEXITCODE_FAILURE, Internal::tr("Format autodetect failed: %Rrc"), vrc);
    860858
    861859    PVDISK pDisk = NULL;
     
    866864    vdInterfaceError.pfnMessage   = handleVDMessage;
    867865
    868     rc = VDInterfaceAdd(&vdInterfaceError.Core, "VBoxManage_IError", VDINTERFACETYPE_ERROR,
    869                         NULL, sizeof(VDINTERFACEERROR), &pVDIfs);
    870     AssertRC(rc);
    871 
    872     rc = VDCreate(pVDIfs, enmType, &pDisk);
    873     if (RT_FAILURE(rc))
    874         return RTMsgErrorExit(RTEXITCODE_FAILURE, Internal::tr("Cannot create the virtual disk container: %Rrc"), rc);
     866    vrc = VDInterfaceAdd(&vdInterfaceError.Core, "VBoxManage_IError", VDINTERFACETYPE_ERROR,
     867                         NULL, sizeof(VDINTERFACEERROR), &pVDIfs);
     868    AssertRC(vrc);
     869
     870    vrc = VDCreate(pVDIfs, enmType, &pDisk);
     871    if (RT_FAILURE(vrc))
     872        return RTMsgErrorExit(RTEXITCODE_FAILURE, Internal::tr("Cannot create the virtual disk container: %Rrc"), vrc);
    875873
    876874    /* Open the image */
    877     rc = VDOpen(pDisk, pszFormat, argv[0], VD_OPEN_FLAGS_READONLY | VD_OPEN_FLAGS_INFO, NULL);
    878     if (RT_FAILURE(rc))
    879         return RTMsgErrorExit(RTEXITCODE_FAILURE, Internal::tr("Cannot open the image: %Rrc"), rc);
     875    vrc = VDOpen(pDisk, pszFormat, argv[0], VD_OPEN_FLAGS_READONLY | VD_OPEN_FLAGS_INFO, NULL);
     876    if (RT_FAILURE(vrc))
     877        return RTMsgErrorExit(RTEXITCODE_FAILURE, Internal::tr("Cannot open the image: %Rrc"), vrc);
    880878
    881879    VDDumpImages(pDisk);
     
    883881    VDCloseAll(pDisk);
    884882
    885     return RT_SUCCESS(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
     883    return RT_SUCCESS(vrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
    886884}
    887885
     
    892890    uint32_t sector_size = 512;
    893891    uint64_t lastUsableLBA = 0;
    894     int rc;
    895892
    896893    VDISKPARTTYPE partitioningType;
     
    899896    memset(pPart->aPartitions, '\0', sizeof(pPart->aPartitions));
    900897
    901     rc = RTFileReadAt(File, 0, &aBuffer, sizeof(aBuffer), NULL);
    902     if (RT_FAILURE(rc))
    903         return rc;
     898    int vrc = RTFileReadAt(File, 0, &aBuffer, sizeof(aBuffer), NULL);
     899    if (RT_FAILURE(vrc))
     900        return vrc;
    904901
    905902    if (aBuffer[450] == 0xEE)/* check the sign of the GPT disk*/
     
    911908            return VERR_INVALID_PARAMETER;
    912909
    913         rc = RTFileReadAt(File, sector_size, &partitionTableHeader, sector_size, NULL);
    914         if (RT_SUCCESS(rc))
     910        vrc = RTFileReadAt(File, sector_size, &partitionTableHeader, sector_size, NULL);
     911        if (RT_SUCCESS(vrc))
    915912        {
    916913            /** @todo r=bird: This is a 64-bit magic value, right... */
     
    971968            /* partition entries begin from LBA2 */
    972969            /** @todo r=aeichner: Reading from LBA 2 is not always correct, the header will contain the starting LBA. */
    973             rc = RTFileReadAt(File, 1024, pbPartTable, RT_ALIGN_Z(partitionEntrySize * partitionsNumber, 512), NULL);
    974             if (RT_FAILURE(rc))
     970            vrc = RTFileReadAt(File, 1024, pbPartTable, RT_ALIGN_Z(partitionEntrySize * partitionsNumber, 512), NULL);
     971            if (RT_FAILURE(vrc))
    975972            {
    976973                RTMsgError(Internal::tr("Reading the partition table failed"));
    977974                RTMemFree(pbPartTable);
    978                 return rc;
     975                return vrc;
    979976            }
    980977
     
    10821079            do
    10831080            {
    1084                 rc = RTFileReadAt(File, (uStart + uOffset) * 512, &aBuffer, sizeof(aBuffer), NULL);
    1085                 if (RT_FAILURE(rc))
    1086                     return rc;
     1081                vrc = RTFileReadAt(File, (uStart + uOffset) * 512, &aBuffer, sizeof(aBuffer), NULL);
     1082                if (RT_FAILURE(vrc))
     1083                    return vrc;
    10871084
    10881085                if (aBuffer[510] != 0x55 || aBuffer[511] != 0xaa)
     
    18311828static RTEXITCODE CmdModUninstall(void)
    18321829{
    1833     int rc = SUPR3Uninstall();
    1834     if (RT_SUCCESS(rc) || rc == VERR_NOT_IMPLEMENTED)
     1830    int vrc = SUPR3Uninstall();
     1831    if (RT_SUCCESS(vrc) || vrc == VERR_NOT_IMPLEMENTED)
    18351832        return RTEXITCODE_SUCCESS;
    18361833    return RTEXITCODE_FAILURE;
     
    18441841static RTEXITCODE CmdModInstall(void)
    18451842{
    1846     int rc = SUPR3Install();
    1847     if (RT_SUCCESS(rc) || rc == VERR_NOT_IMPLEMENTED)
     1843    int vrc = SUPR3Install();
     1844    if (RT_SUCCESS(vrc) || vrc == VERR_NOT_IMPLEMENTED)
    18481845        return RTEXITCODE_SUCCESS;
    18491846    return RTEXITCODE_FAILURE;
  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageAppliance.cpp

    r98103 r98298  
    100100static int parseImportOptions(const char *psz, com::SafeArray<ImportOptions_T> *options)
    101101{
    102     int rc = VINF_SUCCESS;
    103     while (psz && *psz && RT_SUCCESS(rc))
     102    int vrc = VINF_SUCCESS;
     103    while (psz && *psz && RT_SUCCESS(vrc))
    104104    {
    105105        size_t len;
     
    118118                options->push_back(ImportOptions_ImportToVDI);
    119119            else
    120                 rc = VERR_PARSE_ERROR;
     120                vrc = VERR_PARSE_ERROR;
    121121        }
    122122        if (pszComma)
     
    126126    }
    127127
    128     return rc;
     128    return vrc;
    129129}
    130130
     
    14271427static int parseExportOptions(const char *psz, com::SafeArray<ExportOptions_T> *options)
    14281428{
    1429     int rc = VINF_SUCCESS;
    1430     while (psz && *psz && RT_SUCCESS(rc))
     1429    int vrc = VINF_SUCCESS;
     1430    while (psz && *psz && RT_SUCCESS(vrc))
    14311431    {
    14321432        size_t len;
     
    14551455                options->push_back(ExportOptions_StripAllNonNATMACs);
    14561456            else
    1457                 rc = VERR_PARSE_ERROR;
     1457                vrc = VERR_PARSE_ERROR;
    14581458        }
    14591459        if (pszComma)
     
    14631463    }
    14641464
    1465     return rc;
     1465    return vrc;
    14661466}
    14671467
     
    21222122     */
    21232123    RTVFSFILE hVfsFileOva;
    2124     int rc = RTVfsFileOpenNormal(pszOva, RTFILE_O_OPEN | RTFILE_O_READWRITE | RTFILE_O_DENY_WRITE, &hVfsFileOva);
    2125     if (RT_FAILURE(rc))
    2126         return RTMsgErrorExitFailure(Appliance::tr("Failed to open OVA '%s' for updating: %Rrc"), pszOva, rc);
     2124    int vrc = RTVfsFileOpenNormal(pszOva, RTFILE_O_OPEN | RTFILE_O_READWRITE | RTFILE_O_DENY_WRITE, &hVfsFileOva);
     2125    if (RT_FAILURE(vrc))
     2126        return RTMsgErrorExitFailure(Appliance::tr("Failed to open OVA '%s' for updating: %Rrc"), pszOva, vrc);
    21272127
    21282128    RTVFSFSSTREAM hVfsFssOva;
    2129     rc = RTZipTarFsStreamForFile(hVfsFileOva, RTZIPTARFORMAT_DEFAULT, RTZIPTAR_C_UPDATE, &hVfsFssOva);
     2129    vrc = RTZipTarFsStreamForFile(hVfsFileOva, RTZIPTARFORMAT_DEFAULT, RTZIPTAR_C_UPDATE, &hVfsFssOva);
    21302130    RTVfsFileRelease(hVfsFileOva);
    2131     if (RT_FAILURE(rc))
    2132         return RTMsgErrorExitFailure(Appliance::tr("Failed to open OVA '%s' as a TAR file: %Rrc"), pszOva, rc);
     2131    if (RT_FAILURE(vrc))
     2132        return RTMsgErrorExitFailure(Appliance::tr("Failed to open OVA '%s' as a TAR file: %Rrc"), pszOva, vrc);
    21332133    *phVfsFssOva = hVfsFssOva;
    21342134
     
    21472147        RTVFSOBJTYPE    enmType;
    21482148        RTVFSOBJ        hVfsObj;
    2149         rc = RTVfsFsStrmNext(hVfsFssOva, &pszName, &enmType, &hVfsObj);
    2150         if (RT_FAILURE(rc))
     2149        vrc = RTVfsFsStrmNext(hVfsFssOva, &pszName, &enmType, &hVfsObj);
     2150        if (RT_FAILURE(vrc))
    21512151        {
    2152             if (rc == VERR_EOF)
    2153                 rc = VINF_SUCCESS;
     2152            if (vrc == VERR_EOF)
     2153                vrc = VINF_SUCCESS;
    21542154            else
    2155                 RTMsgError(Appliance::tr("RTVfsFsStrmNext returned %Rrc"), rc);
     2155                RTMsgError(Appliance::tr("RTVfsFsStrmNext returned %Rrc"), vrc);
    21562156            break;
    21572157        }
     
    21692169        {
    21702170            if (*phVfsManifest != NIL_RTVFSFILE)
    2171                 rc = RTMsgErrorRc(VERR_DUPLICATE, Appliance::tr("OVA contains multiple manifests! first: %s  second: %s"),
    2172                                   pStrManifestName->c_str(), pszName);
     2171                vrc = RTMsgErrorRc(VERR_DUPLICATE, Appliance::tr("OVA contains multiple manifests! first: %s  second: %s"),
     2172                                   pStrManifestName->c_str(), pszName);
    21732173            else if (pszSignatureName)
    2174                 rc = RTMsgErrorRc(VERR_WRONG_ORDER,
    2175                                   Appliance::tr("Unsupported OVA file ordering! Signature file ('%s') as succeeded by '%s'."),
    2176                                   pszSignatureName, pszName);
     2174                vrc = RTMsgErrorRc(VERR_WRONG_ORDER,
     2175                                   Appliance::tr("Unsupported OVA file ordering! Signature file ('%s') as succeeded by '%s'."),
     2176                                   pszSignatureName, pszName);
    21772177            else
    21782178            {
    21792179                if (iVerbosity >= 2)
    21802180                    RTMsgInfo(Appliance::tr("Found manifest file: %s"), pszName);
    2181                 rc = pStrManifestName->assignNoThrow(pszName);
    2182                 if (RT_SUCCESS(rc))
     2181                vrc = pStrManifestName->assignNoThrow(pszName);
     2182                if (RT_SUCCESS(vrc))
    21832183                {
    21842184                    RTVFSIOSTREAM hVfsIos = RTVfsObjToIoStream(hVfsObj);
    21852185                    Assert(hVfsIos != NIL_RTVFSIOSTREAM);
    2186                     rc = RTVfsMemorizeIoStreamAsFile(hVfsIos, RTFILE_O_READ, phVfsManifest);
     2186                    vrc = RTVfsMemorizeIoStreamAsFile(hVfsIos, RTFILE_O_READ, phVfsManifest);
    21872187                    RTVfsIoStrmRelease(hVfsIos);     /* consumes stream handle.  */
    2188                     if (RT_FAILURE(rc))
    2189                         rc = RTMsgErrorRc(VERR_DUPLICATE, Appliance::tr("Failed to memorize the manifest: %Rrc"), rc);
     2188                    if (RT_FAILURE(vrc))
     2189                        vrc = RTMsgErrorRc(VERR_DUPLICATE, Appliance::tr("Failed to memorize the manifest: %Rrc"), vrc);
    21902190                }
    21912191                else
     
    21982198        {
    21992199            if (*phVfsOldSignature != NIL_RTVFSOBJ)
    2200                 rc = RTMsgErrorRc(VERR_WRONG_ORDER, Appliance::tr("Multiple signature files! (%s)"), pszName);
     2200                vrc = RTMsgErrorRc(VERR_WRONG_ORDER, Appliance::tr("Multiple signature files! (%s)"), pszName);
    22012201            else
    22022202            {
     
    22102210        }
    22112211        else if (pszSignatureName)
    2212             rc = RTMsgErrorRc(VERR_WRONG_ORDER,
    2213                               Appliance::tr("Unsupported OVA file ordering! Signature file ('%s') as succeeded by '%s'."),
    2214                               pszSignatureName, pszName);
     2212            vrc = RTMsgErrorRc(VERR_WRONG_ORDER,
     2213                               Appliance::tr("Unsupported OVA file ordering! Signature file ('%s') as succeeded by '%s'."),
     2214                               pszSignatureName, pszName);
    22152215
    22162216        /*
     
    22192219        RTVfsObjRelease(hVfsObj);
    22202220        RTStrFree(pszName);
    2221         if (RT_FAILURE(rc))
     2221        if (RT_FAILURE(vrc))
    22222222            break;
    22232223    }
     
    22262226     * Complain if no manifest.
    22272227     */
    2228     if (RT_SUCCESS(rc) && *phVfsManifest == NIL_RTVFSFILE)
    2229         rc = RTMsgErrorRc(VERR_NOT_FOUND, Appliance::tr("The OVA contains no manifest and cannot be signed!"));
    2230     else if (RT_SUCCESS(rc) && *phVfsOldSignature != NIL_RTVFSOBJ && !fReSign)
    2231         rc = RTMsgErrorRc(VERR_ALREADY_EXISTS,
    2232                           Appliance::tr("The OVA is already signed ('%s')! (Use the --force option to force re-signing it.)"),
    2233                           pszSignatureName);
     2228    if (RT_SUCCESS(vrc) && *phVfsManifest == NIL_RTVFSFILE)
     2229        vrc = RTMsgErrorRc(VERR_NOT_FOUND, Appliance::tr("The OVA contains no manifest and cannot be signed!"));
     2230    else if (RT_SUCCESS(vrc) && *phVfsOldSignature != NIL_RTVFSOBJ && !fReSign)
     2231        vrc = RTMsgErrorRc(VERR_ALREADY_EXISTS,
     2232                           Appliance::tr("The OVA is already signed ('%s')! (Use the --force option to force re-signing it.)"),
     2233                           pszSignatureName);
    22342234
    22352235    RTStrFree(pszSignatureName);
    2236     return rc;
     2236    return vrc;
    22372237}
    22382238
     
    22552255     * Truncate the file at the old signature, if present.
    22562256     */
    2257     int rc;
     2257    int vrc;
    22582258    if (hVfsOldSignature != NIL_RTVFSOBJ)
    22592259    {
    2260         rc = RTZipTarFsStreamTruncate(hVfsFssOva, hVfsOldSignature, false /*fAfter*/);
    2261         if (RT_FAILURE(rc))
    2262             return RTMsgErrorRc(rc, Appliance::tr("RTZipTarFsStreamTruncate failed on '%s': %Rrc"), pszOva, rc);
     2260        vrc = RTZipTarFsStreamTruncate(hVfsFssOva, hVfsOldSignature, false /*fAfter*/);
     2261        if (RT_FAILURE(vrc))
     2262            return RTMsgErrorRc(vrc, Appliance::tr("RTZipTarFsStreamTruncate failed on '%s': %Rrc"), pszOva, vrc);
    22632263    }
    22642264
     
    22672267     * we'll end up with VERR_EOF, probably not a great idea...
    22682268     */
    2269     rc = RTVfsFileSeek(hVfsFileSignature, 0, RTFILE_SEEK_BEGIN, NULL);
    2270     if (RT_FAILURE(rc))
    2271         return RTMsgErrorRc(rc, Appliance::tr("RTVfsFileSeek(hVfsFileSignature) failed: %Rrc"), rc);
     2269    vrc = RTVfsFileSeek(hVfsFileSignature, 0, RTFILE_SEEK_BEGIN, NULL);
     2270    if (RT_FAILURE(vrc))
     2271        return RTMsgErrorRc(vrc, Appliance::tr("RTVfsFileSeek(hVfsFileSignature) failed: %Rrc"), vrc);
    22722272
    22732273    RTVFSOBJ hVfsObj = RTVfsObjFromFile(hVfsFileSignature);
    2274     rc = RTVfsFsStrmAdd(hVfsFssOva, pszSignatureName, hVfsObj, 0 /*fFlags*/);
     2274    vrc = RTVfsFsStrmAdd(hVfsFssOva, pszSignatureName, hVfsObj, 0 /*fFlags*/);
    22752275    RTVfsObjRelease(hVfsObj);
    2276     if (RT_FAILURE(rc))
    2277         return RTMsgErrorRc(rc, Appliance::tr("RTVfsFsStrmAdd('%s') failed on '%s': %Rrc"), pszSignatureName, pszOva, rc);
     2276    if (RT_FAILURE(vrc))
     2277        return RTMsgErrorRc(vrc, Appliance::tr("RTVfsFsStrmAdd('%s') failed on '%s': %Rrc"), pszSignatureName, pszOva, vrc);
    22782278
    22792279    /*
    22802280     * Terminate the file system stream.
    22812281     */
    2282     rc = RTVfsFsStrmEnd(hVfsFssOva);
    2283     if (RT_FAILURE(rc))
    2284         return RTMsgErrorRc(rc, Appliance::tr("RTVfsFsStrmEnd failed on '%s': %Rrc"), pszOva, rc);
     2282    vrc = RTVfsFsStrmEnd(hVfsFssOva);
     2283    if (RT_FAILURE(vrc))
     2284        return RTMsgErrorRc(vrc, Appliance::tr("RTVfsFsStrmEnd failed on '%s': %Rrc"), pszOva, vrc);
    22852285
    22862286    return VINF_SUCCESS;
     
    22942294                                       unsigned iVerbosity, const char *pszTag, PRTERRINFOSTATIC pErrInfo)
    22952295{
    2296     int rc;
     2296    int vrc;
    22972297
    22982298    /*
     
    23112311             * Check that things add up.
    23122312             */
    2313             rc = RTCrPkcs7SignedData_CheckSanity(pSignedData,
    2314                                                  RTCRPKCS7SIGNEDDATA_SANITY_F_ONLY_KNOWN_HASH
    2315                                                  | RTCRPKCS7SIGNEDDATA_SANITY_F_SIGNING_CERT_PRESENT,
    2316                                                  RTErrInfoInitStatic(pErrInfo), "SD");
    2317             if (RT_SUCCESS(rc))
     2313            vrc = RTCrPkcs7SignedData_CheckSanity(pSignedData,
     2314                                                  RTCRPKCS7SIGNEDDATA_SANITY_F_ONLY_KNOWN_HASH
     2315                                                  | RTCRPKCS7SIGNEDDATA_SANITY_F_SIGNING_CERT_PRESENT,
     2316                                                  RTErrInfoInitStatic(pErrInfo), "SD");
     2317            if (RT_SUCCESS(vrc))
    23182318            {
    23192319                if (iVerbosity > 2 && pszTag == NULL)
     
    23252325                 */
    23262326                RTTIMESPEC Now;
    2327                 rc = RTCrPkcs7VerifySignedDataWithExternalData(pContentInfo, RTCRPKCS7VERIFY_SD_F_TRUST_ALL_CERTS,
    2328                                                                NIL_RTCRSTORE /*hAdditionalCerts*/,
    2329                                                                NIL_RTCRSTORE /*hTrustedCerts*/,
    2330                                                                RTTimeNow(&Now),
    2331                                                                NULL /*pfnVerifyCert*/, NULL /*pvUser*/,
    2332                                                                pvManifest, cbManifest, RTErrInfoInitStatic(pErrInfo));
    2333                 if (RT_SUCCESS(rc))
     2327                vrc = RTCrPkcs7VerifySignedDataWithExternalData(pContentInfo, RTCRPKCS7VERIFY_SD_F_TRUST_ALL_CERTS,
     2328                                                                NIL_RTCRSTORE /*hAdditionalCerts*/,
     2329                                                                NIL_RTCRSTORE /*hTrustedCerts*/,
     2330                                                                RTTimeNow(&Now),
     2331                                                                NULL /*pfnVerifyCert*/, NULL /*pvUser*/,
     2332                                                                pvManifest, cbManifest, RTErrInfoInitStatic(pErrInfo));
     2333                if (RT_SUCCESS(vrc))
    23342334                {
    23352335                    if (iVerbosity > 1 && pszTag != NULL)
     
    23372337                }
    23382338                else
    2339                     rc = RTMsgErrorRc(rc, Appliance::tr("Failed to verify the PKCS#7/CMS signature: %Rrc%RTeim"),
    2340                                       rc, &pErrInfo->Core);
     2339                    vrc = RTMsgErrorRc(vrc, Appliance::tr("Failed to verify the PKCS#7/CMS signature: %Rrc%RTeim"),
     2340                                       vrc, &pErrInfo->Core);
    23412341            }
    23422342            else
    23432343                RTMsgError(Appliance::tr("RTCrPkcs7SignedData_CheckSanity failed on PKCS#7/CMS signature: %Rrc%RTeim"),
    2344                            rc, &pErrInfo->Core);
     2344                           vrc, &pErrInfo->Core);
    23452345
    23462346        }
    23472347        else
    2348             rc = RTMsgErrorRc(VERR_WRONG_TYPE, Appliance::tr("PKCS#7/CMS signature inner ContentType isn't 'data' but: %s"),
    2349                               pSignedData->ContentInfo.ContentType.szObjId);
     2348            vrc = RTMsgErrorRc(VERR_WRONG_TYPE, Appliance::tr("PKCS#7/CMS signature inner ContentType isn't 'data' but: %s"),
     2349                               pSignedData->ContentInfo.ContentType.szObjId);
    23502350    }
    23512351    else
    2352         rc = RTMsgErrorRc(VERR_WRONG_TYPE, Appliance::tr("PKCS#7/CMD signature is not 'signedData': %s"),
    2353                           pContentInfo->ContentType.szObjId);
    2354     return rc;
     2352        vrc = RTMsgErrorRc(VERR_WRONG_TYPE, Appliance::tr("PKCS#7/CMD signature is not 'signedData': %s"),
     2353                           pContentInfo->ContentType.szObjId);
     2354    return vrc;
    23552355}
    23562356
     
    23702370    RTCRPKCS7CONTENTINFO ContentInfo;
    23712371    RT_ZERO(ContentInfo);
    2372     int rc = RTCrPkcs7ContentInfo_DecodeAsn1(&PrimaryCursor.Cursor, 0, &ContentInfo, "CI");
    2373     if (RT_SUCCESS(rc))
     2372    int vrc = RTCrPkcs7ContentInfo_DecodeAsn1(&PrimaryCursor.Cursor, 0, &ContentInfo, "CI");
     2373    if (RT_SUCCESS(vrc))
    23742374    {
    23752375        if (iVerbosity > 5)
    23762376            RTAsn1Dump(&ContentInfo.SeqCore.Asn1Core, 0 /*fFlags*/, 0 /*uLevel*/, RTStrmDumpPrintfV, g_pStdOut);
    23772377
    2378         rc = doCheckPkcs7SignatureWorker(&ContentInfo, pvManifest, cbManifest, iVerbosity, NULL, pErrInfo);
    2379         if (RT_SUCCESS(rc))
     2378        vrc = doCheckPkcs7SignatureWorker(&ContentInfo, pvManifest, cbManifest, iVerbosity, NULL, pErrInfo);
     2379        if (RT_SUCCESS(vrc))
    23802380        {
    23812381            /*
     
    23842384             */
    23852385            RTCRPKCS7CONTENTINFO ContentInfo2;
    2386             rc = RTCrPkcs7ContentInfo_Clone(&ContentInfo2, &ContentInfo, &g_RTAsn1DefaultAllocator);
    2387             if (RT_SUCCESS(rc))
     2386            vrc = RTCrPkcs7ContentInfo_Clone(&ContentInfo2, &ContentInfo, &g_RTAsn1DefaultAllocator);
     2387            if (RT_SUCCESS(vrc))
    23882388            {
    2389                 rc = doCheckPkcs7SignatureWorker(&ContentInfo2, pvManifest, cbManifest, iVerbosity, "cloned", pErrInfo);
     2389                vrc = doCheckPkcs7SignatureWorker(&ContentInfo2, pvManifest, cbManifest, iVerbosity, "cloned", pErrInfo);
    23902390                RTCrPkcs7ContentInfo_Delete(&ContentInfo2);
    23912391            }
    23922392            else
    2393                 rc = RTMsgErrorRc(rc, Appliance::tr("RTCrPkcs7ContentInfo_Clone failed: %Rrc"), rc);
     2393                vrc = RTMsgErrorRc(vrc, Appliance::tr("RTCrPkcs7ContentInfo_Clone failed: %Rrc"), vrc);
    23942394        }
    23952395    }
    23962396    else
    23972397        RTMsgError(Appliance::tr("RTCrPkcs7ContentInfo_DecodeAsn1 failed to decode PKCS#7/CMS signature: %Rrc%RTemi"),
    2398                    rc, &pErrInfo->Core);
     2398                   vrc, &pErrInfo->Core);
    23992399
    24002400    RTCrPkcs7ContentInfo_Delete(&ContentInfo);
    2401     return rc;
     2401    return vrc;
    24022402}
    24032403
     
    24142414     * Add a blank line, just for good measure.
    24152415     */
    2416     int rc = RTVfsFileWrite(hVfsFileSignature, "\n", 1, NULL);
    2417     if (RT_FAILURE(rc))
    2418         return RTMsgErrorRc(rc, "RTVfsFileWrite/signature: %Rrc", rc);
     2416    int vrc = RTVfsFileWrite(hVfsFileSignature, "\n", 1, NULL);
     2417    if (RT_FAILURE(vrc))
     2418        return RTMsgErrorRc(vrc, "RTVfsFileWrite/signature: %Rrc", vrc);
    24192419
    24202420    /*
     
    24222422     */
    24232423    uint64_t cbManifest;
    2424     rc = RTVfsFileQuerySize(hVfsFileManifest, &cbManifest);
    2425     if (RT_FAILURE(rc))
    2426         return RTMsgErrorRc(rc, "RTVfsFileQuerySize/manifest: %Rrc", rc);
     2424    vrc = RTVfsFileQuerySize(hVfsFileManifest, &cbManifest);
     2425    if (RT_FAILURE(vrc))
     2426        return RTMsgErrorRc(vrc, "RTVfsFileQuerySize/manifest: %Rrc", vrc);
    24272427    if (cbManifest > _4M)
    24282428        return RTMsgErrorRc(VERR_OUT_OF_RANGE, Appliance::tr("Manifest is too big: %#RX64 bytes, max 4MiB", "", cbManifest),
     
    24332433        return RTMsgErrorRc(VERR_NO_MEMORY, Appliance::tr("Out of memory!"));
    24342434
    2435     rc = RTVfsFileReadAt(hVfsFileManifest, 0, pvManifest, (size_t)cbManifest, NULL);
    2436     if (RT_SUCCESS(rc))
     2435    vrc = RTVfsFileReadAt(hVfsFileManifest, 0, pvManifest, (size_t)cbManifest, NULL);
     2436    if (RT_SUCCESS(vrc))
    24372437    {
    24382438        /*
     
    24422442        if (cIntermediateCerts)
    24432443        {
    2444             rc = RTCrStoreCreateInMem(&hIntermediateCerts, cIntermediateCerts);
    2445             if (RT_SUCCESS(rc))
     2444            vrc = RTCrStoreCreateInMem(&hIntermediateCerts, cIntermediateCerts);
     2445            if (RT_SUCCESS(vrc))
    24462446            {
    24472447                for (unsigned i = 0; i < cIntermediateCerts; i++)
    24482448                {
    24492449                    const char *pszFile = papszIntermediateCerts[i];
    2450                     rc = RTCrStoreCertAddFromFile(hIntermediateCerts, 0 /*fFlags*/, pszFile, &pErrInfo->Core);
    2451                     if (RT_FAILURE(rc))
     2450                    vrc = RTCrStoreCertAddFromFile(hIntermediateCerts, 0 /*fFlags*/, pszFile, &pErrInfo->Core);
     2451                    if (RT_FAILURE(vrc))
    24522452                    {
    2453                         RTMsgError(Appliance::tr("RTCrStoreCertAddFromFile failed on '%s': %Rrc%#RTeim"), pszFile, rc, &pErrInfo->Core);
     2453                        RTMsgError(Appliance::tr("RTCrStoreCertAddFromFile failed on '%s': %Rrc%#RTeim"),
     2454                                   pszFile, vrc, &pErrInfo->Core);
    24542455                        break;
    24552456                    }
     
    24572458            }
    24582459            else
    2459                 RTMsgError(Appliance::tr("RTCrStoreCreateInMem failed: %Rrc"), rc);
     2460                RTMsgError(Appliance::tr("RTCrStoreCreateInMem failed: %Rrc"), vrc);
    24602461        }
    2461         if (RT_SUCCESS(rc))
     2462        if (RT_SUCCESS(vrc))
    24622463        {
    24632464            /*
     
    24652466             */
    24662467            size_t cbResult = 0;
    2467             rc = RTCrPkcs7SimpleSignSignedData(RTCRPKCS7SIGN_SD_F_DEATCHED | RTCRPKCS7SIGN_SD_F_NO_SMIME_CAP,
    2468                                                pCertificate, hPrivateKey, pvManifest, (size_t)cbManifest, enmDigestType,
    2469                                                hIntermediateCerts, NULL /*pAdditionalAuthenticatedAttribs*/,
    2470                                                NULL /*pvResult*/, &cbResult, RTErrInfoInitStatic(pErrInfo));
    2471             if (rc == VERR_BUFFER_OVERFLOW)
     2468            vrc = RTCrPkcs7SimpleSignSignedData(RTCRPKCS7SIGN_SD_F_DEATCHED | RTCRPKCS7SIGN_SD_F_NO_SMIME_CAP,
     2469                                                pCertificate, hPrivateKey, pvManifest, (size_t)cbManifest, enmDigestType,
     2470                                                hIntermediateCerts, NULL /*pAdditionalAuthenticatedAttribs*/,
     2471                                                NULL /*pvResult*/, &cbResult, RTErrInfoInitStatic(pErrInfo));
     2472            if (vrc == VERR_BUFFER_OVERFLOW)
    24722473            {
    24732474                /*
     
    24772478                if (pvResult)
    24782479                {
    2479                     rc = RTCrPkcs7SimpleSignSignedData(RTCRPKCS7SIGN_SD_F_DEATCHED | RTCRPKCS7SIGN_SD_F_NO_SMIME_CAP,
    2480                                                        pCertificate, hPrivateKey, pvManifest, (size_t)cbManifest, enmDigestType,
    2481                                                        hIntermediateCerts, NULL /*pAdditionalAuthenticatedAttribs*/,
    2482                                                        pvResult, &cbResult, RTErrInfoInitStatic(pErrInfo));
    2483                     if (RT_SUCCESS(rc))
     2480                    vrc = RTCrPkcs7SimpleSignSignedData(RTCRPKCS7SIGN_SD_F_DEATCHED | RTCRPKCS7SIGN_SD_F_NO_SMIME_CAP,
     2481                                                        pCertificate, hPrivateKey, pvManifest, (size_t)cbManifest, enmDigestType,
     2482                                                        hIntermediateCerts, NULL /*pAdditionalAuthenticatedAttribs*/,
     2483                                                        pvResult, &cbResult, RTErrInfoInitStatic(pErrInfo));
     2484                    if (RT_SUCCESS(vrc))
    24842485                    {
    24852486                        /*
    24862487                         * Add it to the signature file in PEM format.
    24872488                         */
    2488                         rc = (int)RTCrPemWriteBlobToVfsFile(hVfsFileSignature, pvResult, cbResult, "CMS");
    2489                         if (RT_SUCCESS(rc))
     2489                        vrc = (int)RTCrPemWriteBlobToVfsFile(hVfsFileSignature, pvResult, cbResult, "CMS");
     2490                        if (RT_SUCCESS(vrc))
    24902491                        {
    24912492                            if (iVerbosity > 1)
     
    24982499                             * Try decode and verify the signature.
    24992500                             */
    2500                             rc = doCheckPkcs7Signature(pvResult, cbResult, pCertificate, hIntermediateCerts,
    2501                                                        pvManifest, (size_t)cbManifest, iVerbosity, pErrInfo);
     2501                            vrc = doCheckPkcs7Signature(pvResult, cbResult, pCertificate, hIntermediateCerts,
     2502                                                        pvManifest, (size_t)cbManifest, iVerbosity, pErrInfo);
    25022503                        }
    25032504                        else
    2504                             RTMsgError(Appliance::tr("RTCrPemWriteBlobToVfsFile failed: %Rrc"), rc);
     2505                            RTMsgError(Appliance::tr("RTCrPemWriteBlobToVfsFile failed: %Rrc"), vrc);
    25052506                    }
    25062507                    RTMemFree(pvResult);
    25072508                }
    25082509                else
    2509                     rc = RTMsgErrorRc(VERR_NO_MEMORY, Appliance::tr("Out of memory!"));
     2510                    vrc = RTMsgErrorRc(VERR_NO_MEMORY, Appliance::tr("Out of memory!"));
    25102511            }
    25112512            else
    2512                 RTMsgError(Appliance::tr("RTCrPkcs7SimpleSignSignedData failed: %Rrc%#RTeim"), rc, &pErrInfo->Core);
     2513                RTMsgError(Appliance::tr("RTCrPkcs7SimpleSignSignedData failed: %Rrc%#RTeim"), vrc, &pErrInfo->Core);
    25132514        }
    25142515    }
    25152516    else
    2516         RTMsgError(Appliance::tr("RTVfsFileReadAt failed: %Rrc"), rc);
     2517        RTMsgError(Appliance::tr("RTVfsFileReadAt failed: %Rrc"), vrc);
    25172518    RTMemFree(pvManifest);
    2518     return rc;
     2519    return vrc;
    25192520}
    25202521
     
    25742575     */
    25752576    RTCRDIGEST hDigest = NIL_RTCRDIGEST;
    2576     int rc = RTCrDigestCreateByType(&hDigest, enmDigestType);
    2577     if (RT_FAILURE(rc))
    2578         return RTMsgErrorRc(rc, Appliance::tr("Failed to create digest for %s: %Rrc"), RTCrDigestTypeToName(enmDigestType), rc);
    2579 
    2580     rc = RTCrDigestUpdateFromVfsFile(hDigest, hVfsFileManifest, true /*fRewindFile*/);
    2581     if (RT_SUCCESS(rc))
    2582         rc = RTCrDigestFinal(hDigest, NULL, 0);
    2583     if (RT_SUCCESS(rc))
     2577    int vrc = RTCrDigestCreateByType(&hDigest, enmDigestType);
     2578    if (RT_FAILURE(vrc))
     2579        return RTMsgErrorRc(vrc, Appliance::tr("Failed to create digest for %s: %Rrc"), RTCrDigestTypeToName(enmDigestType), vrc);
     2580
     2581    vrc = RTCrDigestUpdateFromVfsFile(hDigest, hVfsFileManifest, true /*fRewindFile*/);
     2582    if (RT_SUCCESS(vrc))
     2583        vrc = RTCrDigestFinal(hDigest, NULL, 0);
     2584    if (RT_SUCCESS(vrc))
    25842585    {
    25852586        /*
     
    25902591        PCRTASN1DYNTYPE const pAlgoParams = &pCertificate->TbsCertificate.SubjectPublicKeyInfo.Algorithm.Parameters;
    25912592        size_t cbSignature = 0;
    2592         rc = RTCrPkixPubKeySignDigest(pAlgorithm, hPrivateKey, pAlgoParams, hDigest, 0 /*fFlags*/,
    2593                                       NULL /*pvSignature*/, &cbSignature, RTErrInfoInitStatic(pErrInfo));
    2594         if (rc == VERR_BUFFER_OVERFLOW)
     2593        vrc = RTCrPkixPubKeySignDigest(pAlgorithm, hPrivateKey, pAlgoParams, hDigest, 0 /*fFlags*/,
     2594                                       NULL /*pvSignature*/, &cbSignature, RTErrInfoInitStatic(pErrInfo));
     2595        if (vrc == VERR_BUFFER_OVERFLOW)
    25952596        {
    25962597            void *pvSignature = RTMemAllocZ(cbSignature);
    25972598            if (pvSignature)
    25982599            {
    2599                 rc = RTCrPkixPubKeySignDigest(pAlgorithm, hPrivateKey, pAlgoParams, hDigest, 0,
    2600                                               pvSignature, &cbSignature, RTErrInfoInitStatic(pErrInfo));
    2601                 if (RT_SUCCESS(rc))
     2600                vrc = RTCrPkixPubKeySignDigest(pAlgorithm, hPrivateKey, pAlgoParams, hDigest, 0,
     2601                                               pvSignature, &cbSignature, RTErrInfoInitStatic(pErrInfo));
     2602                if (RT_SUCCESS(vrc))
    26022603                {
    26032604                    if (iVerbosity > 1)
     
    26092610                     * been given the right private key.
    26102611                     */
    2611                     rc = RTCrPkixPubKeyVerifySignedDigestByCertPubKeyInfo(&pCertificate->TbsCertificate.SubjectPublicKeyInfo,
    2612                                                                           pvSignature, cbSignature, hDigest,
    2613                                                                           RTErrInfoInitStatic(pErrInfo));
    2614                     if (RT_SUCCESS(rc))
     2612                    vrc = RTCrPkixPubKeyVerifySignedDigestByCertPubKeyInfo(&pCertificate->TbsCertificate.SubjectPublicKeyInfo,
     2613                                                                           pvSignature, cbSignature, hDigest,
     2614                                                                           RTErrInfoInitStatic(pErrInfo));
     2615                    if (RT_SUCCESS(vrc))
    26152616                    {
    26162617                        if (iVerbosity > 2)
     
    26212622                         */
    26222623                        RTVFSFILE hVfsFileSignature;
    2623                         rc = RTVfsMemFileCreate(NIL_RTVFSIOSTREAM, _8K, &hVfsFileSignature);
    2624                         if (RT_SUCCESS(rc))
     2624                        vrc = RTVfsMemFileCreate(NIL_RTVFSIOSTREAM, _8K, &hVfsFileSignature);
     2625                        if (RT_SUCCESS(vrc))
    26252626                        {
    2626                             rc = (int)RTVfsFilePrintf(hVfsFileSignature, "%s(%s) = %#.*Rhxs\n\n",
    2627                                                       pszDigestType, pszManifestName, cbSignature, pvSignature);
    2628                             if (RT_SUCCESS(rc))
     2627                            vrc = (int)RTVfsFilePrintf(hVfsFileSignature, "%s(%s) = %#.*Rhxs\n\n",
     2628                                                       pszDigestType, pszManifestName, cbSignature, pvSignature);
     2629                            if (RT_SUCCESS(vrc))
    26292630                            {
    2630                                 rc = (int)RTCrX509Certificate_WriteToVfsFile(hVfsFileSignature, pCertificate,
    2631                                                                              RTErrInfoInitStatic(pErrInfo));
    2632                                 if (RT_SUCCESS(rc))
     2631                                vrc = (int)RTCrX509Certificate_WriteToVfsFile(hVfsFileSignature, pCertificate,
     2632                                                                              RTErrInfoInitStatic(pErrInfo));
     2633                                if (RT_SUCCESS(vrc))
    26332634                                {
    26342635                                    if (fPkcs7)
    2635                                         rc = doAddPkcs7Signature(pCertificate, hPrivateKey, enmPkcs7DigestType,
    2636                                                                  cIntermediateCerts, papszIntermediateCerts, hVfsFileManifest,
    2637                                                                  iVerbosity, pErrInfo, hVfsFileSignature);
    2638                                     if (RT_SUCCESS(rc))
     2636                                        vrc = doAddPkcs7Signature(pCertificate, hPrivateKey, enmPkcs7DigestType,
     2637                                                                  cIntermediateCerts, papszIntermediateCerts, hVfsFileManifest,
     2638                                                                  iVerbosity, pErrInfo, hVfsFileSignature);
     2639                                    if (RT_SUCCESS(vrc))
    26392640                                    {
    26402641                                        /*
     
    26472648                                else
    26482649                                    RTMsgError(Appliance::tr("Failed to write certificate to signature file: %Rrc%#RTeim"),
    2649                                                rc, &pErrInfo->Core);
     2650                                               vrc, &pErrInfo->Core);
    26502651                            }
    26512652                            else
    2652                                 RTMsgError(Appliance::tr("Failed to produce signature file: %Rrc"), rc);
     2653                                RTMsgError(Appliance::tr("Failed to produce signature file: %Rrc"), vrc);
    26532654                            RTVfsFileRelease(hVfsFileSignature);
    26542655                        }
    26552656                        else
    2656                             RTMsgError(Appliance::tr("RTVfsMemFileCreate failed: %Rrc"), rc);
     2657                            RTMsgError(Appliance::tr("RTVfsMemFileCreate failed: %Rrc"), vrc);
    26572658                    }
    26582659                    else
    26592660                        RTMsgError(Appliance::tr("Encountered a problem when validating the signature we just created: %Rrc%#RTeim\n"
    26602661                                        "Please make sure the certificate and private key matches."),
    2661                                    rc, &pErrInfo->Core);
     2662                                   vrc, &pErrInfo->Core);
    26622663                }
    26632664                else
    2664                     RTMsgError(Appliance::tr("2nd RTCrPkixPubKeySignDigest call failed: %Rrc%#RTeim"), rc, pErrInfo->Core);
     2665                    RTMsgError(Appliance::tr("2nd RTCrPkixPubKeySignDigest call failed: %Rrc%#RTeim"), vrc, pErrInfo->Core);
    26652666                RTMemFree(pvSignature);
    26662667            }
    26672668            else
    2668                 rc = RTMsgErrorRc(VERR_NO_MEMORY, Appliance::tr("Out of memory!"));
     2669                vrc = RTMsgErrorRc(VERR_NO_MEMORY, Appliance::tr("Out of memory!"));
    26692670        }
    26702671        else
    2671             RTMsgError(Appliance::tr("RTCrPkixPubKeySignDigest failed: %Rrc%#RTeim"), rc, pErrInfo->Core);
     2672            RTMsgError(Appliance::tr("RTCrPkixPubKeySignDigest failed: %Rrc%#RTeim"), vrc, pErrInfo->Core);
    26722673    }
    26732674    else
    2674         RTMsgError(Appliance::tr("Failed to create digest %s: %Rrc"), RTCrDigestTypeToName(enmDigestType), rc);
     2675        RTMsgError(Appliance::tr("Failed to create digest %s: %Rrc"), RTCrDigestTypeToName(enmDigestType), vrc);
    26752676    RTCrDigestRelease(hDigest);
    2676     return rc;
     2677    return vrc;
    26772678}
    26782679
     
    27052706
    27062707    RTGETOPTSTATE GetState;
    2707     int rc = RTGetOptInit(&GetState, arg->argc, arg->argv, s_aOptions, RT_ELEMENTS(s_aOptions), 0, 0);
    2708     AssertRCReturn(rc, RTEXITCODE_FAILURE);
     2708    int vrc = RTGetOptInit(&GetState, arg->argc, arg->argv, s_aOptions, RT_ELEMENTS(s_aOptions), 0, 0);
     2709    AssertRCReturn(vrc, RTEXITCODE_FAILURE);
    27092710
    27102711    const char     *pszOva              = NULL;
     
    28312832    RTVFSFILE       hVfsFileManifest = NIL_RTVFSFILE;
    28322833    Utf8Str         strManifestName;
    2833     rc = openOvaAndGetManifestAndOldSignature(pszOva, iVerbosity, fReSign,
    2834                                               &hVfsFssOva, &strManifestName, &hVfsFileManifest, &hVfsOldSignature);
    2835     if (RT_SUCCESS(rc))
     2834    vrc = openOvaAndGetManifestAndOldSignature(pszOva, iVerbosity, fReSign,
     2835                                               &hVfsFssOva, &strManifestName, &hVfsFileManifest, &hVfsOldSignature);
     2836    if (RT_SUCCESS(vrc))
    28362837    {
    28372838        /*
     
    28402841        RTERRINFOSTATIC     ErrInfo;
    28412842        RTCRX509CERTIFICATE Certificate;
    2842         rc = RTCrX509Certificate_ReadFromFile(&Certificate, pszCertificate, 0, &g_RTAsn1DefaultAllocator,
    2843                                               RTErrInfoInitStatic(&ErrInfo));
    2844         if (RT_FAILURE(rc))
     2843        vrc = RTCrX509Certificate_ReadFromFile(&Certificate, pszCertificate, 0, &g_RTAsn1DefaultAllocator,
     2844                                               RTErrInfoInitStatic(&ErrInfo));
     2845        if (RT_FAILURE(vrc))
    28452846            return RTMsgErrorExitFailure(Appliance::tr("Error reading certificate from '%s': %Rrc%#RTeim"),
    2846                                          pszCertificate, rc, &ErrInfo.Core);
     2847                                         pszCertificate, vrc, &ErrInfo.Core);
    28472848
    28482849        RTCRKEY hPrivateKey = NIL_RTCRKEY;
    2849         rc = RTCrKeyCreateFromFile(&hPrivateKey, 0 /*fFlags*/, pszPrivateKey, strPrivateKeyPassword.c_str(),
    2850                                    RTErrInfoInitStatic(&ErrInfo));
    2851         if (RT_SUCCESS(rc))
     2850        vrc = RTCrKeyCreateFromFile(&hPrivateKey, 0 /*fFlags*/, pszPrivateKey, strPrivateKeyPassword.c_str(),
     2851                                    RTErrInfoInitStatic(&ErrInfo));
     2852        if (RT_SUCCESS(vrc))
    28522853        {
    28532854            if (iVerbosity > 1)
     
    28582859             */
    28592860            RTVFSFILE hVfsFileSignature = NIL_RTVFSFILE;
    2860             rc = doTheOvaSigning(&Certificate, hPrivateKey, enmDigestType, strManifestName.c_str(), hVfsFileManifest,
    2861                                  fPkcs7, cIntermediateCerts, apszIntermediateCerts, iVerbosity, &ErrInfo, &hVfsFileSignature);
     2861            vrc = doTheOvaSigning(&Certificate, hPrivateKey, enmDigestType, strManifestName.c_str(), hVfsFileManifest,
     2862                                  fPkcs7, cIntermediateCerts, apszIntermediateCerts, iVerbosity, &ErrInfo, &hVfsFileSignature);
    28622863
    28632864            /*
    28642865             * Construct the signature filename:
    28652866             */
    2866             if (RT_SUCCESS(rc))
     2867            if (RT_SUCCESS(vrc))
    28672868            {
    28682869                Utf8Str strSignatureName;
    2869                 rc = strSignatureName.assignNoThrow(strManifestName);
    2870                 if (RT_SUCCESS(rc))
    2871                     rc = strSignatureName.stripSuffix().appendNoThrow(".cert");
    2872                 if (RT_SUCCESS(rc) && !fDryRun)
     2870                vrc = strSignatureName.assignNoThrow(strManifestName);
     2871                if (RT_SUCCESS(vrc))
     2872                    vrc = strSignatureName.stripSuffix().appendNoThrow(".cert");
     2873                if (RT_SUCCESS(vrc) && !fDryRun)
    28732874                {
    28742875                    /*
    28752876                     * Update the OVA.
    28762877                     */
    2877                     rc = updateTheOvaSignature(hVfsFssOva, pszOva, strSignatureName.c_str(),
    2878                                                hVfsFileSignature, hVfsOldSignature, iVerbosity);
    2879                     if (RT_SUCCESS(rc) && iVerbosity > 0)
     2878                    vrc = updateTheOvaSignature(hVfsFssOva, pszOva, strSignatureName.c_str(),
     2879                                                hVfsFileSignature, hVfsOldSignature, iVerbosity);
     2880                    if (RT_SUCCESS(vrc) && iVerbosity > 0)
    28802881                        RTMsgInfo(Appliance::tr("Successfully signed '%s'."), pszOva);
    28812882                }
     
    28842885        }
    28852886        else
    2886             RTPrintf(Appliance::tr("Error reading the private key from %s: %Rrc%#RTeim"), pszPrivateKey, rc, &ErrInfo.Core);
     2887            RTPrintf(Appliance::tr("Error reading the private key from %s: %Rrc%#RTeim"), pszPrivateKey, vrc, &ErrInfo.Core);
    28872888        RTCrX509Certificate_Delete(&Certificate);
    28882889    }
     
    28922893    RTVfsFsStrmRelease(hVfsFssOva);
    28932894
    2894     return RT_SUCCESS(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
     2895    return RT_SUCCESS(vrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
    28952896}
  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageBandwidthControl.cpp

    r98103 r98298  
    6666    int iMultiplier = _1M;
    6767    char *pszNext = NULL;
    68     int rc = RTStrToInt64Ex(pcszLimit, &pszNext, 10, pLimit);
    69 
    70     switch (rc)
     68    int vrc = RTStrToInt64Ex(pcszLimit, &pszNext, 10, pLimit);
     69
     70    switch (vrc)
    7171    {
    7272        case VINF_SUCCESS:
  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageCloudMachine.cpp

    r98103 r98298  
    120120{
    121121    CMachineHandlerArg handlerArg(*a);
    122     int rc = getCloudClient(handlerArg, pcszProviderName, pcszProfileName);
    123     if (RT_FAILURE(rc))
     122    int vrc = getCloudClient(handlerArg, pcszProviderName, pcszProfileName);
     123    if (RT_FAILURE(vrc))
    124124        return RTEXITCODE_FAILURE;
    125125
     
    245245    if (aProfiles.size() > 1)
    246246    {
    247         RTMsgError(CloudMachine::tr("cloud: multiple profiles exist,"
    248                                     " '--profile' option is required"));
     247        RTMsgError(CloudMachine::tr("cloud: multiple profiles exist, '--profile' option is required"));
    249248        return VERR_MISSING;
    250249    }
     
    261260                const char *pcszProfileName)
    262261{
    263     HRESULT hrc;
    264     int rc;
    265 
    266262    ComPtr<ICloudProvider> pProvider;
    267     rc = selectCloudProvider(pProvider, a.virtualBox, pcszProviderName);
    268     if (RT_FAILURE(rc))
    269         return rc;
     263    int vrc = selectCloudProvider(pProvider, a.virtualBox, pcszProviderName);
     264    if (RT_FAILURE(vrc))
     265        return vrc;
    270266
    271267    ComPtr<ICloudProfile> pProfile;
    272     rc = selectCloudProfile(pProfile, pProvider, pcszProfileName);
    273     if (RT_FAILURE(rc))
    274         return rc;
     268    vrc = selectCloudProfile(pProfile, pProvider, pcszProfileName);
     269    if (RT_FAILURE(vrc))
     270        return vrc;
    275271
    276272    ComPtr<ICloudClient> pCloudClient;
    277     CHECK_ERROR2_RET(hrc, pProfile,
    278         CreateCloudClient(pCloudClient.asOutParam()),
    279             VERR_GENERAL_FAILURE);
     273    CHECK_ERROR2I_RET(pProfile, CreateCloudClient(pCloudClient.asOutParam()), VERR_GENERAL_FAILURE);
    280274
    281275    a.pClient = pCloudClient;
     
    358352
    359353        if (pMachineFound.isNull())
    360         {
    361354            pMachineFound = pMachine;
    362         }
    363355        else
    364356        {
     
    398390
    399391    RTUUID Uuid;
    400     int rc = RTUuidFromStr(&Uuid, a->pcszSpec);
    401     if (RT_SUCCESS(rc))
     392    int vrc = RTUuidFromStr(&Uuid, a->pcszSpec);
     393    if (RT_SUCCESS(vrc))
    402394        hrc = getMachineById(a);
    403395    else
     
    449441                         int ch, const RTGETOPTUNION &Val)
    450442{
    451     int rc;
     443    int vrc;
    452444
    453445    switch (ch)
     
    472464
    473465            RTUUID Uuid;
    474             rc = RTUuidFromStr(&Uuid, pcszId);
    475             if (RT_FAILURE(rc))
     466            vrc = RTUuidFromStr(&Uuid, pcszId);
     467            if (RT_FAILURE(vrc))
    476468            {
    477469                RTMsgError(CloudMachine::tr("not a valid uuid: %s"), pcszId);
     
    611603handleCloudMachineImpl(CMachineHandlerArg *a, int iFirst)
    612604{
    613     int rc;
    614 
    615605    enum
    616606    {
     
    643633
    644634    RTGETOPTSTATE OptState;
    645     rc = RTGetOptInit(&OptState, a->argc, a->argv,
    646                       s_aOptions, RT_ELEMENTS(s_aOptions),
    647                       iFirst, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
    648     AssertRCReturn(rc, RTMsgErrorExit(RTEXITCODE_INIT,
    649                                       CloudMachine::tr("cloud machine: RTGetOptInit: %Rra"), rc));
     635    int vrc = RTGetOptInit(&OptState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions),
     636                           iFirst, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
     637    AssertRCReturn(vrc, RTMsgErrorExit(RTEXITCODE_INIT, CloudMachine::tr("cloud machine: RTGetOptInit: %Rra"), vrc));
    650638
    651639    int ch;
     
    668656         * Also handles --help.
    669657         */
    670         rc = checkMachineSpecArgument(a, ch, Val);
    671         if (rc == VINF_SUCCESS)
     658        vrc = checkMachineSpecArgument(a, ch, Val);
     659        if (vrc == VINF_SUCCESS)
    672660            continue;
    673         else if (rc == VINF_CALLBACK_RETURN)
     661        if (vrc == VINF_CALLBACK_RETURN)
    674662            return RTEXITCODE_SUCCESS;
    675         else if (rc == VERR_PARSE_ERROR)
     663        if (vrc == VERR_PARSE_ERROR)
    676664            return RTEXITCODE_SYNTAX;
    677665
     
    731719{
    732720    CMachineHandlerArg handlerArg(*a);
    733     int rc = getCloudClient(handlerArg, pcszProviderName, pcszProfileName);
    734     if (RT_FAILURE(rc))
     721    int vrc = getCloudClient(handlerArg, pcszProviderName, pcszProfileName);
     722    if (RT_FAILURE(vrc))
    735723        return RTEXITCODE_FAILURE;
    736724
     
    746734listCloudMachinesImpl(CMachineHandlerArg *a, int iFirst)
    747735{
    748     HRESULT hrc;
    749     int rc;
    750 
    751736    // setCurrentSubcommand(HELP_SCOPE_CLOUD_MACHINE_LIST);
    752737    static const RTGETOPTDEF s_aOptions[] =
     
    769754
    770755    RTGETOPTSTATE OptState;
    771     rc = RTGetOptInit(&OptState, a->argc, a->argv,
    772                       s_aOptions, RT_ELEMENTS(s_aOptions),
    773                       iFirst, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
    774     AssertRCReturn(rc, RTMsgErrorExit(RTEXITCODE_INIT,
    775                                       CloudMachine::tr("cloud machine list: RTGetOptInit: %Rra"), rc));
     756    int vrc = RTGetOptInit(&OptState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions),
     757                           iFirst, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
     758    AssertRCReturn(vrc, RTMsgErrorExit(RTEXITCODE_INIT, CloudMachine::tr("cloud machine list: RTGetOptInit: %Rra"), vrc));
    776759
    777760    int ch;
     
    805788
    806789    com::SafeIfaceArray<ICloudMachine> aMachines;
    807     hrc = getMachineList(aMachines, a->pClient);
     790    HRESULT hrc = getMachineList(aMachines, a->pClient);
    808791    if (FAILED(hrc))
    809792        return RTEXITCODE_FAILURE;
     
    897880{
    898881    CMachineHandlerArg handlerArg(*a);
    899     int rc = getCloudClient(handlerArg, pcszProviderName, pcszProfileName);
    900     if (RT_FAILURE(rc))
     882    int vrc = getCloudClient(handlerArg, pcszProviderName, pcszProfileName);
     883    if (RT_FAILURE(vrc))
    901884        return RTEXITCODE_FAILURE;
    902885
     
    911894handleCloudMachineInfo(CMachineHandlerArg *a, int iFirst)
    912895{
    913     HRESULT hrc;
    914     int rc;
    915 
    916896    enum
    917897    {
     
    929909
    930910    RTGETOPTSTATE OptState;
    931     rc = RTGetOptInit(&OptState, a->argc, a->argv,
    932                       s_aOptions, RT_ELEMENTS(s_aOptions),
    933                       iFirst, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
    934     AssertRCReturn(rc, RTMsgErrorExit(RTEXITCODE_INIT,
    935                            "RTGetOptInit: %Rra", rc));
     911    int vrc = RTGetOptInit(&OptState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions),
     912                           iFirst, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
     913    AssertRCReturn(vrc, RTMsgErrorExit(RTEXITCODE_INIT, "RTGetOptInit: %Rra", vrc));
    936914
    937915    int ch;
     
    939917    while ((ch = RTGetOpt(&OptState, &Val)) != 0)
    940918    {
    941         rc = checkMachineSpecArgument(a, ch, Val);
    942         if (rc == VINF_SUCCESS)
     919        vrc = checkMachineSpecArgument(a, ch, Val);
     920        if (vrc == VINF_SUCCESS)
    943921            continue;
    944         else if (rc == VINF_CALLBACK_RETURN)
     922        if (vrc == VINF_CALLBACK_RETURN)
    945923            return RTEXITCODE_SUCCESS;
    946         else if (rc == VERR_PARSE_ERROR)
     924        if (vrc == VERR_PARSE_ERROR)
    947925            return RTEXITCODE_SYNTAX;
    948926
     
    958936    }
    959937
    960     hrc = getMachineBySpec(a);
     938    HRESULT hrc = getMachineBySpec(a);
    961939    if (FAILED(hrc))
    962940        return RTEXITCODE_FAILURE;
     
    12691247getMachineFromArgs(CMachineHandlerArg *a, int iFirst)
    12701248{
    1271     HRESULT hrc;
    1272     int rc;
    1273 
    12741249    static const RTGETOPTDEF s_aOptions[] =
    12751250    {
     
    12791254
    12801255    RTGETOPTSTATE OptState;
    1281     rc = RTGetOptInit(&OptState, a->argc, a->argv,
    1282                       s_aOptions, RT_ELEMENTS(s_aOptions),
    1283                       iFirst, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
    1284     AssertRCStmt(rc,
    1285         return RTMsgErrorExit(RTEXITCODE_INIT, /* internal error */
    1286                    "RTGetOptInit: %Rra", rc));
     1256    int vrc = RTGetOptInit(&OptState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions),
     1257                           iFirst, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
     1258    AssertRCReturn(vrc, RTMsgErrorExit(RTEXITCODE_INIT, /* internal error */ "RTGetOptInit: %Rra", vrc));
    12871259
    12881260    int ch;
     
    12901262    while ((ch = RTGetOpt(&OptState, &Val)) != 0)
    12911263    {
    1292         rc = checkMachineSpecArgument(a, ch, Val);
    1293         if (rc == VINF_SUCCESS)
     1264        vrc = checkMachineSpecArgument(a, ch, Val);
     1265        if (vrc == VINF_SUCCESS)
    12941266            continue;
    1295         else if (rc == VINF_CALLBACK_RETURN)
     1267        if (vrc == VINF_CALLBACK_RETURN)
    12961268            return RTEXITCODE_SUCCESS;
    1297         else if (rc == VERR_PARSE_ERROR)
     1269        if (vrc == VERR_PARSE_ERROR)
    12981270            return RTEXITCODE_SYNTAX;
    12991271
     
    13061278    }
    13071279
    1308     hrc = getMachineBySpec(a);
     1280    HRESULT hrc = getMachineBySpec(a);
    13091281    if (FAILED(hrc))
    13101282        return RTEXITCODE_FAILURE;
  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageControlVM.cpp

    r98103 r98298  
    6767    uint32_t u32;
    6868    char *pszNext;
    69     int rc = RTStrToUInt32Ex(psz, &pszNext, 10, &u32);
    70     if (    RT_SUCCESS(rc)
     69    int vrc = RTStrToUInt32Ex(psz, &pszNext, 10, &u32);
     70    if (    RT_SUCCESS(vrc)
    7171        &&  *pszNext == '\0'
    7272        &&  u32 >= 1
  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageDebugVM.cpp

    r98103 r98298  
    7575        { "--cpu", 'c', RTGETOPT_REQ_UINT32 },
    7676    };
    77     int rc = RTGetOptInit(&GetState, pArgs->argc, pArgs->argv, s_aOptions, RT_ELEMENTS(s_aOptions), 2, RTGETOPTINIT_FLAGS_OPTS_FIRST);
    78     AssertRCReturn(rc, RTEXITCODE_FAILURE);
    79 
    80     while ((rc = RTGetOpt(&GetState, &ValueUnion)) != 0)
    81     {
    82         switch (rc)
     77    int vrc = RTGetOptInit(&GetState, pArgs->argc, pArgs->argv, s_aOptions, RT_ELEMENTS(s_aOptions), 2, RTGETOPTINIT_FLAGS_OPTS_FIRST);
     78    AssertRCReturn(vrc, RTEXITCODE_FAILURE);
     79
     80    while ((vrc = RTGetOpt(&GetState, &ValueUnion)) != 0)
     81    {
     82        switch (vrc)
    8383        {
    8484            case 'c':
     
    118118
    119119            default:
    120                 return errorGetOpt(rc, &ValueUnion);
     120                return errorGetOpt(vrc, &ValueUnion);
    121121        }
    122122    }
     
    143143    RTGETOPTSTATE  GetState;
    144144    RTGETOPTUNION  ValueUnion;
    145     int rc = RTGetOptInit(&GetState, pArgs->argc, pArgs->argv, NULL, 0, 2, RTGETOPTINIT_FLAGS_OPTS_FIRST);
    146     AssertRCReturn(rc, RTEXITCODE_FAILURE);
    147 
    148     while ((rc = RTGetOpt(&GetState, &ValueUnion)) != 0)
    149     {
    150         switch (rc)
     145    int vrc = RTGetOptInit(&GetState, pArgs->argc, pArgs->argv, NULL, 0, 2, RTGETOPTINIT_FLAGS_OPTS_FIRST);
     146    AssertRCReturn(vrc, RTEXITCODE_FAILURE);
     147
     148    while ((vrc = RTGetOpt(&GetState, &ValueUnion)) != 0)
     149    {
     150        switch (vrc)
    151151        {
    152152            case VINF_GETOPT_NOT_OPTION:
     
    159159                break;
    160160            default:
    161                 return errorGetOpt(rc, &ValueUnion);
     161                return errorGetOpt(vrc, &ValueUnion);
    162162        }
    163163    }
     
    223223        { "--release",      DEBUGVM_LOG_RELEASE, RTGETOPT_REQ_NOTHING }
    224224    };
    225     int rc = RTGetOptInit(&GetState, pArgs->argc, pArgs->argv, s_aOptions, RT_ELEMENTS(s_aOptions), 2,
    226                           /*
    227                            * Note: RTGETOPTINIT_FLAGS_NO_STD_OPTS is needed to not get into an infinite hang in the following
    228                            *       while-loop when processing log groups starting with "h",
    229                            *       e.g. "VBoxManage debugvm <VM Name> log --debug -hex".
    230                            */
     225    /*
     226     * Note: RTGETOPTINIT_FLAGS_NO_STD_OPTS is needed to not get into an infinite hang in the following
     227     *       while-loop when processing log groups starting with "h",
     228     *       e.g. "VBoxManage debugvm <VM Name> log --debug -hex".
     229     */
     230    int vrc = RTGetOptInit(&GetState, pArgs->argc, pArgs->argv, s_aOptions, RT_ELEMENTS(s_aOptions), 2,
    231231                          RTGETOPTINIT_FLAGS_OPTS_FIRST | RTGETOPTINIT_FLAGS_NO_STD_OPTS);
    232     AssertRCReturn(rc, RTEXITCODE_FAILURE);
    233 
    234     while ((rc = RTGetOpt(&GetState, &ValueUnion)) != 0)
    235     {
    236         switch (rc)
     232    AssertRCReturn(vrc, RTEXITCODE_FAILURE);
     233
     234    while ((vrc = RTGetOpt(&GetState, &ValueUnion)) != 0)
     235    {
     236        switch (vrc)
    237237        {
    238238            case DEBUGVM_LOG_RELEASE:
     
    302302        { "--compression",  'c', RTGETOPT_REQ_STRING }
    303303    };
    304     int rc = RTGetOptInit(&GetState, pArgs->argc, pArgs->argv, s_aOptions, RT_ELEMENTS(s_aOptions), 2, 0 /*fFlags*/);
    305     AssertRCReturn(rc, RTEXITCODE_FAILURE);
    306 
    307     while ((rc = RTGetOpt(&GetState, &ValueUnion)) != 0)
    308     {
    309         switch (rc)
     304    int vrc = RTGetOptInit(&GetState, pArgs->argc, pArgs->argv, s_aOptions, RT_ELEMENTS(s_aOptions), 2, 0 /*fFlags*/);
     305    AssertRCReturn(vrc, RTEXITCODE_FAILURE);
     306
     307    while ((vrc = RTGetOpt(&GetState, &ValueUnion)) != 0)
     308    {
     309        switch (vrc)
    310310        {
    311311            case 'c':
     
    320320                break;
    321321            default:
    322                 return errorGetOpt(rc, &ValueUnion);
     322                return errorGetOpt(vrc, &ValueUnion);
    323323        }
    324324    }
     
    331331     */
    332332    char szAbsFilename[RTPATH_MAX];
    333     rc = RTPathAbs(pszFilename, szAbsFilename, sizeof(szAbsFilename));
    334     if (RT_FAILURE(rc))
    335         return RTMsgErrorExit(RTEXITCODE_FAILURE, DebugVM::tr("RTPathAbs failed on '%s': %Rrc"), pszFilename, rc);
     333    vrc = RTPathAbs(pszFilename, szAbsFilename, sizeof(szAbsFilename));
     334    if (RT_FAILURE(vrc))
     335        return RTMsgErrorExit(RTEXITCODE_FAILURE, DebugVM::tr("RTPathAbs failed on '%s': %Rrc"), pszFilename, vrc);
    336336
    337337    com::Bstr bstrFilename(szAbsFilename);
     
    403403        { "--lines", 'n', RTGETOPT_REQ_UINT32 },
    404404    };
    405     int rc = RTGetOptInit(&GetState, pArgs->argc, pArgs->argv, s_aOptions, RT_ELEMENTS(s_aOptions), 2, RTGETOPTINIT_FLAGS_OPTS_FIRST);
    406     AssertRCReturn(rc, RTEXITCODE_FAILURE);
    407     while ((rc = RTGetOpt(&GetState, &ValueUnion)) != 0)
    408         switch (rc)
     405    int vrc = RTGetOptInit(&GetState, pArgs->argc, pArgs->argv, s_aOptions, RT_ELEMENTS(s_aOptions), 2, RTGETOPTINIT_FLAGS_OPTS_FIRST);
     406    AssertRCReturn(vrc, RTEXITCODE_FAILURE);
     407    while ((vrc = RTGetOpt(&GetState, &ValueUnion)) != 0)
     408        switch (vrc)
    409409        {
    410410            case 'n': uMaxMessages = ValueUnion.u32; break;
    411             default: return errorGetOpt(rc, &ValueUnion);
     411            default: return errorGetOpt(vrc, &ValueUnion);
    412412        }
    413413
     
    443443        { "--cpu", 'c', RTGETOPT_REQ_UINT32 },
    444444    };
    445     int rc = RTGetOptInit(&GetState, pArgs->argc, pArgs->argv, s_aOptions, RT_ELEMENTS(s_aOptions), 2, RTGETOPTINIT_FLAGS_OPTS_FIRST);
    446     AssertRCReturn(rc, RTEXITCODE_FAILURE);
    447 
    448     while ((rc = RTGetOpt(&GetState, &ValueUnion)) != 0)
    449     {
    450         switch (rc)
     445    int vrc = RTGetOptInit(&GetState, pArgs->argc, pArgs->argv, s_aOptions, RT_ELEMENTS(s_aOptions), 2, RTGETOPTINIT_FLAGS_OPTS_FIRST);
     446    AssertRCReturn(vrc, RTEXITCODE_FAILURE);
     447
     448    while ((vrc = RTGetOpt(&GetState, &ValueUnion)) != 0)
     449    {
     450        switch (vrc)
    451451        {
    452452            case 'c':
     
    477477
    478478            default:
    479                 return errorGetOpt(rc, &ValueUnion);
     479                return errorGetOpt(vrc, &ValueUnion);
    480480        }
    481481    }
     
    602602        { "--cmd-set",        's', RTGETOPT_REQ_NOTHING  },
    603603    };
    604     int rc = RTGetOptInit(&GetState, pArgs->argc, pArgs->argv, s_aOptions, RT_ELEMENTS(s_aOptions), 2, 0 /*fFlags*/);
    605     AssertRCReturn(rc, RTEXITCODE_FAILURE);
    606 
    607     while ((rc = RTGetOpt(&GetState, &ValueUnion)) != 0)
    608     {
    609         switch (rc)
     604    int vrc = RTGetOptInit(&GetState, pArgs->argc, pArgs->argv, s_aOptions, RT_ELEMENTS(s_aOptions), 2, 0 /*fFlags*/);
     605    AssertRCReturn(vrc, RTEXITCODE_FAILURE);
     606
     607    while ((vrc = RTGetOpt(&GetState, &ValueUnion)) != 0)
     608    {
     609        switch (vrc)
    610610        {
    611611            case 'H':
     
    646646
    647647            default:
    648                 return errorGetOpt(rc, &ValueUnion);
     648                return errorGetOpt(vrc, &ValueUnion);
    649649        }
    650650    }
     
    672672        { "--cpu", 'c', RTGETOPT_REQ_UINT32 },
    673673    };
    674     int rc = RTGetOptInit(&GetState, pArgs->argc, pArgs->argv, s_aOptions, RT_ELEMENTS(s_aOptions), 2, RTGETOPTINIT_FLAGS_OPTS_FIRST);
    675     AssertRCReturn(rc, RTEXITCODE_FAILURE);
    676 
    677     while ((rc = RTGetOpt(&GetState, &ValueUnion)) != 0)
    678     {
    679         switch (rc)
     674    int vrc = RTGetOptInit(&GetState, pArgs->argc, pArgs->argv, s_aOptions, RT_ELEMENTS(s_aOptions), 2, RTGETOPTINIT_FLAGS_OPTS_FIRST);
     675    AssertRCReturn(vrc, RTEXITCODE_FAILURE);
     676
     677    while ((vrc = RTGetOpt(&GetState, &ValueUnion)) != 0)
     678    {
     679        switch (vrc)
    680680        {
    681681            case 'c':
     
    684684
    685685            default:
    686                 return errorGetOpt(rc, &ValueUnion);
     686                return errorGetOpt(vrc, &ValueUnion);
    687687        }
    688688    }
     
    747747        { "--reset",        'r', RTGETOPT_REQ_NOTHING  },
    748748    };
    749     int rc = RTGetOptInit(&GetState, pArgs->argc, pArgs->argv, s_aOptions, RT_ELEMENTS(s_aOptions), 2, 0 /*fFlags*/);
    750     AssertRCReturn(rc, RTEXITCODE_FAILURE);
    751 
    752     while ((rc = RTGetOpt(&GetState, &ValueUnion)) != 0)
    753     {
    754         switch (rc)
     749    int vrc = RTGetOptInit(&GetState, pArgs->argc, pArgs->argv, s_aOptions, RT_ELEMENTS(s_aOptions), 2, 0 /*fFlags*/);
     750    AssertRCReturn(vrc, RTEXITCODE_FAILURE);
     751
     752    while ((vrc = RTGetOpt(&GetState, &ValueUnion)) != 0)
     753    {
     754        switch (vrc)
    755755        {
    756756            case 'd':
     
    769769
    770770            default:
    771                 return errorGetOpt(rc, &ValueUnion);
     771                return errorGetOpt(vrc, &ValueUnion);
    772772        }
    773773    }
     
    821821        { "--sample-time-us",     't', RTGETOPT_REQ_UINT64 },
    822822    };
    823     int rc = RTGetOptInit(&GetState, pArgs->argc, pArgs->argv, s_aOptions, RT_ELEMENTS(s_aOptions), 2, 0 /*fFlags*/);
    824     AssertRCReturn(rc, RTEXITCODE_FAILURE);
    825 
    826     while ((rc = RTGetOpt(&GetState, &ValueUnion)) != 0)
    827     {
    828         switch (rc)
     823    int vrc = RTGetOptInit(&GetState, pArgs->argc, pArgs->argv, s_aOptions, RT_ELEMENTS(s_aOptions), 2, 0 /*fFlags*/);
     824    AssertRCReturn(vrc, RTEXITCODE_FAILURE);
     825
     826    while ((vrc = RTGetOpt(&GetState, &ValueUnion)) != 0)
     827    {
     828        switch (vrc)
    829829        {
    830830            case 'f':
     
    839839
    840840            default:
    841                 return errorGetOpt(rc, &ValueUnion);
     841                return errorGetOpt(vrc, &ValueUnion);
    842842        }
    843843    }
  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageDisk.cpp

    r98103 r98298  
    6868
    6969
    70 static DECLCALLBACK(void) handleVDError(void *pvUser, int rc, RT_SRC_POS_DECL, const char *pszFormat, va_list va)
     70static DECLCALLBACK(void) handleVDError(void *pvUser, int vrc, RT_SRC_POS_DECL, const char *pszFormat, va_list va)
    7171{
    7272    RT_NOREF(pvUser);
    7373    RTMsgErrorV(pszFormat, va);
    74     RTMsgError(Disk::tr("Error code %Rrc at %s(%u) in function %s"), rc, RT_SRC_POS_ARGS);
     74    RTMsgError(Disk::tr("Error code %Rrc at %s(%u) in function %s"), vrc, RT_SRC_POS_ARGS);
    7575}
    7676
    7777static int parseMediumVariant(const char *psz, MediumVariant_T *pMediumVariant)
    7878{
    79     int rc = VINF_SUCCESS;
     79    int vrc = VINF_SUCCESS;
    8080    unsigned uMediumVariant = (unsigned)(*pMediumVariant);
    81     while (psz && *psz && RT_SUCCESS(rc))
     81    while (psz && *psz && RT_SUCCESS(vrc))
    8282    {
    8383        size_t len;
     
    111111                uMediumVariant |= MediumVariant_VmdkRawDisk;
    112112            else
    113                 rc = VERR_PARSE_ERROR;
     113                vrc = VERR_PARSE_ERROR;
    114114        }
    115115        if (pszComma)
     
    119119    }
    120120
    121     if (RT_SUCCESS(rc))
     121    if (RT_SUCCESS(vrc))
    122122        *pMediumVariant = (MediumVariant_T)uMediumVariant;
    123     return rc;
     123    return vrc;
    124124}
    125125
    126126int parseMediumType(const char *psz, MediumType_T *penmMediumType)
    127127{
    128     int rc = VINF_SUCCESS;
     128    int vrc = VINF_SUCCESS;
    129129    MediumType_T enmMediumType = MediumType_Normal;
    130130    if (!RTStrICmp(psz, "normal"))
     
    141141        enmMediumType = MediumType_MultiAttach;
    142142    else
    143         rc = VERR_PARSE_ERROR;
    144 
    145     if (RT_SUCCESS(rc))
     143        vrc = VERR_PARSE_ERROR;
     144
     145    if (RT_SUCCESS(vrc))
    146146        *penmMediumType = enmMediumType;
    147     return rc;
     147    return vrc;
    148148}
    149149
     
    151151int parseBool(const char *psz, bool *pb)
    152152{
    153     int rc = VINF_SUCCESS;
     153    int vrc = VINF_SUCCESS;
    154154    if (    !RTStrICmp(psz, "on")
    155155        ||  !RTStrICmp(psz, "yes")
    156156        ||  !RTStrICmp(psz, "true")
    157         ||  !RTStrICmp(psz, "1")
     157        ||  !RTStrCmp(psz, "1")
    158158        ||  !RTStrICmp(psz, "enable")
    159159        ||  !RTStrICmp(psz, "enabled"))
    160     {
    161160        *pb = true;
    162     }
    163161    else if (   !RTStrICmp(psz, "off")
    164162             || !RTStrICmp(psz, "no")
    165163             || !RTStrICmp(psz, "false")
    166              || !RTStrICmp(psz, "0")
     164             || !RTStrCmp(psz, "0")
    167165             || !RTStrICmp(psz, "disable")
    168166             || !RTStrICmp(psz, "disabled"))
    169     {
    170167        *pb = false;
    171     }
    172168    else
    173         rc = VERR_PARSE_ERROR;
    174 
    175     return rc;
     169        vrc = VERR_PARSE_ERROR;
     170
     171    return vrc;
    176172}
    177173
     
    12361232RTEXITCODE handleConvertFromRaw(HandlerArg *a)
    12371233{
    1238     int rc = VINF_SUCCESS;
    12391234    bool fReadFromStdIn = false;
    12401235    const char *format = "VDI";
     
    12511246    RTGETOPTSTATE GetState;
    12521247    // start at 0 because main() has hacked both the argc and argv given to us
    1253     RTGetOptInit(&GetState, a->argc, a->argv, g_aConvertFromRawHardDiskOptions, RT_ELEMENTS(g_aConvertFromRawHardDiskOptions),
    1254                  0, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
     1248    int vrc = RTGetOptInit(&GetState, a->argc, a->argv,
     1249                           g_aConvertFromRawHardDiskOptions, RT_ELEMENTS(g_aConvertFromRawHardDiskOptions),
     1250                           0, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
     1251    AssertRCReturn(vrc, RTEXITCODE_FAILURE);
    12551252    while ((c = RTGetOpt(&GetState, &ValueUnion)))
    12561253    {
     
    12691266            {
    12701267                MediumVariant_T enmMediumVariant = MediumVariant_Standard;
    1271                 rc = parseMediumVariant(ValueUnion.psz, &enmMediumVariant);
    1272                 if (RT_FAILURE(rc))
     1268                vrc = parseMediumVariant(ValueUnion.psz, &enmMediumVariant);
     1269                if (RT_FAILURE(vrc))
    12731270                    return errorArgument(Disk::tr("Invalid medium variant '%s'"), ValueUnion.psz);
    12741271                /// @todo cleaner solution than assuming 1:1 mapping?
     
    13071304    vdInterfaceError.pfnMessage   = NULL;
    13081305
    1309     rc = VDInterfaceAdd(&vdInterfaceError.Core, "VBoxManage_IError", VDINTERFACETYPE_ERROR,
    1310                         NULL, sizeof(VDINTERFACEERROR), &pVDIfs);
    1311     AssertRC(rc);
     1306    vrc = VDInterfaceAdd(&vdInterfaceError.Core, "VBoxManage_IError", VDINTERFACETYPE_ERROR,
     1307                         NULL, sizeof(VDINTERFACEERROR), &pVDIfs);
     1308    AssertRC(vrc);
    13121309
    13131310    /* open raw image file. */
    13141311    RTFILE File;
    13151312    if (fReadFromStdIn)
    1316         rc = RTFileFromNative(&File, RTFILE_NATIVE_STDIN);
     1313        vrc = RTFileFromNative(&File, RTFILE_NATIVE_STDIN);
    13171314    else
    1318         rc = RTFileOpen(&File, srcfilename, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_WRITE);
    1319     if (RT_FAILURE(rc))
    1320     {
    1321         RTMsgError(Disk::tr("Cannot open file \"%s\": %Rrc"), srcfilename, rc);
     1315        vrc = RTFileOpen(&File, srcfilename, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_WRITE);
     1316    if (RT_FAILURE(vrc))
     1317    {
     1318        RTMsgError(Disk::tr("Cannot open file \"%s\": %Rrc"), srcfilename, vrc);
    13221319        goto out;
    13231320    }
     
    13281325        cbFile = RTStrToUInt64(filesize);
    13291326    else
    1330         rc = RTFileQuerySize(File, &cbFile);
    1331     if (RT_FAILURE(rc))
    1332     {
    1333         RTMsgError(Disk::tr("Cannot get image size for file \"%s\": %Rrc"), srcfilename, rc);
     1327        vrc = RTFileQuerySize(File, &cbFile);
     1328    if (RT_FAILURE(vrc))
     1329    {
     1330        RTMsgError(Disk::tr("Cannot get image size for file \"%s\": %Rrc"), srcfilename, vrc);
    13341331        goto out;
    13351332    }
     
    13401337    char pszComment[256];
    13411338    RTStrPrintf(pszComment, sizeof(pszComment), Disk::tr("Converted image from %s"), srcfilename);
    1342     rc = VDCreate(pVDIfs, VDTYPE_HDD, &pDisk);
    1343     if (RT_FAILURE(rc))
    1344     {
    1345         RTMsgError(Disk::tr("Cannot create the virtual disk container: %Rrc"), rc);
     1339    vrc = VDCreate(pVDIfs, VDTYPE_HDD, &pDisk);
     1340    if (RT_FAILURE(vrc))
     1341    {
     1342        RTMsgError(Disk::tr("Cannot create the virtual disk container: %Rrc"), vrc);
    13461343        goto out;
    13471344    }
     
    13561353    LCHS.cHeads = 0;
    13571354    LCHS.cSectors = 0;
    1358     rc = VDCreateBase(pDisk, format, dstfilename, cbFile,
    1359                       uImageFlags, pszComment, &PCHS, &LCHS, pUuid,
    1360                       VD_OPEN_FLAGS_NORMAL, NULL, NULL);
    1361     if (RT_FAILURE(rc))
    1362     {
    1363         RTMsgError(Disk::tr("Cannot create the disk image \"%s\": %Rrc"), dstfilename, rc);
     1355    vrc = VDCreateBase(pDisk, format, dstfilename, cbFile,
     1356                       uImageFlags, pszComment, &PCHS, &LCHS, pUuid,
     1357                       VD_OPEN_FLAGS_NORMAL, NULL, NULL);
     1358    if (RT_FAILURE(vrc))
     1359    {
     1360        RTMsgError(Disk::tr("Cannot create the disk image \"%s\": %Rrc"), dstfilename, vrc);
    13641361        goto out;
    13651362    }
     
    13701367    if (!pvBuf)
    13711368    {
    1372         rc = VERR_NO_MEMORY;
    1373         RTMsgError(Disk::tr("Out of memory allocating buffers for image \"%s\": %Rrc"), dstfilename, rc);
     1369        vrc = VERR_NO_MEMORY;
     1370        RTMsgError(Disk::tr("Out of memory allocating buffers for image \"%s\": %Rrc"), dstfilename, vrc);
    13741371        goto out;
    13751372    }
     
    13841381        cbToRead = cbFile - offFile >= (uint64_t)cbBuffer ?
    13851382                            cbBuffer : (size_t)(cbFile - offFile);
    1386         rc = RTFileRead(File, pvBuf, cbToRead, &cbRead);
    1387         if (RT_FAILURE(rc) || !cbRead)
     1383        vrc = RTFileRead(File, pvBuf, cbToRead, &cbRead);
     1384        if (RT_FAILURE(vrc) || !cbRead)
    13881385            break;
    1389         rc = VDWrite(pDisk, offFile, pvBuf, cbRead);
    1390         if (RT_FAILURE(rc))
    1391         {
    1392             RTMsgError(Disk::tr("Failed to write to disk image \"%s\": %Rrc"), dstfilename, rc);
     1386        vrc = VDWrite(pDisk, offFile, pvBuf, cbRead);
     1387        if (RT_FAILURE(vrc))
     1388        {
     1389            RTMsgError(Disk::tr("Failed to write to disk image \"%s\": %Rrc"), dstfilename, vrc);
    13931390            goto out;
    13941391        }
     
    14001397        RTMemFree(pvBuf);
    14011398    if (pDisk)
    1402         VDClose(pDisk, RT_FAILURE(rc));
     1399        VDClose(pDisk, RT_FAILURE(vrc));
    14031400    if (File != NIL_RTFILE)
    14041401        RTFileClose(File);
    14051402
    1406     return RT_SUCCESS(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
     1403    return RT_SUCCESS(vrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
    14071404}
    14081405
     
    23182315
    23192316    RTGETOPTSTATE GetState;
    2320     int rc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), iFirst, 0);
    2321     AssertRC(rc);
     2317    int vrc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), iFirst, 0);
     2318    AssertRCReturn(vrc, RTEXITCODE_FAILURE);
    23222319    RTGETOPTUNION ValueUnion;
    2323     while ((rc = RTGetOpt(&GetState, &ValueUnion)) != 0)
    2324     {
    2325         switch (rc)
     2320    while ((vrc = RTGetOpt(&GetState, &ValueUnion)) != 0)
     2321    {
     2322        switch (vrc)
    23262323        {
    23272324            MEDIUMIOCOMMONOPT_CASES(pCommonOpts);
     
    23322329
    23332330            default:
    2334                 return errorGetOpt(rc, &ValueUnion);
     2331                return errorGetOpt(vrc, &ValueUnion);
    23352332        }
    23362333    }
     
    23692366
    23702367    RTGETOPTSTATE GetState;
    2371     int rc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), iFirst, 0);
    2372     AssertRC(rc);
     2368    int vrc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), iFirst, 0);
     2369    AssertRCReturn(vrc, RTEXITCODE_FAILURE);
    23732370    RTGETOPTUNION ValueUnion;
    2374     while ((rc = RTGetOpt(&GetState, &ValueUnion)) != 0)
    2375     {
    2376         switch (rc)
     2371    while ((vrc = RTGetOpt(&GetState, &ValueUnion)) != 0)
     2372    {
     2373        switch (vrc)
    23772374        {
    23782375            MEDIUMIOCOMMONOPT_CASES(pCommonOpts);
     
    23952392
    23962393            default:
    2397                 return errorGetOpt(rc, &ValueUnion);
     2394                return errorGetOpt(vrc, &ValueUnion);
    23982395        }
    23992396    }
     
    24132410        if (pszOutput && (pszOutput[0] != '-' || pszOutput[1] != '\0'))
    24142411        {
    2415             int vrc = RTStrmOpen(pszOutput, fHex ? "wt" : "wb", &pOut);
     2412            vrc = RTStrmOpen(pszOutput, fHex ? "wt" : "wb", &pOut);
    24162413            if (RT_FAILURE(vrc))
    24172414                rcExit = RTMsgErrorExitFailure(Disk::tr("Error opening '%s' for writing: %Rrc"), pszOutput, vrc);
     
    24712468                {
    24722469                    BYTE const *pbBuf = SafeArrayBuf.raw();
    2473                     int vrc = VINF_SUCCESS;
    24742470                    if (!fHex)
    24752471                        vrc = RTStrmWrite(pOut, pbBuf, cbReturned);
     
    24772473                    {
    24782474                        /* hexdump -C */
     2475                        vrc = VINF_SUCCESS;
    24792476                        uint64_t        offHex    = off;
    24802477                        uint64_t const  offHexEnd = off + cbReturned;
     
    25612558            if (pOut != g_pStdOut)
    25622559            {
    2563                 int vrc = RTStrmClose(pOut);
     2560                vrc = RTStrmClose(pOut);
    25642561                if (RT_FAILURE(vrc))
    25652562                    rcExit = RTMsgErrorExitFailure(Disk::tr("Error closing '%s': %Rrc"), pszOutput, vrc);
     
    25922589
    25932590    RTGETOPTSTATE GetState;
    2594     int rc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), iFirst, 0);
    2595     AssertRC(rc);
     2591    int vrc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), iFirst, 0);
     2592    AssertRCReturn(vrc, RTEXITCODE_FAILURE);
    25962593    RTGETOPTUNION ValueUnion;
    2597     while ((rc = RTGetOpt(&GetState, &ValueUnion)) != 0)
    2598     {
    2599         switch (rc)
     2594    while ((vrc = RTGetOpt(&GetState, &ValueUnion)) != 0)
     2595    {
     2596        switch (vrc)
    26002597        {
    26012598            MEDIUMIOCOMMONOPT_CASES(pCommonOpts);
     
    26092606            case 'v':   // --variant
    26102607            {
    2611                 int vrc = parseMediumVariant(ValueUnion.psz, &enmMediumVariant);
     2608                vrc = parseMediumVariant(ValueUnion.psz, &enmMediumVariant);
    26122609                if (RT_FAILURE(vrc))
    26132610                    return errorArgument(Disk::tr("Invalid medium variant '%s'"), ValueUnion.psz);
     
    26162613
    26172614            default:
    2618                 return errorGetOpt(rc, &ValueUnion);
     2615                return errorGetOpt(vrc, &ValueUnion);
    26192616        }
    26202617    }
     
    26342631        if (pszOutput && (pszOutput[0] != '-' || pszOutput[1] != '\0'))
    26352632        {
    2636             int vrc = RTStrmOpen(pszOutput, "wb", &pOut);
     2633            vrc = RTStrmOpen(pszOutput, "wb", &pOut);
    26372634            if (RT_FAILURE(vrc))
    26382635                rcExit = RTMsgErrorExitFailure(Disk::tr("Error opening '%s' for writing: %Rrc"), pszOutput, vrc);
     
    26762673                    {
    26772674                        BYTE const *pbBuf = SafeArrayBuf.raw();
    2678                         int vrc = VINF_SUCCESS;
    26792675                        vrc = RTStrmWrite(pOut, pbBuf, cbReturned);
    26802676                        if (RT_FAILURE(vrc))
     
    26992695            if (pOut != g_pStdOut)
    27002696            {
    2701                 int vrc = RTStrmClose(pOut);
     2697                vrc = RTStrmClose(pOut);
    27022698                if (RT_FAILURE(vrc))
    27032699                    rcExit = RTMsgErrorExitFailure(Disk::tr("Error closing '%s': %Rrc"), pszOutput, vrc);
     
    27272723
    27282724    RTGETOPTSTATE       GetState;
    2729     int rc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), 0, 0);
    2730     AssertRC(rc);
     2725    int vrc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), 0, 0);
     2726    AssertRCReturn(vrc, RTEXITCODE_FAILURE);
    27312727    RTGETOPTUNION       ValueUnion;
    2732     while ((rc = RTGetOpt(&GetState, &ValueUnion)) != 0)
    2733     {
    2734         switch (rc)
     2728    while ((vrc = RTGetOpt(&GetState, &ValueUnion)) != 0)
     2729    {
     2730        switch (vrc)
    27352731        {
    27362732            MEDIUMIOCOMMONOPT_CASES(&CommonOpts);
     
    27512747
    27522748            default:
    2753                 return errorGetOpt(rc, &ValueUnion);
     2749                return errorGetOpt(vrc, &ValueUnion);
    27542750        }
    27552751    }
  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageGuestCtrl.cpp

    r98103 r98298  
    279279    g_fGuestCtrlCanceled = false;
    280280
    281     int rc = VINF_SUCCESS;
     281    int vrc = VINF_SUCCESS;
    282282#ifdef RT_OS_WINDOWS
    283283    if (!SetConsoleCtrlHandler((PHANDLER_ROUTINE)gctlSignalHandler, TRUE /* Add handler */))
    284284    {
    285         rc = RTErrConvertFromWin32(GetLastError());
    286         RTMsgError(GuestCtrl::tr("Unable to install console control handler, rc=%Rrc\n"), rc);
     285        vrc = RTErrConvertFromWin32(GetLastError());
     286        RTMsgError(GuestCtrl::tr("Unable to install console control handler, vrc=%Rrc\n"), vrc);
    287287    }
    288288#else
     
    294294#endif
    295295
    296     if (RT_SUCCESS(rc))
    297         rc = RTSemEventCreate(&g_SemEventGuestCtrlCanceled);
    298 
    299     return rc;
     296    if (RT_SUCCESS(vrc))
     297        vrc = RTSemEventCreate(&g_SemEventGuestCtrlCanceled);
     298
     299    return vrc;
    300300}
    301301
     
    306306static int gctlSignalHandlerUninstall(void)
    307307{
    308     int rc = VINF_SUCCESS;
     308    int vrc = VINF_SUCCESS;
    309309#ifdef RT_OS_WINDOWS
    310310    if (!SetConsoleCtrlHandler((PHANDLER_ROUTINE)NULL, FALSE /* Remove handler */))
    311311    {
    312         rc = RTErrConvertFromWin32(GetLastError());
    313         RTMsgError(GuestCtrl::tr("Unable to uninstall console control handler, rc=%Rrc\n"), rc);
     312        vrc = RTErrConvertFromWin32(GetLastError());
     313        RTMsgError(GuestCtrl::tr("Unable to uninstall console control handler, vrc=%Rrc\n"), vrc);
    314314    }
    315315#else
     
    326326        g_SemEventGuestCtrlCanceled = NIL_RTSEMEVENT;
    327327    }
    328     return rc;
     328    return vrc;
    329329}
    330330
     
    572572     */
    573573    char szUser[1024];
    574     int rc = RTProcQueryUsername(RTProcSelf(), szUser, sizeof(szUser), NULL);
    575     if (   RT_SUCCESS(rc)
     574    int vrc = RTProcQueryUsername(RTProcSelf(), szUser, sizeof(szUser), NULL);
     575    if (   RT_SUCCESS(vrc)
    576576        && RTStrIsValidEncoding(szUser)) /* paranoia was required on posix at some point, not needed any more! */
    577577    {
     
    853853            if (!(pCtx->pCmdDef->fCmdCtx & GCTLCMDCTX_F_NO_SIGNAL_HANDLER))
    854854            {
    855                 int rc = gctlSignalHandlerInstall();
    856                 pCtx->fInstalledSignalHandler = RT_SUCCESS(rc);
     855                int vrc = gctlSignalHandlerInstall();
     856                pCtx->fInstalledSignalHandler = RT_SUCCESS(vrc);
    857857            }
    858858        }
     
    10661066            vrc = RTVfsIoStrmWrite(hVfsIosDst, pbBuf, cbOutputData, true /*fBlocking*/,  NULL);
    10671067            if (RT_FAILURE(vrc))
    1068                 RTMsgError(GuestCtrl::tr("Unable to write output, rc=%Rrc\n"), vrc);
     1068                RTMsgError(GuestCtrl::tr("Unable to write output, vrc=%Rrc\n"), vrc);
    10691069        }
    10701070    }
     
    17621762
    17631763    if (RT_FAILURE(vrc))
    1764         return RTMsgErrorExitFailure(GuestCtrl::tr("Error looking file system information for source '%s', rc=%Rrc"),
     1764        return RTMsgErrorExitFailure(GuestCtrl::tr("Error looking file system information for source '%s', vrc=%Rrc"),
    17651765                                     papszSources[iSrc], vrc);
    17661766
     
    21572157
    21582158    if (RT_FAILURE(vrc))
    2159         return RTMsgErrorExit(RTEXITCODE_FAILURE, GuestCtrl::tr("Failed to initialize, rc=%Rrc\n"), vrc);
     2159        return RTMsgErrorExit(RTEXITCODE_FAILURE, GuestCtrl::tr("Failed to initialize, vrc=%Rrc\n"), vrc);
    21602160
    21612161    size_t cSources = vecSources.size();
     
    27362736#if 0
    27372737        ComPtr<IGuest> guest;
    2738         rc = pConsole->COMGETTER(Guest)(guest.asOutParam());
     2738        HRESULT hrc = pConsole->COMGETTER(Guest)(guest.asOutParam());
    27392739        if (SUCCEEDED(hrc) && !guest.isNull())
    27402740        {
     
    27422742
    27432743            AdditionsRunLevelType_T guestRunLevel; /** @todo Add a runlevel-to-string (e.g. 0 = "None") method? */
    2744             rc = guest->COMGETTER(AdditionsRunLevel)(&guestRunLevel);
     2744            hrc = guest->COMGETTER(AdditionsRunLevel)(&guestRunLevel);
    27452745            if (SUCCEEDED(hrc))
    27462746                SHOW_ULONG_VALUE("GuestAdditionsRunLevel", GuestCtrl::tr("Additions run level:"), (ULONG)guestRunLevel, "");
    27472747
    27482748            Bstr guestString;
    2749             rc = guest->COMGETTER(AdditionsVersion)(guestString.asOutParam());
     2749            hrc = guest->COMGETTER(AdditionsVersion)(guestString.asOutParam());
    27502750            if (   SUCCEEDED(hrc)
    27512751                && !guestString.isEmpty())
    27522752            {
    27532753                ULONG uRevision;
    2754                 rc = guest->COMGETTER(AdditionsRevision)(&uRevision);
     2754                hrc = guest->COMGETTER(AdditionsRevision)(&uRevision);
    27552755                if (FAILED(hrc))
    27562756                    uRevision = 0;
     
    31703170    RTGETOPTUNION ValueUnion;
    31713171    RTGETOPTSTATE GetState;
    3172     RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
     3172    int vrc = RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
     3173    AssertRCReturn(vrc, RTEXITCODE_FAILURE);
    31733174
    31743175    std::vector < uint32_t > vecPID;
     
    31953196                /* Treat every else specified as a PID to kill. */
    31963197                uint32_t uPid;
    3197                 int rc = RTStrToUInt32Ex(ValueUnion.psz, NULL, 0, &uPid);
    3198                 if (   RT_SUCCESS(rc)
    3199                     && rc != VWRN_TRAILING_CHARS
    3200                     && rc != VWRN_NUMBER_TOO_BIG
    3201                     && rc != VWRN_NEGATIVE_UNSIGNED)
     3198                vrc = RTStrToUInt32Ex(ValueUnion.psz, NULL, 0, &uPid);
     3199                if (   RT_SUCCESS(vrc)
     3200                    && vrc != VWRN_TRAILING_CHARS
     3201                    && vrc != VWRN_NUMBER_TOO_BIG
     3202                    && vrc != VWRN_NEGATIVE_UNSIGNED)
    32023203                {
    32033204                    if (uPid != 0)
     
    32163217                }
    32173218                else
    3218                     return errorSyntax(GuestCtrl::tr("Error parsing PID value: %Rrc"), rc);
     3219                    return errorSyntax(GuestCtrl::tr("Error parsing PID value: %Rrc"), vrc);
    32193220                break;
    32203221            }
  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageMisc.cpp

    r98103 r98298  
    467467                    vrc = RTPathAbs(ValueUnion.psz, szTargetFolder, sizeof(szTargetFolder));
    468468                    if (RT_FAILURE(vrc))
    469                         return RTMsgErrorExit(RTEXITCODE_FAILURE, Misc::tr("RTPathAbs(%s,,) failed with rc=%Rrc"),
     469                        return RTMsgErrorExit(RTEXITCODE_FAILURE, Misc::tr("RTPathAbs(%s,,) failed with vrc=%Rrc"),
    470470                                              ValueUnion.psz, vrc);
    471471                } else {
     
    488488
    489489    if (!pszType)
    490     {
    491490        pszType = "basic";
    492     }
    493491
    494492    /* Check for required options */
     
    558556static int parseCloneOptions(const char *psz, com::SafeArray<CloneOptions_T> *options)
    559557{
    560     int rc = VINF_SUCCESS;
    561     while (psz && *psz && RT_SUCCESS(rc))
     558    int vrc = VINF_SUCCESS;
     559    while (psz && *psz && RT_SUCCESS(vrc))
    562560    {
    563561        size_t len;
     
    582580                options->push_back(CloneOptions_KeepHwUUIDs);
    583581            else
    584                 rc = VERR_PARSE_ERROR;
     582                vrc = VERR_PARSE_ERROR;
    585583        }
    586584        if (pszComma)
     
    590588    }
    591589
    592     return rc;
     590    return vrc;
    593591}
    594592
     
    18651863        int vrc = RTPathAbs(pszName, szPath, sizeof(szPath));
    18661864        if (RT_FAILURE(vrc))
    1867             return RTMsgErrorExit(RTEXITCODE_FAILURE, Misc::tr("RTPathAbs(%s,,) failed with rc=%Rrc"), pszName, vrc);
     1865            return RTMsgErrorExit(RTEXITCODE_FAILURE, Misc::tr("RTPathAbs(%s,,) failed with vrc=%Rrc"), pszName, vrc);
    18681866
    18691867        Bstr bstrTarball(szPath);
  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageModifyVM.cpp

    r98103 r98298  
    517517static int32_t parsePci(const char* szPciAddr)
    518518{
    519     char* pszNext = (char*)szPciAddr;
    520     int rc;
    521519    uint8_t aVals[3] = {0, 0, 0};
    522520
    523     rc = RTStrToUInt8Ex(pszNext, &pszNext, 16, &aVals[0]);
    524     if (RT_FAILURE(rc) || pszNext == NULL || *pszNext != ':')
     521    char *pszNext;
     522    int vrc = RTStrToUInt8Ex(pszNext, &pszNext, 16, &aVals[0]);
     523    if (RT_FAILURE(vrc) || pszNext == NULL || *pszNext != ':')
    525524        return -1;
    526525
    527     rc = RTStrToUInt8Ex(pszNext+1, &pszNext, 16, &aVals[1]);
    528     if (RT_FAILURE(rc) || pszNext == NULL || *pszNext != '.')
     526    vrc = RTStrToUInt8Ex(pszNext+1, &pszNext, 16, &aVals[1]);
     527    if (RT_FAILURE(vrc) || pszNext == NULL || *pszNext != '.')
    529528        return -1;
    530529
    531     rc = RTStrToUInt8Ex(pszNext+1, &pszNext, 16, &aVals[2]);
    532     if (RT_FAILURE(rc) || pszNext == NULL)
     530    vrc = RTStrToUInt8Ex(pszNext+1, &pszNext, 16, &aVals[2]);
     531    if (RT_FAILURE(vrc) || pszNext == NULL)
    533532        return -1;
    534533
     
    574573        char *pszNext;
    575574        uint32_t iScreen;
    576         int rc = RTStrToUInt32Ex(pcszScreens, &pszNext, 0, &iScreen);
    577         if (RT_FAILURE(rc))
     575        int vrc = RTStrToUInt32Ex(pcszScreens, &pszNext, 0, &iScreen);
     576        if (RT_FAILURE(vrc))
    578577            return VERR_PARSE_ERROR;
    579578        if (iScreen >= pScreens->size())
  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageSnapshot.cpp

    r98103 r98298  
    285285static int parseSnapshotUniqueFlags(const char *psz, SnapshotUniqueFlags *pUnique)
    286286{
    287     int rc = VINF_SUCCESS;
     287    int vrc = VINF_SUCCESS;
    288288    unsigned uUnique = 0;
    289     while (psz && *psz && RT_SUCCESS(rc))
     289    while (psz && *psz && RT_SUCCESS(vrc))
    290290    {
    291291        size_t len;
     
    306306                uUnique |= SnapshotUniqueFlags_Force;
    307307            else
    308                 rc = VERR_PARSE_ERROR;
     308                vrc = VERR_PARSE_ERROR;
    309309        }
    310310        if (pszComma)
     
    314314    }
    315315
    316     if (RT_SUCCESS(rc))
     316    if (RT_SUCCESS(vrc))
    317317        *pUnique = (SnapshotUniqueFlags)uUnique;
    318     return rc;
     318    return vrc;
    319319}
    320320
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette