VirtualBox

Changeset 98297 in vbox for trunk


Ignore:
Timestamp:
Jan 25, 2023 1:59:25 AM (21 months ago)
Author:
vboxsync
Message:

Main: rc -> hrc/vrc for all but testcases. Enabled scm rc checks accordingly. bugref:10223

Location:
trunk
Files:
18 edited

Legend:

Unmodified
Added
Removed
  • trunk/include/VBox/com/NativeEventQueue.h

    r98103 r98297  
    123123    }
    124124#else
    125     static int dispatchMessageOnWindows(MSG const *pMsg, int rc);
     125    static int dispatchMessageOnWindows(MSG const *pMsg, int vrc);
    126126#endif
    127127
  • trunk/include/VBox/com/errorprint.h

    r98103 r98297  
    5959void GluePrintErrorInfo(const com::ErrorInfo &info);
    6060void GluePrintErrorContext(const char *pcszContext, const char *pcszSourceFile, uint32_t uLine, bool fWarning = false);
    61 void GluePrintRCMessage(HRESULT rc);
    62 void GlueHandleComError(ComPtr<IUnknown> iface, const char *pcszContext, HRESULT rc, const char *pcszSourceFile, uint32_t uLine);
    63 void GlueHandleComErrorNoCtx(ComPtr<IUnknown> iface, HRESULT rc);
    64 void GlueHandleComErrorProgress(ComPtr<IProgress> progress, const char *pcszContext, HRESULT rc,
     61void GluePrintRCMessage(HRESULT hrc);
     62void GlueHandleComError(ComPtr<IUnknown> iface, const char *pcszContext, HRESULT hrc, const char *pcszSourceFile, uint32_t uLine);
     63void GlueHandleComErrorNoCtx(ComPtr<IUnknown> iface, HRESULT hrc);
     64void GlueHandleComErrorProgress(ComPtr<IProgress> progress, const char *pcszContext, HRESULT hrc,
    6565                                const char *pcszSourceFile, uint32_t uLine);
    6666
  • trunk/src/VBox/Main/.scm-settings

    r98296 r98297  
    2525# SPDX-License-Identifier: GPL-3.0-only
    2626#
     27
     28/*: --no-rc-use
    2729
    2830# cbindings have different licences.
     
    5355/cbinding/VBoxCAPI*.h:       --guard-relative-to-dir ''
    5456/cbinding/VBoxCAPIGlue.h.in: --guard-relative-to-dir ''
    55 
    56 /src-all/*cpp: --no-rc-use
    57 /src-client/*cpp: --no-rc-use
    58 /src-global/*cpp: --no-rc-use
    59 /src-helper-apps/*cpp: --no-rc-use
    60 /src-server/*cpp: --no-rc-use
    61 /include/*: --no-rc-use
    6257
    6358# IDL and XML
     
    9893--filter-out-files /testcase/VBoxVBTest/TestForm.frx
    9994--filter-out-files /testcase/VBoxVBTest/VBoxVBTest.vbp
     95# for now:
     96/testcase/*: --unrestricted-rc-use
    10097
    10198/testcase/tstUnattendedScript-1.expected: --treat-as plaintext --external-copyright
  • trunk/src/VBox/Main/cbinding/VBoxCAPI.cpp

    r98103 r98297  
    229229#else /* !VBOX_WITH_XPCOM */
    230230    VARTYPE vt = VT_UNKNOWN;
    231     HRESULT rc = SafeArrayGetVartype(psa, &vt);
    232     if (FAILED(rc))
    233         return rc;
     231    HRESULT hrc = SafeArrayGetVartype(psa, &vt);
     232    if (FAILED(hrc))
     233        return hrc;
    234234    if (vt == VT_BSTR)
    235235    {
     
    238238         * behavior between COM and XPCOM without this kind of trickery. */
    239239        void *pData;
    240         rc = SafeArrayAccessData(psa, &pData);
    241         if (FAILED(rc))
    242             return rc;
     240        hrc = SafeArrayAccessData(psa, &pData);
     241        if (FAILED(hrc))
     242            return hrc;
    243243        ULONG cbElement = VBoxVTElemSize(vt);
    244244        if (!cbElement)
     
    265265    pData = psa->pv;
    266266#else /* !VBOX_WITH_XPCOM */
    267     HRESULT rc = SafeArrayAccessData(psa, &pData);
    268     if (FAILED(rc))
    269         return rc;
     267    HRESULT hrc = SafeArrayAccessData(psa, &pData);
     268    if (FAILED(hrc))
     269        return hrc;
    270270#endif /* !VBOX_WITH_XPCOM */
    271271    memcpy(pData, pv, cb);
     
    305305    cElements = psa->c;
    306306#else /* !VBOX_WITH_XPCOM */
    307     HRESULT rc = SafeArrayAccessData(psa, &pData);
    308     if (FAILED(rc))
     307    HRESULT hrc = SafeArrayAccessData(psa, &pData);
     308    if (FAILED(hrc))
    309309    {
    310310        *ppv = NULL;
    311311        if (pcb)
    312312            *pcb = 0;
    313         return rc;
     313        return hrc;
    314314    }
    315315    cElements = psa->rgsabound[0].cElements;
     
    343343{
    344344    ULONG mypcb;
    345     HRESULT rc = VBoxSafeArrayCopyOutParamHelper((void **)ppaObj, &mypcb, VT_UNKNOWN, psa);
    346     if (FAILED(rc))
     345    HRESULT hrc = VBoxSafeArrayCopyOutParamHelper((void **)ppaObj, &mypcb, VT_UNKNOWN, psa);
     346    if (FAILED(hrc))
    347347    {
    348348        if (pcObj)
    349349            *pcObj = 0;
    350         return rc;
     350        return hrc;
    351351    }
    352352    ULONG cElements = mypcb / sizeof(void *);
     
    404404        sessionIID = IID_ISession;
    405405
    406     HRESULT rc = com::Initialize(VBOX_COM_INIT_F_DEFAULT | VBOX_COM_INIT_F_NO_COM_PATCHING);
    407     if (FAILED(rc))
    408     {
    409         Log(("Cbinding: COM/XPCOM could not be initialized! rc=%Rhrc\n", rc));
     406    HRESULT hrc = com::Initialize(VBOX_COM_INIT_F_DEFAULT | VBOX_COM_INIT_F_NO_COM_PATCHING);
     407    if (FAILED(hrc))
     408    {
     409        Log(("Cbinding: COM/XPCOM could not be initialized! hrc=%Rhrc\n", hrc));
    410410        VBoxComUninitialize();
    411411        return;
     
    413413
    414414#ifdef VBOX_WITH_XPCOM
    415     rc = NS_GetMainEventQ(&g_EventQueue);
    416     if (FAILED(rc))
    417     {
    418         Log(("Cbinding: Could not get XPCOM event queue! rc=%Rhrc\n", rc));
     415    hrc = NS_GetMainEventQ(&g_EventQueue);
     416    if (FAILED(hrc))
     417    {
     418        Log(("Cbinding: Could not get XPCOM event queue! hrc=%Rhrc\n", hrc));
    419419        VBoxComUninitialize();
    420420        return;
     
    424424#ifdef VBOX_WITH_XPCOM
    425425    nsIComponentManager *pManager;
    426     rc = NS_GetComponentManager(&pManager);
    427     if (FAILED(rc))
    428     {
    429         Log(("Cbinding: Could not get component manager! rc=%Rhrc\n", rc));
     426    hrc = NS_GetComponentManager(&pManager);
     427    if (FAILED(hrc))
     428    {
     429        Log(("Cbinding: Could not get component manager! hrc=%Rhrc\n", hrc));
    430430        VBoxComUninitialize();
    431431        return;
    432432    }
    433433
    434     rc = pManager->CreateInstanceByContractID(NS_VIRTUALBOX_CONTRACTID,
    435                                               nsnull,
    436                                               virtualBoxIID,
    437                                               (void **)&g_VirtualBox);
     434    hrc = pManager->CreateInstanceByContractID(NS_VIRTUALBOX_CONTRACTID,
     435                                               nsnull,
     436                                               virtualBoxIID,
     437                                               (void **)&g_VirtualBox);
    438438#else /* !VBOX_WITH_XPCOM */
    439439    IVirtualBoxClient *pVirtualBoxClient;
    440     rc = CoCreateInstance(CLSID_VirtualBoxClient, NULL, CLSCTX_INPROC_SERVER, IID_IVirtualBoxClient, (void **)&pVirtualBoxClient);
    441     if (SUCCEEDED(rc))
     440    hrc = CoCreateInstance(CLSID_VirtualBoxClient, NULL, CLSCTX_INPROC_SERVER, IID_IVirtualBoxClient, (void **)&pVirtualBoxClient);
     441    if (SUCCEEDED(hrc))
    442442    {
    443443        IVirtualBox *pVirtualBox;
    444         rc = pVirtualBoxClient->get_VirtualBox(&pVirtualBox);
    445         if (SUCCEEDED(rc))
     444        hrc = pVirtualBoxClient->get_VirtualBox(&pVirtualBox);
     445        if (SUCCEEDED(hrc))
    446446        {
    447             rc = pVirtualBox->QueryInterface(virtualBoxIID, (void **)&g_VirtualBox);
     447            hrc = pVirtualBox->QueryInterface(virtualBoxIID, (void **)&g_VirtualBox);
    448448            pVirtualBox->Release();
    449449        }
     
    451451    }
    452452#endif /* !VBOX_WITH_XPCOM */
    453     if (FAILED(rc))
    454     {
    455         Log(("Cbinding: Could not instantiate VirtualBox object! rc=%Rhrc\n",rc));
     453    if (FAILED(hrc))
     454    {
     455        Log(("Cbinding: Could not instantiate VirtualBox object! hrc=%Rhrc\n",hrc));
    456456#ifdef VBOX_WITH_XPCOM
    457457        pManager->Release();
     
    465465
    466466#ifdef VBOX_WITH_XPCOM
    467     rc = pManager->CreateInstanceByContractID(NS_SESSION_CONTRACTID,
    468                                               nsnull,
    469                                               sessionIID,
    470                                               (void **)&g_Session);
     467    hrc = pManager->CreateInstanceByContractID(NS_SESSION_CONTRACTID, nsnull, sessionIID, (void **)&g_Session);
    471468#else /* !VBOX_WITH_XPCOM */
    472     rc = CoCreateInstance(CLSID_Session, NULL, CLSCTX_INPROC_SERVER, sessionIID, (void **)&g_Session);
    473 #endif /* !VBOX_WITH_XPCOM */
    474     if (FAILED(rc))
    475     {
    476         Log(("Cbinding: Could not instantiate Session object! rc=%Rhrc\n",rc));
     469    hrc = CoCreateInstance(CLSID_Session, NULL, CLSCTX_INPROC_SERVER, sessionIID, (void **)&g_Session);
     470#endif /* !VBOX_WITH_XPCOM */
     471    if (FAILED(hrc))
     472    {
     473        Log(("Cbinding: Could not instantiate Session object! hrc=%Rhrc\n",hrc));
    477474#ifdef VBOX_WITH_XPCOM
    478475        pManager->Release();
     
    568565VBoxGetException(IErrorInfo **ppException)
    569566{
    570     HRESULT rc;
     567    HRESULT hrc;
    571568
    572569    *ppException = NULL;
     
    574571#ifdef VBOX_WITH_XPCOM
    575572    nsIServiceManager *mgr = NULL;
    576     rc = NS_GetServiceManager(&mgr);
    577     if (FAILED(rc) || !mgr)
    578         return rc;
     573    hrc = NS_GetServiceManager(&mgr);
     574    if (FAILED(hrc) || !mgr)
     575        return hrc;
    579576
    580577    IID esid = NS_IEXCEPTIONSERVICE_IID;
    581578    nsIExceptionService *es = NULL;
    582     rc = mgr->GetServiceByContractID(NS_EXCEPTIONSERVICE_CONTRACTID, esid, (void **)&es);
    583     if (FAILED(rc) || !es)
     579    hrc = mgr->GetServiceByContractID(NS_EXCEPTIONSERVICE_CONTRACTID, esid, (void **)&es);
     580    if (FAILED(hrc) || !es)
    584581    {
    585582        mgr->Release();
    586         return rc;
     583        return hrc;
    587584    }
    588585
    589586    nsIExceptionManager *em;
    590     rc = es->GetCurrentExceptionManager(&em);
    591     if (FAILED(rc) || !em)
     587    hrc = es->GetCurrentExceptionManager(&em);
     588    if (FAILED(hrc) || !em)
    592589    {
    593590        es->Release();
    594591        mgr->Release();
    595         return rc;
     592        return hrc;
    596593    }
    597594
    598595    nsIException *ex;
    599     rc = em->GetCurrentException(&ex);
    600     if (FAILED(rc))
     596    hrc = em->GetCurrentException(&ex);
     597    if (FAILED(hrc))
    601598    {
    602599        em->Release();
    603600        es->Release();
    604601        mgr->Release();
    605         return rc;
     602        return hrc;
    606603    }
    607604
     
    612609#else /* !VBOX_WITH_XPCOM */
    613610    IErrorInfo *ex;
    614     rc = ::GetErrorInfo(0, &ex);
    615     if (FAILED(rc))
    616         return rc;
     611    hrc = ::GetErrorInfo(0, &ex);
     612    if (FAILED(hrc))
     613        return hrc;
    617614
    618615    *ppException = ex;
    619616#endif /* !VBOX_WITH_XPCOM */
    620617
    621     return rc;
     618    return hrc;
    622619}
    623620
     
    625622VBoxClearException(void)
    626623{
    627     HRESULT rc;
     624    HRESULT hrc;
    628625
    629626#ifdef VBOX_WITH_XPCOM
    630627    nsIServiceManager *mgr = NULL;
    631     rc = NS_GetServiceManager(&mgr);
    632     if (FAILED(rc) || !mgr)
    633         return rc;
     628    hrc = NS_GetServiceManager(&mgr);
     629    if (FAILED(hrc) || !mgr)
     630        return hrc;
    634631
    635632    IID esid = NS_IEXCEPTIONSERVICE_IID;
    636633    nsIExceptionService *es = NULL;
    637     rc = mgr->GetServiceByContractID(NS_EXCEPTIONSERVICE_CONTRACTID, esid, (void **)&es);
    638     if (FAILED(rc) || !es)
     634    hrc = mgr->GetServiceByContractID(NS_EXCEPTIONSERVICE_CONTRACTID, esid, (void **)&es);
     635    if (FAILED(hrc) || !es)
    639636    {
    640637        mgr->Release();
    641         return rc;
     638        return hrc;
    642639    }
    643640
    644641    nsIExceptionManager *em;
    645     rc = es->GetCurrentExceptionManager(&em);
    646     if (FAILED(rc) || !em)
     642    hrc = es->GetCurrentExceptionManager(&em);
     643    if (FAILED(hrc) || !em)
    647644    {
    648645        es->Release();
    649646        mgr->Release();
    650         return rc;
    651     }
    652 
    653     rc = em->SetCurrentException(NULL);
     647        return hrc;
     648    }
     649
     650    hrc = em->SetCurrentException(NULL);
    654651    em->Release();
    655652    es->Release();
    656653    mgr->Release();
    657654#else /* !VBOX_WITH_XPCOM */
    658     rc = ::SetErrorInfo(0, NULL);
    659 #endif /* !VBOX_WITH_XPCOM */
    660 
    661     return rc;
     655    hrc = ::SetErrorInfo(0, NULL);
     656#endif /* !VBOX_WITH_XPCOM */
     657
     658    return hrc;
    662659}
    663660
     
    679676        virtualBoxClientIID = IID_IVirtualBoxClient;
    680677
    681     HRESULT rc = com::Initialize(VBOX_COM_INIT_F_DEFAULT | VBOX_COM_INIT_F_NO_COM_PATCHING);
    682     if (FAILED(rc))
    683     {
    684         Log(("Cbinding: COM/XPCOM could not be initialized! rc=%Rhrc\n", rc));
     678    HRESULT hrc = com::Initialize(VBOX_COM_INIT_F_DEFAULT | VBOX_COM_INIT_F_NO_COM_PATCHING);
     679    if (FAILED(hrc))
     680    {
     681        Log(("Cbinding: COM/XPCOM could not be initialized! hrc=%Rhrc\n", hrc));
    685682        VBoxClientUninitialize();
    686         return rc;
    687     }
    688 
    689 #ifdef VBOX_WITH_XPCOM
    690     rc = NS_GetMainEventQ(&g_EventQueue);
    691     if (NS_FAILED(rc))
    692     {
    693         Log(("Cbinding: Could not get XPCOM event queue! rc=%Rhrc\n", rc));
     683        return hrc;
     684    }
     685
     686#ifdef VBOX_WITH_XPCOM
     687    hrc = NS_GetMainEventQ(&g_EventQueue);
     688    if (NS_FAILED(hrc))
     689    {
     690        Log(("Cbinding: Could not get XPCOM event queue! hrc=%Rhrc\n", hrc));
    694691        VBoxClientUninitialize();
    695         return rc;
     692        return hrc;
    696693    }
    697694#endif /* VBOX_WITH_XPCOM */
     
    699696#ifdef VBOX_WITH_XPCOM
    700697    nsIComponentManager *pManager;
    701     rc = NS_GetComponentManager(&pManager);
    702     if (FAILED(rc))
    703     {
    704         Log(("Cbinding: Could not get component manager! rc=%Rhrc\n", rc));
     698    hrc = NS_GetComponentManager(&pManager);
     699    if (FAILED(hrc))
     700    {
     701        Log(("Cbinding: Could not get component manager! hrc=%Rhrc\n", hrc));
    705702        VBoxClientUninitialize();
    706         return rc;
    707     }
    708 
    709     rc = pManager->CreateInstanceByContractID(NS_VIRTUALBOXCLIENT_CONTRACTID,
    710                                               nsnull,
    711                                               virtualBoxClientIID,
    712                                               (void **)ppVirtualBoxClient);
     703        return hrc;
     704    }
     705
     706    hrc = pManager->CreateInstanceByContractID(NS_VIRTUALBOXCLIENT_CONTRACTID,
     707                                               nsnull,
     708                                               virtualBoxClientIID,
     709                                               (void **)ppVirtualBoxClient);
    713710#else /* !VBOX_WITH_XPCOM */
    714     rc = CoCreateInstance(CLSID_VirtualBoxClient, NULL, CLSCTX_INPROC_SERVER, virtualBoxClientIID, (void **)ppVirtualBoxClient);
    715 #endif /* !VBOX_WITH_XPCOM */
    716     if (FAILED(rc))
    717     {
    718         Log(("Cbinding: Could not instantiate VirtualBoxClient object! rc=%Rhrc\n",rc));
     711    hrc = CoCreateInstance(CLSID_VirtualBoxClient, NULL, CLSCTX_INPROC_SERVER, virtualBoxClientIID, (void **)ppVirtualBoxClient);
     712#endif /* !VBOX_WITH_XPCOM */
     713    if (FAILED(hrc))
     714    {
     715        Log(("Cbinding: Could not instantiate VirtualBoxClient object! hrc=%Rhrc\n",hrc));
    719716#ifdef VBOX_WITH_XPCOM
    720717        pManager->Release();
     
    722719#endif /* VBOX_WITH_XPCOM */
    723720        VBoxClientUninitialize();
    724         return rc;
     721        return hrc;
    725722    }
    726723
  • trunk/src/VBox/Main/cbinding/tstCAPIGlue.c

    r98103 r98297  
    136136{
    137137    VBoxEventType_T evType;
    138     HRESULT rc;
     138    HRESULT hrc;
    139139
    140140    if (!event)
     
    145145
    146146    evType = VBoxEventType_Invalid;
    147     rc = IEvent_get_Type(event, &evType);
    148     if (FAILED(rc))
    149     {
    150         printf("cannot get event type, rc=%#x\n", (unsigned)rc);
     147    hrc = IEvent_get_Type(event, &evType);
     148    if (FAILED(hrc))
     149    {
     150        printf("cannot get event type, hrc=%#x\n", (unsigned)hrc);
    151151        return S_OK;
    152152    }
     
    170170            IStateChangedEvent *ev = NULL;
    171171            enum MachineState state;
    172             rc = IEvent_QueryInterface(event, &IID_IStateChangedEvent, (void **)&ev);
    173             if (FAILED(rc))
     172            hrc = IEvent_QueryInterface(event, &IID_IStateChangedEvent, (void **)&ev);
     173            if (FAILED(hrc))
    174174            {
    175                 printf("cannot get StateChangedEvent interface, rc=%#x\n", (unsigned)rc);
     175                printf("cannot get StateChangedEvent interface, hrc=%#x\n", (unsigned)hrc);
    176176                return S_OK;
    177177            }
     
    181181                return S_OK;
    182182            }
    183             rc = IStateChangedEvent_get_State(ev, &state);
    184             if (FAILED(rc))
    185                 printf("warning: cannot get state, rc=%#x\n", (unsigned)rc);
     183            hrc = IStateChangedEvent_get_State(ev, &state);
     184            if (FAILED(hrc))
     185                printf("warning: cannot get state, hrc=%#x\n", (unsigned)hrc);
    186186            IStateChangedEvent_Release(ev);
    187187            printf("OnStateChanged: %s\n", GetStateName(state));
     
    392392static HRESULT LoadTypeInfo(REFIID riid, ITypeInfo **pTInfo)
    393393{
    394     HRESULT rc;
     394    HRESULT hrc;
    395395    ITypeLib *pTypeLib;
    396     rc = LoadRegTypeLib(&LIBID_VirtualBox, 1 /* major */, 0 /* minor */, 0 /* lcid */, &pTypeLib);
    397     if (FAILED(rc))
    398         return rc;
    399     rc = ITypeLib_GetTypeInfoOfGuid(pTypeLib, riid, pTInfo);
     396    hrc = LoadRegTypeLib(&LIBID_VirtualBox, 1 /* major */, 0 /* minor */, 0 /* lcid */, &pTypeLib);
     397    if (FAILED(hrc))
     398        return hrc;
     399    hrc = ITypeLib_GetTypeInfoOfGuid(pTypeLib, riid, pTInfo);
    400400
    401401    /* No longer need access to the type lib, release it. */
    402402    ITypeLib_Release(pTypeLib);
    403403
    404     return rc;
     404    return hrc;
    405405}
    406406#endif
     
    465465{
    466466    IConsole *console = NULL;
    467     HRESULT rc;
    468 
    469     rc = ISession_get_Console(session, &console);
    470     if ((SUCCEEDED(rc)) && console)
     467    HRESULT hrc;
     468
     469    hrc = ISession_get_Console(session, &console);
     470    if (SUCCEEDED(hrc) && console)
    471471    {
    472472        IEventSource *es = NULL;
    473         rc = IConsole_get_EventSource(console, &es);
    474         if (SUCCEEDED(rc) && es)
     473        hrc = IConsole_get_EventSource(console, &es);
     474        if (SUCCEEDED(hrc) && es)
    475475        {
    476476            static const ULONG s_auInterestingEvents[] =
     
    514514                IEventListenerDemo_AddRef(consoleListener);
    515515
    516                 rc = IEventSource_RegisterListener(es, (IEventListener *)consoleListener,
    517                                                    ComSafeArrayAsInParam(interestingEventsSA),
    518                                                    1 /* active */);
    519                 if (SUCCEEDED(rc))
     516                hrc = IEventSource_RegisterListener(es, (IEventListener *)consoleListener,
     517                                                    ComSafeArrayAsInParam(interestingEventsSA),
     518                                                    1 /* active */);
     519                if (SUCCEEDED(hrc))
    520520                {
    521521                    /* Just wait here for events, no easy way to do this better
     
    569569{
    570570    IConsole *console = NULL;
    571     HRESULT rc;
    572 
    573     rc = ISession_get_Console(session, &console);
    574     if (SUCCEEDED(rc) && console)
     571    HRESULT hrc;
     572
     573    hrc = ISession_get_Console(session, &console);
     574    if (SUCCEEDED(hrc) && console)
    575575    {
    576576        IEventSource *es = NULL;
    577         rc = IConsole_get_EventSource(console, &es);
    578         if (SUCCEEDED(rc) && es)
     577        hrc = IConsole_get_EventSource(console, &es);
     578        if (SUCCEEDED(hrc) && es)
    579579        {
    580580            static const ULONG s_auInterestingEvents[] =
     
    609609                                                        sizeof(s_auInterestingEvents));
    610610
    611             rc = IEventSource_CreateListener(es, &consoleListener);
    612             if (SUCCEEDED(rc) && consoleListener)
     611            hrc = IEventSource_CreateListener(es, &consoleListener);
     612            if (SUCCEEDED(hrc) && consoleListener)
    613613            {
    614                 rc = IEventSource_RegisterListener(es, consoleListener,
    615                                                    ComSafeArrayAsInParam(interestingEventsSA),
    616                                                    0 /* passive */);
    617                 if (SUCCEEDED(rc))
     614                hrc = IEventSource_RegisterListener(es, consoleListener,
     615                                                    ComSafeArrayAsInParam(interestingEventsSA),
     616                                                    0 /* passive */);
     617                if (SUCCEEDED(hrc))
    618618                {
    619619                    /* Just wait here for events, no easy way to do this better
     
    630630                    {
    631631                        IEvent *ev = NULL;
    632                         rc = IEventSource_GetEvent(es, consoleListener, 250, &ev);
    633                         if (FAILED(rc))
     632                        hrc = IEventSource_GetEvent(es, consoleListener, 250, &ev);
     633                        if (FAILED(hrc))
    634634                        {
    635                             printf("Failed getting event: %#x\n", (unsigned)rc);
     635                            printf("Failed getting event: %#x\n", (unsigned)hrc);
    636636                            g_fStop = 1;
    637637                            continue;
     
    640640                        if (!ev)
    641641                            continue;
    642                         rc = EventListenerDemoProcessEvent(ev);
    643                         if (FAILED(rc))
     642                        hrc = EventListenerDemoProcessEvent(ev);
     643                        if (FAILED(hrc))
    644644                        {
    645                             printf("Failed processing event: %#x\n", (unsigned)rc);
     645                            printf("Failed processing event: %#x\n", (unsigned)hrc);
    646646                            g_fStop = 1;
    647647                            /* finish processing the event */
    648648                        }
    649                         rc = IEventSource_EventProcessed(es, consoleListener, ev);
    650                         if (FAILED(rc))
     649                        hrc = IEventSource_EventProcessed(es, consoleListener, ev);
     650                        if (FAILED(hrc))
    651651                        {
    652                             printf("Failed to mark event as processed: %#x\n", (unsigned)rc);
     652                            printf("Failed to mark event as processed: %#x\n", (unsigned)hrc);
    653653                            g_fStop = 1;
    654654                            /* continue with event release */
     
    689689 * @param   pszExecutable   string with the executable name
    690690 * @param   pszErrorMsg     string containing the code location specific error message
    691  * @param   rc              COM/XPCOM result code
     691 * @param   hrc             COM/XPCOM result code
    692692 */
    693 static void PrintErrorInfo(const char *pszExecutable, const char *pszErrorMsg, HRESULT rc)
     693static void PrintErrorInfo(const char *pszExecutable, const char *pszErrorMsg, HRESULT hrc)
    694694{
    695695    IErrorInfo *ex;
    696     HRESULT rc2;
    697     fprintf(stderr, "%s: %s (rc=%#010x)\n", pszExecutable, pszErrorMsg, (unsigned)rc);
    698     rc2 = g_pVBoxFuncs->pfnGetException(&ex);
    699     if (SUCCEEDED(rc2) && ex)
     696    HRESULT hrc2;
     697    fprintf(stderr, "%s: %s (hrc=%#010x)\n", pszExecutable, pszErrorMsg, (unsigned)hrc);
     698    hrc2 = g_pVBoxFuncs->pfnGetException(&ex);
     699    if (SUCCEEDED(hrc2) && ex)
    700700    {
    701701        IVirtualBoxErrorInfo *ei;
    702         rc2 = IErrorInfo_QueryInterface(ex, &IID_IVirtualBoxErrorInfo, (void **)&ei);
    703         if (SUCCEEDED(rc2) && ei != NULL)
     702        hrc2 = IErrorInfo_QueryInterface(ex, &IID_IVirtualBoxErrorInfo, (void **)&ei);
     703        if (SUCCEEDED(hrc2) && ei != NULL)
    704704        {
    705705            /* got extended error info, maybe multiple infos */
     
    729729                g_pVBoxFuncs->pfnUtf8Free(text);
    730730
    731                 rc2 = IVirtualBoxErrorInfo_get_Next(ei, &ei_next);
    732                 if (FAILED(rc2))
     731                hrc2 = IVirtualBoxErrorInfo_get_Next(ei, &ei_next);
     732                if (FAILED(hrc2))
    733733                    ei_next = NULL;
    734734                IVirtualBoxErrorInfo_Release(ei);
     
    752752static void startVM(const char *argv0, IVirtualBox *virtualBox, ISession *session, BSTR id)
    753753{
    754     HRESULT rc;
     754    HRESULT hrc;
    755755    IMachine  *machine    = NULL;
    756756    IProgress *progress   = NULL;
     
    759759    SAFEARRAY *groupsSA = g_pVBoxFuncs->pfnSafeArrayOutParamAlloc();
    760760
    761     rc = IVirtualBox_FindMachine(virtualBox, id, &machine);
    762     if (FAILED(rc) || !machine)
    763     {
    764         PrintErrorInfo(argv0, "Error: Couldn't get the Machine reference", rc);
     761    hrc = IVirtualBox_FindMachine(virtualBox, id, &machine);
     762    if (FAILED(hrc) || !machine)
     763    {
     764        PrintErrorInfo(argv0, "Error: Couldn't get the Machine reference", hrc);
    765765        return;
    766766    }
    767767
    768     rc = IMachine_get_Groups(machine, ComSafeArrayAsOutTypeParam(groupsSA, BSTR));
    769     if (SUCCEEDED(rc))
     768    hrc = IMachine_get_Groups(machine, ComSafeArrayAsOutTypeParam(groupsSA, BSTR));
     769    if (SUCCEEDED(hrc))
    770770    {
    771771        BSTR *groups = NULL;
     
    792792
    793793    g_pVBoxFuncs->pfnUtf8ToUtf16("gui", &sessionType);
    794     rc = IMachine_LaunchVMProcess(machine, session, sessionType, ComSafeArrayAsInParam(env), &progress);
     794    hrc = IMachine_LaunchVMProcess(machine, session, sessionType, ComSafeArrayAsInParam(env), &progress);
    795795    g_pVBoxFuncs->pfnUtf16Free(sessionType);
    796     if (SUCCEEDED(rc))
     796    if (SUCCEEDED(hrc))
    797797    {
    798798        BOOL completed;
     
    802802        IProgress_WaitForCompletion(progress, -1);
    803803
    804         rc = IProgress_get_Completed(progress, &completed);
    805         if (FAILED(rc))
     804        hrc = IProgress_get_Completed(progress, &completed);
     805        if (FAILED(hrc))
    806806            fprintf(stderr, "Error: GetCompleted status failed\n");
    807807
     
    837837    }
    838838    else
    839         PrintErrorInfo(argv0, "Error: LaunchVMProcess failed", rc);
     839        PrintErrorInfo(argv0, "Error: LaunchVMProcess failed", hrc);
    840840
    841841    /* It's important to always release resources. */
     
    852852static void listVMs(const char *argv0, IVirtualBox *virtualBox, ISession *session)
    853853{
    854     HRESULT rc;
     854    HRESULT hrc;
    855855    SAFEARRAY *machinesSA = g_pVBoxFuncs->pfnSafeArrayOutParamAlloc();
    856856    IMachine **machines = NULL;
     
    862862     * Get the list of all registered VMs.
    863863     */
    864     rc = IVirtualBox_get_Machines(virtualBox, ComSafeArrayAsOutIfaceParam(machinesSA, IMachine *));
    865     if (FAILED(rc))
    866     {
    867         PrintErrorInfo(argv0, "could not get list of machines", rc);
     864    hrc = IVirtualBox_get_Machines(virtualBox, ComSafeArrayAsOutIfaceParam(machinesSA, IMachine *));
     865    if (FAILED(hrc))
     866    {
     867        PrintErrorInfo(argv0, "could not get list of machines", hrc);
    868868        return;
    869869    }
     
    10121012    BSTR        versionUtf16     = NULL;
    10131013    BSTR        homefolderUtf16  = NULL;
    1014     HRESULT     rc;     /* Result code of various function (method) calls. */
     1014    HRESULT     hrc;     /* Result code of various function (method) calls. */
    10151015    (void)argc;
    10161016
     
    10401040    printf("----------------------------------------------------\n");
    10411041
    1042     rc = IVirtualBoxClient_get_VirtualBox(vboxclient, &vbox);
    1043     if (FAILED(rc) || !vbox)
    1044     {
    1045         PrintErrorInfo(argv[0], "FATAL: could not get VirtualBox reference", rc);
     1042    hrc = IVirtualBoxClient_get_VirtualBox(vboxclient, &vbox);
     1043    if (FAILED(hrc) || !vbox)
     1044    {
     1045        PrintErrorInfo(argv[0], "FATAL: could not get VirtualBox reference", hrc);
    10461046        return EXIT_FAILURE;
    10471047    }
    1048     rc = IVirtualBoxClient_get_Session(vboxclient, &session);
    1049     if (FAILED(rc) || !session)
    1050     {
    1051         PrintErrorInfo(argv[0], "FATAL: could not get Session reference", rc);
     1048    hrc = IVirtualBoxClient_get_Session(vboxclient, &session);
     1049    if (FAILED(hrc) || !session)
     1050    {
     1051        PrintErrorInfo(argv[0], "FATAL: could not get Session reference", hrc);
    10521052        return EXIT_FAILURE;
    10531053    }
     
    10551055#ifdef USE_ACTIVE_EVENT_LISTENER
    10561056# ifdef WIN32
    1057     rc = LoadTypeInfo(&IID_IEventListener, &g_pTInfoIEventListener);
    1058     if (FAILED(rc) || !g_pTInfoIEventListener)
    1059     {
    1060         PrintErrorInfo(argv[0], "FATAL: could not get type information for IEventListener", rc);
     1057    hrc = LoadTypeInfo(&IID_IEventListener, &g_pTInfoIEventListener);
     1058    if (FAILED(hrc) || !g_pTInfoIEventListener)
     1059    {
     1060        PrintErrorInfo(argv[0], "FATAL: could not get type information for IEventListener", hrc);
    10611061        return EXIT_FAILURE;
    10621062    }
     
    10711071
    10721072    /* 1. Revision */
    1073     rc = IVirtualBox_get_Revision(vbox, &revision);
    1074     if (SUCCEEDED(rc))
     1073    hrc = IVirtualBox_get_Revision(vbox, &revision);
     1074    if (SUCCEEDED(hrc))
    10751075        printf("\tRevision: %u\n", (unsigned)revision);
    10761076    else
    1077         PrintErrorInfo(argv[0], "GetRevision() failed", rc);
     1077        PrintErrorInfo(argv[0], "GetRevision() failed", hrc);
    10781078
    10791079    /* 2. Version */
    1080     rc = IVirtualBox_get_Version(vbox, &versionUtf16);
    1081     if (SUCCEEDED(rc))
     1080    hrc = IVirtualBox_get_Version(vbox, &versionUtf16);
     1081    if (SUCCEEDED(hrc))
    10821082    {
    10831083        char *version = NULL;
     
    10881088    }
    10891089    else
    1090         PrintErrorInfo(argv[0], "GetVersion() failed", rc);
     1090        PrintErrorInfo(argv[0], "GetVersion() failed", hrc);
    10911091
    10921092    /* 3. Home Folder */
    1093     rc = IVirtualBox_get_HomeFolder(vbox, &homefolderUtf16);
    1094     if (SUCCEEDED(rc))
     1093    hrc = IVirtualBox_get_HomeFolder(vbox, &homefolderUtf16);
     1094    if (SUCCEEDED(hrc))
    10951095    {
    10961096        char *homefolder = NULL;
     
    11011101    }
    11021102    else
    1103         PrintErrorInfo(argv[0], "GetHomeFolder() failed", rc);
     1103        PrintErrorInfo(argv[0], "GetHomeFolder() failed", hrc);
    11041104
    11051105    listVMs(argv[0], vbox, session);
  • trunk/src/VBox/Main/glue/ErrorInfo.cpp

    r98103 r98297  
    5656HRESULT ErrorInfo::getVirtualBoxErrorInfo(ComPtr<IVirtualBoxErrorInfo> &pVirtualBoxErrorInfo)
    5757{
    58     HRESULT rc = S_OK;
     58    HRESULT hrc = S_OK;
    5959    if (mErrorInfo)
    60         rc = mErrorInfo.queryInterfaceTo(pVirtualBoxErrorInfo.asOutParam());
     60        hrc = mErrorInfo.queryInterfaceTo(pVirtualBoxErrorInfo.asOutParam());
    6161    else
    6262        pVirtualBoxErrorInfo.setNull();
    63     return rc;
     63    return hrc;
    6464}
    6565
     
    111111void ErrorInfo::init(bool aKeepObj /* = false */)
    112112{
    113     HRESULT rc = E_FAIL;
     113    HRESULT hrc = E_FAIL;
    114114
    115115#if !defined(VBOX_WITH_XPCOM)
    116116
    117117    ComPtr<IErrorInfo> err;
    118     rc = ::GetErrorInfo(0, err.asOutParam());
    119     if (rc == S_OK && err)
     118    hrc = ::GetErrorInfo(0, err.asOutParam());
     119    if (hrc == S_OK && err)
    120120    {
    121121        if (aKeepObj)
     
    123123
    124124        ComPtr<IVirtualBoxErrorInfo> info;
    125         rc = err.queryInterfaceTo(info.asOutParam());
    126         if (SUCCEEDED(rc) && info)
     125        hrc = err.queryInterfaceTo(info.asOutParam());
     126        if (SUCCEEDED(hrc) && info)
    127127            init(info);
    128128
     
    131131            bool gotSomething = false;
    132132
    133             rc = err->GetGUID(mInterfaceID.asOutParam());
    134             gotSomething |= SUCCEEDED(rc);
    135             if (SUCCEEDED(rc))
     133            hrc = err->GetGUID(mInterfaceID.asOutParam());
     134            gotSomething |= SUCCEEDED(hrc);
     135            if (SUCCEEDED(hrc))
    136136                GetInterfaceNameByIID(mInterfaceID.ref(), mInterfaceName.asOutParam());
    137137
    138             rc = err->GetSource(mComponent.asOutParam());
    139             gotSomething |= SUCCEEDED(rc);
    140 
    141             rc = err->GetDescription(mText.asOutParam());
    142             gotSomething |= SUCCEEDED(rc);
     138            hrc = err->GetSource(mComponent.asOutParam());
     139            gotSomething |= SUCCEEDED(hrc);
     140
     141            hrc = err->GetDescription(mText.asOutParam());
     142            gotSomething |= SUCCEEDED(hrc);
    143143
    144144            if (gotSomething)
     
    152152
    153153    nsCOMPtr<nsIExceptionService> es;
    154     es = do_GetService(NS_EXCEPTIONSERVICE_CONTRACTID, &rc);
    155     if (NS_SUCCEEDED(rc))
     154    es = do_GetService(NS_EXCEPTIONSERVICE_CONTRACTID, &hrc);
     155    if (NS_SUCCEEDED(hrc))
    156156    {
    157157        nsCOMPtr<nsIExceptionManager> em;
    158         rc = es->GetCurrentExceptionManager(getter_AddRefs(em));
    159         if (NS_SUCCEEDED(rc))
     158        hrc = es->GetCurrentExceptionManager(getter_AddRefs(em));
     159        if (NS_SUCCEEDED(hrc))
    160160        {
    161161            ComPtr<nsIException> ex;
    162             rc = em->GetCurrentException(ex.asOutParam());
    163             if (NS_SUCCEEDED(rc) && ex)
     162            hrc = em->GetCurrentException(ex.asOutParam());
     163            if (NS_SUCCEEDED(hrc) && ex)
    164164            {
    165165                if (aKeepObj)
     
    167167
    168168                ComPtr<IVirtualBoxErrorInfo> info;
    169                 rc = ex.queryInterfaceTo(info.asOutParam());
    170                 if (NS_SUCCEEDED(rc) && info)
     169                hrc = ex.queryInterfaceTo(info.asOutParam());
     170                if (NS_SUCCEEDED(hrc) && info)
    171171                    init(info);
    172172
     
    175175                    bool gotSomething = false;
    176176
    177                     rc = ex->GetResult(&mResultCode);
    178                     gotSomething |= NS_SUCCEEDED(rc);
     177                    hrc = ex->GetResult(&mResultCode);
     178                    gotSomething |= NS_SUCCEEDED(hrc);
    179179
    180180                    char *pszMsg;
    181                     rc = ex->GetMessage(&pszMsg);
    182                     gotSomething |= NS_SUCCEEDED(rc);
    183                     if (NS_SUCCEEDED(rc))
     181                    hrc = ex->GetMessage(&pszMsg);
     182                    gotSomething |= NS_SUCCEEDED(hrc);
     183                    if (NS_SUCCEEDED(hrc))
    184184                    {
    185185                        mText = Bstr(pszMsg);
     
    196196                em->SetCurrentException(NULL);
    197197
    198                 rc = NS_OK;
     198                hrc = NS_OK;
    199199            }
    200200        }
    201201    }
    202202    /* Ignore failure when called after nsComponentManagerImpl::Shutdown(). */
    203     else if (rc == NS_ERROR_UNEXPECTED)
    204         rc = NS_OK;
    205 
    206     AssertComRC(rc);
     203    else if (hrc == NS_ERROR_UNEXPECTED)
     204        hrc = NS_OK;
     205
     206    AssertComRC(hrc);
    207207
    208208#endif // defined(VBOX_WITH_XPCOM)
     
    219219    ComPtr<IUnknown> iface = aI;
    220220    ComPtr<ISupportErrorInfo> serr;
    221     HRESULT rc = iface.queryInterfaceTo(serr.asOutParam());
    222     if (SUCCEEDED(rc))
    223     {
    224         rc = serr->InterfaceSupportsErrorInfo(aIID);
    225         if (SUCCEEDED(rc))
     221    HRESULT hrc = iface.queryInterfaceTo(serr.asOutParam());
     222    if (SUCCEEDED(hrc))
     223    {
     224        hrc = serr->InterfaceSupportsErrorInfo(aIID);
     225        if (SUCCEEDED(hrc))
    226226            init(aKeepObj);
    227227    }
     
    244244    AssertReturnVoid(info);
    245245
    246     HRESULT rc = E_FAIL;
     246    HRESULT hrc = E_FAIL;
    247247    bool gotSomething = false;
    248248    bool gotAll = true;
    249249    LONG lrc, lrd;
    250250
    251     rc = info->COMGETTER(ResultCode)(&lrc); mResultCode = lrc;
    252     gotSomething |= SUCCEEDED(rc);
    253     gotAll &= SUCCEEDED(rc);
    254 
    255     rc = info->COMGETTER(ResultDetail)(&lrd); mResultDetail = lrd;
    256     gotSomething |= SUCCEEDED(rc);
    257     gotAll &= SUCCEEDED(rc);
     251    hrc = info->COMGETTER(ResultCode)(&lrc); mResultCode = lrc;
     252    gotSomething |= SUCCEEDED(hrc);
     253    gotAll &= SUCCEEDED(hrc);
     254
     255    hrc = info->COMGETTER(ResultDetail)(&lrd); mResultDetail = lrd;
     256    gotSomething |= SUCCEEDED(hrc);
     257    gotAll &= SUCCEEDED(hrc);
    258258
    259259    Bstr iid;
    260     rc = info->COMGETTER(InterfaceID)(iid.asOutParam());
    261     gotSomething |= SUCCEEDED(rc);
    262     gotAll &= SUCCEEDED(rc);
    263     if (SUCCEEDED(rc))
     260    hrc = info->COMGETTER(InterfaceID)(iid.asOutParam());
     261    gotSomething |= SUCCEEDED(hrc);
     262    gotAll &= SUCCEEDED(hrc);
     263    if (SUCCEEDED(hrc))
    264264    {
    265265        mInterfaceID = iid;
     
    267267    }
    268268
    269     rc = info->COMGETTER(Component)(mComponent.asOutParam());
    270     gotSomething |= SUCCEEDED(rc);
    271     gotAll &= SUCCEEDED(rc);
    272 
    273     rc = info->COMGETTER(Text)(mText.asOutParam());
    274     gotSomething |= SUCCEEDED(rc);
    275     gotAll &= SUCCEEDED(rc);
     269    hrc = info->COMGETTER(Component)(mComponent.asOutParam());
     270    gotSomething |= SUCCEEDED(hrc);
     271    gotAll &= SUCCEEDED(hrc);
     272
     273    hrc = info->COMGETTER(Text)(mText.asOutParam());
     274    gotSomething |= SUCCEEDED(hrc);
     275    gotAll &= SUCCEEDED(hrc);
    276276
    277277    m_pNext = NULL;
    278278
    279279    ComPtr<IVirtualBoxErrorInfo> next;
    280     rc = info->COMGETTER(Next)(next.asOutParam());
    281     if (SUCCEEDED(rc) && !next.isNull())
     280    hrc = info->COMGETTER(Next)(next.asOutParam());
     281    if (SUCCEEDED(hrc) && !next.isNull())
    282282    {
    283283        m_pNext = new ErrorInfo(next);
    284284        Assert(m_pNext != NULL);
    285285        if (!m_pNext)
    286             rc = E_OUTOFMEMORY;
    287     }
    288 
    289     gotSomething |= SUCCEEDED(rc);
    290     gotAll &= SUCCEEDED(rc);
     286            hrc = E_OUTOFMEMORY;
     287    }
     288
     289    gotSomething |= SUCCEEDED(hrc);
     290    gotAll &= SUCCEEDED(hrc);
    291291
    292292    mIsBasicAvailable = gotSomething;
     
    312312
    313313    ComPtr<IVirtualBoxErrorInfo> info;
    314     HRESULT rc = progress->COMGETTER(ErrorInfo)(info.asOutParam());
    315     if (SUCCEEDED(rc) && info)
     314    HRESULT hrc = progress->COMGETTER(ErrorInfo)(info.asOutParam());
     315    if (SUCCEEDED(hrc) && info)
    316316        init(info);
    317317}
     
    328328        return S_OK;
    329329
    330     HRESULT rc = S_OK;
     330    HRESULT hrc = S_OK;
    331331
    332332#if !defined(VBOX_WITH_XPCOM)
     
    335335    if (!mErrorInfo.isNull())
    336336    {
    337         rc = mErrorInfo.queryInterfaceTo(err.asOutParam());
    338         AssertComRC(rc);
    339     }
    340     rc = ::SetErrorInfo(0, err);
     337        hrc = mErrorInfo.queryInterfaceTo(err.asOutParam());
     338        AssertComRC(hrc);
     339    }
     340    hrc = ::SetErrorInfo(0, err);
    341341
    342342#else // defined(VBOX_WITH_XPCOM)
    343343
    344344    nsCOMPtr <nsIExceptionService> es;
    345     es = do_GetService(NS_EXCEPTIONSERVICE_CONTRACTID, &rc);
    346     if (NS_SUCCEEDED(rc))
     345    es = do_GetService(NS_EXCEPTIONSERVICE_CONTRACTID, &hrc);
     346    if (NS_SUCCEEDED(hrc))
    347347    {
    348348        nsCOMPtr <nsIExceptionManager> em;
    349         rc = es->GetCurrentExceptionManager(getter_AddRefs(em));
    350         if (NS_SUCCEEDED(rc))
     349        hrc = es->GetCurrentExceptionManager(getter_AddRefs(em));
     350        if (NS_SUCCEEDED(hrc))
    351351        {
    352352            ComPtr<nsIException> ex;
    353353            if (!mErrorInfo.isNull())
    354354            {
    355                 rc = mErrorInfo.queryInterfaceTo(ex.asOutParam());
    356                 AssertComRC(rc);
     355                hrc = mErrorInfo.queryInterfaceTo(ex.asOutParam());
     356                AssertComRC(hrc);
    357357            }
    358             rc = em->SetCurrentException(ex);
     358            hrc = em->SetCurrentException(ex);
    359359        }
    360360    }
     
    362362#endif // defined(VBOX_WITH_XPCOM)
    363363
    364     if (SUCCEEDED(rc))
     364    if (SUCCEEDED(hrc))
    365365    {
    366366        mErrorInfo.setNull();
     
    368368    }
    369369
    370     return rc;
     370    return hrc;
    371371}
    372372
  • trunk/src/VBox/Main/glue/EventQueue.cpp

    r98103 r98297  
    4949      mShutdown(false)
    5050{
    51     int rc = RTCritSectInit(&mCritSect);
    52     AssertRC(rc);
    53 
    54     rc = RTSemEventCreate(&mSemEvent);
    55     AssertRC(rc);
     51    int vrc = RTCritSectInit(&mCritSect);
     52    AssertRC(vrc);
     53
     54    vrc = RTSemEventCreate(&mSemEvent);
     55    AssertRC(vrc);
    5656}
    5757
    5858EventQueue::~EventQueue(void)
    5959{
    60     int rc = RTCritSectDelete(&mCritSect);
    61     AssertRC(rc);
    62 
    63     rc = RTSemEventDestroy(mSemEvent);
    64     AssertRC(rc);
     60    int vrc = RTCritSectDelete(&mCritSect);
     61    AssertRC(vrc);
     62
     63    vrc = RTSemEventDestroy(mSemEvent);
     64    AssertRC(vrc);
    6565
    6666    EventQueueListIterator it  = mEvents.begin();
     
    9898{
    9999    size_t cNumEvents;
    100     int rc = RTCritSectEnter(&mCritSect);
    101     if (RT_SUCCESS(rc))
     100    int vrc = RTCritSectEnter(&mCritSect);
     101    if (RT_SUCCESS(vrc))
    102102    {
    103103        if (mUserCnt == 0) /* No concurrent access allowed. */
     
    108108            if (!cNumEvents)
    109109            {
    110                 int rc2 = RTCritSectLeave(&mCritSect);
    111                 AssertRC(rc2);
    112 
    113                 rc = RTSemEventWaitNoResume(mSemEvent, cMsTimeout);
    114 
    115                 rc2 = RTCritSectEnter(&mCritSect);
    116                 AssertRC(rc2);
    117 
    118                 if (RT_SUCCESS(rc))
     110                int vrc2 = RTCritSectLeave(&mCritSect);
     111                AssertRC(vrc2);
     112
     113                vrc = RTSemEventWaitNoResume(mSemEvent, cMsTimeout);
     114
     115                vrc2 = RTCritSectEnter(&mCritSect);
     116                AssertRC(vrc2);
     117
     118                if (RT_SUCCESS(vrc))
    119119                {
    120120                    if (mShutdown)
    121                         rc = VERR_INTERRUPTED;
     121                        vrc = VERR_INTERRUPTED;
    122122                    cNumEvents = mEvents.size();
    123123                }
    124124            }
    125125
    126             if (RT_SUCCESS(rc))
    127                 rc = processPendingEvents(cNumEvents);
     126            if (RT_SUCCESS(vrc))
     127                vrc = processPendingEvents(cNumEvents);
    128128
    129129            Assert(mUserCnt);
     
    131131        }
    132132        else
    133             rc = VERR_WRONG_ORDER;
    134 
    135         int rc2 = RTCritSectLeave(&mCritSect);
    136         if (RT_SUCCESS(rc))
    137             rc = rc2;
    138     }
    139 
    140     Assert(rc != VERR_TIMEOUT || cMsTimeout != RT_INDEFINITE_WAIT);
    141     return rc;
     133            vrc = VERR_WRONG_ORDER;
     134
     135        int vrc2 = RTCritSectLeave(&mCritSect);
     136        if (RT_SUCCESS(vrc))
     137            vrc = vrc2;
     138    }
     139
     140    Assert(vrc != VERR_TIMEOUT || cMsTimeout != RT_INDEFINITE_WAIT);
     141    return vrc;
    142142}
    143143
     
    154154        return VINF_SUCCESS;
    155155
    156     int rc = VINF_SUCCESS;
     156    int vrc = VINF_SUCCESS;
    157157
    158158    EventQueueListIterator it = mEvents.begin();
     
    166166        mEvents.erase(it);
    167167
    168         int rc2 = RTCritSectLeave(&mCritSect);
    169         AssertRC(rc2);
     168        int vrc2 = RTCritSectLeave(&mCritSect);
     169        AssertRC(vrc2);
    170170
    171171        pEvent->handler();
    172172        pEvent->Release();
    173173
    174         rc2 = RTCritSectEnter(&mCritSect);
    175         AssertRC(rc2);
     174        vrc2 = RTCritSectEnter(&mCritSect);
     175        AssertRC(vrc2);
    176176
    177177        it = mEvents.begin();
    178178        if (mShutdown)
    179179        {
    180             rc = VERR_INTERRUPTED;
     180            vrc = VERR_INTERRUPTED;
    181181            break;
    182182        }
    183183    }
    184184
    185     return rc;
     185    return vrc;
    186186}
    187187
     
    208208BOOL EventQueue::postEvent(Event *pEvent)
    209209{
    210     int rc = RTCritSectEnter(&mCritSect);
    211     if (RT_SUCCESS(rc))
     210    int vrc = RTCritSectEnter(&mCritSect);
     211    if (RT_SUCCESS(vrc))
    212212    {
    213213        try
     
    231231
    232232            /* Leave critical section before signalling event. */
    233             rc = RTCritSectLeave(&mCritSect);
    234             if (RT_SUCCESS(rc))
    235             {
    236                 int rc2 = RTSemEventSignal(mSemEvent);
    237                 AssertRC(rc2);
     233            vrc = RTCritSectLeave(&mCritSect);
     234            if (RT_SUCCESS(vrc))
     235            {
     236                int vrc2 = RTSemEventSignal(mSemEvent);
     237                AssertRC(vrc2);
    238238            }
    239239        }
     
    241241        {
    242242            NOREF(ba);
    243             rc = VERR_NO_MEMORY;
    244         }
    245 
    246         if (RT_FAILURE(rc))
    247         {
    248             int rc2 = RTCritSectLeave(&mCritSect);
    249             AssertRC(rc2);
    250         }
    251     }
    252 
    253     return RT_SUCCESS(rc) ? TRUE : FALSE;
     243            vrc = VERR_NO_MEMORY;
     244        }
     245
     246        if (RT_FAILURE(vrc))
     247        {
     248            int vrc2 = RTCritSectLeave(&mCritSect);
     249            AssertRC(vrc2);
     250        }
     251    }
     252
     253    return RT_SUCCESS(vrc) ? TRUE : FALSE;
    254254}
    255255
  • trunk/src/VBox/Main/glue/NativeEventQueue.cpp

    r98103 r98297  
    163163    // NULL to the event thread (because it stopped accepting events).
    164164
    165     nsresult rc = NS_GetEventQueueService(getter_AddRefs(mEventQService));
    166 
    167     if (NS_SUCCEEDED(rc))
    168     {
    169         rc = mEventQService->GetThreadEventQueue(NS_CURRENT_THREAD,
    170                                                  getter_AddRefs(mEventQ));
    171         if (rc == NS_ERROR_NOT_AVAILABLE)
     165    nsresult hrc = NS_GetEventQueueService(getter_AddRefs(mEventQService));
     166
     167    if (NS_SUCCEEDED(hrc))
     168    {
     169        hrc = mEventQService->GetThreadEventQueue(NS_CURRENT_THREAD, getter_AddRefs(mEventQ));
     170        if (hrc == NS_ERROR_NOT_AVAILABLE)
    172171        {
    173             rc = mEventQService->CreateThreadEventQueue();
    174             if (NS_SUCCEEDED(rc))
     172            hrc = mEventQService->CreateThreadEventQueue();
     173            if (NS_SUCCEEDED(hrc))
    175174            {
    176175                mEQCreated = true;
    177                 rc = mEventQService->GetThreadEventQueue(NS_CURRENT_THREAD,
    178                                                          getter_AddRefs(mEventQ));
     176                hrc = mEventQService->GetThreadEventQueue(NS_CURRENT_THREAD, getter_AddRefs(mEventQ));
    179177            }
    180178        }
    181179    }
    182     AssertComRC(rc);
     180    AssertComRC(hrc);
    183181
    184182#endif // VBOX_WITH_XPCOM
     
    356354    }
    357355
    358     int rc = select(fd + 1, &fdsetR, NULL, &fdsetE, ptv);
    359     if (rc > 0)
    360         rc = VINF_SUCCESS;
    361     else if (rc == 0)
    362         rc = VERR_TIMEOUT;
     356    int iRc = select(fd + 1, &fdsetR, NULL, &fdsetE, ptv);
     357    int vrc;
     358    if (iRc > 0)
     359        vrc = VINF_SUCCESS;
     360    else if (iRc == 0)
     361        vrc = VERR_TIMEOUT;
    363362    else if (errno == EINTR)
    364         rc = VINF_INTERRUPTED;
     363        vrc = VINF_INTERRUPTED;
    365364    else
    366365    {
     
    368367        if (s_ErrorCount < 500)
    369368        {
    370             LogRel(("waitForEventsOnXPCOM rc=%d errno=%d\n", rc, errno));
     369            LogRel(("waitForEventsOnXPCOM iRc=%d errno=%d\n", iRc, errno));
    371370            ++s_ErrorCount;
    372371        }
    373372
    374         AssertMsgFailed(("rc=%d errno=%d\n", rc, errno));
    375         rc = VERR_INTERNAL_ERROR_4;
    376     }
    377     return rc;
     373        AssertMsgFailed(("iRc=%d errno=%d\n", iRc, errno));
     374        vrc = VERR_INTERNAL_ERROR_4;
     375    }
     376    return vrc;
    378377}
    379378
     
    388387 * This will pick out our events and handle them specially.
    389388 *
    390  * @returns @a rc or VERR_INTERRUPTED (WM_QUIT or NULL msg).
     389 * @returns @a vrc or VERR_INTERRUPTED (WM_QUIT or NULL msg).
    391390 * @param   pMsg    The message to dispatch.
    392  * @param   rc      The current status code.
     391 * @param   vrc     The current status code.
    393392 */
    394393/*static*/
    395 int NativeEventQueue::dispatchMessageOnWindows(MSG const *pMsg, int rc)
     394int NativeEventQueue::dispatchMessageOnWindows(MSG const *pMsg, int vrc)
    396395{
    397396    /*
     
    410409            }
    411410            else
    412                 rc = VERR_INTERRUPTED;
    413             return rc;
     411                vrc = VERR_INTERRUPTED;
     412            return vrc;
    414413        }
    415414        AssertMsgFailed(("lParam=%p wParam=%p\n", pMsg->lParam, pMsg->wParam));
     
    420419     */
    421420    if (pMsg->message == WM_QUIT)
    422         rc = VERR_INTERRUPTED;
     421        vrc = VERR_INTERRUPTED;
    423422    TranslateMessage(pMsg);
    424423    DispatchMessage(pMsg);
    425424
    426     return rc;
     425    return vrc;
    427426}
    428427
     
    437436static int processPendingEvents(void)
    438437{
    439     int rc = VERR_TIMEOUT;
     438    int vrc = VERR_TIMEOUT;
    440439    MSG Msg;
    441440    if (PeekMessage(&Msg, NULL /*hWnd*/, 0 /*wMsgFilterMin*/, 0 /*wMsgFilterMax*/, PM_REMOVE))
    442441    {
    443         rc = VINF_SUCCESS;
     442        vrc = VINF_SUCCESS;
    444443        do
    445             rc = NativeEventQueue::dispatchMessageOnWindows(&Msg, rc);
     444            vrc = NativeEventQueue::dispatchMessageOnWindows(&Msg, vrc);
    446445        while (PeekMessage(&Msg, NULL /*hWnd*/, 0 /*wMsgFilterMin*/, 0 /*wMsgFilterMax*/, PM_REMOVE));
    447446    }
    448     return rc;
     447    return vrc;
    449448}
    450449
     
    463462    /* ProcessPendingEvents doesn't report back what it did, so check here. */
    464463    PRBool fHasEvents = PR_FALSE;
    465     nsresult hr = pQueue->PendingEvents(&fHasEvents);
    466     if (NS_FAILED(hr))
     464    nsresult hrc = pQueue->PendingEvents(&fHasEvents);
     465    if (NS_FAILED(hrc))
    467466        return VERR_INTERNAL_ERROR_2;
    468467
    469468    /* Process pending events. */
    470     int rc = VINF_SUCCESS;
     469    int vrc = VINF_SUCCESS;
    471470    if (fHasEvents)
    472471        pQueue->ProcessPendingEvents();
    473472    else
    474         rc = VERR_TIMEOUT;
     473        vrc = VERR_TIMEOUT;
    475474
    476475# ifdef RT_OS_DARWIN
    477476    /* Process pending native events. */
    478     int rc2 = waitForEventsOnDarwin(0);
    479     if (rc == VERR_TIMEOUT || rc2 == VERR_INTERRUPTED)
    480         rc = rc2;
     477    int vrc2 = waitForEventsOnDarwin(0);
     478    if (vrc == VERR_TIMEOUT || vrc2 == VERR_INTERRUPTED)
     479        vrc = vrc2;
    481480# endif
    482481
    483     return rc;
     482    return vrc;
    484483}
    485484
     
    514513int NativeEventQueue::processEventQueue(RTMSINTERVAL cMsTimeout)
    515514{
    516     int rc;
     515    int vrc;
    517516    CHECK_THREAD_RET(VERR_INVALID_CONTEXT);
    518517
     
    527526     *       while select() is.  So we cannot use it for indefinite waits.
    528527     */
    529     rc = processPendingEvents(mEventQ);
    530     if (    rc == VERR_TIMEOUT
     528    vrc = processPendingEvents(mEventQ);
     529    if (    vrc == VERR_TIMEOUT
    531530        &&  cMsTimeout > 0)
    532531    {
     
    538537         *         Ctrl-C handling is important, signal needs to be handled on
    539538         *         a different thread or something. */
    540         rc = waitForEventsOnDarwin(cMsTimeout);
     539        vrc = waitForEventsOnDarwin(cMsTimeout);
    541540# else // !RT_OS_DARWIN
    542         rc = waitForEventsOnXPCOM(mEventQ, cMsTimeout);
     541        vrc = waitForEventsOnXPCOM(mEventQ, cMsTimeout);
    543542# endif // !RT_OS_DARWIN
    544         if (    RT_SUCCESS(rc)
    545             ||  rc == VERR_TIMEOUT)
     543        if (    RT_SUCCESS(vrc)
     544            ||  vrc == VERR_TIMEOUT)
    546545        {
    547             int rc2 = processPendingEvents(mEventQ);
     546            int vrc2 = processPendingEvents(mEventQ);
    548547            /* If the wait was successful don't fail the whole operation. */
    549             if (RT_FAILURE(rc) && RT_FAILURE(rc2))
    550                 rc = rc2;
     548            if (RT_FAILURE(vrc) && RT_FAILURE(vrc2))
     549                vrc = vrc2;
    551550        }
    552551    }
    553552
    554     if (  (   RT_SUCCESS(rc)
    555            || rc == VERR_INTERRUPTED
    556            || rc == VERR_TIMEOUT)
     553    if (  (   RT_SUCCESS(vrc)
     554           || vrc == VERR_INTERRUPTED
     555           || vrc == VERR_TIMEOUT)
    557556        && mInterrupted)
    558557    {
    559558        mInterrupted = false;
    560         rc = VERR_INTERRUPTED;
     559        vrc = VERR_INTERRUPTED;
    561560    }
    562561
     
    566565        BOOL fRet = 0; /* Shut up MSC */
    567566        MSG  Msg;
    568         rc = VINF_SUCCESS;
    569         while (   rc != VERR_INTERRUPTED
     567        vrc = VINF_SUCCESS;
     568        while (   vrc != VERR_INTERRUPTED
    570569               && (fRet = GetMessage(&Msg, NULL /*hWnd*/, WM_USER, WM_USER))
    571570               && fRet != -1)
    572             rc = NativeEventQueue::dispatchMessageOnWindows(&Msg, rc);
     571            vrc = NativeEventQueue::dispatchMessageOnWindows(&Msg, vrc);
    573572        if (fRet == 0)
    574             rc = VERR_INTERRUPTED;
     573            vrc = VERR_INTERRUPTED;
    575574        else if (fRet == -1)
    576             rc = RTErrConvertFromWin32(GetLastError());
     575            vrc = RTErrConvertFromWin32(GetLastError());
    577576    }
    578577    else
    579578    {
    580         rc = processPendingEvents();
    581         if (   rc == VERR_TIMEOUT
     579        vrc = processPendingEvents();
     580        if (   vrc == VERR_TIMEOUT
    582581            && cMsTimeout != 0)
    583582        {
     
    590589                            ("%d\n", rcW),
    591590                            VERR_INTERNAL_ERROR_4);
    592             rc = processPendingEvents();
     591            vrc = processPendingEvents();
    593592        }
    594593    }
    595594#endif // !VBOX_WITH_XPCOM
    596595
    597     Assert(rc != VERR_TIMEOUT || cMsTimeout != RT_INDEFINITE_WAIT);
    598     return rc;
     596    Assert(vrc != VERR_TIMEOUT || cMsTimeout != RT_INDEFINITE_WAIT);
     597    return vrc;
    599598}
    600599
     
    646645        mEventQ->InitEvent(pMyEvent, this, com::NativeEventQueue::plEventHandler,
    647646                           com::NativeEventQueue::plEventDestructor);
    648         HRESULT rc = mEventQ->PostEvent(pMyEvent);
    649         return NS_SUCCEEDED(rc);
     647        HRESULT hrc = mEventQ->PostEvent(pMyEvent);
     648        return NS_SUCCEEDED(hrc);
    650649    }
    651650    catch (std::bad_alloc &ba)
  • trunk/src/VBox/Main/glue/com.cpp

    r98103 r98297  
    7878#if !defined(VBOX_WITH_XPCOM)
    7979
    80     LONG rc;
    8180    LPOLESTR iidStr = NULL;
    8281    if (StringFromIID(aIID, &iidStr) == S_OK)
    8382    {
    8483        HKEY ifaceKey;
    85         rc = RegOpenKeyExW(HKEY_CLASSES_ROOT, L"Interface",
    86                            0, KEY_QUERY_VALUE, &ifaceKey);
    87         if (rc == ERROR_SUCCESS)
     84        LSTATUS lrc = RegOpenKeyExW(HKEY_CLASSES_ROOT, L"Interface", 0, KEY_QUERY_VALUE, &ifaceKey);
     85        if (lrc == ERROR_SUCCESS)
    8886        {
    8987            HKEY iidKey;
    90             rc = RegOpenKeyExW(ifaceKey, iidStr, 0, KEY_QUERY_VALUE, &iidKey);
    91             if (rc == ERROR_SUCCESS)
     88            lrc = RegOpenKeyExW(ifaceKey, iidStr, 0, KEY_QUERY_VALUE, &iidKey);
     89            if (lrc == ERROR_SUCCESS)
    9290            {
    9391                /* determine the size and type */
    9492                DWORD sz, type;
    95                 rc = RegQueryValueExW(iidKey, NULL, NULL, &type, NULL, &sz);
    96                 if (rc == ERROR_SUCCESS && type == REG_SZ)
     93                lrc = RegQueryValueExW(iidKey, NULL, NULL, &type, NULL, &sz);
     94                if (lrc == ERROR_SUCCESS && type == REG_SZ)
    9795                {
    9896                    /* query the value to BSTR */
    9997                    *aName = SysAllocStringLen(NULL, (sz + 1) / sizeof(TCHAR) + 1);
    100                     rc = RegQueryValueExW(iidKey, NULL, NULL, NULL, (LPBYTE) *aName, &sz);
    101                     if (rc != ERROR_SUCCESS)
     98                    lrc = RegQueryValueExW(iidKey, NULL, NULL, NULL, (LPBYTE) *aName, &sz);
     99                    if (lrc != ERROR_SUCCESS)
    102100                    {
    103101                        SysFreeString(*aName);
     
    149147                                 void** ppobj)
    150148{
    151     HRESULT rc;
    152     nsCOMPtr<ipcIService> ipcServ = do_GetService(IPC_SERVICE_CONTRACTID, &rc);
    153     if (SUCCEEDED(rc))
     149    HRESULT hrc = E_UNEXPECTED;
     150    nsCOMPtr<ipcIService> ipcServ = do_GetService(IPC_SERVICE_CONTRACTID, &hrc);
     151    if (SUCCEEDED(hrc))
    154152    {
    155153        PRUint32 serverID = 0;
    156         rc = ipcServ->ResolveClientName(serverName, &serverID);
    157         if (SUCCEEDED (rc))
     154        hrc = ipcServ->ResolveClientName(serverName, &serverID);
     155        if (SUCCEEDED (hrc))
    158156        {
    159             nsCOMPtr<ipcIDConnectService> dconServ = do_GetService(IPC_DCONNECTSERVICE_CONTRACTID, &rc);
    160             if (SUCCEEDED(rc))
    161                 rc = dconServ->CreateInstance(serverID,
    162                                               clsid,
    163                                               id,
    164                                               ppobj);
     157            nsCOMPtr<ipcIDConnectService> dconServ = do_GetService(IPC_DCONNECTSERVICE_CONTRACTID, &hrc);
     158            if (SUCCEEDED(hrc))
     159                hrc = dconServ->CreateInstance(serverID,
     160                                               clsid,
     161                                               id,
     162                                               ppobj);
    165163        }
    166164    }
    167     return rc;
     165    return hrc;
    168166}
    169167
     
    173171{
    174172    nsCOMPtr<nsIComponentManager> manager;
    175     HRESULT rc = NS_GetComponentManager(getter_AddRefs(manager));
    176     if (SUCCEEDED(rc))
    177         rc = manager->CreateInstance(clsid,
    178                                      nsnull,
    179                                      id,
    180                                      ppobj);
    181     return rc;
     173    HRESULT hrc = NS_GetComponentManager(getter_AddRefs(manager));
     174    if (SUCCEEDED(hrc))
     175        hrc = manager->CreateInstance(clsid,
     176                                      nsnull,
     177                                      id,
     178                                      ppobj);
     179    return hrc;
    182180}
    183181
  • trunk/src/VBox/Main/glue/errorprint.cpp

    r98103 r98297  
    5757    try
    5858    {
    59         HRESULT rc = S_OK;
     59        HRESULT hrc = S_OK;
    6060        Utf8Str str;
    6161        RTCList<Utf8Str> comp;
     
    6767        if (haveResultCode)
    6868        {
    69             rc = info.getResultCode();
    70             comp.append(Utf8StrFmt("code %Rhrc (0x%RX32)", rc, rc));
     69            hrc = info.getResultCode();
     70            comp.append(Utf8StrFmt("code %Rhrc (0x%RX32)", hrc, hrc));
    7171        }
    7272        if (haveComponent)
     
    9090
    9191        // print and log
    92         if (FAILED(rc))
     92        if (FAILED(hrc))
    9393        {
    9494            RTMsgError("%s", str.c_str());
     
    126126}
    127127
    128 void GluePrintRCMessage(HRESULT rc)
     128void GluePrintRCMessage(HRESULT hrc)
    129129{
    130130    // print and log
    131     if (FAILED(rc))
    132     {
    133         RTMsgError("Code %Rhra (extended info not available)\n", rc);
    134         Log(("ERROR: Code %Rhra (extended info not available)\n", rc));
     131    if (FAILED(hrc))
     132    {
     133        RTMsgError("Code %Rhra (extended info not available)\n", hrc);
     134        Log(("ERROR: Code %Rhra (extended info not available)\n", hrc));
    135135    }
    136136    else
    137137    {
    138         RTMsgWarning("Code %Rhra (extended info not available)\n", rc);
    139         Log(("WARNING: Code %Rhra (extended info not available)\n", rc));
     138        RTMsgWarning("Code %Rhra (extended info not available)\n", hrc);
     139        Log(("WARNING: Code %Rhra (extended info not available)\n", hrc));
    140140    }
    141141}
     
    143143static void glueHandleComErrorInternal(com::ErrorInfo &info,
    144144                                       const char *pcszContext,
    145                                        HRESULT rc,
     145                                       HRESULT hrc,
    146146                                       const char *pcszSourceFile,
    147147                                       uint32_t ulLine)
     
    154154            GluePrintErrorInfo(*pInfo);
    155155
    156             /* Use rc for figuring out if there were just warnings. */
    157             HRESULT rc2 = pInfo->getResultCode();
    158             if (   (SUCCEEDED_WARNING(rc) && FAILED(rc2))
    159                 || (SUCCEEDED(rc) && (FAILED(rc2) || SUCCEEDED_WARNING(rc2))))
    160                 rc = rc2;
     156            /* Use hrc for figuring out if there were just warnings. */
     157            HRESULT hrc2 = pInfo->getResultCode();
     158            if (   (SUCCEEDED_WARNING(hrc) && FAILED(hrc2))
     159                || (SUCCEEDED(hrc) && (FAILED(hrc2) || SUCCEEDED_WARNING(hrc2))))
     160                hrc = hrc2;
    161161
    162162            pInfo = pInfo->getNext();
     
    171171                RTMsgError("--------\n");
    172172            }
    173         }
    174         while (pInfo);
     173        } while (pInfo);
    175174    }
    176175    else
    177         GluePrintRCMessage(rc);
     176        GluePrintRCMessage(hrc);
    178177
    179178    if (pcszContext != NULL || pcszSourceFile != NULL)
    180         GluePrintErrorContext(pcszContext, pcszSourceFile, ulLine, SUCCEEDED_WARNING(rc));
     179        GluePrintErrorContext(pcszContext, pcszSourceFile, ulLine, SUCCEEDED_WARNING(hrc));
    181180}
    182181
    183182void GlueHandleComError(ComPtr<IUnknown> iface,
    184183                        const char *pcszContext,
    185                         HRESULT rc,
     184                        HRESULT hrc,
    186185                        const char *pcszSourceFile,
    187186                        uint32_t ulLine)
     
    193192    glueHandleComErrorInternal(info,
    194193                               pcszContext,
    195                                rc,
     194                               hrc,
    196195                               pcszSourceFile,
    197196                               ulLine);
     
    199198}
    200199
    201 void GlueHandleComErrorNoCtx(ComPtr<IUnknown> iface, HRESULT rc)
    202 {
    203     GlueHandleComError(iface, NULL, rc, NULL, 0);
     200void GlueHandleComErrorNoCtx(ComPtr<IUnknown> iface, HRESULT hrc)
     201{
     202    GlueHandleComError(iface, NULL, hrc, NULL, 0);
    204203}
    205204
    206205void GlueHandleComErrorProgress(ComPtr<IProgress> progress,
    207206                                const char *pcszContext,
    208                                 HRESULT rc,
     207                                HRESULT hrc,
    209208                                const char *pcszSourceFile,
    210209                                uint32_t ulLine)
     
    215214    glueHandleComErrorInternal(ei,
    216215                               pcszContext,
    217                                rc,
     216                               hrc,
    218217                               pcszSourceFile,
    219218                               ulLine);
  • trunk/src/VBox/Main/glue/initterm.cpp

    r98103 r98297  
    443443HRESULT Initialize(uint32_t fInitFlags /*=VBOX_COM_INIT_F_DEFAULT*/)
    444444{
    445     HRESULT rc = E_FAIL;
     445    HRESULT hrc = E_FAIL;
    446446
    447447#if !defined(VBOX_WITH_XPCOM)
     
    511511                  | COINIT_SPEED_OVER_MEMORY;
    512512
    513     rc = CoInitializeEx(NULL, flags);
     513    hrc = CoInitializeEx(NULL, flags);
    514514
    515515    /* the overall result must be either S_OK or S_FALSE (S_FALSE means
    516516     * "already initialized using the same apartment model") */
    517     AssertMsg(rc == S_OK || rc == S_FALSE, ("rc=%08X\n", rc));
     517    AssertMsg(hrc == S_OK || hrc == S_FALSE, ("hrc=%08X\n", hrc));
    518518
    519519#if defined(VBOX_WITH_SDS)
    520520    // Setup COM Security to enable impersonation
    521     HRESULT hrGUICoInitializeSecurity = CoInitializeSecurity(NULL,
    522                                                              -1,
    523                                                              NULL,
    524                                                              NULL,
    525                                                              RPC_C_AUTHN_LEVEL_DEFAULT,
    526                                                              RPC_C_IMP_LEVEL_IMPERSONATE,
    527                                                              NULL,
    528                                                              EOAC_NONE,
    529                                                              NULL);
    530     NOREF(hrGUICoInitializeSecurity);
    531     Assert(SUCCEEDED(hrGUICoInitializeSecurity) || hrGUICoInitializeSecurity == RPC_E_TOO_LATE);
     521    HRESULT hrcGUICoInitializeSecurity = CoInitializeSecurity(NULL,
     522                                                              -1,
     523                                                              NULL,
     524                                                              NULL,
     525                                                              RPC_C_AUTHN_LEVEL_DEFAULT,
     526                                                              RPC_C_IMP_LEVEL_IMPERSONATE,
     527                                                              NULL,
     528                                                              EOAC_NONE,
     529                                                              NULL);
     530    NOREF(hrcGUICoInitializeSecurity);
     531    Assert(SUCCEEDED(hrcGUICoInitializeSecurity) || hrcGUICoInitializeSecurity == RPC_E_TOO_LATE);
    532532#endif
    533533
     
    556556    {
    557557        if (   gCOMMainThread == hSelf
    558             && SUCCEEDED(rc))
     558            && SUCCEEDED(hrc))
    559559            gCOMMainInitCount++;
    560560
    561         AssertComRC(rc);
    562         return rc;
     561        AssertComRC(hrc);
     562        return hrc;
    563563    }
    564564    Assert(RTThreadIsMain(hSelf));
     
    566566    /* this is the first main thread initialization */
    567567    Assert(gCOMMainInitCount == 0);
    568     if (SUCCEEDED(rc))
     568    if (SUCCEEDED(hrc))
    569569        gCOMMainInitCount = 1;
    570570
     
    583583
    584584        nsCOMPtr<nsIEventQueue> eventQ;
    585         rc = NS_GetMainEventQ(getter_AddRefs(eventQ));
    586 
    587         if (NS_SUCCEEDED(rc))
     585        hrc = NS_GetMainEventQ(getter_AddRefs(eventQ));
     586
     587        if (NS_SUCCEEDED(hrc))
    588588        {
    589589            PRBool isOnMainThread = PR_FALSE;
    590             rc = eventQ->IsOnCurrentThread(&isOnMainThread);
    591             if (NS_SUCCEEDED(rc) && isOnMainThread)
     590            hrc = eventQ->IsOnCurrentThread(&isOnMainThread);
     591            if (NS_SUCCEEDED(hrc) && isOnMainThread)
    592592                ++gXPCOMInitCount;
    593593        }
    594594
    595         AssertComRC(rc);
    596         return rc;
     595        AssertComRC(hrc);
     596        return hrc;
    597597    }
    598598    Assert(RTThreadIsMain(RTThreadSelf()));
     
    682682        if (RT_FAILURE(vrc))
    683683        {
    684             rc = NS_ERROR_FAILURE;
     684            hrc = NS_ERROR_FAILURE;
    685685            continue;
    686686        }
     
    689689        if (RT_FAILURE(vrc))
    690690        {
    691             rc = NS_ERROR_FAILURE;
     691            hrc = NS_ERROR_FAILURE;
    692692            continue;
    693693        }
     
    695695        if (RT_FAILURE(vrc))
    696696        {
    697             rc = NS_ERROR_FAILURE;
     697            hrc = NS_ERROR_FAILURE;
    698698            continue;
    699699        }
     
    703703        dsProv = new DirectoryServiceProvider();
    704704        if (dsProv)
    705             rc = dsProv->init(szCompReg, szXptiDat, szCompDir, szAppHomeDir);
     705            hrc = dsProv->init(szCompReg, szXptiDat, szCompDir, szAppHomeDir);
    706706        else
    707             rc = NS_ERROR_OUT_OF_MEMORY;
    708         if (NS_FAILED(rc))
     707            hrc = NS_ERROR_OUT_OF_MEMORY;
     708        if (NS_FAILED(hrc))
    709709            break;
    710710
     
    721721            {
    722722                nsCOMPtr<nsILocalFile> file;
    723                 rc = NS_NewNativeLocalFile(nsEmbedCString(appDirCP),
    724                                            PR_FALSE, getter_AddRefs(file));
    725                 if (NS_SUCCEEDED(rc))
    726                     appDir = do_QueryInterface(file, &rc);
     723                hrc = NS_NewNativeLocalFile(nsEmbedCString(appDirCP), PR_FALSE, getter_AddRefs(file));
     724                if (NS_SUCCEEDED(hrc))
     725                    appDir = do_QueryInterface(file, &hrc);
    727726
    728727                RTStrFree(appDirCP);
    729728            }
    730729            else
    731                 rc = NS_ERROR_FAILURE;
    732         }
    733         if (NS_FAILED(rc))
     730                hrc = NS_ERROR_FAILURE;
     731        }
     732        if (NS_FAILED(hrc))
    734733            break;
    735734
     
    742741        {
    743742            nsCOMPtr<nsIServiceManager> serviceManager;
    744             rc = NS_InitXPCOM2(getter_AddRefs(serviceManager), appDir, dsProv);
    745             if (NS_SUCCEEDED(rc))
     743            hrc = NS_InitXPCOM2(getter_AddRefs(serviceManager), appDir, dsProv);
     744            if (NS_SUCCEEDED(hrc))
    746745            {
    747                 nsCOMPtr<nsIComponentRegistrar> registrar =
    748                     do_QueryInterface(serviceManager, &rc);
    749                 if (NS_SUCCEEDED(rc))
     746                nsCOMPtr<nsIComponentRegistrar> registrar = do_QueryInterface(serviceManager, &hrc);
     747                if (NS_SUCCEEDED(hrc))
    750748                {
    751                     rc = registrar->AutoRegister(nsnull);
    752                     if (NS_SUCCEEDED(rc))
     749                    hrc = registrar->AutoRegister(nsnull);
     750                    if (NS_SUCCEEDED(hrc))
    753751                    {
    754752                        /* We succeeded, stop probing paths */
     
    761759
    762760        /* clean up before the new try */
    763         HRESULT rc2 = NS_ShutdownXPCOM(nsnull);
    764         if (SUCCEEDED(rc))
    765             rc = rc2;
     761        HRESULT hrc2 = NS_ShutdownXPCOM(nsnull);
     762        if (SUCCEEDED(hrc))
     763            hrc = hrc2;
    766764
    767765        if (i == 0)
     
    774772#endif /* !defined(VBOX_WITH_XPCOM) */
    775773
    776     AssertComRCReturnRC(rc);
     774    AssertComRCReturnRC(hrc);
    777775
    778776    // for both COM and XPCOM, we only get here if this is the main thread;
     
    784782     * Init the main event queue (ASSUMES it cannot fail).
    785783     */
    786     if (SUCCEEDED(rc))
     784    if (SUCCEEDED(hrc))
    787785        NativeEventQueue::init();
    788786
    789     return rc;
     787    return hrc;
    790788}
    791789
    792790HRESULT Shutdown()
    793791{
    794     HRESULT rc = S_OK;
     792    HRESULT hrc = S_OK;
    795793
    796794#if !defined(VBOX_WITH_XPCOM)
     
    813811
    814812    nsCOMPtr<nsIEventQueue> eventQ;
    815     rc = NS_GetMainEventQ(getter_AddRefs(eventQ));
    816 
    817     if (NS_SUCCEEDED(rc) || rc == NS_ERROR_NOT_AVAILABLE)
     813    hrc = NS_GetMainEventQ(getter_AddRefs(eventQ));
     814
     815    if (NS_SUCCEEDED(hrc) || hrc == NS_ERROR_NOT_AVAILABLE)
    818816    {
    819817        /* NS_ERROR_NOT_AVAILABLE seems to mean that
     
    825823
    826824        PRBool isOnMainThread = PR_FALSE;
    827         if (NS_SUCCEEDED(rc))
    828         {
    829             rc = eventQ->IsOnCurrentThread(&isOnMainThread);
     825        if (NS_SUCCEEDED(hrc))
     826        {
     827            hrc = eventQ->IsOnCurrentThread(&isOnMainThread);
    830828            eventQ = nsnull; /* early release before shutdown */
    831829        }
     
    833831        {
    834832            isOnMainThread = RTThreadIsMain(RTThreadSelf());
    835             rc = NS_OK;
    836         }
    837 
    838         if (NS_SUCCEEDED(rc) && isOnMainThread)
     833            hrc = NS_OK;
     834        }
     835
     836        if (NS_SUCCEEDED(hrc) && isOnMainThread)
    839837        {
    840838            /* only the main thread needs to uninitialize XPCOM and only if
     
    843841            {
    844842                NativeEventQueue::uninit();
    845                 rc = NS_ShutdownXPCOM(nsnull);
     843                hrc = NS_ShutdownXPCOM(nsnull);
    846844
    847845                /* This is a thread initialized XPCOM and set gIsXPCOMInitialized to
     
    856854#endif /* !defined(VBOX_WITH_XPCOM) */
    857855
    858     AssertComRC(rc);
    859 
    860     return rc;
     856    AssertComRC(hrc);
     857
     858    return hrc;
    861859}
    862860
  • trunk/src/VBox/Main/glue/string.cpp

    r98103 r98297  
    112112    {
    113113        size_t cwcAppend;
    114         int rc = ::RTStrCalcUtf16LenEx(pachChars, cbChars, &cwcAppend);
    115         AssertRCReturnStmt(rc, pArgs->hrc = E_UNEXPECTED, 0);
     114        int vrc = ::RTStrCalcUtf16LenEx(pachChars, cbChars, &cwcAppend);
     115        AssertRCReturnStmt(vrc, pArgs->hrc = E_UNEXPECTED, 0);
    116116
    117117        /*
     
    143143        PRTUTF16 pwszDst = pThis->m_bstr + pArgs->offDst;
    144144        Assert(pArgs->cwcAlloc > pArgs->offDst);
    145         rc = ::RTStrToUtf16Ex(pachChars, cbChars, &pwszDst, pArgs->cwcAlloc - pArgs->offDst, &cwcAppend);
    146         AssertRCReturnStmt(rc, pArgs->hrc = E_UNEXPECTED, 0);
     145        vrc = ::RTStrToUtf16Ex(pachChars, cbChars, &pwszDst, pArgs->cwcAlloc - pArgs->offDst, &cwcAppend);
     146        AssertRCReturnStmt(vrc, pArgs->hrc = E_UNEXPECTED, 0);
    147147        pArgs->offDst += cwcAppend;
    148148    }
     
    269269    {
    270270        RTUNICP ucLeft;
    271         int rc = RTUtf16GetCpEx(&pwszLeft, &ucLeft);
    272         AssertRCReturn(rc, 1);
     271        int vrc = RTUtf16GetCpEx(&pwszLeft, &ucLeft);
     272        AssertRCReturn(vrc, 1);
    273273
    274274        RTUNICP ucRight;
    275         rc = RTStrGetCpEx(&a_pszRight, &ucRight);
    276         AssertRCReturn(rc, -1);
     275        vrc = RTStrGetCpEx(&a_pszRight, &ucRight);
     276        AssertRCReturn(vrc, -1);
    277277        if (ucLeft == ucRight)
    278278        {
     
    577577{
    578578    size_t cwcSrc;
    579     int rc = RTStrCalcUtf16LenEx(pszSrc, cchSrc, &cwcSrc);
     579    int vrc = RTStrCalcUtf16LenEx(pszSrc, cchSrc, &cwcSrc);
    580580#ifdef RT_EXCEPTIONS_ENABLED
    581     AssertRCStmt(rc, throw std::bad_alloc());
     581    AssertRCStmt(vrc, throw std::bad_alloc());
    582582#else
    583     AssertRCReturn(rc, *this);
     583    AssertRCReturn(vrc, *this);
    584584#endif
    585585
     
    590590    {
    591591        PRTUTF16 pwszDst = &m_bstr[cwcOld];
    592         rc = RTStrToUtf16Ex(pszSrc, cchSrc, &pwszDst, cwcSrc + 1, NULL);
     592        vrc = RTStrToUtf16Ex(pszSrc, cchSrc, &pwszDst, cwcSrc + 1, NULL);
    593593#ifdef RT_EXCEPTIONS_ENABLED
    594         AssertRCStmt(rc, throw std::bad_alloc());
     594        AssertRCStmt(vrc, throw std::bad_alloc());
    595595#else
    596         AssertRC(rc);
     596        AssertRC(vrc);
    597597#endif
    598598    }
     
    605605{
    606606    size_t cwcSrc;
    607     int rc = RTStrCalcUtf16LenEx(pszSrc, cchSrc, &cwcSrc);
    608     AssertRCStmt(rc, E_INVALIDARG);
     607    int vrc = RTStrCalcUtf16LenEx(pszSrc, cchSrc, &cwcSrc);
     608    AssertRCStmt(vrc, E_INVALIDARG);
    609609
    610610    size_t cwcOld = length();
     
    615615    {
    616616        PRTUTF16 pwszDst = &m_bstr[cwcOld];
    617         rc = RTStrToUtf16Ex(pszSrc, cchSrc, &pwszDst, cwcSrc + 1, NULL);
    618         AssertRCStmt(rc, E_INVALIDARG);
     617        vrc = RTStrToUtf16Ex(pszSrc, cchSrc, &pwszDst, cwcSrc + 1, NULL);
     618        AssertRCStmt(vrc, E_INVALIDARG);
    619619    }
    620620    m_bstr[cwcTotal] = '\0';
  • trunk/src/VBox/Main/src-all/win/VBoxProxyStub.c

    r98103 r98297  
    360360
    361361    /** The current total result. */
    362     LSTATUS rc;
     362    LSTATUS lrc;
    363363
    364364    /** KEY_WOW64_32KEY, KEY_WOW64_64KEY or 0 (for default).  Allows doing all
     
    395395static LSTATUS vbpsRegInit(VBPSREGSTATE *pState, HKEY hkeyRoot, const char *pszSubRoot, bool fDelete, bool fUpdate, DWORD fSamWow)
    396396{
    397     LSTATUS rc;
     397    LSTATUS lrc;
    398398    unsigned i = 0;
    399399
     
    411411    }
    412412    pState->cAltDeletes                 = 0;
    413     pState->rc                          = ERROR_SUCCESS;
     413    pState->lrc                         = ERROR_SUCCESS;
    414414    pState->fDelete                     = fDelete;
    415415    pState->fUpdate                     = fUpdate;
     
    428428     * Open the root keys.
    429429     */
    430     rc = RegOpenKeyExA(hkeyRoot, pszSubRoot, 0 /*fOptions*/, pState->fSamBoth, &pState->hkeyClassesRootDst);
    431     if (rc == ERROR_SUCCESS)
    432     {
    433         rc = RegCreateKeyExW(pState->hkeyClassesRootDst, L"CLSID", 0 /*Reserved*/, NULL /*pszClass*/, 0 /*fOptions*/,
    434                              pState->fSamBoth, NULL /*pSecAttr*/, &pState->hkeyClsidRootDst, NULL /*pdwDisposition*/);
    435         if (rc == ERROR_SUCCESS)
     430    lrc = RegOpenKeyExA(hkeyRoot, pszSubRoot, 0 /*fOptions*/, pState->fSamBoth, &pState->hkeyClassesRootDst);
     431    if (lrc == ERROR_SUCCESS)
     432    {
     433        lrc = RegCreateKeyExW(pState->hkeyClassesRootDst, L"CLSID", 0 /*Reserved*/, NULL /*pszClass*/, 0 /*fOptions*/,
     434                              pState->fSamBoth, NULL /*pSecAttr*/, &pState->hkeyClsidRootDst, NULL /*pdwDisposition*/);
     435        if (lrc == ERROR_SUCCESS)
    436436            return ERROR_SUCCESS;
    437437
    438438        /* Ignore access denied errors as these may easily happen for
    439439           non-admin users. Just give up when this happens */
    440         AssertLogRelMsgReturn(rc == ERROR_ACCESS_DENIED, ("%u\n", rc), pState->rc = rc);
     440        AssertLogRelMsgReturn(lrc == ERROR_ACCESS_DENIED, ("%u\n", lrc), pState->lrc = lrc);
    441441    }
    442442    else
    443        AssertLogRelMsgReturn(rc == ERROR_ACCESS_DENIED, ("%u\n", rc), pState->rc = rc);
    444     return pState->rc = rc;
     443       AssertLogRelMsgReturn(lrc == ERROR_ACCESS_DENIED, ("%u\n", lrc), pState->lrc = lrc);
     444    return pState->lrc = lrc;
    445445}
    446446
     
    453453static void vbpsRegTerm(VBPSREGSTATE *pState)
    454454{
    455     LSTATUS rc;
     455    LSTATUS lrc;
    456456    if (pState->hkeyClassesRootDst)
    457457    {
    458         rc = RegCloseKey(pState->hkeyClassesRootDst);
    459         Assert(rc == ERROR_SUCCESS);
     458        lrc = RegCloseKey(pState->hkeyClassesRootDst);
     459        Assert(lrc == ERROR_SUCCESS);
    460460        pState->hkeyClassesRootDst = NULL;
    461461    }
    462462    if (pState->hkeyClsidRootDst)
    463463    {
    464         rc = RegCloseKey(pState->hkeyClsidRootDst);
    465         Assert(rc == ERROR_SUCCESS);
     464        lrc = RegCloseKey(pState->hkeyClsidRootDst);
     465        Assert(lrc == ERROR_SUCCESS);
    466466        pState->hkeyClsidRootDst = NULL;
    467467    }
    468468    if (pState->hkeyInterfaceRootDst)
    469469    {
    470         rc = RegCloseKey(pState->hkeyInterfaceRootDst);
    471         Assert(rc == ERROR_SUCCESS);
     470        lrc = RegCloseKey(pState->hkeyInterfaceRootDst);
     471        Assert(lrc == ERROR_SUCCESS);
    472472        pState->hkeyInterfaceRootDst = NULL;
    473473    }
     
    478478        if (pState->aAltDeletes[i].hkeyClasses)
    479479        {
    480             rc = RegCloseKey(pState->aAltDeletes[i].hkeyClasses);
    481             Assert(rc == ERROR_SUCCESS);
     480            lrc = RegCloseKey(pState->aAltDeletes[i].hkeyClasses);
     481            Assert(lrc == ERROR_SUCCESS);
    482482            pState->aAltDeletes[i].hkeyClasses = NULL;
    483483        }
    484484        if (pState->aAltDeletes[i].hkeyClsid)
    485485        {
    486             rc = RegCloseKey(pState->aAltDeletes[i].hkeyClsid);
    487             Assert(rc == ERROR_SUCCESS);
     486            lrc = RegCloseKey(pState->aAltDeletes[i].hkeyClsid);
     487            Assert(lrc == ERROR_SUCCESS);
    488488            pState->aAltDeletes[i].hkeyClsid = NULL;
    489489        }
    490490        if (pState->aAltDeletes[i].hkeyInterface)
    491491        {
    492             rc = RegCloseKey(pState->aAltDeletes[i].hkeyInterface);
    493             Assert(rc == ERROR_SUCCESS);
     492            lrc = RegCloseKey(pState->aAltDeletes[i].hkeyInterface);
     493            Assert(lrc == ERROR_SUCCESS);
    494494            pState->aAltDeletes[i].hkeyInterface = NULL;
    495495        }
     
    512512{
    513513    unsigned i;
    514     LSTATUS rc;
     514    LSTATUS lrc;
    515515
    516516    /* Ignore call if not in delete mode. */
     
    520520    /* Check that there is space in the state. */
    521521    i = pState->cAltDeletes;
    522     AssertReturn(i < RT_ELEMENTS(pState->aAltDeletes), pState->rc = ERROR_TOO_MANY_NAMES);
     522    AssertReturn(i < RT_ELEMENTS(pState->aAltDeletes), pState->lrc = ERROR_TOO_MANY_NAMES);
    523523
    524524
    525525    /* Open the root. */
    526     rc = RegOpenKeyExA(hkeyAltRoot, pszAltSubRoot, 0 /*fOptions*/, pState->fSamDelete,
     526    lrc = RegOpenKeyExA(hkeyAltRoot, pszAltSubRoot, 0 /*fOptions*/, pState->fSamDelete,
    527527                       &pState->aAltDeletes[i].hkeyClasses);
    528     if (rc == ERROR_SUCCESS)
     528    if (lrc == ERROR_SUCCESS)
    529529    {
    530530        /* Try open the CLSID subkey, it's fine if it doesn't exists. */
    531         rc = RegOpenKeyExW(pState->aAltDeletes[i].hkeyClasses, L"CLSID", 0 /*fOptions*/, pState->fSamDelete,
    532                            &pState->aAltDeletes[i].hkeyClsid);
    533         if (rc == ERROR_SUCCESS || rc == ERROR_FILE_NOT_FOUND)
     531        lrc = RegOpenKeyExW(pState->aAltDeletes[i].hkeyClasses, L"CLSID", 0 /*fOptions*/, pState->fSamDelete,
     532                            &pState->aAltDeletes[i].hkeyClsid);
     533        if (lrc == ERROR_SUCCESS || lrc == ERROR_FILE_NOT_FOUND)
    534534        {
    535             if (rc == ERROR_FILE_NOT_FOUND)
     535            if (lrc == ERROR_FILE_NOT_FOUND)
    536536                pState->aAltDeletes[i].hkeyClsid = NULL;
    537537            pState->cAltDeletes = i + 1;
    538538            return ERROR_SUCCESS;
    539539        }
    540         AssertLogRelMsgFailed(("%u\n", rc));
     540        AssertLogRelMsgFailed(("%u\n", lrc));
    541541        RegCloseKey(pState->aAltDeletes[i].hkeyClasses);
    542542    }
    543543    /* No need to add non-existing alternative roots, nothing to delete in the void. */
    544     else if (rc == ERROR_FILE_NOT_FOUND)
    545         rc = ERROR_SUCCESS;
     544    else if (lrc == ERROR_FILE_NOT_FOUND)
     545        lrc = ERROR_SUCCESS;
    546546    else
    547547    {
    548         AssertLogRelMsgFailed(("%u (%#x %s)\n", rc));
    549         pState->rc = rc;
     548        AssertLogRelMsgFailed(("%u (%#x %s)\n", lrc));
     549        pState->lrc = lrc;
    550550    }
    551551
    552552    pState->aAltDeletes[i].hkeyClasses = NULL;
    553553    pState->aAltDeletes[i].hkeyClsid   = NULL;
    554     return rc;
     554    return lrc;
    555555}
    556556
     
    568568{
    569569    unsigned i;
    570     LSTATUS rc;
     570    LSTATUS lrc;
    571571
    572572    /*
     
    576576    {
    577577        if (pState->fSamUpdate)
    578             rc = RegCreateKeyExW(pState->hkeyClassesRootDst, L"Interface", 0 /*Reserved*/, NULL /*pszClass*/, 0 /*fOptions*/,
    579                                  pState->fSamBoth, NULL /*pSecAttr*/, &pState->hkeyInterfaceRootDst, NULL /*pdwDisposition*/);
     578            lrc = RegCreateKeyExW(pState->hkeyClassesRootDst, L"Interface", 0 /*Reserved*/, NULL /*pszClass*/, 0 /*fOptions*/,
     579                                  pState->fSamBoth, NULL /*pSecAttr*/, &pState->hkeyInterfaceRootDst, NULL /*pdwDisposition*/);
    580580        else
    581             rc = RegOpenKeyExW(pState->hkeyClassesRootDst, L"Interface", 0 /*fOptions*/, pState->fSamBoth,
    582                                &pState->hkeyClsidRootDst);
    583         if (rc == ERROR_ACCESS_DENIED)
     581            lrc = RegOpenKeyExW(pState->hkeyClassesRootDst, L"Interface", 0 /*fOptions*/, pState->fSamBoth,
     582                                &pState->hkeyClsidRootDst);
     583        if (lrc == ERROR_ACCESS_DENIED)
    584584        {
    585585            pState->hkeyInterfaceRootDst = NULL;
    586             return pState->rc = rc;
     586            return pState->lrc = lrc;
    587587        }
    588         AssertLogRelMsgReturnStmt(rc == ERROR_SUCCESS, ("%u\n", rc), pState->hkeyInterfaceRootDst = NULL,  pState->rc = rc);
     588        AssertLogRelMsgReturnStmt(lrc == ERROR_SUCCESS, ("%u\n", lrc), pState->hkeyInterfaceRootDst = NULL,  pState->lrc = lrc);
    589589    }
    590590
     
    596596        if (pState->aAltDeletes[i].hkeyInterface == NULL)
    597597        {
    598             rc = RegOpenKeyExW(pState->aAltDeletes[i].hkeyClasses, L"Interface", 0 /*fOptions*/, pState->fSamDelete,
    599                                &pState->aAltDeletes[i].hkeyInterface);
    600             if (rc != ERROR_SUCCESS)
     598            lrc = RegOpenKeyExW(pState->aAltDeletes[i].hkeyClasses, L"Interface", 0 /*fOptions*/, pState->fSamDelete,
     599                                &pState->aAltDeletes[i].hkeyInterface);
     600            if (lrc != ERROR_SUCCESS)
    601601            {
    602                 AssertMsgStmt(rc == ERROR_FILE_NOT_FOUND || rc == ERROR_ACCESS_DENIED, ("%u\n", rc), pState->rc = rc);
     602                AssertMsgStmt(lrc == ERROR_FILE_NOT_FOUND || lrc == ERROR_ACCESS_DENIED, ("%u\n", lrc), pState->lrc = lrc);
    603603                pState->aAltDeletes[i].hkeyInterface = NULL;
    604604            }
     
    687687{
    688688    DWORD const cbValue = (DWORD)((RTUtf16Len(pwszValue) + 1) * sizeof(RTUTF16));
    689     LSTATUS rc;
     689    LSTATUS lrc;
    690690    Assert(pState->fUpdate);
    691691
     
    699699        PRTUTF16    pwszExistingData = (PRTUTF16)alloca(cbExistingData);
    700700        DWORD       dwExistingType;
    701         rc = RegQueryValueExW(hkey, pwszValueNm, 0 /*Reserved*/, &dwExistingType, (BYTE *)pwszExistingData, &cbExistingData);
    702         if (rc == ERROR_SUCCESS)
     701        lrc = RegQueryValueExW(hkey, pwszValueNm, 0 /*Reserved*/, &dwExistingType, (BYTE *)pwszExistingData, &cbExistingData);
     702        if (lrc == ERROR_SUCCESS)
    703703        {
    704704            if (   dwExistingType == REG_SZ
     
    718718        }
    719719        else
    720             Assert(rc == ERROR_FILE_NOT_FOUND || rc == ERROR_MORE_DATA);
     720            Assert(lrc == ERROR_FILE_NOT_FOUND || lrc == ERROR_MORE_DATA);
    721721    }
    722722
     
    724724     * Set the value.
    725725     */
    726     rc = RegSetValueExW(hkey, pwszValueNm, 0 /*Reserved*/, REG_SZ, (const BYTE *)pwszValue, cbValue);
    727     if (rc == ERROR_SUCCESS)
     726    lrc = RegSetValueExW(hkey, pwszValueNm, 0 /*Reserved*/, REG_SZ, (const BYTE *)pwszValue, cbValue);
     727    if (lrc == ERROR_SUCCESS)
    728728    {
    729729        VBSP_LOG_SET_VALUE(("vbpsSetRegValueWW: %ls/%ls=%ls (at %d)\n",
     
    732732    }
    733733
    734     AssertLogRelMsg(VBPS_LOGREL_NO_ASSERT(rc == ERROR_ACCESS_DENIED),
    735                     ("%d: '%ls'='%ls' -> %u\n", uLine, pwszValueNm, pwszValue, rc));
    736     pState->rc = rc;
    737     return rc;
     734    AssertLogRelMsg(VBPS_LOGREL_NO_ASSERT(lrc == ERROR_ACCESS_DENIED),
     735                    ("%d: '%ls'='%ls' -> %u\n", uLine, pwszValueNm, pwszValue, lrc));
     736    pState->lrc = lrc;
     737    return lrc;
    738738}
    739739
     
    752752{
    753753    DWORD const cbValue = (DWORD)strlen(pszValue) + 1;
    754     LSTATUS rc;
     754    LSTATUS lrc;
    755755    Assert(pState->fUpdate);
    756756
     
    764764        char *pszExistingData = alloca(cbExistingData);
    765765        DWORD dwExistingType;
    766         rc = RegQueryValueExA(hkey, pszValueNm, 0 /*Reserved*/, &dwExistingType, (PBYTE)pszExistingData, &cbExistingData);
    767         if (rc == ERROR_SUCCESS)
     766        lrc = RegQueryValueExA(hkey, pszValueNm, 0 /*Reserved*/, &dwExistingType, (PBYTE)pszExistingData, &cbExistingData);
     767        if (lrc == ERROR_SUCCESS)
    768768        {
    769769            if (   dwExistingType == REG_SZ
     
    785785        }
    786786        else
    787             Assert(rc == ERROR_FILE_NOT_FOUND || rc == ERROR_MORE_DATA);
     787            Assert(lrc == ERROR_FILE_NOT_FOUND || lrc == ERROR_MORE_DATA);
    788788    }
    789789
     
    791791     * Set the value.
    792792     */
    793     rc = RegSetValueExA(hkey, pszValueNm, 0 /*Reserved*/, REG_SZ, (PBYTE)pszValue, cbValue);
    794     if (rc == ERROR_SUCCESS)
     793    lrc = RegSetValueExA(hkey, pszValueNm, 0 /*Reserved*/, REG_SZ, (PBYTE)pszValue, cbValue);
     794    if (lrc == ERROR_SUCCESS)
    795795    {
    796796        VBSP_LOG_SET_VALUE(("vbpsSetRegValueAA: %ls/%s=%s (at %d)\n",
     
    799799    }
    800800
    801     AssertLogRelMsg(VBPS_LOGREL_NO_ASSERT(rc == ERROR_ACCESS_DENIED),
    802                     ("%d: '%s'='%s' -> %u\n", uLine, pszValueNm, pszValue, rc));
    803     pState->rc = rc;
    804     return rc;
     801    AssertLogRelMsg(VBPS_LOGREL_NO_ASSERT(lrc == ERROR_ACCESS_DENIED),
     802                    ("%d: '%s'='%s' -> %u\n", uLine, pszValueNm, pszValue, lrc));
     803    pState->lrc = lrc;
     804    return lrc;
    805805}
    806806
     
    816816static LSTATUS vbpsCloseKey(VBPSREGSTATE *pState, HKEY hkey, unsigned uLine)
    817817{
    818     LSTATUS rc = RegCloseKey(hkey);
    819     if (rc == ERROR_SUCCESS)
     818    LSTATUS lrc = RegCloseKey(hkey);
     819    if (lrc == ERROR_SUCCESS)
    820820        return ERROR_SUCCESS;
    821821
    822     AssertLogRelMsgFailed(("%d: close key -> %u\n", uLine, rc));
    823     pState->rc = rc;
    824     return rc;
     822    AssertLogRelMsgFailed(("%d: close key -> %u\n", uLine, lrc));
     823    pState->lrc = lrc;
     824    return lrc;
    825825}
    826826
     
    844844    HKEY hNewKey;
    845845    DWORD dwDisposition = 0;
    846     LSTATUS rc = RegCreateKeyExA(hkeyParent, pszKey, 0 /*Reserved*/, NULL /*pszClass*/, 0 /*fOptions*/,
    847                                  pState->fSamBoth, NULL /*pSecAttr*/, &hNewKey, &dwDisposition);
    848     if (rc == ERROR_SUCCESS)
     846    LSTATUS lrc = RegCreateKeyExA(hkeyParent, pszKey, 0 /*Reserved*/, NULL /*pszClass*/, 0 /*fOptions*/,
     847                                  pState->fSamBoth, NULL /*pSecAttr*/, &hNewKey, &dwDisposition);
     848    if (lrc == ERROR_SUCCESS)
    849849    {
    850850        *phkey = hNewKey;
     
    854854    else
    855855    {
    856         AssertLogRelMsg(VBPS_LOGREL_NO_ASSERT(rc == ERROR_ACCESS_DENIED),
    857                         ("%d: create key '%s' -> %u\n", uLine, pszKey,  rc));
    858         pState->rc = rc;
     856        AssertLogRelMsg(VBPS_LOGREL_NO_ASSERT(lrc == ERROR_ACCESS_DENIED),
     857                        ("%d: create key '%s' -> %u\n", uLine, pszKey,  lrc));
     858        pState->lrc = lrc;
    859859        *phkey = NULL;
    860860    }
    861     return rc;
     861    return lrc;
    862862}
    863863
     
    878878{
    879879    HKEY hNewKey;
    880     LSTATUS rc = vbpsCreateRegKeyA(pState, hkeyParent, pszKey, &hNewKey, uLine);
    881     if (rc == ERROR_SUCCESS)
    882     {
    883         rc = vbpsSetRegValueAA(pState, hNewKey, NULL /*pszValueNm*/, pszValue, uLine);
     880    LSTATUS lrc = vbpsCreateRegKeyA(pState, hkeyParent, pszKey, &hNewKey, uLine);
     881    if (lrc == ERROR_SUCCESS)
     882    {
     883        lrc = vbpsSetRegValueAA(pState, hNewKey, NULL /*pszValueNm*/, pszValue, uLine);
    884884        vbpsCloseKey(pState, hNewKey, uLine);
    885885    }
    886886    else
    887887    {
    888         AssertLogRelMsg(VBPS_LOGREL_NO_ASSERT(rc == ERROR_ACCESS_DENIED),
    889                         ("%d: create key '%s'(/Default='%s') -> %u\n", uLine, pszKey, pszValue, rc));
    890         pState->rc = rc;
    891     }
    892     return rc;
     888        AssertLogRelMsg(VBPS_LOGREL_NO_ASSERT(lrc == ERROR_ACCESS_DENIED),
     889                        ("%d: create key '%s'(/Default='%s') -> %u\n", uLine, pszKey, pszValue, lrc));
     890        pState->lrc = lrc;
     891    }
     892    return lrc;
    893893}
    894894
     
    909909{
    910910    HKEY hNewKey;
    911     LSTATUS rc = vbpsCreateRegKeyA(pState, hkeyParent, pszKey, &hNewKey, uLine);
    912     if (rc == ERROR_SUCCESS)
    913     {
    914         rc = vbpsSetRegValueWW(pState, hNewKey, NULL /*pwszValueNm*/, pwszValue, uLine);
     911    LSTATUS lrc = vbpsCreateRegKeyA(pState, hkeyParent, pszKey, &hNewKey, uLine);
     912    if (lrc == ERROR_SUCCESS)
     913    {
     914        lrc = vbpsSetRegValueWW(pState, hNewKey, NULL /*pwszValueNm*/, pwszValue, uLine);
    915915        vbpsCloseKey(pState, hNewKey, uLine);
    916916    }
    917917    else
    918918    {
    919         AssertLogRelMsg(VBPS_LOGREL_NO_ASSERT(rc == ERROR_ACCESS_DENIED),
    920                         ("%d: create key '%s'(/Default='%ls') -> %u\n", uLine, pszKey, pwszValue, rc));
    921         pState->rc = rc;
    922     }
    923     return rc;
     919        AssertLogRelMsg(VBPS_LOGREL_NO_ASSERT(lrc == ERROR_ACCESS_DENIED),
     920                        ("%d: create key '%s'(/Default='%ls') -> %u\n", uLine, pszKey, pwszValue, lrc));
     921        pState->lrc = lrc;
     922    }
     923    return lrc;
    924924}
    925925
     
    941941{
    942942    HKEY hNewKey;
    943     LSTATUS rc = vbpsCreateRegKeyA(pState, hkeyParent, pszKey, &hNewKey, uLine);
    944     if (rc == ERROR_SUCCESS)
    945     {
    946         rc = vbpsSetRegValueAA(pState, hNewKey, NULL /*pszValueNm*/, pszValue, uLine);
     943    LSTATUS lrc = vbpsCreateRegKeyA(pState, hkeyParent, pszKey, &hNewKey, uLine);
     944    if (lrc == ERROR_SUCCESS)
     945    {
     946        lrc = vbpsSetRegValueAA(pState, hNewKey, NULL /*pszValueNm*/, pszValue, uLine);
    947947        *phkey = hNewKey;
    948948    }
    949949    else
    950950    {
    951         AssertLogRelMsg(VBPS_LOGREL_NO_ASSERT(rc == ERROR_ACCESS_DENIED),
    952                         ("%d: create key '%s'(/Default='%s') -> %u\n", uLine, pszKey, pszValue, rc));
    953         pState->rc = rc;
     951        AssertLogRelMsg(VBPS_LOGREL_NO_ASSERT(lrc == ERROR_ACCESS_DENIED),
     952                        ("%d: create key '%s'(/Default='%s') -> %u\n", uLine, pszKey, pszValue, lrc));
     953        pState->lrc = lrc;
    954954        *phkey = NULL;
    955955    }
    956     return rc;
     956    return lrc;
    957957}
    958958
     
    970970static LSTATUS vbpsDeleteKeyRecursiveA(VBPSREGSTATE *pState, HKEY hkeyParent, const char *pszKey, unsigned uLine)
    971971{
    972     LSTATUS rc;
     972    LSTATUS lrc;
    973973
    974974    Assert(pState->fDelete);
    975975    Assert(pszKey);
    976     AssertReturn(*pszKey != '\0', pState->rc = ERROR_INVALID_PARAMETER);
     976    AssertReturn(*pszKey != '\0', pState->lrc = ERROR_INVALID_PARAMETER);
    977977
    978978#ifdef VBSP_LOG_ENABLED
    979979    {
    980980        HKEY hkeyLog;
    981         rc = RegOpenKeyExA(hkeyParent, pszKey, 0 /*fOptions*/, pState->fSamDelete, &hkeyLog);
    982         if (rc != ERROR_FILE_NOT_FOUND)
     981        lrc = RegOpenKeyExA(hkeyParent, pszKey, 0 /*fOptions*/, pState->fSamDelete, &hkeyLog);
     982        if (lrc != ERROR_FILE_NOT_FOUND)
    983983            VBSP_LOG_DEL_KEY(("vbpsDeleteKeyRecursiveA: %ls/%s (at %d)\n", vbpsDebugKeyToWSZ(hkeyParent), pszKey, uLine));
    984         if (rc == ERROR_SUCCESS)
     984        if (lrc == ERROR_SUCCESS)
    985985            RegCloseKey(hkeyLog);
    986986    }
    987987#endif
    988988
    989     rc = SHDeleteKeyA(hkeyParent, pszKey);
    990     if (rc == ERROR_SUCCESS || rc == ERROR_FILE_NOT_FOUND)
     989    lrc = SHDeleteKeyA(hkeyParent, pszKey);
     990    if (lrc == ERROR_SUCCESS || lrc == ERROR_FILE_NOT_FOUND)
    991991        return ERROR_SUCCESS;
    992992
    993     AssertLogRelMsg(VBPS_LOGREL_NO_ASSERT(rc == ERROR_ACCESS_DENIED),
    994                     ("%d: delete key '%s' -> %u\n", uLine, pszKey, rc));
    995     pState->rc = rc;
    996     return rc;
     993    AssertLogRelMsg(VBPS_LOGREL_NO_ASSERT(lrc == ERROR_ACCESS_DENIED),
     994                    ("%d: delete key '%s' -> %u\n", uLine, pszKey, lrc));
     995    pState->lrc = lrc;
     996    return lrc;
    997997}
    998998
     
    10101010static LSTATUS vbpsDeleteKeyRecursiveW(VBPSREGSTATE *pState, HKEY hkeyParent, PCRTUTF16 pwszKey, unsigned uLine)
    10111011{
    1012     LSTATUS rc;
     1012    LSTATUS lrc;
    10131013
    10141014    Assert(pState->fDelete);
    10151015    Assert(pwszKey);
    1016     AssertReturn(*pwszKey != '\0', pState->rc = ERROR_INVALID_PARAMETER);
     1016    AssertReturn(*pwszKey != '\0', pState->lrc = ERROR_INVALID_PARAMETER);
    10171017
    10181018#ifdef VBSP_LOG_ENABLED
    10191019    {
    10201020        HKEY hkeyLog;
    1021         rc = RegOpenKeyExW(hkeyParent, pwszKey, 0 /*fOptions*/, pState->fSamDelete, &hkeyLog);
    1022         if (rc != ERROR_FILE_NOT_FOUND)
     1021        lrc = RegOpenKeyExW(hkeyParent, pwszKey, 0 /*fOptions*/, pState->fSamDelete, &hkeyLog);
     1022        if (lrc != ERROR_FILE_NOT_FOUND)
    10231023            VBSP_LOG_DEL_KEY(("vbpsDeleteKeyRecursiveW: %ls/%ls (at %d)\n", vbpsDebugKeyToWSZ(hkeyParent), pwszKey, uLine));
    1024         if (rc == ERROR_SUCCESS)
     1024        if (lrc == ERROR_SUCCESS)
    10251025            RegCloseKey(hkeyLog);
    10261026    }
    10271027#endif
    10281028
    1029     rc = SHDeleteKeyW(hkeyParent, pwszKey);
    1030     if (rc == ERROR_SUCCESS || rc == ERROR_FILE_NOT_FOUND)
     1029    lrc = SHDeleteKeyW(hkeyParent, pwszKey);
     1030    if (lrc == ERROR_SUCCESS || lrc == ERROR_FILE_NOT_FOUND)
    10311031        return ERROR_SUCCESS;
    10321032
    1033     AssertLogRelMsg(VBPS_LOGREL_NO_ASSERT(rc == ERROR_ACCESS_DENIED),
    1034                     ("%d: delete key '%ls' -> %u\n", uLine, pwszKey, rc));
    1035     pState->rc = rc;
    1036     return rc;
     1033    AssertLogRelMsg(VBPS_LOGREL_NO_ASSERT(lrc == ERROR_ACCESS_DENIED),
     1034                    ("%d: delete key '%ls' -> %u\n", uLine, pwszKey, lrc));
     1035    pState->lrc = lrc;
     1036    return lrc;
    10371037}
    10381038
     
    10521052                          const char *pszDescription, const char *pszServiceName)
    10531053{
    1054     LSTATUS rc;
     1054    LSTATUS lrc;
    10551055    HKEY hkeyAppIds;
    10561056    Assert(*pszAppId == '{');
     
    10641064        while (i-- > 0)
    10651065        {
    1066             rc = RegOpenKeyExW(pState->aAltDeletes[i].hkeyClasses, L"AppID", 0 /*fOptions*/, pState->fSamDelete, &hkeyAppIds);
    1067             AssertLogRelMsgStmt(rc == ERROR_SUCCESS || rc == ERROR_FILE_NOT_FOUND, ("%u\n", rc), pState->rc = rc);
    1068             if (rc == ERROR_SUCCESS)
     1066            lrc = RegOpenKeyExW(pState->aAltDeletes[i].hkeyClasses, L"AppID", 0 /*fOptions*/, pState->fSamDelete, &hkeyAppIds);
     1067            AssertLogRelMsgStmt(lrc == ERROR_SUCCESS || lrc == ERROR_FILE_NOT_FOUND, ("%u\n", lrc), pState->lrc = lrc);
     1068            if (lrc == ERROR_SUCCESS)
    10691069            {
    10701070                vbpsDeleteKeyRecursiveA(pState, hkeyAppIds, pszAppId, __LINE__);
     
    10761076    if (pState->fUpdate)
    10771077    {
    1078         rc = RegCreateKeyExW(pState->hkeyClassesRootDst, L"AppID", 0 /*Reserved*/, NULL /*pszClass*/, 0 /*fOptions*/,
    1079                              pState->fSamBoth, NULL /*pSecAttr*/, &hkeyAppIds, NULL /*pdwDisposition*/);
    1080         if (rc == ERROR_ACCESS_DENIED)
     1078        lrc = RegCreateKeyExW(pState->hkeyClassesRootDst, L"AppID", 0 /*Reserved*/, NULL /*pszClass*/, 0 /*fOptions*/,
     1079                              pState->fSamBoth, NULL /*pSecAttr*/, &hkeyAppIds, NULL /*pdwDisposition*/);
     1080        if (lrc == ERROR_ACCESS_DENIED)
    10811081            return ERROR_SUCCESS;
    10821082    }
    10831083    else
    10841084    {
    1085         rc = RegOpenKeyExW(pState->hkeyClassesRootDst, L"AppID", 0 /*fOptions*/, pState->fSamBoth, &hkeyAppIds);
    1086         if (rc == ERROR_FILE_NOT_FOUND || rc == ERROR_ACCESS_DENIED)
     1085        lrc = RegOpenKeyExW(pState->hkeyClassesRootDst, L"AppID", 0 /*fOptions*/, pState->fSamBoth, &hkeyAppIds);
     1086        if (lrc == ERROR_FILE_NOT_FOUND || lrc == ERROR_ACCESS_DENIED)
    10871087            return ERROR_SUCCESS;
    10881088    }
    1089     if (rc == ERROR_ACCESS_DENIED)
    1090         return pState->rc = rc;
    1091     AssertLogRelMsgReturn(rc == ERROR_SUCCESS, ("%u\n", rc), pState->rc = rc);
     1089    if (lrc == ERROR_ACCESS_DENIED)
     1090        return pState->lrc = lrc;
     1091    AssertLogRelMsgReturn(lrc == ERROR_SUCCESS, ("%u\n", lrc), pState->lrc = lrc);
    10921092
    10931093    if (pState->fDelete)
     
    11031103    {
    11041104        HKEY hkey;
    1105         rc = vbpsCreateRegKeyA(pState, hkeyAppIds, pszAppId, &hkey, __LINE__);
    1106         if (rc == ERROR_SUCCESS)
     1105        lrc = vbpsCreateRegKeyA(pState, hkeyAppIds, pszAppId, &hkey, __LINE__);
     1106        if (lrc == ERROR_SUCCESS)
    11071107        {
    11081108            vbpsSetRegValueAA(pState, hkey, NULL /*pszValueNm*/, pszDescription, __LINE__);
     
    11121112        }
    11131113
    1114         rc = vbpsCreateRegKeyA(pState, hkeyAppIds, pszModuleName, &hkey, __LINE__);
    1115         if (rc == ERROR_SUCCESS)
     1114        lrc = vbpsCreateRegKeyA(pState, hkeyAppIds, pszModuleName, &hkey, __LINE__);
     1115        if (lrc == ERROR_SUCCESS)
    11161116        {
    11171117            vbpsSetRegValueAA(pState, hkey, NULL /*pszValueNm*/, "", __LINE__);
     
    11231123    vbpsCloseKey(pState, hkeyAppIds, __LINE__);
    11241124
    1125     return pState->rc;
     1125    return pState->lrc;
    11261126}
    11271127
     
    11421142                              const CLSID *pClsId, const char *pszCurVerSuffIfRootName)
    11431143{
    1144     LSTATUS rc;
     1144    LSTATUS lrc;
    11451145
    11461146    /*
     
    11621162        /* pszClassName/Default = description. */
    11631163        HKEY hkeyClass;
    1164         rc = vbpsCreateRegKeyWithDefaultValueAAEx(pState, pState->hkeyClassesRootDst, pszClassName, pszDescription,
    1165                                                   &hkeyClass, __LINE__);
    1166         if (rc == ERROR_SUCCESS)
     1164        lrc = vbpsCreateRegKeyWithDefaultValueAAEx(pState, pState->hkeyClassesRootDst, pszClassName, pszDescription,
     1165                                                   &hkeyClass, __LINE__);
     1166        if (lrc == ERROR_SUCCESS)
    11671167        {
    11681168            char szClsId[CURLY_UUID_STR_BUF_SIZE];
     
    11751175            {
    11761176                char szCurClassNameVer[128];
    1177                 rc = RTStrCopy(szCurClassNameVer, sizeof(szCurClassNameVer), pszClassName);
    1178                 if (RT_SUCCESS(rc))
    1179                     rc = RTStrCat(szCurClassNameVer, sizeof(szCurClassNameVer), pszCurVerSuffIfRootName);
    1180                 AssertStmt(RT_SUCCESS(rc), pState->rc = rc = ERROR_INVALID_DATA);
    1181                 if (rc == ERROR_SUCCESS)
     1177                lrc = RTStrCopy(szCurClassNameVer, sizeof(szCurClassNameVer), pszClassName);
     1178                if (RT_SUCCESS(lrc))
     1179                    lrc = RTStrCat(szCurClassNameVer, sizeof(szCurClassNameVer), pszCurVerSuffIfRootName);
     1180                AssertStmt(RT_SUCCESS(lrc), pState->lrc = lrc = ERROR_INVALID_DATA);
     1181                if (lrc == ERROR_SUCCESS)
    11821182                    vbpsCreateRegKeyWithDefaultValueAA(pState, hkeyClass, "CurVer", szCurClassNameVer, __LINE__);
    11831183            }
     
    11871187    }
    11881188
    1189     return pState->rc;
     1189    return pState->lrc;
    11901190}
    11911191
     
    12181218                            const char *pszThreadingModel)
    12191219{
    1220     LSTATUS rc;
     1220    LSTATUS lrc;
    12211221    char szClsId[CURLY_UUID_STR_BUF_SIZE];
    12221222    RT_NOREF(pszAppId);
     
    12481248    {
    12491249        HKEY hkeyClass;
    1250         rc = vbpsCreateRegKeyWithDefaultValueAAEx(pState, pState->hkeyClsidRootDst, szClsId, pszDescription,
    1251                                                   &hkeyClass, __LINE__);
    1252         if (rc == ERROR_SUCCESS)
     1250        lrc = vbpsCreateRegKeyWithDefaultValueAAEx(pState, pState->hkeyClsidRootDst, szClsId, pszDescription,
     1251                                                   &hkeyClass, __LINE__);
     1252        if (lrc == ERROR_SUCCESS)
    12531253        {
    12541254            bool const fIsLocalServer32 = strcmp(pszServerType, "LocalServer32") == 0;
     
    12571257
    12581258            /* pszServerType/Default = module. */
    1259             rc = vbpsCreateRegKeyA(pState, hkeyClass, pszServerType, &hkeyServerType, __LINE__);
    1260             if (rc == ERROR_SUCCESS)
     1259            lrc = vbpsCreateRegKeyA(pState, hkeyClass, pszServerType, &hkeyServerType, __LINE__);
     1260            if (lrc == ERROR_SUCCESS)
    12611261            {
    12621262                RTUTF16 wszModule[MAX_PATH * 2];
     
    12651265                    *pwszCur++ = '"';
    12661266
    1267                 rc = RTUtf16Copy(pwszCur, MAX_PATH, pwszVBoxDir); AssertRC(rc);
     1267                int vrc = RTUtf16Copy(pwszCur, MAX_PATH, pwszVBoxDir); AssertRC(vrc);
    12681268                pwszCur += RTUtf16Len(pwszCur);
    1269                 rc = RTUtf16CopyAscii(pwszCur, MAX_PATH - 3, pszServerSubPath); AssertRC(rc);
     1269                vrc = RTUtf16CopyAscii(pwszCur, MAX_PATH - 3, pszServerSubPath); AssertRC(vrc);
    12701270                pwszCur += RTUtf16Len(pwszCur);
    12711271
     
    12861286            if (pszClassName)
    12871287            {
    1288                 rc = RTStrCopy(szCurClassNameVer, sizeof(szCurClassNameVer), pszClassName);
    1289                 if (RT_SUCCESS(rc))
    1290                     rc = RTStrCat(szCurClassNameVer, sizeof(szCurClassNameVer), pszCurClassNameVerSuffix);
    1291                 AssertStmt(RT_SUCCESS(rc), pState->rc = rc = ERROR_INVALID_DATA);
    1292                 if (rc == ERROR_SUCCESS)
     1288                int vrc = RTStrCopy(szCurClassNameVer, sizeof(szCurClassNameVer), pszClassName);
     1289                if (RT_SUCCESS(vrc))
     1290                    vrc = RTStrCat(szCurClassNameVer, sizeof(szCurClassNameVer), pszCurClassNameVerSuffix);
     1291                AssertStmt(RT_SUCCESS(vrc), pState->lrc = lrc = ERROR_INVALID_DATA);
     1292                if (lrc == ERROR_SUCCESS)
    12931293                    vbpsCreateRegKeyWithDefaultValueAA(pState, hkeyClass, "ProgId", szCurClassNameVer, __LINE__);
    12941294
     
    13131313    }
    13141314
    1315     return pState->rc;
     1315    return pState->lrc;
    13161316}
    13171317
     
    13931393    HKEY hkeyTypeLibs;
    13941394    HKEY hkeyTypeLibId;
    1395     LSTATUS rc;
     1395    LSTATUS lrc;
    13961396    RT_NOREF(fIs32On64);
    13971397
     
    14031403
    14041404    /* Open Classes/TypeLib/. */
    1405     rc = vbpsCreateRegKeyA(pState, pState->hkeyClassesRootDst, "TypeLib", &hkeyTypeLibs, __LINE__);
    1406     if (rc != ERROR_SUCCESS)
     1405    lrc = vbpsCreateRegKeyA(pState, pState->hkeyClassesRootDst, "TypeLib", &hkeyTypeLibs, __LINE__);
     1406    if (lrc != ERROR_SUCCESS)
    14071407        return;
    14081408
    14091409    /* Create TypeLib/{UUID}. */
    1410     rc = vbpsCreateRegKeyA(pState, hkeyTypeLibs, vbpsFormatUuidInCurly(szTypeLibId, &LIBID_VirtualBox), &hkeyTypeLibId, __LINE__);
    1411     if (rc == ERROR_SUCCESS)
     1410    lrc = vbpsCreateRegKeyA(pState, hkeyTypeLibs, vbpsFormatUuidInCurly(szTypeLibId, &LIBID_VirtualBox), &hkeyTypeLibId, __LINE__);
     1411    if (lrc == ERROR_SUCCESS)
    14121412    {
    14131413        /* {UUID}/Major.Minor/Default = pszDescription. */
     
    14151415        char szMajMin[64];
    14161416        sprintf(szMajMin, "%u.%u", kTypeLibraryMajorVersion, kTypeLibraryMinorVersion);
    1417         rc = vbpsCreateRegKeyWithDefaultValueAAEx(pState, hkeyTypeLibId, szMajMin, pszDescription, &hkeyMajMin, __LINE__);
    1418         if (rc == ERROR_SUCCESS)
     1417        lrc = vbpsCreateRegKeyWithDefaultValueAAEx(pState, hkeyTypeLibId, szMajMin, pszDescription, &hkeyMajMin, __LINE__);
     1418        if (lrc == ERROR_SUCCESS)
    14191419        {
    14201420            RTUTF16 wszBuf[MAX_PATH * 2];
     
    14221422            /* {UUID}/Major.Minor/0. */
    14231423            HKEY hkey0;
    1424             rc = vbpsCreateRegKeyA(pState, hkeyMajMin, "0", &hkey0, __LINE__);
    1425             if (rc == ERROR_SUCCESS)
     1424            lrc = vbpsCreateRegKeyA(pState, hkeyMajMin, "0", &hkey0, __LINE__);
     1425            if (lrc == ERROR_SUCCESS)
    14261426            {
    14271427                /* {UUID}/Major.Minor/0/winXX/Default = VBoxProxyStub. */
    1428                 rc = RTUtf16Copy(wszBuf, MAX_PATH, pwszVBoxDir); AssertRC(rc);
    1429                 rc = RTUtf16CatAscii(wszBuf, MAX_PATH * 2, pszTypeLibDll); AssertRC(rc);
     1428                int vrc = RTUtf16Copy(wszBuf, MAX_PATH, pwszVBoxDir); AssertRC(vrc);
     1429                vrc = RTUtf16CatAscii(wszBuf, MAX_PATH * 2, pszTypeLibDll); AssertRC(vrc);
    14301430
    14311431                vbpsCreateRegKeyWithDefaultValueAW(pState, hkey0, pszWinXx, wszBuf, __LINE__);
     
    14371437
    14381438            /* {UUID}/Major.Minor/HELPDIR */
    1439             rc = RTUtf16Copy(wszBuf, MAX_PATH, pwszVBoxDir); AssertRC(rc);
     1439            int vrc = RTUtf16Copy(wszBuf, MAX_PATH, pwszVBoxDir); AssertRC(vrc);
    14401440#if 0 /* MSI: trailing slash;  regsvr32/comregister: strip unnecessary trailing slash.  Go with MSI to avoid user issues. */
    14411441            {
     
    14971497    const ProxyFileInfo **ppProxyFile = &g_apProxyFiles[0];
    14981498    const ProxyFileInfo  *pProxyFile;
    1499     LSTATUS               rc;
     1499    LSTATUS               lrc;
    15001500    char                  szProxyClsId[CURLY_UUID_STR_BUF_SIZE];
    15011501    char                  szTypeLibId[CURLY_UUID_STR_BUF_SIZE];
     
    15071507
    15081508    Assert(pState->fUpdate && !pState->fDelete);
    1509     rc = vbpsRegOpenInterfaceKeys(pState);
    1510     if (rc != ERROR_SUCCESS)
     1509    lrc = vbpsRegOpenInterfaceKeys(pState);
     1510    if (lrc != ERROR_SUCCESS)
    15111511        return;
    15121512
     
    15341534            HKEY                hkeyIfId;
    15351535
    1536             AssertReturnVoidStmt(cchIfNm >= 3 && cchIfNm <= 72, pState->rc = ERROR_INVALID_DATA);
    1537 
    1538             AssertReturnVoidStmt(cMethods >= 3 && cMethods < 1024, pState->rc = ERROR_INVALID_DATA);
     1536            AssertReturnVoidStmt(cchIfNm >= 3 && cchIfNm <= 72, pState->lrc = ERROR_INVALID_DATA);
     1537
     1538            AssertReturnVoidStmt(cMethods >= 3 && cMethods < 1024, pState->lrc = ERROR_INVALID_DATA);
    15391539            sprintf(szMethods, "%u", cMethods);
    15401540
    1541             rc = vbpsCreateRegKeyWithDefaultValueAAEx(pState, pState->hkeyInterfaceRootDst,
    1542                                                       vbpsFormatUuidInCurly(szIfId, papStubVtbls[iIf]->header.piid),
    1543                                                       pszIfNm, &hkeyIfId, __LINE__);
    1544             if (rc == ERROR_SUCCESS)
     1541            lrc = vbpsCreateRegKeyWithDefaultValueAAEx(pState, pState->hkeyInterfaceRootDst,
     1542                                                       vbpsFormatUuidInCurly(szIfId, papStubVtbls[iIf]->header.piid),
     1543                                                       pszIfNm, &hkeyIfId, __LINE__);
     1544            if (lrc == ERROR_SUCCESS)
    15451545            {
    15461546                HKEY hkeyTypeLib;
     
    15491549
    15501550                /* The MSI seems to still be putting TypeLib keys here. So, let's do that too. */
    1551                 rc = vbpsCreateRegKeyWithDefaultValueAAEx(pState, hkeyIfId, "TypeLib", szTypeLibId, &hkeyTypeLib, __LINE__);
    1552                 if (rc == ERROR_SUCCESS)
     1551                lrc = vbpsCreateRegKeyWithDefaultValueAAEx(pState, hkeyIfId, "TypeLib", szTypeLibId, &hkeyTypeLib, __LINE__);
     1552                if (lrc == ERROR_SUCCESS)
    15531553                {
    15541554                    vbpsSetRegValueAA(pState, hkeyTypeLib, "Version", szTypeLibVersion, __LINE__);
     
    16291629#endif
    16301630    VBPSREGSTATE    State;
    1631     LSTATUS         rc;
     1631    LSTATUS         lrc;
    16321632
    16331633    /*
    16341634     * Do registration for the current execution mode of the DLL.
    16351635     */
    1636     rc = vbpsRegInit(&State, HKEY_CLASSES_ROOT, NULL /* Alt: HKEY_LOCAL_MACHINE, "Software\\Classes", */, fDelete, fUpdate, 0);
    1637     if (rc == ERROR_SUCCESS)
     1636    lrc = vbpsRegInit(&State, HKEY_CLASSES_ROOT, NULL /* Alt: HKEY_LOCAL_MACHINE, "Software\\Classes", */, fDelete, fUpdate, 0);
     1637    if (lrc == ERROR_SUCCESS)
    16381638    {
    16391639        if (!fUpdate)
     
    16461646
    16471647        RegisterXidlModulesAndClassesGenerated(&State, pwszVBoxDir, fIs32On64);
    1648         rc = State.rc;
     1648        lrc = State.lrc;
    16491649    }
    16501650    vbpsRegTerm(&State);
     
    16531653     * Translate error code? Return.
    16541654     */
    1655     if (rc == ERROR_SUCCESS)
     1655    if (lrc == ERROR_SUCCESS)
    16561656        return S_OK;
    16571657    return E_FAIL;
     
    18801880         */
    18811881        HKEY hkeyInterfaces;
    1882         LRESULT rc = RegOpenKeyExW(pState->aAltDeletes[iAlt].hkeyClasses, L"Interface",
    1883                                    0 /*fOptions*/, pState->fSamDelete, &hkeyInterfaces);
    1884         if (rc == ERROR_SUCCESS)
     1882        LRESULT lrc = RegOpenKeyExW(pState->aAltDeletes[iAlt].hkeyClasses, L"Interface",
     1883                                    0 /*fOptions*/, pState->fSamDelete, &hkeyInterfaces);
     1884        if (lrc == ERROR_SUCCESS)
    18851885        {
    18861886            /*
     
    18931893                RTUTF16 wszCurNm[128 + 48];
    18941894                DWORD   cwcCurNm = 128;
    1895                 rc = RegEnumKeyExW(hkeyInterfaces, idxKey, wszCurNm, &cwcCurNm,
    1896                                    NULL /*pdwReserved*/, NULL /*pwszClass*/, NULL /*pcwcClass*/, NULL /*pLastWriteTime*/);
    1897                 if (rc == ERROR_SUCCESS)
     1895                lrc = RegEnumKeyExW(hkeyInterfaces, idxKey, wszCurNm, &cwcCurNm,
     1896                                    NULL /*pdwReserved*/, NULL /*pwszClass*/, NULL /*pcwcClass*/, NULL /*pLastWriteTime*/);
     1897                if (lrc == ERROR_SUCCESS)
    18981898                {
    18991899                    /*
     
    19181918                    /* Try the TypeLib sub-key. */
    19191919                    memcpy(&wszCurNm[cwcCurNm], s_wszTypeLib, sizeof(s_wszTypeLib));
    1920                     rc = RegOpenKeyExW(hkeyInterfaces, wszCurNm, 0 /*fOptions*/, KEY_QUERY_VALUE, &hkeySub);
    1921                     if (rc == ERROR_SUCCESS)
     1920                    lrc = RegOpenKeyExW(hkeyInterfaces, wszCurNm, 0 /*fOptions*/, KEY_QUERY_VALUE, &hkeySub);
     1921                    if (lrc == ERROR_SUCCESS)
    19221922                    {
    19231923                        cbValue = sizeof(wszValue) - sizeof(RTUTF16);
    1924                         rc = RegQueryValueExW(hkeySub, NULL /*pszValueNm*/, NULL /*pdwReserved*/,
    1925                                               &dwType, (PBYTE)&wszValue[0], &cbValue);
    1926                         if (rc != ERROR_SUCCESS || dwType != REG_SZ)
     1924                        lrc = RegQueryValueExW(hkeySub, NULL /*pszValueNm*/, NULL /*pdwReserved*/,
     1925                                               &dwType, (PBYTE)&wszValue[0], &cbValue);
     1926                        if (lrc != ERROR_SUCCESS || dwType != REG_SZ)
    19271927                            cbValue = 0;
    19281928                        wszValue[cbValue / sizeof(RTUTF16)] = '\0';
    19291929
    1930                         if (   rc == ERROR_SUCCESS
     1930                        if (   lrc == ERROR_SUCCESS
    19311931                            && vbpsIsTypeLibIdToRemove(wszValue))
    19321932                        {
    19331933                            /* Check the TypeLib/Version value to make sure. */
    19341934                            cbValue = sizeof(wszValue) - sizeof(RTUTF16);
    1935                             rc = RegQueryValueExW(hkeySub, L"Version", 0 /*pdwReserved*/, &dwType, (PBYTE)&wszValue[0], &cbValue);
    1936                             if (rc != ERROR_SUCCESS)
     1935                            lrc = RegQueryValueExW(hkeySub, L"Version", 0 /*pdwReserved*/, &dwType, (PBYTE)&wszValue[0], &cbValue);
     1936                            if (lrc != ERROR_SUCCESS)
    19371937                                cbValue = 0;
    19381938                            wszValue[cbValue] = '\0';
    19391939
    1940                             if (   rc == ERROR_SUCCESS
     1940                            if (   lrc == ERROR_SUCCESS
    19411941                                && vbpsIsTypeLibVersionToRemove(wszValue))
    19421942                                fDeleteMe = true;
     
    19441944                        vbpsCloseKey(pState, hkeySub, __LINE__);
    19451945                    }
    1946                     else if (rc == ERROR_FILE_NOT_FOUND)
     1946                    else if (lrc == ERROR_FILE_NOT_FOUND)
    19471947                    {
    19481948                        /* No TypeLib, try the ProxyStubClsid32 sub-key next. */
    19491949                        static RTUTF16 const    s_wszProxyStubClsid32[] = L"\\ProxyStubClsid32";
    19501950                        memcpy(&wszCurNm[cwcCurNm], s_wszProxyStubClsid32, sizeof(s_wszProxyStubClsid32));
    1951                         rc = RegOpenKeyExW(hkeyInterfaces, wszCurNm, 0 /*fOptions*/, KEY_QUERY_VALUE, &hkeySub);
    1952                         if (rc == ERROR_SUCCESS)
     1951                        lrc = RegOpenKeyExW(hkeyInterfaces, wszCurNm, 0 /*fOptions*/, KEY_QUERY_VALUE, &hkeySub);
     1952                        if (lrc == ERROR_SUCCESS)
    19531953                        {
    19541954                            cbValue = sizeof(wszValue) - sizeof(RTUTF16);
    1955                             rc = RegQueryValueExW(hkeySub, NULL /*pszValueNm*/, NULL /*pdwReserved*/,
    1956                                                   &dwType, (PBYTE)&wszValue[0], &cbValue);
    1957                             if (rc != ERROR_SUCCESS || dwType != REG_SZ)
     1955                            lrc = RegQueryValueExW(hkeySub, NULL /*pszValueNm*/, NULL /*pdwReserved*/,
     1956                                                   &dwType, (PBYTE)&wszValue[0], &cbValue);
     1957                            if (lrc != ERROR_SUCCESS || dwType != REG_SZ)
    19581958                                cbValue = 0;
    19591959                            wszValue[cbValue / sizeof(RTUTF16)] = '\0';
    19601960
    1961                             if (   rc == ERROR_SUCCESS
     1961                            if (   lrc == ERROR_SUCCESS
    19621962                                && vbpsIsProxyStubClsIdToRemove(wszValue))
    19631963                                fDeleteMe = true;
     
    19781978                else
    19791979                {
    1980                     Assert(rc == ERROR_NO_MORE_ITEMS);
     1980                    Assert(lrc == ERROR_NO_MORE_ITEMS);
    19811981                    break;
    19821982                }
     
    20042004         */
    20052005        HKEY hkeyClsIds;
    2006         LRESULT rc;
    2007         rc = RegOpenKeyExW(pState->aAltDeletes[iAlt].hkeyClasses, L"CLSID", 0 /*fOptions*/, pState->fSamDelete, &hkeyClsIds);
    2008         if (rc == ERROR_SUCCESS)
     2006        LRESULT lrc;
     2007        lrc = RegOpenKeyExW(pState->aAltDeletes[iAlt].hkeyClasses, L"CLSID", 0 /*fOptions*/, pState->fSamDelete, &hkeyClsIds);
     2008        if (lrc == ERROR_SUCCESS)
    20092009        {
    20102010            /*
     
    20172017                RTUTF16 wszCurNm[128 + 48];
    20182018                DWORD   cwcCurNm = 128;
    2019                 rc = RegEnumKeyExW(hkeyClsIds, idxKey, wszCurNm, &cwcCurNm,
    2020                                    NULL /*pdwReserved*/, NULL /*pwszClass*/, NULL /*pcwcClass*/, NULL /*pLastWriteTime*/);
    2021                 if (rc == ERROR_SUCCESS)
     2019                lrc = RegEnumKeyExW(hkeyClsIds, idxKey, wszCurNm, &cwcCurNm,
     2020                                    NULL /*pdwReserved*/, NULL /*pwszClass*/, NULL /*pcwcClass*/, NULL /*pLastWriteTime*/);
     2021                if (lrc == ERROR_SUCCESS)
    20222022                {
    20232023                    /*
     
    20392039                    /* The TypeLib sub-key. */
    20402040                    memcpy(&wszCurNm[cwcCurNm], s_wszTypeLib, sizeof(s_wszTypeLib));
    2041                     rc = RegOpenKeyExW(hkeyClsIds, wszCurNm, 0 /*fOptions*/, KEY_QUERY_VALUE, &hkeySub);
    2042                     if (rc == ERROR_SUCCESS)
     2041                    lrc = RegOpenKeyExW(hkeyClsIds, wszCurNm, 0 /*fOptions*/, KEY_QUERY_VALUE, &hkeySub);
     2042                    if (lrc == ERROR_SUCCESS)
    20432043                    {
    20442044                        bool fDeleteMe = false;
    20452045
    20462046                        cbValue = sizeof(wszValue) - sizeof(RTUTF16);
    2047                         rc = RegQueryValueExW(hkeySub, NULL /*pszValueNm*/, NULL /*pdwReserved*/,
    2048                                               &dwType, (PBYTE)&wszValue[0], &cbValue);
    2049                         if (rc != ERROR_SUCCESS || dwType != REG_SZ)
     2047                        lrc = RegQueryValueExW(hkeySub, NULL /*pszValueNm*/, NULL /*pdwReserved*/,
     2048                                               &dwType, (PBYTE)&wszValue[0], &cbValue);
     2049                        if (lrc != ERROR_SUCCESS || dwType != REG_SZ)
    20502050                            cbValue = 0;
    20512051                        wszValue[cbValue / sizeof(RTUTF16)] = '\0';
    20522052
    2053                         if (   rc == ERROR_SUCCESS
     2053                        if (   lrc == ERROR_SUCCESS
    20542054                            && vbpsIsTypeLibIdToRemove(wszValue))
    20552055                            fDeleteMe = true;
     
    20622062                            static RTUTF16 const    s_wszProgId[] = L"\\ProgId";
    20632063                            memcpy(&wszCurNm[cwcCurNm], s_wszProgId, sizeof(s_wszProgId));
    2064                             rc = RegOpenKeyExW(hkeyClsIds, wszCurNm, 0 /*fOptions*/, KEY_QUERY_VALUE, &hkeySub);
    2065                             if (rc == ERROR_SUCCESS)
     2064                            lrc = RegOpenKeyExW(hkeyClsIds, wszCurNm, 0 /*fOptions*/, KEY_QUERY_VALUE, &hkeySub);
     2065                            if (lrc == ERROR_SUCCESS)
    20662066                            {
    20672067                                static RTUTF16 const s_wszProgIdPrefix[] = L"VirtualBox.";
    20682068
    20692069                                cbValue = sizeof(wszValue) - sizeof(RTUTF16);
    2070                                 rc = RegQueryValueExW(hkeySub, NULL /*pszValueNm*/, NULL /*pdwReserved*/,
    2071                                                       &dwType, (PBYTE)&wszValue[0], &cbValue);
    2072                                 if (rc != ERROR_SUCCESS || dwType != REG_SZ)
     2070                                lrc = RegQueryValueExW(hkeySub, NULL /*pszValueNm*/, NULL /*pdwReserved*/,
     2071                                                       &dwType, (PBYTE)&wszValue[0], &cbValue);
     2072                                if (lrc != ERROR_SUCCESS || dwType != REG_SZ)
    20732073                                    cbValue = 0;
    20742074                                wszValue[cbValue / sizeof(RTUTF16)] = '\0';
     
    20812081                            }
    20822082                            else
    2083                                 AssertStmt(rc == ERROR_FILE_NOT_FOUND, fDeleteMe = false);
     2083                                AssertStmt(lrc == ERROR_FILE_NOT_FOUND, fDeleteMe = false);
    20842084
    20852085                            if (fDeleteMe)
     
    20942094                    }
    20952095                    else
    2096                         Assert(rc == ERROR_FILE_NOT_FOUND);
     2096                        Assert(lrc == ERROR_FILE_NOT_FOUND);
    20972097                }
    20982098                else
    20992099                {
    2100                     Assert(rc == ERROR_NO_MORE_ITEMS);
     2100                    Assert(lrc == ERROR_NO_MORE_ITEMS);
    21012101                    break;
    21022102                }
     
    21062106        }
    21072107        else
    2108             Assert(rc == ERROR_FILE_NOT_FOUND);
     2108            Assert(lrc == ERROR_FILE_NOT_FOUND);
    21092109    }
    21102110}
     
    21232123         */
    21242124        HKEY hkeyTypeLibs;
    2125         LSTATUS rc;
    2126         rc = RegOpenKeyExW(pState->aAltDeletes[iAlt].hkeyClasses, L"TypeLib", 0 /*fOptions*/, pState->fSamDelete, &hkeyTypeLibs);
    2127         if (rc == ERROR_SUCCESS)
     2125        LSTATUS lrc;
     2126        lrc = RegOpenKeyExW(pState->aAltDeletes[iAlt].hkeyClasses, L"TypeLib", 0 /*fOptions*/, pState->fSamDelete, &hkeyTypeLibs);
     2127        if (lrc == ERROR_SUCCESS)
    21282128        {
    21292129            /*
     
    21342134            {
    21352135                HKEY hkeyTypeLibId;
    2136                 rc = RegOpenKeyExW(hkeyTypeLibs, g_apwszTypeLibIds[iTlb], 0 /*fOptions*/, pState->fSamDelete, &hkeyTypeLibId);
    2137                 if (rc == ERROR_SUCCESS)
     2136                lrc = RegOpenKeyExW(hkeyTypeLibs, g_apwszTypeLibIds[iTlb], 0 /*fOptions*/, pState->fSamDelete, &hkeyTypeLibId);
     2137                if (lrc == ERROR_SUCCESS)
    21382138                {
    21392139                    unsigned iVer = RT_ELEMENTS(g_apwszTypelibVersions);
     
    21412141                    {
    21422142                        HKEY hkeyVer;
    2143                         rc = RegOpenKeyExW(hkeyTypeLibId, g_apwszTypelibVersions[iVer], 0, KEY_READ, &hkeyVer);
    2144                         if (rc == ERROR_SUCCESS)
     2143                        lrc = RegOpenKeyExW(hkeyTypeLibId, g_apwszTypelibVersions[iVer], 0, KEY_READ, &hkeyVer);
     2144                        if (lrc == ERROR_SUCCESS)
    21452145                        {
    21462146                            char szValue[128];
    21472147                            DWORD cbValue = sizeof(szValue) - 1;
    2148                             rc = RegQueryValueExA(hkeyVer, NULL, NULL, NULL, (PBYTE)&szValue[0], &cbValue);
     2148                            lrc = RegQueryValueExA(hkeyVer, NULL, NULL, NULL, (PBYTE)&szValue[0], &cbValue);
    21492149                            vbpsCloseKey(pState, hkeyVer, __LINE__);
    2150                             if (rc == ERROR_SUCCESS)
     2150                            if (lrc == ERROR_SUCCESS)
    21512151                            {
    21522152                                szValue[cbValue] = '\0';
     
    21672167                     * The type library ID key should be empty now, so we can try remove it (non-recursively).
    21682168                     */
    2169                     rc = RegDeleteKeyW(hkeyTypeLibs, g_apwszTypeLibIds[iTlb]);
    2170                     Assert(rc == ERROR_SUCCESS);
     2169                    lrc = RegDeleteKeyW(hkeyTypeLibs, g_apwszTypeLibIds[iTlb]);
     2170                    Assert(lrc == ERROR_SUCCESS);
    21712171                }
    21722172            }
    21732173        }
    21742174        else
    2175             Assert(rc == ERROR_FILE_NOT_FOUND);
     2175            Assert(lrc == ERROR_FILE_NOT_FOUND);
    21762176    }
    21772177}
     
    21882188     */
    21892189    VBPSREGSTATE State;
    2190     LRESULT rc = vbpsRegInit(&State, HKEY_CLASSES_ROOT, NULL, true /*fDelete*/, false /*fUpdate*/, fSamWow);
    2191     if (rc == ERROR_SUCCESS)
     2190    LRESULT lrc = vbpsRegInit(&State, HKEY_CLASSES_ROOT, NULL, true /*fDelete*/, false /*fUpdate*/, fSamWow);
     2191    if (lrc == ERROR_SUCCESS)
    21922192    {
    21932193        vbpsRegAddAltDelete(&State, HKEY_CURRENT_USER,  "Software\\Classes");
     
    23422342     */
    23432343    WCHAR wszFilePath[MAX_PATH + 2];
    2344     int rc = RTUtf16CopyAscii(wszFilePath, RT_ELEMENTS(wszFilePath), "\"");
    2345     if (RT_SUCCESS(rc))
    2346         rc = RTUtf16Cat(wszFilePath, RT_ELEMENTS(wszFilePath), pwszVBoxDir);
    2347     if (RT_SUCCESS(rc))
    2348         rc = RTUtf16Cat(wszFilePath, RT_ELEMENTS(wszFilePath), pwszModule);
    2349     if (RT_SUCCESS(rc))
    2350         rc = RTUtf16CatAscii(wszFilePath, RT_ELEMENTS(wszFilePath), "\"");
    2351     AssertLogRelRCReturnVoid(rc);
     2344    int vrc = RTUtf16CopyAscii(wszFilePath, RT_ELEMENTS(wszFilePath), "\"");
     2345    if (RT_SUCCESS(vrc))
     2346        vrc = RTUtf16Cat(wszFilePath, RT_ELEMENTS(wszFilePath), pwszVBoxDir);
     2347    if (RT_SUCCESS(vrc))
     2348        vrc = RTUtf16Cat(wszFilePath, RT_ELEMENTS(wszFilePath), pwszModule);
     2349    if (RT_SUCCESS(vrc))
     2350        vrc = RTUtf16CatAscii(wszFilePath, RT_ELEMENTS(wszFilePath), "\"");
     2351    AssertLogRelRCReturnVoid(vrc);
    23522352
    23532353    /*
     
    24632463            else
    24642464            {
    2465                 pState->rc = GetLastError();
    2466                 LogRel(("Failed to not open service %ls for stop+delete: %u\n", pwszServiceName, pState->rc));
     2465                pState->lrc = GetLastError();
     2466                LogRel(("Failed to not open service %ls for stop+delete: %u\n", pwszServiceName, pState->lrc));
    24672467                hService = OpenServiceW(hSCM, pwszServiceName, SERVICE_CHANGE_CONFIG);
    24682468            }
     
    25062506                else
    25072507                {
    2508                     pState->rc = GetLastError();
    2509                     AssertMsgFailed(("Failed to create service '%ls': %u\n", pwszServiceName, pState->rc));
     2508                    pState->lrc = GetLastError();
     2509                    AssertMsgFailed(("Failed to create service '%ls': %u\n", pwszServiceName, pState->lrc));
    25102510                }
    25112511                CloseServiceHandle(hSCM);
     
    25132513            else
    25142514            {
    2515                 pState->rc = GetLastError();
    2516                 LogRel(("Failed to open service manager with create service access: %u\n", pState->rc));
     2515                pState->lrc = GetLastError();
     2516                LogRel(("Failed to open service manager with create service access: %u\n", pState->lrc));
    25172517            }
    25182518        }
     
    25352535DECLEXPORT(uint32_t) VbpsUpdateRegistrations(void)
    25362536{
    2537     LSTATUS         rc;
     2537    LSTATUS         lrc;
    25382538    VBPSREGSTATE    State;
    25392539#ifdef VBOX_IN_32_ON_64_MAIN_API
     
    25572557     * Update registry entries for the current CPU bitness.
    25582558     */
    2559     rc = vbpsRegInit(&State, HKEY_CLASSES_ROOT, NULL, false /*fDelete*/, true /*fUpdate*/, 0);
    2560     if (rc == ERROR_SUCCESS && !vbpsIsUpToDate(&State))
     2559    lrc = vbpsRegInit(&State, HKEY_CLASSES_ROOT, NULL, false /*fDelete*/, true /*fUpdate*/, 0);
     2560    if (lrc == ERROR_SUCCESS && !vbpsIsUpToDate(&State))
    25612561    {
    25622562
     
    25702570        RegisterXidlModulesAndClassesGenerated(&State, wszVBoxDir, fIs32On64);
    25712571        vbpsMarkUpToDate(&State);
    2572         rc = State.rc;
     2572        lrc = State.lrc;
    25732573    }
    25742574    vbpsRegTerm(&State);
     
    25792579     * Update registry entries for the other CPU bitness.
    25802580     */
    2581     if (rc == ERROR_SUCCESS)
    2582     {
    2583         rc = vbpsRegInit(&State, HKEY_CLASSES_ROOT, NULL, false /*fDelete*/, true /*fUpdate*/,
    2584                          !fIs32On64 ? KEY_WOW64_32KEY : KEY_WOW64_64KEY);
    2585         if (rc == ERROR_SUCCESS && !vbpsIsUpToDate(&State))
     2581    if (lrc == ERROR_SUCCESS)
     2582    {
     2583        lrc = vbpsRegInit(&State, HKEY_CLASSES_ROOT, NULL, false /*fDelete*/, true /*fUpdate*/,
     2584                          !fIs32On64 ? KEY_WOW64_32KEY : KEY_WOW64_64KEY);
     2585        if (lrc == ERROR_SUCCESS && !vbpsIsUpToDate(&State))
    25862586        {
    25872587            vbpsUpdateTypeLibRegistration(&State, wszVBoxDir, !fIs32On64);
     
    25902590            RegisterXidlModulesAndClassesGenerated(&State, wszVBoxDir, !fIs32On64);
    25912591            vbpsMarkUpToDate(&State);
    2592             rc = State.rc;
     2592            lrc = State.lrc;
    25932593        }
    25942594        vbpsRegTerm(&State);
  • trunk/src/VBox/Main/webservice/split-soapC.cpp

    r98103 r98297  
    4444    if (pFileIn)
    4545    {
    46         int rc2 = fseek(pFileIn, 0, SEEK_END);
     46        int iRc2 = fseek(pFileIn, 0, SEEK_END);
    4747        long cbFileIn = ftell(pFileIn);
    48         int rc3 = fseek(pFileIn, 0, SEEK_SET);
    49         if (rc3 != -1 && rc2 != -1 && cbFileIn >= 0)
     48        int iRc3 = fseek(pFileIn, 0, SEEK_SET);
     49        if (iRc3 != -1 && iRc2 != -1 && cbFileIn >= 0)
    5050        {
    5151            char *pBuffer = (char *)malloc(cbFileIn + 1);
  • trunk/src/VBox/Main/webservice/vboxweb.cpp

    r98103 r98297  
    386386        m_soap->max_keep_alive = g_cMaxKeepAlive;
    387387
    388         int rc = RTThreadCreate(&m_pThread,
    389                                 fntWrapper,
    390                                 this,           // pvUser
    391                                 0,              // cbStack
    392                                 RTTHREADTYPE_MAIN_HEAVY_WORKER,
    393                                 0,
    394                                 m_strThread.c_str());
    395         if (RT_FAILURE(rc))
    396         {
    397             RTMsgError("Cannot start worker thread %d: %Rrc\n", u, rc);
     388        int vrc = RTThreadCreate(&m_pThread,
     389                                 fntWrapper,
     390                                 this,           // pvUser
     391                                 0,              // cbStack
     392                                 RTTHREADTYPE_MAIN_HEAVY_WORKER,
     393                                 0,
     394                                 m_strThread.c_str());
     395        if (RT_FAILURE(vrc))
     396        {
     397            RTMsgError("Cannot start worker thread %d: %Rrc\n", u, vrc);
    398398            exit(1);
    399399        }
     
    837837    for (int i = 0; i < num_locks; i++)
    838838    {
    839         int rc = RTCritSectInitEx(&g_pSSLMutexes[i], RTCRITSECT_FLAGS_NO_LOCK_VAL,
    840                                   NIL_RTLOCKVALCLASS, RTLOCKVAL_SUB_CLASS_NONE,
    841                                   "openssl-%d", i);
    842         if (RT_FAILURE(rc))
     839        int vrc = RTCritSectInitEx(&g_pSSLMutexes[i], RTCRITSECT_FLAGS_NO_LOCK_VAL,
     840                                   NIL_RTLOCKVALCLASS, RTLOCKVAL_SUB_CLASS_NONE,
     841                                   "openssl-%d", i);
     842        if (RT_FAILURE(vrc))
    843843        {
    844844            for ( ; i >= 0; i--)
     
    10761076{
    10771077    // initialize runtime
    1078     int rc = RTR3InitExe(argc, &argv, 0);
    1079     if (RT_FAILURE(rc))
    1080         return RTMsgInitFailure(rc);
     1078    int vrc = RTR3InitExe(argc, &argv, 0);
     1079    if (RT_FAILURE(vrc))
     1080        return RTMsgInitFailure(vrc);
    10811081#ifdef RT_OS_WINDOWS
    10821082    ATL::CComModule _Module; /* Required internally by ATL (constructor records instance in global variable). */
     
    11331133                    else
    11341134                    {
    1135                         int vrc = RTStrmOpen(ValueUnion.psz, "r", &StrmIn);
     1135                        vrc = RTStrmOpen(ValueUnion.psz, "r", &StrmIn);
    11361136                        if (RT_FAILURE(vrc))
    11371137                            return RTMsgErrorExit(RTEXITCODE_FAILURE, "failed to open password file (%s, %Rrc)", ValueUnion.psz, vrc);
    11381138                    }
    11391139                    char szPasswd[512];
    1140                     int vrc = RTStrmGetLine(StrmIn, szPasswd, sizeof(szPasswd));
     1140                    vrc = RTStrmGetLine(StrmIn, szPasswd, sizeof(szPasswd));
    11411141                    if (RT_FAILURE(vrc))
    11421142                        return RTMsgErrorExit(RTEXITCODE_FAILURE, "failed to read password (%s, %Rrc)", ValueUnion.psz, vrc);
     
    12231223
    12241224            default:
    1225                 rc = RTGetOptPrintError(c, &ValueUnion);
    1226                 return rc;
     1225                return RTGetOptPrintError(c, &ValueUnion);
    12271226        }
    12281227    }
     
    12301229    /* create release logger, to stdout */
    12311230    RTERRINFOSTATIC ErrInfo;
    1232     rc = com::VBoxLogRelCreate("web service", g_fDaemonize ? NULL : pszLogFile,
    1233                                RTLOGFLAGS_PREFIX_THREAD | RTLOGFLAGS_PREFIX_TIME_PROG,
    1234                                "all", "VBOXWEBSRV_RELEASE_LOG",
    1235                                RTLOGDEST_STDOUT, UINT32_MAX /* cMaxEntriesPerGroup */,
    1236                                g_cHistory, g_uHistoryFileTime, g_uHistoryFileSize,
    1237                                RTErrInfoInitStatic(&ErrInfo));
    1238     if (RT_FAILURE(rc))
    1239         return RTMsgErrorExit(RTEXITCODE_FAILURE, "failed to open release log (%s, %Rrc)", ErrInfo.Core.pszMsg, rc);
     1231    vrc = com::VBoxLogRelCreate("web service", g_fDaemonize ? NULL : pszLogFile,
     1232                                RTLOGFLAGS_PREFIX_THREAD | RTLOGFLAGS_PREFIX_TIME_PROG,
     1233                                "all", "VBOXWEBSRV_RELEASE_LOG",
     1234                                RTLOGDEST_STDOUT, UINT32_MAX /* cMaxEntriesPerGroup */,
     1235                                g_cHistory, g_uHistoryFileTime, g_uHistoryFileSize,
     1236                                RTErrInfoInitStatic(&ErrInfo));
     1237    if (RT_FAILURE(vrc))
     1238        return RTMsgErrorExit(RTEXITCODE_FAILURE, "failed to open release log (%s, %Rrc)", ErrInfo.Core.pszMsg, vrc);
    12401239
    12411240#if defined(RT_OS_DARWIN) || defined(RT_OS_LINUX) || defined (RT_OS_SOLARIS) || defined(RT_OS_FREEBSD)
     
    12471246        if (!pszLogFile || !*pszLogFile)
    12481247        {
    1249             rc = com::GetVBoxUserHomeDirectory(szLogFile, sizeof(szLogFile));
    1250             if (RT_FAILURE(rc))
    1251                  return RTMsgErrorExit(RTEXITCODE_FAILURE, "could not get base directory for logging: %Rrc", rc);
    1252             rc = RTPathAppend(szLogFile, sizeof(szLogFile), "vboxwebsrv.log");
    1253             if (RT_FAILURE(rc))
    1254                  return RTMsgErrorExit(RTEXITCODE_FAILURE, "could not construct logging path: %Rrc", rc);
     1248            vrc = com::GetVBoxUserHomeDirectory(szLogFile, sizeof(szLogFile));
     1249            if (RT_FAILURE(vrc))
     1250                 return RTMsgErrorExit(RTEXITCODE_FAILURE, "could not get base directory for logging: %Rrc", vrc);
     1251            vrc = RTPathAppend(szLogFile, sizeof(szLogFile), "vboxwebsrv.log");
     1252            if (RT_FAILURE(vrc))
     1253                 return RTMsgErrorExit(RTEXITCODE_FAILURE, "could not construct logging path: %Rrc", vrc);
    12551254            pszLogFile = szLogFile;
    12561255        }
    12571256
    1258         rc = RTProcDaemonizeUsingFork(false /* fNoChDir */, false /* fNoClose */, pszPidFile);
    1259         if (RT_FAILURE(rc))
    1260             return RTMsgErrorExit(RTEXITCODE_FAILURE, "failed to daemonize, rc=%Rrc. exiting.", rc);
     1257        vrc = RTProcDaemonizeUsingFork(false /* fNoChDir */, false /* fNoClose */, pszPidFile);
     1258        if (RT_FAILURE(vrc))
     1259            return RTMsgErrorExit(RTEXITCODE_FAILURE, "failed to daemonize, vrc=%Rrc. exiting.", vrc);
    12611260
    12621261        /* create release logger, to file */
    1263         rc = com::VBoxLogRelCreate("web service", pszLogFile,
    1264                                    RTLOGFLAGS_PREFIX_THREAD | RTLOGFLAGS_PREFIX_TIME_PROG,
    1265                                    "all", "VBOXWEBSRV_RELEASE_LOG",
    1266                                    RTLOGDEST_FILE, UINT32_MAX /* cMaxEntriesPerGroup */,
    1267                                    g_cHistory, g_uHistoryFileTime, g_uHistoryFileSize,
    1268                                    RTErrInfoInitStatic(&ErrInfo));
    1269         if (RT_FAILURE(rc))
    1270             return RTMsgErrorExit(RTEXITCODE_FAILURE, "failed to open release log (%s, %Rrc)", ErrInfo.Core.pszMsg, rc);
     1262        vrc = com::VBoxLogRelCreate("web service", pszLogFile,
     1263                                    RTLOGFLAGS_PREFIX_THREAD | RTLOGFLAGS_PREFIX_TIME_PROG,
     1264                                    "all", "VBOXWEBSRV_RELEASE_LOG",
     1265                                    RTLOGDEST_FILE, UINT32_MAX /* cMaxEntriesPerGroup */,
     1266                                    g_cHistory, g_uHistoryFileTime, g_uHistoryFileSize,
     1267                                    RTErrInfoInitStatic(&ErrInfo));
     1268        if (RT_FAILURE(vrc))
     1269            return RTMsgErrorExit(RTEXITCODE_FAILURE, "failed to open release log (%s, %Rrc)", ErrInfo.Core.pszMsg, vrc);
    12711270    }
    12721271#endif
     
    13101309    if (FAILED(hrc))
    13111310    {
    1312         RTMsgError("Failed to get VirtualBox object (rc=%Rhrc)!", hrc);
     1311        RTMsgError("Failed to get VirtualBox object (hrc=%Rhrc)!", hrc);
    13131312        return RTEXITCODE_FAILURE;
    13141313    }
     
    13451344    // SOAP queue pumper thread
    13461345    RTTHREAD threadQPumper;
    1347     rc = RTThreadCreate(&threadQPumper,
    1348                         fntQPumper,
    1349                         NULL,        // pvUser
    1350                         0,           // cbStack (default)
    1351                         RTTHREADTYPE_MAIN_WORKER,
    1352                         RTTHREADFLAGS_WAITABLE,
    1353                         "SQPmp");
    1354     if (RT_FAILURE(rc))
    1355         return RTMsgErrorExit(RTEXITCODE_FAILURE, "Cannot start SOAP queue pumper thread: %Rrc", rc);
     1346    vrc = RTThreadCreate(&threadQPumper,
     1347                         fntQPumper,
     1348                         NULL,        // pvUser
     1349                         0,           // cbStack (default)
     1350                         RTTHREADTYPE_MAIN_WORKER,
     1351                         RTTHREADFLAGS_WAITABLE,
     1352                         "SQPmp");
     1353    if (RT_FAILURE(vrc))
     1354        return RTMsgErrorExit(RTEXITCODE_FAILURE, "Cannot start SOAP queue pumper thread: %Rrc", vrc);
    13561355
    13571356    // watchdog thread
     
    13601359    {
    13611360        // start our watchdog thread
    1362         rc = RTThreadCreate(&threadWatchdog,
    1363                             fntWatchdog,
    1364                             NULL,
    1365                             0,
    1366                             RTTHREADTYPE_MAIN_WORKER,
    1367                             RTTHREADFLAGS_WAITABLE,
    1368                             "Watchdog");
    1369         if (RT_FAILURE(rc))
    1370             return RTMsgErrorExit(RTEXITCODE_FAILURE, "Cannot start watchdog thread: %Rrc", rc);
     1361        vrc = RTThreadCreate(&threadWatchdog,
     1362                             fntWatchdog,
     1363                             NULL,
     1364                             0,
     1365                             RTTHREADTYPE_MAIN_WORKER,
     1366                             RTTHREADFLAGS_WAITABLE,
     1367                             "Watchdog");
     1368        if (RT_FAILURE(vrc))
     1369            return RTMsgErrorExit(RTEXITCODE_FAILURE, "Cannot start watchdog thread: %Rrc", vrc);
    13711370    }
    13721371
     
    13741373    if (!SetConsoleCtrlHandler((PHANDLER_ROUTINE)websrvSignalHandler, TRUE /* Add handler */))
    13751374    {
    1376         rc = RTErrConvertFromWin32(GetLastError());
    1377         RTMsgError("Unable to install console control handler, rc=%Rrc\n", rc);
     1375        vrc = RTErrConvertFromWin32(GetLastError());
     1376        RTMsgError("Unable to install console control handler, vrc=%Rrc\n", vrc);
    13781377    }
    13791378#else
     
    13901389        // we have to process main event queue
    13911390        WEBDEBUG(("Pumping COM event queue\n"));
    1392         rc = pQ->processEventQueue(RT_INDEFINITE_WAIT);
    1393         if (RT_FAILURE(rc))
    1394             RTMsgError("processEventQueue -> %Rrc", rc);
     1391        vrc = pQ->processEventQueue(RT_INDEFINITE_WAIT);
     1392        if (RT_FAILURE(vrc))
     1393            RTMsgError("processEventQueue -> %Rrc", vrc);
    13951394    }
    13961395
     
    14001399    if (!SetConsoleCtrlHandler((PHANDLER_ROUTINE)websrvSignalHandler, FALSE /* Remove handler */))
    14011400    {
    1402         rc = RTErrConvertFromWin32(GetLastError());
    1403         RTMsgError("Unable to remove console control handler, rc=%Rrc\n", rc);
     1401        vrc = RTErrConvertFromWin32(GetLastError());
     1402        RTMsgError("Unable to remove console control handler, vrc=%Rrc\n", vrc);
    14041403    }
    14051404#else
     
    16541653
    16551654    aStr.reserve(cchOut+1);
    1656     int rc = RTBase64Encode(sfaData.raw(), cbData,
    1657                             aStr.mutableRaw(), aStr.capacity(),
    1658                             NULL);
    1659     AssertRC(rc);
     1655    int vrc = RTBase64Encode(sfaData.raw(), cbData, aStr.mutableRaw(), aStr.capacity(), NULL);
     1656    AssertRC(vrc);
    16601657    aStr.jolt();
    16611658
     
    16761673
    16771674    com::SafeArray<BYTE> result(cbOut);
    1678     int rc = RTBase64Decode(pszStr, result.raw(), cbOut, NULL, NULL);
    1679     if (FAILED(rc))
    1680     {
    1681         LogRel(("String Decoding Failed. Error code: %Rrc\n", rc));
     1675    int vrc = RTBase64Decode(pszStr, result.raw(), cbOut, NULL, NULL);
     1676    if (FAILED(vrc))
     1677    {
     1678        LogRel(("String Decoding Failed. Error code: %Rrc\n", vrc));
    16821679        RaiseSoapRuntimeFault(soap, idThis, pszMethodName, E_INVALIDARG, pObj, iid);
    16831680    }
     
    17231720
    17241721    // compose descriptive message
    1725     com::Utf8Str str = com::Utf8StrFmt("VirtualBox error: rc=%#lx", apirc);
     1722    com::Utf8StrFmt str("VirtualBox error: apirc=%#lx", apirc);
    17261723    if (info.isFullAvailable() || info.isBasicAvailable())
    17271724    {
     
    18751872                                    IVirtualBox **ppVirtualBox)
    18761873{
    1877     int rc = VERR_WEB_NOT_AUTHENTICATED;
     1874    int vrc = VERR_WEB_NOT_AUTHENTICATED;
    18781875    ComPtr<IVirtualBox> pVirtualBox;
    18791876    {
     
    18821879    }
    18831880    if (pVirtualBox.isNull())
    1884         return rc;
     1881        return vrc;
    18851882    pVirtualBox.queryInterfaceTo(ppVirtualBox);
    18861883
     
    19131910            {
    19141911                if (RTPathHavePath(filename.c_str()))
    1915                     rc = RTLdrLoad(filename.c_str(), &hlibAuth);
     1912                    vrc = RTLdrLoad(filename.c_str(), &hlibAuth);
    19161913                else
    1917                     rc = RTLdrLoadAppPriv(filename.c_str(), &hlibAuth);
    1918 
    1919                 if (RT_FAILURE(rc))
     1914                    vrc = RTLdrLoadAppPriv(filename.c_str(), &hlibAuth);
     1915                if (RT_FAILURE(vrc))
    19201916                {
    19211917                    WEBDEBUG(("%s() Failed to load external authentication library '%s'. Error code: %Rrc\n",
    1922                               __FUNCTION__, filename.c_str(), rc));
     1918                              __FUNCTION__, filename.c_str(), vrc));
    19231919                    break;
    19241920                }
    19251921
    1926                 if (RT_FAILURE(rc = RTLdrGetSymbol(hlibAuth, AUTHENTRY3_NAME, (void**)&pfnAuthEntry3)))
     1922                if (RT_FAILURE(vrc = RTLdrGetSymbol(hlibAuth, AUTHENTRY3_NAME, (void**)&pfnAuthEntry3)))
    19271923                {
    19281924                    WEBDEBUG(("%s(): Could not resolve import '%s'. Error code: %Rrc\n",
    1929                               __FUNCTION__, AUTHENTRY3_NAME, rc));
    1930 
    1931                     if (RT_FAILURE(rc = RTLdrGetSymbol(hlibAuth, AUTHENTRY2_NAME, (void**)&pfnAuthEntry2)))
     1925                              __FUNCTION__, AUTHENTRY3_NAME, vrc));
     1926
     1927                    if (RT_FAILURE(vrc = RTLdrGetSymbol(hlibAuth, AUTHENTRY2_NAME, (void**)&pfnAuthEntry2)))
    19321928                    {
    19331929                        WEBDEBUG(("%s(): Could not resolve import '%s'. Error code: %Rrc\n",
    1934                                   __FUNCTION__, AUTHENTRY2_NAME, rc));
    1935 
    1936                         if (RT_FAILURE(rc = RTLdrGetSymbol(hlibAuth, AUTHENTRY_NAME, (void**)&pfnAuthEntry)))
     1930                                  __FUNCTION__, AUTHENTRY2_NAME, vrc));
     1931
     1932                        if (RT_FAILURE(vrc = RTLdrGetSymbol(hlibAuth, AUTHENTRY_NAME, (void**)&pfnAuthEntry)))
    19371933                            WEBDEBUG(("%s(): Could not resolve import '%s'. Error code: %Rrc\n",
    1938                                       __FUNCTION__, AUTHENTRY_NAME, rc));
     1934                                      __FUNCTION__, AUTHENTRY_NAME, vrc));
    19391935                    }
    19401936                }
     
    19501946    {
    19511947        LogRel(("Access denied, excessive username length: %zu\n", strlen(pcszUsername)));
    1952         rc = VERR_WEB_NOT_AUTHENTICATED;
     1948        vrc = VERR_WEB_NOT_AUTHENTICATED;
    19531949    }
    19541950    else if (strlen(pcszPassword) >= _1K)
    19551951    {
    19561952        LogRel(("Access denied, excessive password length: %zu\n", strlen(pcszPassword)));
    1957         rc = VERR_WEB_NOT_AUTHENTICATED;
     1953        vrc = VERR_WEB_NOT_AUTHENTICATED;
    19581954    }
    19591955    else if (pfnAuthEntry3 || pfnAuthEntry2 || pfnAuthEntry)
     
    19811977        {
    19821978            LogRel(("Access for user '%s' granted\n", pcszUsername));
    1983             rc = VINF_SUCCESS;
     1979            vrc = VINF_SUCCESS;
    19841980        }
    19851981        else
     
    19871983            if (result == AuthResultAccessDenied)
    19881984                LogRel(("Access for user '%s' denied\n", pcszUsername));
    1989             rc = VERR_WEB_NOT_AUTHENTICATED;
     1985            vrc = VERR_WEB_NOT_AUTHENTICATED;
    19901986        }
    19911987    }
     
    19941990        // fAuthLibLoaded = true but all pointers are NULL:
    19951991        // The authlib was "null" and auth was disabled
    1996         rc = VINF_SUCCESS;
     1992        vrc = VINF_SUCCESS;
    19971993    }
    19981994    else
    19991995    {
    20001996        WEBDEBUG(("Could not resolve AuthEntry, VRDPAuth2 or VRDPAuth entry point"));
    2001         rc = VERR_WEB_NOT_AUTHENTICATED;
     1997        vrc = VERR_WEB_NOT_AUTHENTICATED;
    20021998    }
    20031999
    20042000    lock.release();
    20052001
    2006     return rc;
     2002    return vrc;
    20072003}
    20082004
     
    22322228                                    bool fNullAllowed)
    22332229{
    2234     int rc = 0;
     2230    int vrc = VINF_SUCCESS;
    22352231
    22362232    do
     
    22502246                                   &objId))
    22512247        {
    2252             rc = VERR_WEB_INVALID_MANAGED_OBJECT_REFERENCE;
     2248            vrc = VERR_WEB_INVALID_MANAGED_OBJECT_REFERENCE;
    22532249            break;
    22542250        }
     
    22582254        {
    22592255            WEBDEBUG(("   %s: cannot find websession for objref %s\n", __FUNCTION__, id.c_str()));
    2260             rc = VERR_WEB_INVALID_SESSION_ID;
     2256            vrc = VERR_WEB_INVALID_SESSION_ID;
    22612257            break;
    22622258        }
     
    22702266        {
    22712267            WEBDEBUG(("   %s: cannot find comobj for objref %s\n", __FUNCTION__, id.c_str()));
    2272             rc = VERR_WEB_INVALID_OBJECT_ID;
     2268            vrc = VERR_WEB_INVALID_OBJECT_ID;
    22732269            break;
    22742270        }
     
    22782274    } while (0);
    22792275
    2280     return rc;
     2276    return vrc;
    22812277}
    22822278
     
    23042300{
    23052301    RT_NOREF(soap);
    2306     HRESULT rc = S_OK;
     2302    HRESULT hrc = S_OK; /** @todo r=bird: hrc is not set.... */
    23072303    WEBDEBUG(("-- entering %s\n", __FUNCTION__));
    23082304
     
    23182314    } while (0);
    23192315
    2320     WEBDEBUG(("-- leaving %s, rc: %#lx\n", __FUNCTION__, rc));
    2321     if (FAILED(rc))
     2316    WEBDEBUG(("-- leaving %s, hrc: %#lx\n", __FUNCTION__, hrc));
     2317    if (FAILED(hrc))
    23222318        return SOAP_FAULT;
    23232319    return SOAP_OK;
     
    23402336{
    23412337    RT_NOREF(resp);
    2342     HRESULT rc;
     2338    HRESULT hrc;
    23432339    WEBDEBUG(("-- entering %s\n", __FUNCTION__));
    23442340
     
    23482344
    23492345        ManagedObjectRef *pRef;
    2350         rc = ManagedObjectRef::findRefFromId(req->_USCOREthis, &pRef, false);
    2351         if (rc == S_OK)
     2346        hrc = ManagedObjectRef::findRefFromId(req->_USCOREthis, &pRef, false);
     2347        if (hrc == S_OK)
    23522348        {
    23532349            WEBDEBUG(("   found reference; deleting!\n"));
     
    23622358    }
    23632359
    2364     WEBDEBUG(("-- leaving %s, rc: %#lx\n", __FUNCTION__, rc));
    2365     if (FAILED(rc))
     2360    WEBDEBUG(("-- leaving %s, hrc: %#lx\n", __FUNCTION__, hrc));
     2361    if (FAILED(hrc))
    23662362        return SOAP_FAULT;
    23672363    return SOAP_OK;
     
    24052401{
    24062402    RT_NOREF(soap);
    2407     HRESULT rc = S_OK;
     2403    HRESULT hrc = S_OK;
    24082404    WEBDEBUG(("-- entering %s\n", __FUNCTION__));
    24092405
     
    24362432        }
    24372433        else
    2438             rc = E_FAIL;
     2434            hrc = E_FAIL;
    24392435    } while (0);
    24402436
    2441     WEBDEBUG(("-- leaving %s, rc: %#lx\n", __FUNCTION__, rc));
    2442     if (FAILED(rc))
     2437    WEBDEBUG(("-- leaving %s, hrc: %#lx\n", __FUNCTION__, hrc));
     2438    if (FAILED(hrc))
    24432439        return SOAP_FAULT;
    24442440    return SOAP_OK;
     
    24562452        _vbox__IWebsessionManager_USCOREgetSessionObjectResponse *resp)
    24572453{
    2458     HRESULT rc = S_OK;
     2454    HRESULT hrc = S_OK;
    24592455    WEBDEBUG(("-- entering %s\n", __FUNCTION__));
    24602456
     
    24632459        // create a new ISession object
    24642460        ComPtr<ISession> pSession;
    2465         rc = g_pVirtualBoxClient->COMGETTER(Session)(pSession.asOutParam());
    2466         if (FAILED(rc))
     2461        hrc = g_pVirtualBoxClient->COMGETTER(Session)(pSession.asOutParam());
     2462        if (FAILED(hrc))
    24672463        {
    24682464            WEBDEBUG(("ERROR: cannot create session object!"));
     
    24752471    } while (0);
    24762472
    2477     WEBDEBUG(("-- leaving %s, rc: %#lx\n", __FUNCTION__, rc));
    2478     if (FAILED(rc))
     2473    WEBDEBUG(("-- leaving %s, hrc: %#lx\n", __FUNCTION__, hrc));
     2474    if (FAILED(hrc))
    24792475        return SOAP_FAULT;
    24802476    return SOAP_OK;
     
    24942490{
    24952491    RT_NOREF(resp);
    2496     HRESULT rc = S_OK;
     2492    HRESULT hrc = S_OK;
    24972493    WEBDEBUG(("-- entering %s\n", __FUNCTION__));
    24982494
     
    25122508    }
    25132509
    2514     WEBDEBUG(("-- leaving %s, rc: %#lx\n", __FUNCTION__, rc));
    2515     if (FAILED(rc))
     2510    WEBDEBUG(("-- leaving %s, hrc: %#lx\n", __FUNCTION__, hrc));
     2511    if (FAILED(hrc))
    25162512        return SOAP_FAULT;
    25172513    return SOAP_OK;
  • trunk/src/VBox/Main/webservice/vboxweb.h

    r98103 r98297  
    275275    util::AutoWriteLock lock(g_pWebsessionsLockHandle COMMA_LOCKVAL_SRC_POS);
    276276
    277     int rc;
    278277    ManagedObjectRef *pRef;
    279     if ((rc = ManagedObjectRef::findRefFromId(id, &pRef, fNullAllowed)))
     278    int vrc = ManagedObjectRef::findRefFromId(id, &pRef, fNullAllowed);
     279    if (vrc != VINF_SUCCESS)
    280280        // error:
    281281        RaiseSoapInvalidObjectFault(soap, id);
     
    286286            WEBDEBUG(("   %s(): returning NULL object as permitted\n", __FUNCTION__));
    287287            pComPtr.setNull();
    288             return 0;
     288            return VINF_SUCCESS;
    289289        }
    290290
     
    301301            WEBDEBUG(("   %s(): returning original %s*=0x%lX (IUnknown*=0x%lX)\n", __FUNCTION__, pRef->getInterfaceName(), pobjInterface, pobjUnknown));
    302302            pComPtr = (T*)pobjInterface;        // this calls AddRef() once
    303             return 0;
     303            return VINF_SUCCESS;
    304304        }
    305305
     
    312312            WEBDEBUG(("   %s(): returning pointer 0x%lX for queried interface %RTuuid (IUnknown*=0x%lX)\n", __FUNCTION__, pT, guidCaller.raw(), pobjUnknown));
    313313            *(pComPtr.asOutParam()) = pT;
    314             return 0;
     314            return VINF_SUCCESS;
    315315        }
    316316
    317317        WEBDEBUG(("    Interface not supported for object reference %s, which is of class %s\n", id.c_str(), pRef->getInterfaceName()));
    318         rc = VERR_WEB_UNSUPPORTED_INTERFACE;
     318        vrc = VERR_WEB_UNSUPPORTED_INTERFACE;
    319319        RaiseSoapInvalidObjectFault(soap, id);      // @todo better message
    320320    }
    321321
    322     return rc;
     322    return vrc;
    323323}
    324324
  • trunk/src/VBox/Main/webservice/webtest.cpp

    r98103 r98297  
    9494
    9595    /* SSL callbacks drag in IPRT sem/thread use, so make sure it is ready. */
    96     int rc = RTR3InitExe(argc, &argv, 0);
    97     if (RT_FAILURE(rc))
    98         return RTMsgInitFailure(rc);
     96    int vrc = RTR3InitExe(argc, &argv, 0);
     97    if (RT_FAILURE(vrc))
     98        return RTMsgInitFailure(vrc);
    9999
    100100    int ap;
  • trunk/src/VBox/Main/xml/Settings.cpp

    r98103 r98297  
    497497           )
    498498        {
    499             int rc;
    500             if (    (RT_SUCCESS(rc = RTStrToInt32Ex(pcsz, NULL, 0, &yyyy)))
     499            int vrc;
     500            if (    (RT_SUCCESS(vrc = RTStrToInt32Ex(pcsz, NULL, 0, &yyyy)))
    501501                        // could theoretically be negative but let's assume that nobody
    502502                        // created virtual machines before the Christian era
    503                  && (RT_SUCCESS(rc = RTStrToUInt32Ex(pcsz + 5, NULL, 0, &mm)))
    504                  && (RT_SUCCESS(rc = RTStrToUInt32Ex(pcsz + 8, NULL, 0, &dd)))
    505                  && (RT_SUCCESS(rc = RTStrToUInt32Ex(pcsz + 11, NULL, 0, &hh)))
    506                  && (RT_SUCCESS(rc = RTStrToUInt32Ex(pcsz + 14, NULL, 0, &min)))
    507                  && (RT_SUCCESS(rc = RTStrToUInt32Ex(pcsz + 17, NULL, 0, &secs)))
     503                 && (RT_SUCCESS(vrc = RTStrToUInt32Ex(pcsz + 5, NULL, 0, &mm)))
     504                 && (RT_SUCCESS(vrc = RTStrToUInt32Ex(pcsz + 8, NULL, 0, &dd)))
     505                 && (RT_SUCCESS(vrc = RTStrToUInt32Ex(pcsz + 11, NULL, 0, &hh)))
     506                 && (RT_SUCCESS(vrc = RTStrToUInt32Ex(pcsz + 14, NULL, 0, &min)))
     507                 && (RT_SUCCESS(vrc = RTStrToUInt32Ex(pcsz + 17, NULL, 0, &secs)))
    508508               )
    509509            {
     
    527527            }
    528528
    529             throw ConfigFileError(this, pElm, N_("Cannot parse ISO timestamp '%s': runtime error, %Rra"), str.c_str(), rc);
     529            throw ConfigFileError(this, pElm, N_("Cannot parse ISO timestamp '%s': runtime error, %Rra"), str.c_str(), vrc);
    530530        }
    531531
     
    22742274                    if (pszEnd)
    22752275                    {
    2276                         int rc = RTStrToUInt16Ex(RTStrStripL(pszEnd + 1), NULL, 10, &uPort);
    2277                         if (RT_FAILURE(rc))
     2276                        int vrc = RTStrToUInt16Ex(RTStrStripL(pszEnd + 1), NULL, 10, &uPort);
     2277                        if (RT_FAILURE(vrc))
    22782278                            uPort = 1080;
    22792279                    }
    22802280                    RTURIPARSED Parsed;
    2281                     int rc = RTUriParse(systemProperties.strProxyUrl.c_str(), &Parsed);
    2282                     if (RT_SUCCESS(rc))
     2281                    int vrc = RTUriParse(systemProperties.strProxyUrl.c_str(), &Parsed);
     2282                    if (RT_SUCCESS(vrc))
    22832283                    {
    22842284                        if (Parsed.uAuthorityPort == UINT32_MAX)
     
    50105010         * placing it to local cache. */
    50115011
    5012         int rc = GuestPropValidateName(prop.strName.c_str(), prop.strName.length() + 1  /* '\0' */);
    5013         if (RT_FAILURE(rc))
     5012        int vrc = GuestPropValidateName(prop.strName.c_str(), prop.strName.length() + 1  /* '\0' */);
     5013        if (RT_FAILURE(vrc))
    50145014        {
    50155015            LogRel(("WARNING: Guest property with invalid name (%s) present in VM configuration file. Guest property will be dropped.\n",
     
    50185018        }
    50195019
    5020         rc = GuestPropValidateValue(prop.strValue.c_str(), prop.strValue.length() + 1  /* '\0' */);
    5021         if (rc == VERR_TOO_MUCH_DATA)
     5020        vrc = GuestPropValidateValue(prop.strValue.c_str(), prop.strValue.length() + 1  /* '\0' */);
     5021        if (vrc == VERR_TOO_MUCH_DATA)
    50225022        {
    50235023            LogRel(("WARNING: Guest property '%s' present in VM configuration file and has too long value. Guest property value will be truncated.\n",
     
    50285028            prop.strValue.truncate(GUEST_PROP_MAX_VALUE_LEN - 1 /*terminator*/);
    50295029        }
    5030         else if (RT_FAILURE(rc))
     5030        else if (RT_FAILURE(vrc))
    50315031        {
    50325032            LogRel(("WARNING: Guest property '%s' present in VM configuration file and has invalid value. Guest property will be dropped.\n",
     
    67636763
    67646764        VBOXCRYPTOCTX hCryptoCtx = NULL;
    6765         int rc = pCryptoIf->pfnCryptoCtxLoad(strKeyStore.c_str(), pszPassword, &hCryptoCtx);
    6766         if (RT_SUCCESS(rc))
     6765        int vrc = pCryptoIf->pfnCryptoCtxLoad(strKeyStore.c_str(), pszPassword, &hCryptoCtx);
     6766        if (RT_SUCCESS(vrc))
    67676767        {
    67686768            com::Utf8Str str = elmMachine.getValue();
     
    67736773                parseBase64(abEncrypted, str, &elmMachine);
    67746774            }
    6775             catch(...)
    6776             {
    6777                 int rc2 = pCryptoIf->pfnCryptoCtxDestroy(hCryptoCtx);
    6778                 AssertRC(rc2);
     6775            catch (...)
     6776            {
     6777                int vrc2 = pCryptoIf->pfnCryptoCtxDestroy(hCryptoCtx);
     6778                AssertRC(vrc2);
    67796779                throw;
    67806780            }
     
    67826782            IconBlob abDecrypted(abEncrypted.size());
    67836783            size_t cbDecrypted = 0;
    6784             rc = pCryptoIf->pfnCryptoCtxDecrypt(hCryptoCtx, false /*fPartial*/,
    6785                                                 &abEncrypted[0], abEncrypted.size(),
    6786                                                 uuid.raw(), sizeof(RTUUID),
    6787                                                 &abDecrypted[0], abDecrypted.size(), &cbDecrypted);
    6788             int rc2 = pCryptoIf->pfnCryptoCtxDestroy(hCryptoCtx);
    6789             AssertRC(rc2);
    6790 
    6791             if (RT_SUCCESS(rc))
     6784            vrc = pCryptoIf->pfnCryptoCtxDecrypt(hCryptoCtx, false /*fPartial*/,
     6785                                                 &abEncrypted[0], abEncrypted.size(),
     6786                                                 uuid.raw(), sizeof(RTUUID),
     6787                                                 &abDecrypted[0], abDecrypted.size(), &cbDecrypted);
     6788            int vrc2 = pCryptoIf->pfnCryptoCtxDestroy(hCryptoCtx);
     6789            AssertRC(vrc2);
     6790
     6791            if (RT_SUCCESS(vrc))
    67926792            {
    67936793                abDecrypted.resize(cbDecrypted);
     
    68036803        }
    68046804
    6805         if (RT_FAILURE(rc))
    6806         {
    6807             if (rc == VERR_ACCESS_DENIED)
     6805        if (RT_FAILURE(vrc))
     6806        {
     6807            if (vrc == VERR_ACCESS_DENIED)
    68086808                enmParseState = ParseState_PasswordError;
    68096809            else
    6810                 throw ConfigFileError(this, &elmMachine, N_("Parsing config failed. (%Rrc)"), rc);
     6810                throw ConfigFileError(this, &elmMachine, N_("Parsing config failed. (%Rrc)"), vrc);
    68116811        }
    68126812    }
     
    88048804    xml::XmlStringWriter writer;
    88058805    com::Utf8Str strMachineXml;
    8806     int rc = writer.write(*pDoc, &strMachineXml);
     8806    int vrc = writer.write(*pDoc, &strMachineXml);
    88078807    delete pDoc;
    8808     if (RT_SUCCESS(rc))
     8808    if (RT_SUCCESS(vrc))
    88098809    {
    88108810        VBOXCRYPTOCTX hCryptoCtx;
    88118811        if (strKeyStore.isEmpty())
    88128812        {
    8813             rc = pCryptoIf->pfnCryptoCtxCreate("AES-GCM256", pszPassword, &hCryptoCtx);
    8814             if (RT_SUCCESS(rc))
     8813            vrc = pCryptoIf->pfnCryptoCtxCreate("AES-GCM256", pszPassword, &hCryptoCtx);
     8814            if (RT_SUCCESS(vrc))
    88158815            {
    88168816                char *pszNewKeyStore;
    8817                 rc = pCryptoIf->pfnCryptoCtxSave(hCryptoCtx, &pszNewKeyStore);
    8818                 if (RT_SUCCESS(rc))
     8817                vrc = pCryptoIf->pfnCryptoCtxSave(hCryptoCtx, &pszNewKeyStore);
     8818                if (RT_SUCCESS(vrc))
    88198819                {
    88208820                    strKeyStore = pszNewKeyStore;
     
    88268826        }
    88278827        else
    8828             rc = pCryptoIf->pfnCryptoCtxLoad(strKeyStore.c_str(), pszPassword, &hCryptoCtx);
    8829         if (RT_SUCCESS(rc))
     8828            vrc = pCryptoIf->pfnCryptoCtxLoad(strKeyStore.c_str(), pszPassword, &hCryptoCtx);
     8829        if (RT_SUCCESS(vrc))
    88308830        {
    88318831            IconBlob abEncrypted;
    88328832            size_t cbEncrypted = 0;
    8833             rc = pCryptoIf->pfnCryptoCtxQueryEncryptedSize(hCryptoCtx, strMachineXml.length(), &cbEncrypted);
    8834             if (RT_SUCCESS(rc))
     8833            vrc = pCryptoIf->pfnCryptoCtxQueryEncryptedSize(hCryptoCtx, strMachineXml.length(), &cbEncrypted);
     8834            if (RT_SUCCESS(vrc))
    88358835            {
    88368836                abEncrypted.resize(cbEncrypted);
    8837                 rc = pCryptoIf->pfnCryptoCtxEncrypt(hCryptoCtx, false /*fPartial*/, NULL /*pvIV*/, 0 /*cbIV*/,
    8838                                                     strMachineXml.c_str(), strMachineXml.length(),
    8839                                                     uuid.raw(), sizeof(RTUUID),
    8840                                                     &abEncrypted[0], abEncrypted.size(), &cbEncrypted);
    8841                 int rc2 = pCryptoIf->pfnCryptoCtxDestroy(hCryptoCtx);
    8842                 AssertRC(rc2);
    8843                 if (RT_SUCCESS(rc))
     8837                vrc = pCryptoIf->pfnCryptoCtxEncrypt(hCryptoCtx, false /*fPartial*/, NULL /*pvIV*/, 0 /*cbIV*/,
     8838                                                     strMachineXml.c_str(), strMachineXml.length(),
     8839                                                     uuid.raw(), sizeof(RTUUID),
     8840                                                     &abEncrypted[0], abEncrypted.size(), &cbEncrypted);
     8841                int vrc2 = pCryptoIf->pfnCryptoCtxDestroy(hCryptoCtx);
     8842                AssertRC(vrc2);
     8843                if (RT_SUCCESS(vrc))
    88448844                {
    88458845                    abEncrypted.resize(cbEncrypted);
     
    88538853        }
    88548854
    8855         if (RT_FAILURE(rc))
    8856             throw ConfigFileError(this, &elmMachine, N_("Creating machine encrypted xml failed. (%Rrc)"), rc);
     8855        if (RT_FAILURE(vrc))
     8856            throw ConfigFileError(this, &elmMachine, N_("Creating machine encrypted xml failed. (%Rrc)"), vrc);
    88578857    }
    88588858    else
    8859         throw ConfigFileError(this, &elmMachine, N_("Creating machine xml failed. (%Rrc)"), rc);
     8859        throw ConfigFileError(this, &elmMachine, N_("Creating machine xml failed. (%Rrc)"), vrc);
    88608860}
    88618861
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