VirtualBox

Ignore:
Timestamp:
May 8, 2022 7:05:31 PM (3 years ago)
Author:
vboxsync
Message:

Main/src-all: Adjust to the new rules wrt. to rc -> hrc,vrc usage, ​bugref:10223

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/VBox/Main/src-all/ExtPackUtil.cpp

    r94714 r94912  
    341341     */
    342342    RTFSOBJINFO ObjInfo;
    343     int rc = RTVfsFileQueryInfo(hVfsFile, &ObjInfo, RTFSOBJATTRADD_UNIX);
    344     if (RT_FAILURE(rc))
    345         return &(new RTCString)->printf(ExtPackUtil::tr("RTVfsFileQueryInfo failed: %Rrc"), rc);
     343    int vrc = RTVfsFileQueryInfo(hVfsFile, &ObjInfo, RTFSOBJATTRADD_UNIX);
     344    if (RT_FAILURE(vrc))
     345        return &(new RTCString)->printf(ExtPackUtil::tr("RTVfsFileQueryInfo failed: %Rrc"), vrc);
    346346    if (a_pObjInfo)
    347347        *a_pObjInfo = ObjInfo;
     
    359359
    360360    /* Rewind to the start of the file. */
    361     rc = RTVfsFileSeek(hVfsFile, 0, RTFILE_SEEK_BEGIN, NULL);
    362     if (RT_FAILURE(rc))
    363         return &(new RTCString)->printf(ExtPackUtil::tr("RTVfsFileSeek(,0,BEGIN) failed: %Rrc"), rc);
     361    vrc = RTVfsFileSeek(hVfsFile, 0, RTFILE_SEEK_BEGIN, NULL);
     362    if (RT_FAILURE(vrc))
     363        return &(new RTCString)->printf(ExtPackUtil::tr("RTVfsFileSeek(,0,BEGIN) failed: %Rrc"), vrc);
    364364
    365365    /* Allocate memory and read the file content into it. */
     
    369369
    370370    RTCString *pstrErr = NULL;
    371     rc = RTVfsFileRead(hVfsFile, pvFile, cbFile, NULL);
    372     if (RT_FAILURE(rc))
    373         pstrErr = &(new RTCString)->printf(ExtPackUtil::tr("RTVfsFileRead failed: %Rrc"), rc);
     371    vrc = RTVfsFileRead(hVfsFile, pvFile, cbFile, NULL);
     372    if (RT_FAILURE(vrc))
     373        pstrErr = &(new RTCString)->printf(ExtPackUtil::tr("RTVfsFileRead failed: %Rrc"), vrc);
    374374
    375375    /*
     
    377377     */
    378378    xml::Document Doc;
    379     if (RT_SUCCESS(rc))
     379    if (RT_SUCCESS(vrc))
    380380    {
    381381        xml::XmlMemParser   Parser;
     
    388388        {
    389389            pstrErr = new RTCString(rErr.what());
    390             rc = VERR_PARSE_ERROR;
     390            vrc = VERR_PARSE_ERROR;
    391391        }
    392392    }
     
    396396     * Hand the xml doc over to the common code.
    397397     */
    398     if (RT_SUCCESS(rc))
     398    if (RT_SUCCESS(vrc))
    399399        try
    400400        {
     
    650650    {
    651651        /** @todo Should probably restrict this to known build types (alpha,
    652          *        beta, rc, ++). */
     652         *        beta, release candidate, ++). */
    653653        do
    654654            pszVersion++;
     
    708708 * RTStrPrintfv wrapper.
    709709 *
    710  * @returns @a rc
    711  * @param   rc                  The status code to return.
     710 * @returns @a vrc
     711 * @param   vrc                 The status code to return.
    712712 * @param   pszError            The error buffer.
    713713 * @param   cbError             The size of the buffer.
     
    715715 * @param   ...                 Format arguments.
    716716 */
    717 static int vboxExtPackReturnError(int rc, char *pszError, size_t cbError, const char *pszFormat, ...)
     717static int vboxExtPackReturnError(int vrc, char *pszError, size_t cbError, const char *pszFormat, ...)
    718718{
    719719    va_list va;
     
    721721    RTStrPrintfV(pszError, cbError, pszFormat, va);
    722722    va_end(va);
    723     return rc;
     723    return vrc;
    724724}
    725725
     
    769769    /** @todo drop this restriction after the old install interface is
    770770     *        dropped. */
    771     int rc = VINF_SUCCESS;
     771    int vrc = VINF_SUCCESS;
    772772    if (   pszExtPackName
    773773        && !ExtPackDesc.strName.equalsIgnoreCase(pszExtPackName))
    774         rc = vboxExtPackReturnError(VERR_NOT_EQUAL, pszError, cbError,
    775                                     ExtPackUtil::tr("The name of the downloaded file and the name stored inside the extension pack does not match"
    776                                     " (xml='%s' file='%s')"), ExtPackDesc.strName.c_str(), pszExtPackName);
    777     return rc;
     774        vrc = vboxExtPackReturnError(VERR_NOT_EQUAL, pszError, cbError,
     775                                     ExtPackUtil::tr("The name of the downloaded file and the name stored inside the extension pack does not match"
     776                                     " (xml='%s' file='%s')"), ExtPackDesc.strName.c_str(), pszExtPackName);
     777    return vrc;
    778778}
    779779
     
    794794     * Read the manifest from the extension pack.
    795795     */
    796     int rc = RTVfsFileSeek(hManifestFile, 0, RTFILE_SEEK_BEGIN, NULL);
    797     if (RT_FAILURE(rc))
    798         return vboxExtPackReturnError(rc, pszError, cbError, ExtPackUtil::tr("RTVfsFileSeek failed: %Rrc"), rc);
     796    int vrc = RTVfsFileSeek(hManifestFile, 0, RTFILE_SEEK_BEGIN, NULL);
     797    if (RT_FAILURE(vrc))
     798        return vboxExtPackReturnError(vrc, pszError, cbError, ExtPackUtil::tr("RTVfsFileSeek failed: %Rrc"), vrc);
    799799
    800800    RTMANIFEST hTheirManifest;
    801     rc = RTManifestCreate(0 /*fFlags*/, &hTheirManifest);
    802     if (RT_FAILURE(rc))
    803         return vboxExtPackReturnError(rc, pszError, cbError, ExtPackUtil::tr("RTManifestCreate failed: %Rrc"), rc);
     801    vrc = RTManifestCreate(0 /*fFlags*/, &hTheirManifest);
     802    if (RT_FAILURE(vrc))
     803        return vboxExtPackReturnError(vrc, pszError, cbError, ExtPackUtil::tr("RTManifestCreate failed: %Rrc"), vrc);
    804804
    805805    RTVFSIOSTREAM hVfsIos = RTVfsFileToIoStream(hManifestFile);
    806     rc = RTManifestReadStandard(hTheirManifest, hVfsIos);
     806    vrc = RTManifestReadStandard(hTheirManifest, hVfsIos);
    807807    RTVfsIoStrmRelease(hVfsIos);
    808     if (RT_SUCCESS(rc))
     808    if (RT_SUCCESS(vrc))
    809809    {
    810810        /*
     
    820820        };
    821821        char szError[RTPATH_MAX];
    822         rc = RTManifestEqualsEx(hOurManifest, hTheirManifest, &s_apszIgnoreEntries[0], NULL,
    823                                 RTMANIFEST_EQUALS_IGN_MISSING_ATTRS /*fFlags*/,
    824                                 szError, sizeof(szError));
    825         if (RT_SUCCESS(rc))
     822        vrc = RTManifestEqualsEx(hOurManifest, hTheirManifest, &s_apszIgnoreEntries[0], NULL,
     823                                 RTMANIFEST_EQUALS_IGN_MISSING_ATTRS /*fFlags*/,
     824                                 szError, sizeof(szError));
     825        if (RT_SUCCESS(vrc))
    826826        {
    827827            /*
     
    832832
    833833        }
    834         else if (rc == VERR_NOT_EQUAL && szError[0])
     834        else if (vrc == VERR_NOT_EQUAL && szError[0])
    835835            vboxExtPackSetError(pszError, cbError, ExtPackUtil::tr("Manifest mismatch: %s"), szError);
    836836        else
    837             vboxExtPackSetError(pszError, cbError, ExtPackUtil::tr("RTManifestEqualsEx failed: %Rrc"), rc);
     837            vboxExtPackSetError(pszError, cbError, ExtPackUtil::tr("RTManifestEqualsEx failed: %Rrc"), vrc);
    838838#if 0
    839839        RTVFSIOSTREAM hVfsIosStdOut = NIL_RTVFSIOSTREAM;
     
    846846    }
    847847    else
    848         vboxExtPackSetError(pszError, cbError, ExtPackUtil::tr("Error parsing '%s': %Rrc"), VBOX_EXTPACK_MANIFEST_NAME, rc);
     848        vboxExtPackSetError(pszError, cbError, ExtPackUtil::tr("Error parsing '%s': %Rrc"), VBOX_EXTPACK_MANIFEST_NAME, vrc);
    849849
    850850    RTManifestRelease(hTheirManifest);
    851     return rc;
     851    return vrc;
    852852}
    853853
     
    871871     */
    872872    char szCalculatedDigest[RTSHA256_DIGEST_LEN + 1];
    873     int rc = RTManifestEntryQueryAttr(hFileManifest, "extpack", NULL /*no name*/, RTMANIFEST_ATTR_SHA256,
    874                                       szCalculatedDigest, sizeof(szCalculatedDigest), NULL);
    875     if (RT_SUCCESS(rc))
     873    int vrc = RTManifestEntryQueryAttr(hFileManifest, "extpack", NULL /*no name*/, RTMANIFEST_ATTR_SHA256,
     874                                       szCalculatedDigest, sizeof(szCalculatedDigest), NULL);
     875    if (RT_SUCCESS(vrc))
    876876    {
    877877        /*
     
    881881         */
    882882        uint8_t abCalculatedHash[RTSHA256_HASH_SIZE];
    883         rc = RTSha256FromString(szCalculatedDigest, abCalculatedHash);
    884         if (RT_SUCCESS(rc))
     883        vrc = RTSha256FromString(szCalculatedDigest, abCalculatedHash);
     884        if (RT_SUCCESS(vrc))
    885885        {
    886886            if (   pszFileDigest
     
    888888            {
    889889                uint8_t abFileHash[RTSHA256_HASH_SIZE];
    890                 rc = RTSha256FromString(pszFileDigest, abFileHash);
    891                 if (RT_SUCCESS(rc))
     890                vrc = RTSha256FromString(pszFileDigest, abFileHash);
     891                if (RT_SUCCESS(vrc))
    892892                {
    893893                    if (memcmp(abFileHash, abCalculatedHash, sizeof(abFileHash)))
     
    895895                        vboxExtPackSetError(pszError, cbError,
    896896                                            ExtPackUtil::tr("The extension pack file has changed (SHA-256 mismatch)"));
    897                         rc = VERR_NOT_EQUAL;
     897                        vrc = VERR_NOT_EQUAL;
    898898                    }
    899899                }
    900900                else
    901                     vboxExtPackSetError(pszError, cbError, ExtPackUtil::tr("Bad SHA-256 '%s': %Rrc"), szCalculatedDigest, rc);
     901                    vboxExtPackSetError(pszError, cbError, ExtPackUtil::tr("Bad SHA-256 '%s': %Rrc"), szCalculatedDigest, vrc);
    902902            }
    903903
     
    905905             * Set the output hash on success.
    906906             */
    907             if (pStrDigest && RT_SUCCESS(rc))
     907            if (pStrDigest && RT_SUCCESS(vrc))
    908908            {
    909909                try
     
    913913                catch (std::bad_alloc &)
    914914                {
    915                     rc = VERR_NO_MEMORY;
     915                    vrc = VERR_NO_MEMORY;
    916916                }
    917917            }
    918918        }
    919919        else
    920             vboxExtPackSetError(pszError, cbError, ExtPackUtil::tr("Bad SHA-256 '%s': %Rrc"), szCalculatedDigest, rc);
     920            vboxExtPackSetError(pszError, cbError, ExtPackUtil::tr("Bad SHA-256 '%s': %Rrc"), szCalculatedDigest, vrc);
    921921    }
    922922    else
    923         vboxExtPackSetError(pszError, cbError, "RTManifestEntryGetAttr: %Rrc", rc);
    924     return rc;
     923        vboxExtPackSetError(pszError, cbError, "RTManifestEntryGetAttr: %Rrc", vrc);
     924    return vrc;
    925925}
    926926
     
    945945                                           PRTVFSOBJ phVfsObj, PRTVFSFILE phVfsFile, char *pszError, size_t cbError)
    946946{
    947     int rc;
     947    int vrc;
    948948
    949949    /*
     
    951951     */
    952952    if (phVfsFile && *phVfsFile != NIL_RTVFSFILE)
    953         rc = vboxExtPackReturnError(VERR_DUPLICATE, pszError, cbError,
    954                                     ExtPackUtil::tr("There can only be one '%s'"), pszAdjName);
     953        vrc = vboxExtPackReturnError(VERR_DUPLICATE, pszError, cbError,
     954                                     ExtPackUtil::tr("There can only be one '%s'"), pszAdjName);
    955955    else if (enmType != RTVFSOBJTYPE_IO_STREAM && enmType != RTVFSOBJTYPE_FILE)
    956         rc = vboxExtPackReturnError(VERR_NOT_A_FILE, pszError, cbError,
    957                                     ExtPackUtil::tr("Standard member '%s' is not a file"), pszAdjName);
     956        vrc = vboxExtPackReturnError(VERR_NOT_A_FILE, pszError, cbError,
     957                                     ExtPackUtil::tr("Standard member '%s' is not a file"), pszAdjName);
    958958    else
    959959    {
    960960        RTFSOBJINFO ObjInfo;
    961         rc = RTVfsObjQueryInfo(*phVfsObj, &ObjInfo, RTFSOBJATTRADD_NOTHING);
    962         if (RT_SUCCESS(rc))
     961        vrc = RTVfsObjQueryInfo(*phVfsObj, &ObjInfo, RTFSOBJATTRADD_NOTHING);
     962        if (RT_SUCCESS(vrc))
    963963        {
    964964            if (!RTFS_IS_FILE(ObjInfo.Attr.fMode))
    965                 rc = vboxExtPackReturnError(VERR_NOT_A_FILE, pszError, cbError,
    966                                             ExtPackUtil::tr("Standard member '%s' is not a file"), pszAdjName);
     965                vrc = vboxExtPackReturnError(VERR_NOT_A_FILE, pszError, cbError,
     966                                             ExtPackUtil::tr("Standard member '%s' is not a file"), pszAdjName);
    967967            else if (ObjInfo.cbObject >= _1M)
    968                 rc = vboxExtPackReturnError(VERR_OUT_OF_RANGE, pszError, cbError,
    969                                             ExtPackUtil::tr("Standard member '%s' is too large: %'RU64 bytes (max 1 MB)", "",
    970                                                             (size_t)ObjInfo.cbObject),
    971                                             pszAdjName, (uint64_t)ObjInfo.cbObject);
     968                vrc = vboxExtPackReturnError(VERR_OUT_OF_RANGE, pszError, cbError,
     969                                             ExtPackUtil::tr("Standard member '%s' is too large: %'RU64 bytes (max 1 MB)", "",
     970                                                             (size_t)ObjInfo.cbObject),
     971                                             pszAdjName, (uint64_t)ObjInfo.cbObject);
    972972            else
    973973            {
     
    978978                RTVFSIOSTREAM hVfsIos = RTVfsObjToIoStream(*phVfsObj);
    979979                RTVFSFILE     hVfsFile;
    980                 rc = RTVfsMemorizeIoStreamAsFile(hVfsIos, RTFILE_O_READ, &hVfsFile);
    981                 if (RT_SUCCESS(rc))
     980                vrc = RTVfsMemorizeIoStreamAsFile(hVfsIos, RTFILE_O_READ, &hVfsFile);
     981                if (RT_SUCCESS(vrc))
    982982                {
    983                     rc = RTVfsIoStrmValidateUtf8Encoding(hVfsIos,
    984                                                          RTVFS_VALIDATE_UTF8_BY_RTC_3629 | RTVFS_VALIDATE_UTF8_NO_NULL,
    985                                                          NULL);
    986                     if (RT_SUCCESS(rc))
     983                    vrc = RTVfsIoStrmValidateUtf8Encoding(hVfsIos,
     984                                                          RTVFS_VALIDATE_UTF8_BY_RTC_3629 | RTVFS_VALIDATE_UTF8_NO_NULL,
     985                                                          NULL);
     986                    if (RT_SUCCESS(vrc))
    987987                    {
    988988                        /*
    989989                         * Replace *phVfsObj with the memorized file.
    990990                         */
    991                         rc = RTVfsFileSeek(hVfsFile, 0, RTFILE_SEEK_BEGIN, NULL);
    992                         if (RT_SUCCESS(rc))
     991                        vrc = RTVfsFileSeek(hVfsFile, 0, RTFILE_SEEK_BEGIN, NULL);
     992                        if (RT_SUCCESS(vrc))
    993993                        {
    994994                            RTVfsObjRelease(*phVfsObj);
     
    997997                        else
    998998                            vboxExtPackSetError(pszError, cbError,
    999                                                 ExtPackUtil::tr("RTVfsFileSeek failed on '%s': %Rrc"), pszAdjName, rc);
     999                                                ExtPackUtil::tr("RTVfsFileSeek failed on '%s': %Rrc"), pszAdjName, vrc);
    10001000                    }
    10011001
    1002                     if (phVfsFile && RT_SUCCESS(rc))
     1002                    if (phVfsFile && RT_SUCCESS(vrc))
    10031003                        *phVfsFile = hVfsFile;
    10041004                    else
     
    10071007                else
    10081008                    vboxExtPackSetError(pszError, cbError,
    1009                                         ExtPackUtil::tr("RTVfsMemorizeIoStreamAsFile failed on '%s': %Rrc"), pszAdjName, rc);
     1009                                        ExtPackUtil::tr("RTVfsMemorizeIoStreamAsFile failed on '%s': %Rrc"), pszAdjName, vrc);
    10101010                RTVfsIoStrmRelease(hVfsIos);
    10111011            }
    10121012        }
    10131013        else
    1014             vboxExtPackSetError(pszError, cbError, ExtPackUtil::tr("RTVfsObjQueryInfo failed on '%s': %Rrc"), pszAdjName, rc);
    1015     }
    1016     return rc;
     1014            vboxExtPackSetError(pszError, cbError, ExtPackUtil::tr("RTVfsObjQueryInfo failed on '%s': %Rrc"), pszAdjName, vrc);
     1015    }
     1016    return vrc;
    10171017}
    10181018
     
    11001100static int vboxExtPackValidateMemberFile(const char *pszName, RTVFSOBJ hVfsObj, char *pszError, size_t cbError)
    11011101{
    1102     int rc = vboxExtPackValidateMemberName(pszName, pszError, cbError);
    1103     if (RT_SUCCESS(rc))
     1102    int vrc = vboxExtPackValidateMemberName(pszName, pszError, cbError);
     1103    if (RT_SUCCESS(vrc))
    11041104    {
    11051105        RTFSOBJINFO ObjInfo;
    1106         rc = RTVfsObjQueryInfo(hVfsObj, &ObjInfo, RTFSOBJATTRADD_NOTHING);
    1107         if (RT_SUCCESS(rc))
     1106        vrc = RTVfsObjQueryInfo(hVfsObj, &ObjInfo, RTFSOBJATTRADD_NOTHING);
     1107        if (RT_SUCCESS(vrc))
    11081108        {
    11091109            if (ObjInfo.cbObject >= 9*_1G64)
    1110                 rc = vboxExtPackReturnError(VERR_OUT_OF_RANGE, pszError, cbError,
    1111                                             ExtPackUtil::tr("'%s': too large (%'RU64 bytes)", "", (size_t)ObjInfo.cbObject),
    1112                                             pszName, (uint64_t)ObjInfo.cbObject);
     1110                vrc = vboxExtPackReturnError(VERR_OUT_OF_RANGE, pszError, cbError,
     1111                                             ExtPackUtil::tr("'%s': too large (%'RU64 bytes)", "", (size_t)ObjInfo.cbObject),
     1112                                             pszName, (uint64_t)ObjInfo.cbObject);
    11131113            if (!RTFS_IS_FILE(ObjInfo.Attr.fMode))
    1114                 rc = vboxExtPackReturnError(VERR_NOT_A_FILE, pszError, cbError,
    1115                                             ExtPackUtil::tr("The alleged file '%s' has a mode mask stating otherwise (%RTfmode)"),
    1116                                             pszName, ObjInfo.Attr.fMode);
     1114                vrc = vboxExtPackReturnError(VERR_NOT_A_FILE, pszError, cbError,
     1115                                             ExtPackUtil::tr("The alleged file '%s' has a mode mask stating otherwise (%RTfmode)"),
     1116                                             pszName, ObjInfo.Attr.fMode);
    11171117        }
    11181118        else
    1119             vboxExtPackSetError(pszError, cbError, ExtPackUtil::tr("RTVfsObjQueryInfo failed on '%s': %Rrc"), pszName, rc);
    1120     }
    1121     return rc;
     1119            vboxExtPackSetError(pszError, cbError, ExtPackUtil::tr("RTVfsObjQueryInfo failed on '%s': %Rrc"), pszName, vrc);
     1120    }
     1121    return vrc;
    11221122}
    11231123
     
    11341134static int vboxExtPackValidateMemberDir(const char *pszName, RTVFSOBJ hVfsObj, char *pszError, size_t cbError)
    11351135{
    1136     int rc = vboxExtPackValidateMemberName(pszName, pszError, cbError);
    1137     if (RT_SUCCESS(rc))
     1136    int vrc = vboxExtPackValidateMemberName(pszName, pszError, cbError);
     1137    if (RT_SUCCESS(vrc))
    11381138    {
    11391139        RTFSOBJINFO ObjInfo;
    1140         rc = RTVfsObjQueryInfo(hVfsObj, &ObjInfo, RTFSOBJATTRADD_NOTHING);
    1141         if (RT_SUCCESS(rc))
     1140        vrc = RTVfsObjQueryInfo(hVfsObj, &ObjInfo, RTFSOBJATTRADD_NOTHING);
     1141        if (RT_SUCCESS(vrc))
    11421142        {
    11431143            if (!RTFS_IS_DIRECTORY(ObjInfo.Attr.fMode))
    1144                 rc = vboxExtPackReturnError(VERR_NOT_A_DIRECTORY, pszError, cbError,
    1145                                             ExtPackUtil::tr("The alleged directory '%s' has a mode mask saying differently (%RTfmode)"),
    1146                                             pszName, ObjInfo.Attr.fMode);
     1144                vrc = vboxExtPackReturnError(VERR_NOT_A_DIRECTORY, pszError, cbError,
     1145                                             ExtPackUtil::tr("The alleged directory '%s' has a mode mask saying differently (%RTfmode)"),
     1146                                             pszName, ObjInfo.Attr.fMode);
    11471147        }
    11481148        else
    1149             vboxExtPackSetError(pszError, cbError, ExtPackUtil::tr("RTVfsObjQueryInfo failed on '%s': %Rrc"), pszName, rc);
    1150     }
    1151     return rc;
     1149            vboxExtPackSetError(pszError, cbError, ExtPackUtil::tr("RTVfsObjQueryInfo failed on '%s': %Rrc"), pszName, vrc);
     1150    }
     1151    return vrc;
    11521152}
    11531153
     
    11671167    *pszError = '\0';
    11681168
    1169     int rc;
     1169    int vrc;
    11701170    if (   enmType == RTVFSOBJTYPE_FILE
    11711171        || enmType == RTVFSOBJTYPE_IO_STREAM)
    1172         rc = vboxExtPackValidateMemberFile(pszName, hVfsObj, pszError, cbError);
     1172        vrc = vboxExtPackValidateMemberFile(pszName, hVfsObj, pszError, cbError);
    11731173    else if (   enmType == RTVFSOBJTYPE_DIR
    11741174             || enmType == RTVFSOBJTYPE_BASE)
    1175         rc = vboxExtPackValidateMemberDir(pszName, hVfsObj, pszError, cbError);
     1175        vrc = vboxExtPackValidateMemberDir(pszName, hVfsObj, pszError, cbError);
    11761176    else
    1177         rc = vboxExtPackReturnError(VERR_UNEXPECTED_FS_OBJ_TYPE, pszError, cbError,
    1178                                     ExtPackUtil::tr("'%s' is not a file or directory (enmType=%d)"), pszName, enmType);
    1179     return rc;
     1177        vrc = vboxExtPackReturnError(VERR_UNEXPECTED_FS_OBJ_TYPE, pszError, cbError,
     1178                                     ExtPackUtil::tr("'%s' is not a file or directory (enmType=%d)"), pszName, enmType);
     1179    return vrc;
    11801180}
    11811181
     
    12051205     * Rewind the file and set up a VFS chain for it.
    12061206     */
    1207     int rc = RTFileSeek(hTarballFile, 0, RTFILE_SEEK_BEGIN, NULL);
    1208     if (RT_FAILURE(rc))
    1209         return vboxExtPackReturnError(rc, pszError, cbError,
    1210                                       ExtPackUtil::tr("Failed seeking to the start of the tarball: %Rrc"), rc);
     1207    int vrc = RTFileSeek(hTarballFile, 0, RTFILE_SEEK_BEGIN, NULL);
     1208    if (RT_FAILURE(vrc))
     1209        return vboxExtPackReturnError(vrc, pszError, cbError,
     1210                                      ExtPackUtil::tr("Failed seeking to the start of the tarball: %Rrc"), vrc);
    12111211
    12121212    RTVFSIOSTREAM hTarballIos;
    1213     rc = RTVfsIoStrmFromRTFile(hTarballFile, RTFILE_O_READ | RTFILE_O_DENY_WRITE | RTFILE_O_OPEN, true /*fLeaveOpen*/,
    1214                                &hTarballIos);
    1215     if (RT_FAILURE(rc))
    1216         return vboxExtPackReturnError(rc, pszError, cbError, ExtPackUtil::tr("RTVfsIoStrmFromRTFile failed: %Rrc"), rc);
     1213    vrc = RTVfsIoStrmFromRTFile(hTarballFile, RTFILE_O_READ | RTFILE_O_DENY_WRITE | RTFILE_O_OPEN, true /*fLeaveOpen*/,
     1214                                &hTarballIos);
     1215    if (RT_FAILURE(vrc))
     1216        return vboxExtPackReturnError(vrc, pszError, cbError, ExtPackUtil::tr("RTVfsIoStrmFromRTFile failed: %Rrc"), vrc);
    12171217
    12181218    RTMANIFEST hFileManifest = NIL_RTMANIFEST;
    1219     rc = RTManifestCreate(0 /*fFlags*/, &hFileManifest);
    1220     if (RT_SUCCESS(rc))
     1219    vrc = RTManifestCreate(0 /*fFlags*/, &hFileManifest);
     1220    if (RT_SUCCESS(vrc))
    12211221    {
    12221222        RTVFSIOSTREAM hPtIos;
    1223         rc = RTManifestEntryAddPassthruIoStream(hFileManifest, hTarballIos, "extpack", RTMANIFEST_ATTR_SHA256,
    1224                                                 true /*read*/, &hPtIos);
    1225         if (RT_SUCCESS(rc))
     1223        vrc = RTManifestEntryAddPassthruIoStream(hFileManifest, hTarballIos, "extpack", RTMANIFEST_ATTR_SHA256,
     1224                                                 true /*read*/, &hPtIos);
     1225        if (RT_SUCCESS(vrc))
    12261226        {
    12271227            RTVFSIOSTREAM hGunzipIos;
    1228             rc = RTZipGzipDecompressIoStream(hPtIos, 0 /*fFlags*/, &hGunzipIos);
    1229             if (RT_SUCCESS(rc))
     1228            vrc = RTZipGzipDecompressIoStream(hPtIos, 0 /*fFlags*/, &hGunzipIos);
     1229            if (RT_SUCCESS(vrc))
    12301230            {
    12311231                RTVFSFSSTREAM hTarFss;
    1232                 rc = RTZipTarFsStreamFromIoStream(hGunzipIos, 0 /*fFlags*/, &hTarFss);
    1233                 if (RT_SUCCESS(rc))
     1232                vrc = RTZipTarFsStreamFromIoStream(hGunzipIos, 0 /*fFlags*/, &hTarFss);
     1233                if (RT_SUCCESS(vrc))
    12341234                {
    12351235                    RTVfsIoStrmRelease(hPtIos);
     
    12441244                }
    12451245
    1246                 vboxExtPackSetError(pszError, cbError, ExtPackUtil::tr("RTZipTarFsStreamFromIoStream failed: %Rrc"), rc);
     1246                vboxExtPackSetError(pszError, cbError, ExtPackUtil::tr("RTZipTarFsStreamFromIoStream failed: %Rrc"), vrc);
    12471247                RTVfsIoStrmRelease(hGunzipIos);
    12481248            }
    12491249            else
    1250                 vboxExtPackSetError(pszError, cbError, ExtPackUtil::tr("RTZipGzipDecompressIoStream failed: %Rrc"), rc);
     1250                vboxExtPackSetError(pszError, cbError, ExtPackUtil::tr("RTZipGzipDecompressIoStream failed: %Rrc"), vrc);
    12511251            RTVfsIoStrmRelease(hPtIos);
    12521252        }
    12531253        else
    1254             vboxExtPackSetError(pszError, cbError, ExtPackUtil::tr("RTManifestEntryAddPassthruIoStream failed: %Rrc"), rc);
     1254            vboxExtPackSetError(pszError, cbError, ExtPackUtil::tr("RTManifestEntryAddPassthruIoStream failed: %Rrc"), vrc);
    12551255        RTManifestRelease(hFileManifest);
    12561256    }
    12571257    else
    1258         vboxExtPackSetError(pszError, cbError, ExtPackUtil::tr("RTManifestCreate failed: %Rrc"), rc);
     1258        vboxExtPackSetError(pszError, cbError, ExtPackUtil::tr("RTManifestCreate failed: %Rrc"), vrc);
    12591259
    12601260    RTVfsIoStrmRelease(hTarballIos);
    1261     return rc;
     1261    return vrc;
    12621262}
    12631263
     
    13111311    RTMANIFEST      hFileManifest;
    13121312    RTVFSFSSTREAM   hTarFss;
    1313     int rc = VBoxExtPackOpenTarFss(hTarballFile, pszError, cbError, &hTarFss, &hFileManifest);
    1314     if (RT_FAILURE(rc))
    1315         return rc;
     1313    int vrc = VBoxExtPackOpenTarFss(hTarballFile, pszError, cbError, &hTarFss, &hFileManifest);
     1314    if (RT_FAILURE(vrc))
     1315        return vrc;
    13161316
    13171317    RTMANIFEST hOurManifest;
    1318     rc = RTManifestCreate(0 /*fFlags*/, &hOurManifest);
    1319     if (RT_SUCCESS(rc))
     1318    vrc = RTManifestCreate(0 /*fFlags*/, &hOurManifest);
     1319    if (RT_SUCCESS(vrc))
    13201320    {
    13211321        /*
     
    13331333            RTVFSOBJ        hVfsObj;
    13341334            RTVFSOBJTYPE    enmType;
    1335             rc = RTVfsFsStrmNext(hTarFss, &pszName, &enmType, &hVfsObj);
    1336             if (RT_FAILURE(rc))
     1335            vrc = RTVfsFsStrmNext(hTarFss, &pszName, &enmType, &hVfsObj);
     1336            if (RT_FAILURE(vrc))
    13371337            {
    1338                 if (rc != VERR_EOF)
    1339                     vboxExtPackSetError(pszError, cbError, ExtPackUtil::tr("RTVfsFsStrmNext failed: %Rrc"), rc);
     1338                if (vrc != VERR_EOF)
     1339                    vboxExtPackSetError(pszError, cbError, ExtPackUtil::tr("RTVfsFsStrmNext failed: %Rrc"), vrc);
    13401340                else
    1341                     rc = VINF_SUCCESS;
     1341                    vrc = VINF_SUCCESS;
    13421342                break;
    13431343            }
     
    13511351             *      failure - cleanup reasons.
    13521352             */
    1353             rc = VBoxExtPackValidateMember(pszName, enmType, hVfsObj, pszError, cbError);
    1354             if (RT_SUCCESS(rc))
     1353            vrc = VBoxExtPackValidateMember(pszName, enmType, hVfsObj, pszError, cbError);
     1354            if (RT_SUCCESS(vrc))
    13551355            {
    13561356                PRTVFSFILE phVfsFile = NULL;
     
    13621362                    phVfsFile = &hSignatureFile;
    13631363                else if (!strncmp(pszAdjName, VBOX_EXTPACK_LICENSE_NAME_PREFIX, sizeof(VBOX_EXTPACK_LICENSE_NAME_PREFIX) - 1))
    1364                     rc = VBoxExtPackValidateStandardFile(pszAdjName, enmType, &hVfsObj, NULL, pszError, cbError);
     1364                    vrc = VBoxExtPackValidateStandardFile(pszAdjName, enmType, &hVfsObj, NULL, pszError, cbError);
    13651365                if (phVfsFile)
    1366                     rc = VBoxExtPackValidateStandardFile(pszAdjName, enmType, &hVfsObj, phVfsFile, pszError, cbError);
     1366                    vrc = VBoxExtPackValidateStandardFile(pszAdjName, enmType, &hVfsObj, phVfsFile, pszError, cbError);
    13671367            }
    13681368
     
    13701370             * Add any I/O stream to the manifest
    13711371             */
    1372             if (   RT_SUCCESS(rc)
     1372            if (   RT_SUCCESS(vrc)
    13731373                && (   enmType == RTVFSOBJTYPE_FILE
    13741374                    || enmType == RTVFSOBJTYPE_IO_STREAM))
    13751375            {
    13761376                RTVFSIOSTREAM hVfsIos = RTVfsObjToIoStream(hVfsObj);
    1377                 rc = RTManifestEntryAddIoStream(hOurManifest, hVfsIos, pszAdjName, RTMANIFEST_ATTR_SIZE | RTMANIFEST_ATTR_SHA256);
    1378                 if (RT_FAILURE(rc))
     1377                vrc = RTManifestEntryAddIoStream(hOurManifest, hVfsIos, pszAdjName, RTMANIFEST_ATTR_SIZE | RTMANIFEST_ATTR_SHA256);
     1378                if (RT_FAILURE(vrc))
    13791379                    vboxExtPackSetError(pszError, cbError,
    1380                                         ExtPackUtil::tr("RTManifestEntryAddIoStream failed on '%s': %Rrc"), pszAdjName, rc);
     1380                                        ExtPackUtil::tr("RTManifestEntryAddIoStream failed on '%s': %Rrc"), pszAdjName, vrc);
    13811381                RTVfsIoStrmRelease(hVfsIos);
    13821382            }
     
    13871387            RTVfsObjRelease(hVfsObj);
    13881388            RTStrFree(pszName);
    1389             if (RT_FAILURE(rc))
     1389            if (RT_FAILURE(vrc))
    13901390                break;
    13911391        }
     
    13941394         * Check the integrity of the tarball file.
    13951395         */
    1396         if (RT_SUCCESS(rc))
     1396        if (RT_SUCCESS(vrc))
    13971397        {
    13981398            RTVfsFsStrmRelease(hTarFss);
    13991399            hTarFss = NIL_RTVFSFSSTREAM;
    1400             rc = vboxExtPackVerifyFileDigest(hFileManifest, pszTarballDigest, pStrDigest, pszError, cbError);
     1400            vrc = vboxExtPackVerifyFileDigest(hFileManifest, pszTarballDigest, pStrDigest, pszError, cbError);
    14011401        }
    14021402
     
    14051405         * mandatory files are present.
    14061406         */
    1407         if (RT_SUCCESS(rc))
     1407        if (RT_SUCCESS(vrc))
    14081408        {
    14091409            if (hXmlFile == NIL_RTVFSFILE)
    1410                 rc = vboxExtPackReturnError(VERR_MISSING, pszError, cbError, ExtPackUtil::tr("Mandator file '%s' is missing"),
    1411                                             VBOX_EXTPACK_DESCRIPTION_NAME);
     1410                vrc = vboxExtPackReturnError(VERR_MISSING, pszError, cbError, ExtPackUtil::tr("Mandator file '%s' is missing"),
     1411                                             VBOX_EXTPACK_DESCRIPTION_NAME);
    14121412            if (hManifestFile == NIL_RTVFSFILE)
    1413                 rc = vboxExtPackReturnError(VERR_MISSING, pszError, cbError, ExtPackUtil::tr("Mandator file '%s' is missing"),
    1414                                             VBOX_EXTPACK_MANIFEST_NAME);
     1413                vrc = vboxExtPackReturnError(VERR_MISSING, pszError, cbError, ExtPackUtil::tr("Mandator file '%s' is missing"),
     1414                                             VBOX_EXTPACK_MANIFEST_NAME);
    14151415            if (hSignatureFile == NIL_RTVFSFILE)
    1416                 rc = vboxExtPackReturnError(VERR_MISSING, pszError, cbError, ExtPackUtil::tr("Mandator file '%s' is missing"),
    1417                                             VBOX_EXTPACK_SIGNATURE_NAME);
     1416                vrc = vboxExtPackReturnError(VERR_MISSING, pszError, cbError, ExtPackUtil::tr("Mandator file '%s' is missing"),
     1417                                             VBOX_EXTPACK_SIGNATURE_NAME);
    14181418        }
    14191419
     
    14211421         * Check the manifest and it's signature.
    14221422         */
    1423         if (RT_SUCCESS(rc))
    1424             rc = vboxExtPackVerifyManifestAndSignature(hOurManifest, hManifestFile, hSignatureFile, pszError, cbError);
     1423        if (RT_SUCCESS(vrc))
     1424            vrc = vboxExtPackVerifyManifestAndSignature(hOurManifest, hManifestFile, hSignatureFile, pszError, cbError);
    14251425
    14261426        /*
    14271427         * Check the XML.
    14281428         */
    1429         if (RT_SUCCESS(rc))
    1430             rc = vboxExtPackVerifyXml(hXmlFile, pszExtPackName, pszError, cbError);
     1429        if (RT_SUCCESS(vrc))
     1430            vrc = vboxExtPackVerifyXml(hXmlFile, pszExtPackName, pszError, cbError);
    14311431
    14321432        /*
    14331433         * Returns objects.
    14341434         */
    1435         if (RT_SUCCESS(rc))
     1435        if (RT_SUCCESS(vrc))
    14361436        {
    14371437            if (phValidManifest)
     
    14561456    }
    14571457    else
    1458         vboxExtPackSetError(pszError, cbError, "RTManifestCreate failed: %Rrc", rc);
     1458        vboxExtPackSetError(pszError, cbError, "RTManifestCreate failed: %Rrc", vrc);
    14591459    RTVfsFsStrmRelease(hTarFss);
    14601460    RTManifestRelease(hFileManifest);
    14611461
    1462     return rc;
    1463 }
    1464 
     1462    return vrc;
     1463}
     1464
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