VirtualBox

Changeset 71542 in vbox for trunk/src/VBox/Main


Ignore:
Timestamp:
Mar 28, 2018 3:20:26 PM (7 years ago)
Author:
vboxsync
Message:

Guest Control/IGuestSession: Added more session readiness checks.

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r71414 r71542  
    25232523    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    25242524
     2525    HRESULT hr = i_isReadyExternal();
     2526    if (FAILED(hr))
     2527        return hr;
     2528
    25252529    /* Close session on guest. */
    25262530    int rcGuest = VINF_SUCCESS;
    2527     int rc = i_closeSession(0 /* Flags */, 30 * 1000 /* Timeout */,
    2528                             &rcGuest);
     2531    int rc = i_closeSession(0 /* Flags */, 30 * 1000 /* Timeout */, &rcGuest);
    25292532    /* On failure don't return here, instead do all the cleanup
    25302533     * work first and then return an error. */
    … …  
    25802583        return setError(E_NOTIMPL, tr("Flag(s) not yet implemented"));
    25812584
     2585    HRESULT hrc = i_isReadyExternal();
     2586    if (FAILED(hrc))
     2587        return hrc;
     2588
    25822589    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    2583 
    2584     HRESULT hr = S_OK;
    25852590
    25862591    try
    … …  
    25942599        catch(...)
    25952600        {
    2596             hr = setError(VBOX_E_IPRT_ERROR, tr("Failed to create SessionTaskCopyFileFrom object"));
     2601            hrc = setError(VBOX_E_IPRT_ERROR, tr("Failed to create SessionTaskCopyFileFrom object"));
    25972602            throw;
    25982603        }
    25992604
    26002605
    2601         hr = pTask->Init(Utf8StrFmt(tr("Copying \"%s\" from guest to \"%s\" on the host"), aSource.c_str(), aDest.c_str()));
    2602         if (FAILED(hr))
     2606        hrc = pTask->Init(Utf8StrFmt(tr("Copying \"%s\" from guest to \"%s\" on the host"), aSource.c_str(), aDest.c_str()));
     2607        if (FAILED(hrc))
    26032608        {
    26042609            delete pTask;
    2605             hr = setError(VBOX_E_IPRT_ERROR,
    2606                           tr("Creating progress object for SessionTaskCopyFileFrom object failed"));
    2607             throw hr;
    2608         }
    2609 
    2610         hr = pTask->createThreadWithType(RTTHREADTYPE_MAIN_HEAVY_WORKER);
    2611 
    2612         if (SUCCEEDED(hr))
     2610            hrc = setError(VBOX_E_IPRT_ERROR,
     2611                           tr("Creating progress object for SessionTaskCopyFileFrom object failed"));
     2612            throw hrc;
     2613        }
     2614
     2615        hrc = pTask->createThreadWithType(RTTHREADTYPE_MAIN_HEAVY_WORKER);
     2616
     2617        if (SUCCEEDED(hrc))
    26132618        {
    26142619            /* Return progress to the caller. */
    26152620            pProgress = pTask->GetProgressObject();
    2616             hr = pProgress.queryInterfaceTo(aProgress.asOutParam());
     2621            hrc = pProgress.queryInterfaceTo(aProgress.asOutParam());
    26172622        }
    26182623        else
    2619             hr = setError(VBOX_E_IPRT_ERROR,
    2620                           tr("Starting thread for copying file \"%s\" from guest to \"%s\" on the host failed "),
    2621                           aSource.c_str(), aDest.c_str());
     2624            hrc = setError(VBOX_E_IPRT_ERROR,
     2625                           tr("Starting thread for copying file \"%s\" from guest to \"%s\" on the host failed "),
     2626                           aSource.c_str(), aDest.c_str());
    26222627
    26232628    }
    26242629    catch(std::bad_alloc &)
    26252630    {
    2626         hr = E_OUTOFMEMORY;
     2631        hrc = E_OUTOFMEMORY;
    26272632    }
    26282633    catch(HRESULT eHR)
    26292634    {
    2630         hr = eHR;
     2635        hrc = eHR;
    26312636        LogFlowThisFunc(("Exception was caught in the function \n"));
    26322637    }
    26332638
    2634     return hr;
     2639    return hrc;
    26352640}
    26362641
    … …  
    26552660        return setError(E_NOTIMPL, tr("Flag(s) not yet implemented"));
    26562661
     2662    HRESULT hrc = i_isReadyExternal();
     2663    if (FAILED(hrc))
     2664        return hrc;
     2665
    26572666    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    2658 
    2659     HRESULT hr = S_OK;
    26602667
    26612668    try
    … …  
    26692676        catch(...)
    26702677        {
    2671             hr = setError(VBOX_E_IPRT_ERROR, tr("Failed to create SessionTaskCopyFileTo object"));
     2678            hrc = setError(VBOX_E_IPRT_ERROR, tr("Failed to create SessionTaskCopyFileTo object"));
    26722679            throw;
    26732680        }
    26742681
    2675         hr = pTask->Init(Utf8StrFmt(tr("Copying \"%s\" from host to \"%s\" on the guest"), aSource.c_str(), aDest.c_str()));
    2676         if (FAILED(hr))
     2682        hrc = pTask->Init(Utf8StrFmt(tr("Copying \"%s\" from host to \"%s\" on the guest"), aSource.c_str(), aDest.c_str()));
     2683        if (FAILED(hrc))
    26772684        {
    26782685            delete pTask;
    2679             hr = setError(VBOX_E_IPRT_ERROR,
    2680                           tr("Creating progress object for SessionTaskCopyFileTo object failed"));
    2681             throw hr;
    2682         }
    2683 
    2684         hr = pTask->createThreadWithType(RTTHREADTYPE_MAIN_HEAVY_WORKER);
    2685 
    2686         if (SUCCEEDED(hr))
     2686            hrc = setError(VBOX_E_IPRT_ERROR,
     2687                           tr("Creating progress object for SessionTaskCopyFileTo object failed"));
     2688            throw hrc;
     2689        }
     2690
     2691        hrc = pTask->createThreadWithType(RTTHREADTYPE_MAIN_HEAVY_WORKER);
     2692
     2693        if (SUCCEEDED(hrc))
    26872694        {
    26882695            /* Return progress to the caller. */
    26892696            pProgress = pTask->GetProgressObject();
    2690             hr = pProgress.queryInterfaceTo(aProgress.asOutParam());
     2697            hrc = pProgress.queryInterfaceTo(aProgress.asOutParam());
    26912698        }
    26922699        else
    2693             hr = setError(VBOX_E_IPRT_ERROR,
    2694                           tr("Starting thread for copying file \"%s\" from host to \"%s\" on the guest failed "),
    2695                           aSource.c_str(), aDest.c_str());
     2700            hrc = setError(VBOX_E_IPRT_ERROR,
     2701                           tr("Starting thread for copying file \"%s\" from host to \"%s\" on the guest failed "),
     2702                           aSource.c_str(), aDest.c_str());
    26962703    }
    26972704    catch(std::bad_alloc &)
    26982705    {
    2699         hr = E_OUTOFMEMORY;
     2706        hrc = E_OUTOFMEMORY;
    27002707    }
    27012708    catch(HRESULT eHR)
    27022709    {
    2703         hr = eHR;
     2710        hrc = eHR;
    27042711        LogFlowThisFunc(("Exception was caught in the function \n"));
    27052712    }
    27062713
    2707     return hr;
     2714    return hrc;
    27082715}
    27092716
    … …  
    27392746    }
    27402747
     2748    HRESULT hrc = i_isReadyExternal();
     2749    if (FAILED(hrc))
     2750        return hrc;
     2751
    27412752    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    2742 
    2743     HRESULT hr = S_OK;
    27442753
    27452754    try
    … …  
    27542763        catch(...)
    27552764        {
    2756             hr = setError(VBOX_E_IPRT_ERROR, tr("Failed to create SessionTaskCopyDirFrom object"));
     2765            hrc = setError(VBOX_E_IPRT_ERROR, tr("Failed to create SessionTaskCopyDirFrom object"));
    27572766            throw;
    27582767        }
    27592768
    2760         hr = pTask->Init(Utf8StrFmt(tr("Copying directory \"%s\" from guest to \"%s\" on the host"),
    2761                                     aSource.c_str(), aDestination.c_str()));
    2762         if (FAILED(hr))
     2769        hrc = pTask->Init(Utf8StrFmt(tr("Copying directory \"%s\" from guest to \"%s\" on the host"),
     2770                                     aSource.c_str(), aDestination.c_str()));
     2771        if (FAILED(hrc))
    27632772        {
    27642773            delete pTask;
    2765             hr = setError(VBOX_E_IPRT_ERROR,
    2766                           tr("Creating progress object for SessionTaskCopyDirFrom object failed"));
    2767             throw hr;
    2768         }
    2769 
    2770         hr = pTask->createThreadWithType(RTTHREADTYPE_MAIN_HEAVY_WORKER);
    2771 
    2772         if (SUCCEEDED(hr))
     2774            hrc = setError(VBOX_E_IPRT_ERROR,
     2775                           tr("Creating progress object for SessionTaskCopyDirFrom object failed"));
     2776            throw hrc;
     2777        }
     2778
     2779        hrc = pTask->createThreadWithType(RTTHREADTYPE_MAIN_HEAVY_WORKER);
     2780
     2781        if (SUCCEEDED(hrc))
    27732782        {
    27742783            /* Return progress to the caller. */
    27752784            pProgress = pTask->GetProgressObject();
    2776             hr = pProgress.queryInterfaceTo(aProgress.asOutParam());
     2785            hrc = pProgress.queryInterfaceTo(aProgress.asOutParam());
    27772786        }
    27782787        else
    2779             hr = setError(VBOX_E_IPRT_ERROR,
    2780                           tr("Starting thread for copying directory \"%s\" from guest to \"%s\" on the host failed"),
    2781                           aSource.c_str(), aDestination.c_str());
     2788            hrc = setError(VBOX_E_IPRT_ERROR,
     2789                           tr("Starting thread for copying directory \"%s\" from guest to \"%s\" on the host failed"),
     2790                           aSource.c_str(), aDestination.c_str());
    27822791    }
    27832792    catch(std::bad_alloc &)
    27842793    {
    2785         hr = E_OUTOFMEMORY;
     2794        hrc = E_OUTOFMEMORY;
    27862795    }
    27872796    catch(HRESULT eHR)
    27882797    {
    2789         hr = eHR;
     2798        hrc = eHR;
    27902799        LogFlowThisFunc(("Exception was caught in the function\n"));
    27912800    }
    27922801
    2793     return hr;
     2802    return hrc;
    27942803}
    27952804
    … …  
    28212830    }
    28222831
     2832    HRESULT hrc = i_isReadyExternal();
     2833    if (FAILED(hrc))
     2834        return hrc;
     2835
    28232836    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    2824 
    2825     HRESULT hr = S_OK;
    28262837
    28272838    try
    … …  
    28362847        catch(...)
    28372848        {
    2838             hr = setError(VBOX_E_IPRT_ERROR, tr("Failed to create SessionTaskCopyDirTo object"));
     2849            hrc = setError(VBOX_E_IPRT_ERROR, tr("Failed to create SessionTaskCopyDirTo object"));
    28392850            throw;
    28402851        }
    28412852
    2842         hr = pTask->Init(Utf8StrFmt(tr("Copying directory \"%s\" from host to \"%s\" on the guest"),
    2843                                     aSource.c_str(), aDestination.c_str()));
    2844         if (FAILED(hr))
     2853        hrc = pTask->Init(Utf8StrFmt(tr("Copying directory \"%s\" from host to \"%s\" on the guest"),
     2854                                     aSource.c_str(), aDestination.c_str()));
     2855        if (FAILED(hrc))
    28452856        {
    28462857            delete pTask;
    2847             hr = setError(VBOX_E_IPRT_ERROR,
    2848                           tr("Creating progress object for SessionTaskCopyDirTo object failed"));
    2849             throw hr;
    2850         }
    2851 
    2852         hr = pTask->createThreadWithType(RTTHREADTYPE_MAIN_HEAVY_WORKER);
    2853 
    2854         if (SUCCEEDED(hr))
     2858            hrc = setError(VBOX_E_IPRT_ERROR,
     2859                           tr("Creating progress object for SessionTaskCopyDirTo object failed"));
     2860            throw hrc;
     2861        }
     2862
     2863        hrc = pTask->createThreadWithType(RTTHREADTYPE_MAIN_HEAVY_WORKER);
     2864
     2865        if (SUCCEEDED(hrc))
    28552866        {
    28562867            /* Return progress to the caller. */
    28572868            pProgress = pTask->GetProgressObject();
    2858             hr = pProgress.queryInterfaceTo(aProgress.asOutParam());
     2869            hrc = pProgress.queryInterfaceTo(aProgress.asOutParam());
    28592870        }
    28602871        else
    2861             hr = setError(VBOX_E_IPRT_ERROR,
    2862                           tr("Starting thread for copying directory \"%s\" from host to \"%s\" on the guest failed"),
    2863                           aSource.c_str(), aDestination.c_str());
     2872            hrc = setError(VBOX_E_IPRT_ERROR,
     2873                           tr("Starting thread for copying directory \"%s\" from host to \"%s\" on the guest failed"),
     2874                           aSource.c_str(), aDestination.c_str());
    28642875    }
    28652876    catch(std::bad_alloc &)
    28662877    {
    2867         hr = E_OUTOFMEMORY;
     2878        hrc = E_OUTOFMEMORY;
    28682879    }
    28692880    catch(HRESULT eHR)
    28702881    {
    2871         hr = eHR;
     2882        hrc = eHR;
    28722883        LogFlowThisFunc(("Exception was caught in the function\n"));
    28732884    }
    28742885
    2875     return hr;
     2886    return hrc;
    28762887}
    28772888
    … …  
    28952906    }
    28962907
    2897     HRESULT hr = S_OK;
     2908    HRESULT hrc = i_isReadyExternal();
     2909    if (FAILED(hrc))
     2910        return hrc;
    28982911
    28992912    ComObjPtr <GuestDirectory> pDirectory; int rcGuest;
    … …  
    29032916        if (GuestProcess::i_isGuestError(rc))
    29042917        {
    2905             hr = setError(VBOX_E_IPRT_ERROR, tr("Directory creation failed: %s"),
    2906                                                 GuestDirectory::i_guestErrorToString(rcGuest).c_str());
     2918            hrc = setError(VBOX_E_IPRT_ERROR, tr("Directory creation failed: %s"),
     2919                                                 GuestDirectory::i_guestErrorToString(rcGuest).c_str());
    29072920        }
    29082921        else
    … …  
    29112924            {
    29122925                case VERR_INVALID_PARAMETER:
    2913                     hr = setError(VBOX_E_IPRT_ERROR, tr("Directory creation failed: Invalid parameters given"));
     2926                    hrc = setError(VBOX_E_IPRT_ERROR, tr("Directory creation failed: Invalid parameters given"));
    29142927                    break;
    29152928
    29162929                case VERR_BROKEN_PIPE:
    2917                     hr = setError(VBOX_E_IPRT_ERROR, tr("Directory creation failed: Unexpectedly aborted"));
     2930                    hrc = setError(VBOX_E_IPRT_ERROR, tr("Directory creation failed: Unexpectedly aborted"));
    29182931                    break;
    29192932
    29202933                default:
    2921                     hr = setError(VBOX_E_IPRT_ERROR, tr("Directory creation failed: %Rrc"), rc);
     2934                    hrc = setError(VBOX_E_IPRT_ERROR, tr("Directory creation failed: %Rrc"), rc);
    29222935                    break;
    29232936            }
    … …  
    29252938    }
    29262939
    2927     return hr;
     2940    return hrc;
    29282941}
    29292942
    … …  
    29392952        return setError(E_INVALIDARG, tr("No directory name specified"));
    29402953
    2941     HRESULT hr = S_OK;
     2954    HRESULT hrc = i_isReadyExternal();
     2955    if (FAILED(hrc))
     2956        return hrc;
    29422957
    29432958    int rcGuest;
    … …  
    29482963        {
    29492964            case VERR_GSTCTL_GUEST_ERROR:
    2950                 hr = GuestProcess::i_setErrorExternal(this, rcGuest);
     2965                hrc = GuestProcess::i_setErrorExternal(this, rcGuest);
    29512966                break;
    29522967
    29532968            default:
    2954                hr = setError(VBOX_E_IPRT_ERROR, tr("Temporary directory creation \"%s\" with template \"%s\" failed: %Rrc"),
    2955                              aPath.c_str(), aTemplateName.c_str(), rc);
     2969               hrc = setError(VBOX_E_IPRT_ERROR, tr("Temporary directory creation \"%s\" with template \"%s\" failed: %Rrc"),
     2970                              aPath.c_str(), aTemplateName.c_str(), rc);
    29562971               break;
    29572972        }
    29582973    }
    29592974
    2960     return hr;
     2975    return hrc;
    29612976}
    29622977
    … …  
    29682983        return setError(E_INVALIDARG, tr("No directory to check existence for specified"));
    29692984
    2970     HRESULT hr = S_OK;
     2985    HRESULT hrc = i_isReadyExternal();
     2986    if (FAILED(hrc))
     2987        return hrc;
    29712988
    29722989    GuestFsObjData objData; int rcGuest;
    … …  
    29863003                        break;
    29873004                    default:
    2988                         hr = setError(VBOX_E_IPRT_ERROR, tr("Querying directory existence \"%s\" failed: %s"),
    2989                                       aPath.c_str(), GuestProcess::i_guestErrorToString(rcGuest).c_str());
     3005                        hrc = setError(VBOX_E_IPRT_ERROR, tr("Querying directory existence \"%s\" failed: %s"),
     3006                                                             aPath.c_str(), GuestProcess::i_guestErrorToString(rcGuest).c_str());
    29903007                        break;
    29913008                }
    … …  
    29943011
    29953012            default:
    2996                hr = setError(VBOX_E_IPRT_ERROR, tr("Querying directory existence \"%s\" failed: %Rrc"),
    2997                              aPath.c_str(), rc);
     3013               hrc = setError(VBOX_E_IPRT_ERROR, tr("Querying directory existence \"%s\" failed: %Rrc"),
     3014                                                    aPath.c_str(), rc);
    29983015               break;
    29993016        }
    30003017    }
    30013018
    3002     return hr;
     3019    return hrc;
    30033020}
    30043021
    … …  
    30233040    }
    30243041
    3025     HRESULT hr = S_OK;
     3042    HRESULT hrc = i_isReadyExternal();
     3043    if (FAILED(hrc))
     3044        return hrc;
    30263045
    30273046    GuestDirectoryOpenInfo openInfo;
    … …  
    30353054    {
    30363055        /* Return directory object to the caller. */
    3037         hr = pDirectory.queryInterfaceTo(aDirectory.asOutParam());
     3056        hrc = pDirectory.queryInterfaceTo(aDirectory.asOutParam());
    30383057    }
    30393058    else
    … …  
    30423061        {
    30433062            case VERR_INVALID_PARAMETER:
    3044                hr = setError(VBOX_E_IPRT_ERROR, tr("Opening directory \"%s\" failed; invalid parameters given"),
    3045                                                    aPath.c_str());
     3063               hrc = setError(VBOX_E_IPRT_ERROR, tr("Opening directory \"%s\" failed; invalid parameters given"),
     3064                                                    aPath.c_str());
    30463065               break;
    30473066
    30483067            case VERR_GSTCTL_GUEST_ERROR:
    3049                 hr = GuestDirectory::i_setErrorExternal(this, rcGuest);
     3068                hrc = GuestDirectory::i_setErrorExternal(this, rcGuest);
    30503069                break;
    30513070
    30523071            default:
    3053                hr = setError(VBOX_E_IPRT_ERROR, tr("Opening directory \"%s\" failed: %Rrc"),
    3054                              aPath.c_str(),rc);
     3072               hrc = setError(VBOX_E_IPRT_ERROR, tr("Opening directory \"%s\" failed: %Rrc"),
     3073                                                    aPath.c_str(),rc);
    30553074               break;
    30563075        }
    30573076    }
    30583077
    3059     return hr;
     3078    return hrc;
    30603079}
    30613080
    … …  
    30673086        return setError(E_INVALIDARG, tr("No directory to remove specified"));
    30683087
    3069     HRESULT hr = i_isReadyExternal();
    3070     if (FAILED(hr))
    3071         return hr;
     3088    HRESULT hrc = i_isReadyExternal();
     3089    if (FAILED(hrc))
     3090        return hrc;
    30723091
    30733092    /* No flags; only remove the directory when empty. */
    … …  
    30813100        {
    30823101            case VERR_NOT_SUPPORTED:
    3083                 hr = setError(VBOX_E_IPRT_ERROR,
    3084                               tr("Handling removing guest directories not supported by installed Guest Additions"));
     3102                hrc = setError(VBOX_E_IPRT_ERROR,
     3103                               tr("Handling removing guest directories not supported by installed Guest Additions"));
    30853104                break;
    30863105
    30873106            case VERR_GSTCTL_GUEST_ERROR:
    3088                 hr = GuestDirectory::i_setErrorExternal(this, rcGuest);
     3107                hrc = GuestDirectory::i_setErrorExternal(this, rcGuest);
    30893108                break;
    30903109
    30913110            default:
    3092                 hr = setError(VBOX_E_IPRT_ERROR, tr("Removing guest directory \"%s\" failed: %Rrc"),
    3093                               aPath.c_str(), vrc);
     3111                hrc = setError(VBOX_E_IPRT_ERROR, tr("Removing guest directory \"%s\" failed: %Rrc"),
     3112                                                     aPath.c_str(), vrc);
    30943113                break;
    30953114        }
    30963115    }
    30973116
    3098     return hr;
     3117    return hrc;
    30993118}
    31003119
    … …  
    31113130 *        further down!! */
    31123131
    3113     HRESULT hr = i_isReadyExternal();
    3114     if (FAILED(hr))
    3115         return hr;
     3132    HRESULT hrc = i_isReadyExternal();
     3133    if (FAILED(hrc))
     3134        return hrc;
    31163135
    31173136    ComObjPtr<Progress> pProgress;
    3118     hr = pProgress.createObject();
    3119     if (SUCCEEDED(hr))
    3120         hr = pProgress->init(static_cast<IGuestSession *>(this),
    3121                              Bstr(tr("Removing guest directory")).raw(),
    3122                              TRUE /*aCancelable*/);
    3123     if (FAILED(hr))
    3124         return hr;
     3137    hrc = pProgress.createObject();
     3138    if (SUCCEEDED(hrc))
     3139        hrc = pProgress->init(static_cast<IGuestSession *>(this),
     3140                              Bstr(tr("Removing guest directory")).raw(),
     3141                              TRUE /*aCancelable*/);
     3142    if (FAILED(hrc))
     3143        return hrc;
    31253144
    31263145    /* Note: At the moment we don't supply progress information while
    … …  
    31283147     *       the progress object right now. */
    31293148     /** @todo Implement progress reporting on guest directory deletion! */
    3130     hr = pProgress->i_notifyComplete(S_OK);
    3131     if (FAILED(hr))
    3132         return hr;
     3149    hrc = pProgress->i_notifyComplete(S_OK);
     3150    if (FAILED(hrc))
     3151        return hrc;
    31333152
    31343153    /* Remove the directory + all its contents. */
    … …  
    31423161        {
    31433162            case VERR_NOT_SUPPORTED:
    3144                 hr = setError(VBOX_E_IPRT_ERROR,
     3163                hrc = setError(VBOX_E_IPRT_ERROR,
    31453164                              tr("Handling removing guest directories recursively not supported by installed Guest Additions"));
    31463165                break;
    31473166
    31483167            case VERR_GSTCTL_GUEST_ERROR:
    3149                 hr = GuestFile::i_setErrorExternal(this, rcGuest);
     3168                hrc = GuestFile::i_setErrorExternal(this, rcGuest);
    31503169                break;
    31513170
    31523171            default:
    3153                 hr = setError(VBOX_E_IPRT_ERROR, tr("Recursively removing guest directory \"%s\" failed: %Rrc"),
    3154                               aPath.c_str(), vrc);
     3172                hrc = setError(VBOX_E_IPRT_ERROR, tr("Recursively removing guest directory \"%s\" failed: %Rrc"),
     3173                                                     aPath.c_str(), vrc);
    31553174                break;
    31563175        }
    … …  
    31613180    }
    31623181
    3163     return hr;
     3182    return hrc;
    31643183}
    31653184
    … …  
    32943313    }
    32953314
     3315    HRESULT hrc = i_isReadyExternal();
     3316    if (FAILED(hrc))
     3317        return hrc;
     3318
    32963319    GuestFsObjData objData; int rcGuest;
    32973320    int vrc = i_fileQueryInfo(aPath, aFollowSymlinks != FALSE, objData, &rcGuest);
    … …  
    33023325    }
    33033326
    3304     HRESULT hr = S_OK;
    3305 
    33063327    switch (vrc)
    33073328    {
    33083329        case VERR_GSTCTL_GUEST_ERROR:
    3309             hr = GuestProcess::i_setErrorExternal(this, rcGuest);
     3330            hrc = GuestProcess::i_setErrorExternal(this, rcGuest);
    33103331            break;
    33113332
    … …  
    33173338
    33183339        default:
    3319             hr = setError(VBOX_E_IPRT_ERROR, tr("Querying file information for \"%s\" failed: %Rrc"),
    3320                           aPath.c_str(), vrc);
     3340            hrc = setError(VBOX_E_IPRT_ERROR, tr("Querying file information for \"%s\" failed: %Rrc"),
     3341                                                 aPath.c_str(), vrc);
    33213342            break;
    33223343    }
    33233344
    3324     return hr;
     3345    return hrc;
    33253346}
    33263347
    … …  
    33423363        return setError(E_INVALIDARG, tr("No file to open specified"));
    33433364
    3344     HRESULT hr = i_isReadyExternal();
    3345     if (FAILED(hr))
    3346         return hr;
     3365    HRESULT hrc = i_isReadyExternal();
     3366    if (FAILED(hrc))
     3367        return hrc;
    33473368
    33483369    GuestFileOpenInfo openInfo;
    … …  
    34113432    if (RT_SUCCESS(vrc))
    34123433        /* Return directory object to the caller. */
    3413         hr = pFile.queryInterfaceTo(aFile.asOutParam());
     3434        hrc = pFile.queryInterfaceTo(aFile.asOutParam());
    34143435    else
    34153436    {
    … …  
    34173438        {
    34183439            case VERR_NOT_SUPPORTED:
    3419                 hr = setError(VBOX_E_IPRT_ERROR,
     3440                hrc = setError(VBOX_E_IPRT_ERROR,
    34203441                              tr("Handling guest files not supported by installed Guest Additions"));
    34213442                break;
    34223443
    34233444            case VERR_GSTCTL_GUEST_ERROR:
    3424                 hr = GuestFile::i_setErrorExternal(this, rcGuest);
     3445                hrc = GuestFile::i_setErrorExternal(this, rcGuest);
    34253446                break;
    34263447
    34273448            default:
    3428                 hr = setError(VBOX_E_IPRT_ERROR, tr("Opening guest file \"%s\" failed: %Rrc"),
     3449                hrc = setError(VBOX_E_IPRT_ERROR, tr("Opening guest file \"%s\" failed: %Rrc"),
    34293450                              aPath.c_str(), vrc);
    34303451                break;
    … …  
    34323453    }
    34333454
    3434     return hr;
     3455    return hrc;
    34353456}
    34363457
    … …  
    34403461        return setError(E_INVALIDARG, tr("No path specified"));
    34413462
    3442     HRESULT hr = S_OK;
     3463    HRESULT hrc = i_isReadyExternal();
     3464    if (FAILED(hrc))
     3465        return hrc;
    34433466
    34443467    int64_t llSize; int rcGuest;
    … …  
    34523475        if (GuestProcess::i_isGuestError(vrc))
    34533476        {
    3454             hr = GuestProcess::i_setErrorExternal(this, rcGuest);
     3477            hrc = GuestProcess::i_setErrorExternal(this, rcGuest);
    34553478        }
    34563479        else
    3457             hr = setError(VBOX_E_IPRT_ERROR, tr("Querying file size failed: %Rrc"), vrc);
    3458     }
    3459 
    3460     return hr;
     3480            hrc = setError(VBOX_E_IPRT_ERROR, tr("Querying file size failed: %Rrc"), vrc);
     3481    }
     3482
     3483    return hrc;
    34613484}
    34623485
    … …  
    34663489        return setError(E_INVALIDARG, tr("No path specified"));
    34673490
     3491    HRESULT hrc = i_isReadyExternal();
     3492    if (FAILED(hrc))
     3493        return hrc;
     3494
    34683495    LogFlowThisFunc(("aPath=%s, aFollowSymlinks=%RTbool\n", aPath.c_str(), RT_BOOL(aFollowSymlinks)));
    3469 
    3470     HRESULT hrc = S_OK;
    34713496
    34723497    *aExists = false;
    … …  
    35053530        return setError(E_INVALIDARG, tr("No path specified"));
    35063531
     3532    HRESULT hrc = i_isReadyExternal();
     3533    if (FAILED(hrc))
     3534        return hrc;
     3535
    35073536    LogFlowThisFunc(("aPath=%s, aFollowSymlinks=%RTbool\n", aPath.c_str(), RT_BOOL(aFollowSymlinks)));
    3508 
    3509     HRESULT hrc = S_OK;
    35103537
    35113538    GuestFsObjData Info; int rcGuest;
    … …  
    35423569        return setError(E_INVALIDARG, tr("No path specified"));
    35433570
     3571    HRESULT hrc = i_isReadyExternal();
     3572    if (FAILED(hrc))
     3573        return hrc;
     3574
    35443575    LogFlowThisFunc(("aPath=%s\n", aPath.c_str()));
    3545 
    3546     HRESULT hrc = S_OK;
    35473576
    35483577    int rcGuest;
    … …  
    35733602    LogFlowThisFunc(("aSource=%s, aDestination=%s\n", aSource.c_str(), aDestination.c_str()));
    35743603
    3575     HRESULT hr = i_isReadyExternal();
    3576     if (FAILED(hr))
    3577         return hr;
     3604    HRESULT hrc = i_isReadyExternal();
     3605    if (FAILED(hrc))
     3606        return hrc;
    35783607
    35793608    /* Combine, validate and convert flags. */
    … …  
    36003629        {
    36013630            case VERR_NOT_SUPPORTED:
    3602                 hr = setError(VBOX_E_IPRT_ERROR,
     3631                hrc = setError(VBOX_E_IPRT_ERROR,
    36033632                              tr("Handling renaming guest directories not supported by installed Guest Additions"));
    36043633                break;
    36053634
    36063635            case VERR_GSTCTL_GUEST_ERROR:
    3607                 hr = setError(VBOX_E_IPRT_ERROR,
     3636                hrc = setError(VBOX_E_IPRT_ERROR,
    36083637                              tr("Renaming guest directory failed: %Rrc"), rcGuest);
    36093638                break;
    36103639
    36113640            default:
    3612                 hr = setError(VBOX_E_IPRT_ERROR, tr("Renaming guest directory \"%s\" failed: %Rrc"),
    3613                               aSource.c_str(), vrc);
     3641                hrc = setError(VBOX_E_IPRT_ERROR, tr("Renaming guest directory \"%s\" failed: %Rrc"),
     3642                                                     aSource.c_str(), vrc);
    36143643                break;
    36153644        }
    36163645    }
    36173646
    3618     return hr;
     3647    return hrc;
    36193648}
    36203649
    … …  
    38023831    LogFlowThisFuncEnter();
    38033832
     3833    HRESULT hrc = i_isReadyExternal();
     3834    if (FAILED(hrc))
     3835        return hrc;
     3836
    38043837    /*
    38053838     * Note: Do not hold any locks here while waiting!
    38063839     */
    3807     HRESULT hr = S_OK;
    3808 
    38093840    int rcGuest; GuestSessionWaitResult_T waitResult;
    38103841    int vrc = i_waitFor(aWaitFor, aTimeoutMS, waitResult, &rcGuest);
    … …  
    38163847        {
    38173848            case VERR_GSTCTL_GUEST_ERROR:
    3818                 hr = GuestSession::i_setErrorExternal(this, rcGuest);
     3849                hrc = GuestSession::i_setErrorExternal(this, rcGuest);
    38193850                break;
    38203851
    … …  
    38263857            {
    38273858                const char *pszSessionName = mData.mSession.mName.c_str();
    3828                 hr = setError(VBOX_E_IPRT_ERROR,
    3829                               tr("Waiting for guest session \"%s\" failed: %Rrc"),
    3830                                  pszSessionName ? pszSessionName : tr("Unnamed"), vrc);
     3859                hrc = setError(VBOX_E_IPRT_ERROR,
     3860                               tr("Waiting for guest session \"%s\" failed: %Rrc"),
     3861                                  pszSessionName ? pszSessionName : tr("Unnamed"), vrc);
    38313862                break;
    38323863            }
    … …  
    38353866
    38363867    LogFlowFuncLeaveRC(vrc);
    3837     return hr;
     3868    return hrc;
    38383869}
    38393870
    … …  
    38423873{
    38433874    LogFlowThisFuncEnter();
     3875
     3876    HRESULT hrc = i_isReadyExternal();
     3877    if (FAILED(hrc))
     3878        return hrc;
    38443879
    38453880    /*
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