VirtualBox

Changeset 42194 in vbox for trunk/src


Ignore:
Timestamp:
Jul 17, 2012 2:58:32 PM (12 years ago)
Author:
vboxsync
Message:

Guest Control 2.0: Update.

Location:
trunk/src/VBox/Main
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/VBox/Main/idl/VirtualBox.xidl

    r42178 r42194  
    91549154  <interface
    91559155    name="IGuestSession" extends="$unknown"
    9156     uuid="158aff3c-5258-4994-88cb-6fd679c7e3ed"
     9156    uuid="530aef35-6a48-455c-960c-aac5792abc38"
    91579157    wsmap="managed"
    91589158    >
     
    94549454        </result>
    94559455      </desc>
     9456    </method>
     9457   
     9458    <method name="EnvironmentGet">
     9459      <desc>
     9460        TODO
     9461
     9462        <result name="VBOX_E_NOT_SUPPORTED">
     9463          TODO
     9464        </result>
     9465      </desc>
     9466      <param name="name" type="wstring" dir="in">
     9467        <desc>TODO</desc>
     9468      </param>
     9469      <param name="value" type="wstring" dir="return">
     9470        <desc>TODO</desc>
     9471      </param>
    94569472    </method>
    94579473   
  • trunk/src/VBox/Main/include/GuestCtrlImplPrivate.h

    r42171 r42194  
    122122    static void FreeEnvironmentBlock(void *pvEnv);
    123123
     124    Utf8Str Get(const Utf8Str &strKey);
     125
    124126    Utf8Str Get(size_t nPos);
    125127
  • trunk/src/VBox/Main/include/GuestSessionImpl.h

    r42171 r42194  
    8282    STDMETHOD(DirectorySetACL)(IN_BSTR aPath, IN_BSTR aACL);
    8383    STDMETHOD(EnvironmentClear)(void);
     84    STDMETHOD(EnvironmentGet)(IN_BSTR aName, BSTR *aValue);
    8485    STDMETHOD(EnvironmentSet)(IN_BSTR aName, IN_BSTR aValue);
    8586    STDMETHOD(EnvironmentSetArray)(ComSafeArrayIn(IN_BSTR, aValues));
  • trunk/src/VBox/Main/src-client/GuestCtrlImpl.cpp

    r42171 r42194  
    26892689
    26902690    int rc = VERR_MAX_PROCS_REACHED;
    2691     ComObjPtr<GuestSession> pGuestSession;
    26922691    try
    26932692    {
     
    26992698        {
    27002699            /* Is the context ID already used?  Try next ID ... */
    2701             if (!sessionExists(uNewSessionID++))
    2702             {
    2703                 /* Callback with context ID was not found. This means
    2704                  * we can use this context ID for our new callback we want
    2705                  * to add below. */
     2700            if (!sessionExists(++uNewSessionID))
     2701            {
    27062702                rc = VINF_SUCCESS;
    27072703                break;
     
    27142710
    27152711        /* Create the session object. */
     2712        ComObjPtr<GuestSession> pGuestSession;
    27162713        HRESULT hr = pGuestSession.createObject();
    27172714        if (FAILED(hr)) throw VERR_COM_UNEXPECTED;
     
    27192716        rc = pGuestSession->init(this, uNewSessionID,
    27202717                                 strUser, strPassword, strDomain, strSessionName);
    2721         if (RT_FAILURE(rc)) throw VBOX_E_IPRT_ERROR;
    2722 
    2723         mData.mGuestSessions[uNewSessionID] = pGuestSession;
     2718        if (RT_FAILURE(rc)) throw rc;
    27242719
    27252720        /* Return guest session to the caller. */
    27262721        hr = pGuestSession.queryInterfaceTo(aGuestSession);
    27272722        if (FAILED(hr)) throw VERR_COM_OBJECT_NOT_FOUND;
     2723
     2724        mData.mGuestSessions[uNewSessionID] = pGuestSession;
    27282725    }
    27292726    catch (int rc2)
  • trunk/src/VBox/Main/src-client/GuestCtrlPrivate.cpp

    r42171 r42194  
    2121 ******************************************************************************/
    2222#include "GuestCtrlImplPrivate.h"
     23
     24#include <iprt/ctype.h>
    2325#ifdef DEBUG
    2426# include "Logging.h"
     
    210212    std::map<Utf8Str, Utf8Str>::const_iterator it = mEnvironment.begin();
    211213    for (; it != mEnvironment.end() && curPos < nPos;
    212          ++it) { }
     214         ++it, ++curPos) { }
    213215
    214216    if (it != mEnvironment.end())
     
    218220}
    219221
     222Utf8Str GuestEnvironment::Get(const Utf8Str &strKey)
     223{
     224    std::map <Utf8Str, Utf8Str>::const_iterator itEnv = mEnvironment.find(strKey);
     225    Utf8Str strRet;
     226    if (itEnv != mEnvironment.end())
     227        strRet = itEnv->second;
     228    return strRet;
     229}
     230
    220231bool GuestEnvironment::Has(const Utf8Str &strKey)
    221232{
     
    226237int GuestEnvironment::Set(const Utf8Str &strKey, const Utf8Str &strValue)
    227238{
    228     mEnvironment[strValue] = strValue;
    229     return VINF_SUCCESS;
     239    /** @todo Do some validation using regex. */
     240    if (strKey.isEmpty())
     241        return VERR_INVALID_PARAMETER;
     242
     243    int rc = VINF_SUCCESS;
     244    const char *pszString = strKey.c_str();
     245    while (*pszString != '\0' && RT_SUCCESS(rc))
     246    {
     247         if (!RT_C_IS_ALNUM(*pszString++))
     248             rc = VERR_INVALID_PARAMETER;
     249    }
     250
     251    if (RT_SUCCESS(rc))
     252        mEnvironment[strKey] = strValue;
     253
     254    return rc;
    230255}
    231256
     
    233258{
    234259    RTCList<RTCString> listPair = strPair.split("=", RTCString::KeepEmptyParts);
     260    /* Skip completely empty pairs. Note that we still need pairs with a valid
     261     * (set) key and an empty value. */
     262    if (listPair.size() <= 1)
     263        return VINF_SUCCESS;
     264
     265    int rc = VINF_SUCCESS;
    235266    size_t p = 0;
    236     while(p < listPair.size())
     267    while(p < listPair.size() && RT_SUCCESS(rc))
    237268    {
    238269        Utf8Str strKey = listPair.at(p++);
    239         if (strKey.isEmpty()) /* Skip pairs with empty keys (e.g. "=FOO"). */
    240         {
    241             p++;
    242             continue;
     270        if (   strKey.isEmpty()
     271            || strKey.equals("=")) /* Skip pairs with empty keys (e.g. "=FOO"). */
     272        {
     273            break;
    243274        }
    244275        Utf8Str strValue;
    245         if (p < listPair.size())
     276        if (p < listPair.size()) /* Does the list also contain a value? */
    246277            strValue = listPair.at(p++);
    247        mEnvironment[strKey] = strValue;
    248     }
    249 
    250     return VINF_SUCCESS;
     278
     279       rc = Set(strKey, strValue);
     280    }
     281
     282    return rc;
    251283}
    252284
  • trunk/src/VBox/Main/src-client/GuestSessionImpl.cpp

    r42171 r42194  
    5858                       Utf8Str aUser, Utf8Str aPassword, Utf8Str aDomain, Utf8Str aName)
    5959{
     60    LogFlowThisFuncEnter();
     61
    6062    AssertPtrReturn(aGuest, VERR_INVALID_POINTER);
     63    AssertReturn(aSessionID, VERR_INVALID_PARAMETER);
    6164
    6265    /* Enclose the state transition NotReady->InInit->Ready. */
     
    7578    autoInitSpan.setSucceeded();
    7679
     80    LogFlowFuncLeaveRC(VINF_SUCCESS);
    7781    return VINF_SUCCESS;
    7882}
     
    8488void GuestSession::uninit(void)
    8589{
    86     LogFlowThisFunc(("\n"));
     90    LogFlowThisFuncEnter();
    8791
    8892    /* Enclose the state transition Ready->InUninit->NotReady. */
     
    117121
    118122    mData.mParent->sessionClose(this);
     123
     124    LogFlowThisFuncLeave();
    119125#endif
    120126}
     
    128134    ReturnComNotImplemented();
    129135#else
     136    LogFlowThisFuncEnter();
     137
    130138    CheckComArgOutPointerValid(aUser);
    131139
     
    137145    mData.mCredentials.mUser.cloneTo(aUser);
    138146
     147    LogFlowFuncLeaveRC(S_OK);
    139148    return S_OK;
    140149#endif /* VBOX_WITH_GUEST_CONTROL */
     
    146155    ReturnComNotImplemented();
    147156#else
     157    LogFlowThisFuncEnter();
     158
    148159    CheckComArgOutPointerValid(aDomain);
    149160
     
    155166    mData.mCredentials.mDomain.cloneTo(aDomain);
    156167
     168    LogFlowFuncLeaveRC(S_OK);
    157169    return S_OK;
    158170#endif /* VBOX_WITH_GUEST_CONTROL */
     
    164176    ReturnComNotImplemented();
    165177#else
     178    LogFlowThisFuncEnter();
     179
    166180    CheckComArgOutPointerValid(aName);
    167181
     
    173187    mData.mName.cloneTo(aName);
    174188
     189    LogFlowFuncLeaveRC(S_OK);
    175190    return S_OK;
    176191#endif /* VBOX_WITH_GUEST_CONTROL */
     
    182197    ReturnComNotImplemented();
    183198#else
     199    LogFlowThisFuncEnter();
     200
    184201    CheckComArgOutPointerValid(aId);
    185202
     
    191208    *aId = mData.mId;
    192209
     210    LogFlowFuncLeaveRC(S_OK);
    193211    return S_OK;
    194212#endif /* VBOX_WITH_GUEST_CONTROL */
     
    200218    ReturnComNotImplemented();
    201219#else
     220    LogFlowThisFuncEnter();
     221
    202222    CheckComArgOutPointerValid(aTimeout);
    203223
     
    209229    *aTimeout = mData.mTimeout;
    210230
     231    LogFlowFuncLeaveRC(S_OK);
    211232    return S_OK;
    212233#endif /* VBOX_WITH_GUEST_CONTROL */
     
    218239    ReturnComNotImplemented();
    219240#else
     241    LogFlowThisFuncEnter();
     242
    220243    CheckComArgOutSafeArrayPointerValid(aEnvironment);
    221244
     
    225248    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    226249
    227     com::SafeArray<BSTR> arguments(mData.mEnvironment.Size());
    228     for (size_t i = 0; i < arguments.size(); i++)
    229         arguments[i] = Bstr(mData.mEnvironment.Get(i)).raw();
    230     arguments.detachTo(ComSafeArrayOutArg(aEnvironment));
    231 
     250    size_t cEnvVars = mData.mEnvironment.Size();
     251    LogFlowThisFunc(("%s cEnvVars=%RU32\n", mData.mName.c_str(), cEnvVars));
     252    com::SafeArray<BSTR> environment(cEnvVars);
     253
     254    for (size_t i = 0; i < cEnvVars; i++)
     255    {
     256        Bstr strEnv(mData.mEnvironment.Get(i));
     257        strEnv.cloneTo(&environment[i]);
     258    }
     259    environment.detachTo(ComSafeArrayOutArg(aEnvironment));
     260
     261    LogFlowFuncLeaveRC(S_OK);
    232262    return S_OK;
    233263#endif /* VBOX_WITH_GUEST_CONTROL */
     
    239269    ReturnComNotImplemented();
    240270#else
     271    LogFlowThisFuncEnter();
     272
    241273    CheckComArgOutSafeArrayPointerValid(aProcesses);
    242274
     
    249281    collection.detachTo(ComSafeArrayOutArg(aProcesses));
    250282
     283    LogFlowFuncLeaveRC(S_OK);
    251284    return S_OK;
    252285#endif /* VBOX_WITH_GUEST_CONTROL */
     
    258291    ReturnComNotImplemented();
    259292#else
     293    LogFlowThisFuncEnter();
     294
    260295    CheckComArgOutSafeArrayPointerValid(aDirectories);
    261296
     
    268303    collection.detachTo(ComSafeArrayOutArg(aDirectories));
    269304
     305    LogFlowFuncLeaveRC(S_OK);
    270306    return S_OK;
    271307#endif /* VBOX_WITH_GUEST_CONTROL */
     
    277313    ReturnComNotImplemented();
    278314#else
     315    LogFlowThisFuncEnter();
     316
    279317    CheckComArgOutSafeArrayPointerValid(aFiles);
    280318
     
    287325    collection.detachTo(ComSafeArrayOutArg(aFiles));
    288326
     327    LogFlowFuncLeaveRC(S_OK);
    289328    return S_OK;
    290329#endif /* VBOX_WITH_GUEST_CONTROL */
     
    444483    ReturnComNotImplemented();
    445484#else
     485    LogFlowThisFuncEnter();
     486
    446487    uninit();
    447488
     489    LogFlowFuncLeaveRC(S_OK);
    448490    return S_OK;
    449491#endif /* VBOX_WITH_GUEST_CONTROL */
     
    455497    ReturnComNotImplemented();
    456498#else
     499    LogFlowThisFuncEnter();
     500
    457501    AutoCaller autoCaller(this);
    458502    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     
    467511    ReturnComNotImplemented();
    468512#else
     513    LogFlowThisFuncEnter();
     514
    469515    AutoCaller autoCaller(this);
    470516    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     
    479525    ReturnComNotImplemented();
    480526#else
     527    LogFlowThisFuncEnter();
     528
    481529    AutoCaller autoCaller(this);
    482530    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     
    491539    ReturnComNotImplemented();
    492540#else
     541    LogFlowThisFuncEnter();
     542
    493543    AutoCaller autoCaller(this);
    494544    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     
    503553    ReturnComNotImplemented();
    504554#else
     555    LogFlowThisFuncEnter();
     556
    505557    AutoCaller autoCaller(this);
    506558    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     
    515567    ReturnComNotImplemented();
    516568#else
     569    LogFlowThisFuncEnter();
     570
    517571    AutoCaller autoCaller(this);
    518572    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     
    527581    ReturnComNotImplemented();
    528582#else
     583    LogFlowThisFuncEnter();
     584
    529585    AutoCaller autoCaller(this);
    530586    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     
    539595    ReturnComNotImplemented();
    540596#else
     597    LogFlowThisFuncEnter();
     598
    541599    AutoCaller autoCaller(this);
    542600    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     
    551609    ReturnComNotImplemented();
    552610#else
     611    LogFlowThisFuncEnter();
     612
    553613    AutoCaller autoCaller(this);
    554614    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     
    563623    ReturnComNotImplemented();
    564624#else
     625    LogFlowThisFuncEnter();
     626
    565627    AutoCaller autoCaller(this);
    566628    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     
    575637    ReturnComNotImplemented();
    576638#else
     639    LogFlowThisFuncEnter();
     640
    577641    AutoCaller autoCaller(this);
    578642    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     
    587651    ReturnComNotImplemented();
    588652#else
     653    LogFlowThisFuncEnter();
     654
    589655    AutoCaller autoCaller(this);
    590656    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     
    594660    mData.mEnvironment.Clear();
    595661
     662    LogFlowFuncLeaveRC(S_OK);
     663    return S_OK;
     664#endif /* VBOX_WITH_GUEST_CONTROL */
     665}
     666
     667STDMETHODIMP GuestSession::EnvironmentGet(IN_BSTR aName, BSTR *aValue)
     668{
     669#ifndef VBOX_WITH_GUEST_CONTROL
     670    ReturnComNotImplemented();
     671#else
     672    LogFlowThisFuncEnter();
     673
     674    if (RT_UNLIKELY((aName) == NULL || *(aName) == '\0'))
     675        return setError(E_INVALIDARG, tr("No value name specified"));
     676
     677    CheckComArgOutPointerValid(aValue);
     678
     679    AutoCaller autoCaller(this);
     680    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     681
     682    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
     683
     684    Bstr strValue(mData.mEnvironment.Get(Utf8Str(aName)));
     685    strValue.cloneTo(aValue);
     686
     687    LogFlowFuncLeaveRC(S_OK);
    596688    return S_OK;
    597689#endif /* VBOX_WITH_GUEST_CONTROL */
     
    603695    ReturnComNotImplemented();
    604696#else
     697    LogFlowThisFuncEnter();
     698
     699    if (RT_UNLIKELY((aName) == NULL || *(aName) == '\0'))
     700        return setError(E_INVALIDARG, tr("No value name specified"));
     701
    605702    AutoCaller autoCaller(this);
    606703    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     
    608705    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    609706
    610     mData.mEnvironment.Set(Utf8Str(aName), Utf8Str(aValue));
    611 
    612     return S_OK;
     707    int rc = mData.mEnvironment.Set(Utf8Str(aName), Utf8Str(aValue));
     708
     709    HRESULT hr = RT_SUCCESS(rc) ? S_OK : VBOX_E_IPRT_ERROR;
     710    LogFlowFuncLeaveRC(hr);
     711    return hr;
    613712#endif /* VBOX_WITH_GUEST_CONTROL */
    614713}
     
    619718    ReturnComNotImplemented();
    620719#else
     720    LogFlowThisFuncEnter();
     721
    621722    AutoCaller autoCaller(this);
    622723    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     
    628729    int rc = VINF_SUCCESS;
    629730    for (size_t i = 0; i < environment.size() && RT_SUCCESS(rc); i++)
    630         rc = mData.mEnvironment.Set(Utf8Str(environment[i]));
    631 
    632     return RT_SUCCESS(rc) ? S_OK : VBOX_E_IPRT_ERROR;
     731    {
     732        Utf8Str strEnv(environment[i]);
     733        if (!strEnv.isEmpty()) /* Silently skip empty entries. */
     734            rc = mData.mEnvironment.Set(strEnv);
     735    }
     736
     737    HRESULT hr = RT_SUCCESS(rc) ? S_OK : VBOX_E_IPRT_ERROR;
     738    LogFlowFuncLeaveRC(hr);
     739    return hr;
    633740#endif /* VBOX_WITH_GUEST_CONTROL */
    634741}
     
    639746    ReturnComNotImplemented();
    640747#else
     748    LogFlowThisFuncEnter();
     749
    641750    AutoCaller autoCaller(this);
    642751    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     
    646755    mData.mEnvironment.Unset(Utf8Str(aName));
    647756
     757    LogFlowFuncLeaveRC(S_OK);
    648758    return S_OK;
    649759#endif /* VBOX_WITH_GUEST_CONTROL */
     
    655765    ReturnComNotImplemented();
    656766#else
     767    LogFlowThisFuncEnter();
     768
    657769    AutoCaller autoCaller(this);
    658770    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     
    667779    ReturnComNotImplemented();
    668780#else
     781    LogFlowThisFuncEnter();
     782
    669783    AutoCaller autoCaller(this);
    670784    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     
    679793    ReturnComNotImplemented();
    680794#else
     795    LogFlowThisFuncEnter();
     796
    681797    AutoCaller autoCaller(this);
    682798    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     
    691807    ReturnComNotImplemented();
    692808#else
     809    LogFlowThisFuncEnter();
     810
    693811    AutoCaller autoCaller(this);
    694812    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     
    703821    ReturnComNotImplemented();
    704822#else
     823    LogFlowThisFuncEnter();
     824
    705825    AutoCaller autoCaller(this);
    706826    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     
    715835    ReturnComNotImplemented();
    716836#else
     837    LogFlowThisFuncEnter();
     838
    717839    AutoCaller autoCaller(this);
    718840    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     
    727849    ReturnComNotImplemented();
    728850#else
     851    LogFlowThisFuncEnter();
     852
    729853    AutoCaller autoCaller(this);
    730854    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     
    739863    ReturnComNotImplemented();
    740864#else
     865    LogFlowThisFuncEnter();
     866
    741867    AutoCaller autoCaller(this);
    742868    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     
    752878    ReturnComNotImplemented();
    753879#else
     880    LogFlowThisFuncEnter();
    754881
    755882    com::SafeArray<LONG> affinity;
     
    768895    ReturnComNotImplemented();
    769896#else
     897    LogFlowThisFuncEnter();
     898
    770899    AutoCaller autoCaller(this);
    771900    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     
    812941        rc = processCreateExInteral(procInfo, aProcess);
    813942    }
    814     return RT_SUCCESS(rc) ? S_OK : VBOX_E_IPRT_ERROR;
     943
     944    HRESULT hr = RT_SUCCESS(rc) ? S_OK : VBOX_E_IPRT_ERROR;
     945    LogFlowFuncLeaveRC(hr);
     946    return hr;
    815947#endif /* VBOX_WITH_GUEST_CONTROL */
    816948}
     
    821953    ReturnComNotImplemented();
    822954#else
     955    LogFlowThisFuncEnter();
     956
    823957    AutoCaller autoCaller(this);
    824958    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     
    833967    ReturnComNotImplemented();
    834968#else
     969    LogFlowThisFuncEnter();
     970
    835971    AutoCaller autoCaller(this);
    836972    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     
    845981    ReturnComNotImplemented();
    846982#else
     983    LogFlowThisFuncEnter();
     984
    847985    AutoCaller autoCaller(this);
    848986    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     
    857995    ReturnComNotImplemented();
    858996#else
     997    LogFlowThisFuncEnter();
     998
    859999    AutoCaller autoCaller(this);
    8601000    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     
    8691009    ReturnComNotImplemented();
    8701010#else
     1011    LogFlowThisFuncEnter();
     1012
    8711013    AutoCaller autoCaller(this);
    8721014    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     
    8811023    ReturnComNotImplemented();
    8821024#else
     1025    LogFlowThisFuncEnter();
     1026
    8831027    AutoCaller autoCaller(this);
    8841028    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     
    8931037    ReturnComNotImplemented();
    8941038#else
    895     AutoCaller autoCaller(this);
    896     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    897 
    898     ReturnComNotImplemented();
    899 #endif /* VBOX_WITH_GUEST_CONTROL */
    900 }
    901 
     1039    LogFlowThisFuncEnter();
     1040
     1041    AutoCaller autoCaller(this);
     1042    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     1043
     1044    ReturnComNotImplemented();
     1045#endif /* VBOX_WITH_GUEST_CONTROL */
     1046}
     1047
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