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

Timestamp:

Jul 16, 2012 8:28:47 PM (13 years ago)

Author:

vboxsync

Message:

Guest Control 2.0: Update.

Location:

trunk/src/VBox/Main

Files:

• include/GuestCtrlImplPrivate.h (modified) (3 diffs)
• include/GuestSessionImpl.h (modified) (4 diffs)
• src-client/GuestCtrlImpl.cpp (modified) (1 diff)
• src-client/GuestCtrlPrivate.cpp (modified) (1 diff)
• src-client/GuestProcessImpl.cpp (modified) (5 diffs)
• src-client/GuestSessionImpl.cpp (modified) (8 diffs)

trunk/src/VBox/Main/include/GuestCtrlImplPrivate.h

@@ -48 +48 @@
 typedef std::vector <LONG> ProcessAffinity;
 typedef std::vector <Utf8Str> ProcessArguments;
-typedef std::map <Utf8Str, Utf8Str> ProcessEnvironmentMap;
 
 
@@ -108 +107 @@
 };
 
+typedef std::vector <Utf8Str> GuestEnvironmentArray;
+class GuestEnvironment
+{
+public:
+
+    int BuildEnvironmentBlock(void **ppvEnv, uint32_t *pcbEnv, uint32_t *pcEnvVars);
+
+    void Clear(void);
+
+    int CopyFrom(const GuestEnvironmentArray &environment);
+
+    int CopyTo(GuestEnvironmentArray &environment);
+
+    static void FreeEnvironmentBlock(void *pvEnv);
+
+    Utf8Str Get(size_t nPos);
+
+    bool Has(const Utf8Str &strKey);
+
+    int Set(const Utf8Str &strKey, const Utf8Str &strValue);
+
+    int Set(const Utf8Str &strPair);
+
+    size_t Size(void);
+
+    int Unset(const Utf8Str &strKey);
+
+public:
+
+    GuestEnvironment& operator=(const GuestEnvironmentArray &that);
+
+    GuestEnvironment& operator=(const GuestEnvironment &that);
+
+protected:
+
+    int appendToEnvBlock(const char *pszEnv, void **ppvList, uint32_t *pcbList, uint32_t *pcEnvVars);
+
+protected:
+
+    std::map <Utf8Str, Utf8Str> mEnvironment;
+};
+
+
 /**
  * Structure for keeping all the relevant process
@@ -116 +158 @@
     Utf8Str                     mCommand;
     ProcessArguments            mArguments;
-    ProcessEnvironmentMap       mEnvironment;
+    GuestEnvironment            mEnvironment;
     uint32_t                    mFlags;
     ULONG                       mTimeoutMS;

trunk/src/VBox/Main/include/GuestSessionImpl.h

@@ -108 +108 @@
     /** @}  */
 
+private:
+
+    typedef std::vector <ComObjPtr<GuestDirectory> > SessionDirectories;
+    typedef std::vector <ComObjPtr<GuestFile> > SessionFiles;
+    typedef std::map <uint32_t, ComObjPtr<GuestProcess> > SessionProcesses;
+
 public:
     /** @name Public internal methods.
@@ -114 +120 @@
     int                     fileClose(ComObjPtr<GuestFile> pFile);
     const GuestCredentials &getCredentials(void);
+    const GuestEnvironment &getEnvironment(void);
     int                     processClose(ComObjPtr<GuestProcess> pProcess);
     int                     processCreateExInteral(GuestProcessInfo &aProcInfo, IGuestProcess **aProcess);
@@ -120 +127 @@
 
 private:
-
-    typedef std::map <Utf8Str, Utf8Str> SessionEnvironment;
-
-    typedef std::vector <ComObjPtr<GuestDirectory> > SessionDirectories;
-    typedef std::vector <ComObjPtr<GuestFile> > SessionFiles;
-    typedef std::map <uint32_t, ComObjPtr<GuestProcess> > SessionProcesses;
 
     struct Data
@@ -142 +143 @@
         /** The session timeout. Default is 30s. */
         ULONG                mTimeout;
-        SessionEnvironment   mEnvironment;
+        GuestEnvironment     mEnvironment;
         SessionDirectories   mDirectories;
         SessionFiles         mFiles;

trunk/src/VBox/Main/src-client/GuestCtrlImpl.cpp

@@ -2760 +2760 @@
     if (FAILED(autoCaller.rc())) return autoCaller.rc();
 
-
+    int rc = sessionCreate(aUser, aPassword, aDomain, aSessionName, aGuestSession);
+    return RT_SUCCESS(rc) ? S_OK : VBOX_E_IPRT_ERROR;
 #endif /* VBOX_WITH_GUEST_CONTROL */
 }

trunk/src/VBox/Main/src-client/GuestCtrlPrivate.cpp

@@ -125 +125 @@
     Assert(mEventSem != NIL_RTSEMEVENT);
     return RTSemEventWait(mEventSem, timeoutMS);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+int GuestEnvironment::BuildEnvironmentBlock(void **ppvEnv, uint32_t *pcbEnv, uint32_t *pcEnvVars)
+{
+    AssertPtrReturn(ppvEnv, VERR_INVALID_POINTER);
+    /* Rest is optional. */
+
+    uint32_t cbEnv = 0;
+    uint32_t cEnvVars = 0;
+
+    int rc = VINF_SUCCESS;
+
+    size_t cEnv = mEnvironment.size();
+    if (cEnv)
+    {
+        std::map<Utf8Str, Utf8Str>::const_iterator itEnv = mEnvironment.begin();
+        for (; itEnv != mEnvironment.end() && RT_SUCCESS(rc); itEnv++)
+        {
+            char *pszEnv;
+            if (!RTStrAPrintf(&pszEnv, "%s=%s", itEnv->first.c_str(), itEnv->second.c_str()))
+            {
+                rc = VERR_NO_MEMORY;
+                break;
+            }
+            AssertPtr(pszEnv);
+            rc = appendToEnvBlock(pszEnv, ppvEnv, &cbEnv, &cEnvVars);
+            RTStrFree(pszEnv);
+        }
+        Assert(cEnv == cEnvVars);
+    }
+
+    if (pcbEnv)
+        *pcbEnv = cbEnv;
+    if (pcEnvVars)
+        *pcEnvVars = cEnvVars;
+
+    return rc;
+}
+
+void GuestEnvironment::Clear(void)
+{
+    mEnvironment.clear();
+}
+
+int GuestEnvironment::CopyFrom(const GuestEnvironmentArray &environment)
+{
+    int rc = VINF_SUCCESS;
+
+    for (GuestEnvironmentArray::const_iterator it = environment.begin();
+         it != environment.end() && RT_SUCCESS(rc);
+         ++it)
+    {
+        rc = Set((*it));
+    }
+
+    return rc;
+}
+
+int GuestEnvironment::CopyTo(GuestEnvironmentArray &environment)
+{
+    size_t s = 0;
+    for (std::map<Utf8Str, Utf8Str>::const_iterator it = mEnvironment.begin();
+         it != mEnvironment.end();
+         ++it, ++s)
+    {
+        environment[s] = Bstr(it->first + "=" + it->second).raw();
+    }
+
+    return VINF_SUCCESS;
+}
+
+/* static */
+void GuestEnvironment::FreeEnvironmentBlock(void *pvEnv)
+{
+    if (pvEnv)
+        RTMemFree(pvEnv);
+}
+
+Utf8Str GuestEnvironment::Get(size_t nPos)
+{
+    size_t curPos = 0;
+    std::map<Utf8Str, Utf8Str>::const_iterator it = mEnvironment.begin();
+    for (; it != mEnvironment.end() && curPos < nPos;
+         ++it) { }
+
+    if (it != mEnvironment.end())
+        return Utf8Str(it->first + "=" + it->second);
+
+    return Utf8Str("");
+}
+
+bool GuestEnvironment::Has(const Utf8Str &strKey)
+{
+    std::map <Utf8Str, Utf8Str>::const_iterator itEnv = mEnvironment.find(strKey);
+    return (itEnv != mEnvironment.end());
+}
+
+int GuestEnvironment::Set(const Utf8Str &strKey, const Utf8Str &strValue)
+{
+    mEnvironment[strValue] = strValue;
+    return VINF_SUCCESS;
+}
+
+int GuestEnvironment::Set(const Utf8Str &strPair)
+{
+    RTCList<RTCString> listPair = strPair.split("=", RTCString::KeepEmptyParts);
+    size_t p = 0;
+    while(p < listPair.size())
+    {
+        Utf8Str strKey = listPair.at(p++);
+        if (strKey.isEmpty()) /* Skip pairs with empty keys (e.g. "=FOO"). */
+        {
+            p++;
+            continue;
+        }
+        Utf8Str strValue;
+        if (p < listPair.size())
+            strValue = listPair.at(p++);
+       mEnvironment[strKey] = strValue;
+    }
+
+    return VINF_SUCCESS;
+}
+
+size_t GuestEnvironment::Size(void)
+{
+    return mEnvironment.size();
+}
+
+int GuestEnvironment::Unset(const Utf8Str &strKey)
+{
+    std::map <Utf8Str, Utf8Str>::iterator itEnv = mEnvironment.find(strKey);
+    if (itEnv != mEnvironment.end())
+    {
+        mEnvironment.erase(itEnv);
+        return VINF_SUCCESS;
+    }
+
+    return VERR_NOT_FOUND;
+}
+
+GuestEnvironment& GuestEnvironment::operator=(const GuestEnvironmentArray &that)
+{
+    CopyFrom(that);
+    return *this;
+}
+
+GuestEnvironment& GuestEnvironment::operator=(const GuestEnvironment &that)
+{
+    for (std::map<Utf8Str, Utf8Str>::const_iterator it = that.mEnvironment.begin();
+         it != that.mEnvironment.end();
+         ++it)
+    {
+        mEnvironment[it->first] = it->second;
+    }
+
+    return *this;
+}
+
+/**
+ * Appends environment variables to the environment block.
+ *
+ * Each var=value pair is separated by the null character ('\\0').  The whole
+ * block will be stored in one blob and disassembled on the guest side later to
+ * fit into the HGCM param structure.
+ *
+ * @returns VBox status code.
+ *
+ * @param   pszEnvVar       The environment variable=value to append to the
+ *                          environment block.
+ * @param   ppvList         This is actually a pointer to a char pointer
+ *                          variable which keeps track of the environment block
+ *                          that we're constructing.
+ * @param   pcbList         Pointer to the variable holding the current size of
+ *                          the environment block.  (List is a misnomer, go
+ *                          ahead a be confused.)
+ * @param   pcEnvVars       Pointer to the variable holding count of variables
+ *                          stored in the environment block.
+ */
+int GuestEnvironment::appendToEnvBlock(const char *pszEnv, void **ppvList, uint32_t *pcbList, uint32_t *pcEnvVars)
+{
+    int rc = VINF_SUCCESS;
+    uint32_t cchEnv = strlen(pszEnv); Assert(cchEnv >= 2);
+    if (*ppvList)
+    {
+        uint32_t cbNewLen = *pcbList + cchEnv + 1; /* Include zero termination. */
+        char *pvTmp = (char *)RTMemRealloc(*ppvList, cbNewLen);
+        if (pvTmp == NULL)
+            rc = VERR_NO_MEMORY;
+        else
+        {
+            memcpy(pvTmp + *pcbList, pszEnv, cchEnv);
+            pvTmp[cbNewLen - 1] = '\0'; /* Add zero termination. */
+            *ppvList = (void **)pvTmp;
+        }
+    }
+    else
+    {
+        char *pszTmp;
+        if (RTStrAPrintf(&pszTmp, "%s", pszEnv) >= 0)
+        {
+            *ppvList = (void **)pszTmp;
+            /* Reset counters. */
+            *pcEnvVars = 0;
+            *pcbList = 0;
+        }
+    }
+    if (RT_SUCCESS(rc))
+    {
+        *pcbList += cchEnv + 1; /* Include zero termination. */
+        *pcEnvVars += 1;        /* Increase env variable count. */
+    }
+    return rc;
 }
 

trunk/src/VBox/Main/src-client/GuestProcessImpl.cpp

@@ -184 +184 @@
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    com::SafeArray<BSTR> collection(mData.mProcess.mEnvironment.size());
-    size_t s = 0;
-    for (ProcessEnvironmentMap::const_iterator it = mData.mProcess.mEnvironment.begin();
-         it != mData.mProcess.mEnvironment.end();
-         it++, s++)
-    {
-        Bstr strEnv = it->first + Utf8Str("=") + it->second;
-        collection[s] = strEnv.raw();
-    }
-
-    collection.detachTo(ComSafeArrayOutArg(aEnvironment));
+    com::SafeArray<BSTR> arguments(mData.mProcess.mEnvironment.Size());
+    for (size_t i = 0; i < arguments.size(); i++)
+        arguments[i] = Bstr(mData.mProcess.mEnvironment.Get(i)).raw();
+    arguments.detachTo(ComSafeArrayOutArg(aEnvironment));
 
     return S_OK;
@@ -347 +340 @@
 }
 
-/**
- * Appends environment variables to the environment block.
- *
- * Each var=value pair is separated by the null character ('\\0').  The whole
- * block will be stored in one blob and disassembled on the guest side later to
- * fit into the HGCM param structure.
- *
- * @returns VBox status code.
- *
- * @param   pszEnvVar       The environment variable=value to append to the
- *                          environment block.
- * @param   ppvList         This is actually a pointer to a char pointer
- *                          variable which keeps track of the environment block
- *                          that we're constructing.
- * @param   pcbList         Pointer to the variable holding the current size of
- *                          the environment block.  (List is a misnomer, go
- *                          ahead a be confused.)
- * @param   pcEnvVars       Pointer to the variable holding count of variables
- *                          stored in the environment block.
- */
-int GuestProcess::prepareExecuteEnv(const char *pszEnv, void **ppvList, uint32_t *pcbList, uint32_t *pcEnvVars)
-{
-    int rc = VINF_SUCCESS;
-    uint32_t cchEnv = strlen(pszEnv); Assert(cchEnv >= 2);
-    if (*ppvList)
-    {
-        uint32_t cbNewLen = *pcbList + cchEnv + 1; /* Include zero termination. */
-        char *pvTmp = (char *)RTMemRealloc(*ppvList, cbNewLen);
-        if (pvTmp == NULL)
-            rc = VERR_NO_MEMORY;
-        else
-        {
-            memcpy(pvTmp + *pcbList, pszEnv, cchEnv);
-            pvTmp[cbNewLen - 1] = '\0'; /* Add zero termination. */
-            *ppvList = (void **)pvTmp;
-        }
-    }
-    else
-    {
-        char *pszTmp;
-        if (RTStrAPrintf(&pszTmp, "%s", pszEnv) >= 0)
-        {
-            *ppvList = (void **)pszTmp;
-            /* Reset counters. */
-            *pcEnvVars = 0;
-            *pcbList = 0;
-        }
-    }
-    if (RT_SUCCESS(rc))
-    {
-        *pcbList += cchEnv + 1; /* Include zero termination. */
-        *pcEnvVars += 1;        /* Increase env variable count. */
-    }
-    return rc;
-}
-
 int GuestProcess::readData(ULONG aHandle, ULONG aSize, ULONG aTimeoutMS, ComSafeArrayOut(BYTE, aData))
 {
@@ -460 +397 @@
         /* Prepare environment. */
         void *pvEnv = NULL;
-        size_t cEnv = mData.mProcess.mEnvironment.size();
         uint32_t cbEnv = 0;
-        if (   RT_SUCCESS(rc)
-            && cEnv)
-        {
-            uint32_t cEnvBuild = 0;
-            ProcessEnvironmentMap::const_iterator itEnv = mData.mProcess.mEnvironment.begin();
-            for (; itEnv != mData.mProcess.mEnvironment.end() && RT_SUCCESS(rc); itEnv++)
-            {
-                char *pszEnv;
-                if (!RTStrAPrintf(&pszEnv, "%s=%s", itEnv->first.c_str(), itEnv->second.c_str()))
-                {
-                    rc = VERR_NO_MEMORY;
-                    break;
-                }
-                AssertPtr(pszEnv);
-                rc = prepareExecuteEnv(pszEnv, &pvEnv, &cbEnv, &cEnvBuild);
-                RTStrFree(pszEnv);
-            }
-            Assert(cEnv == cEnvBuild);
-        }
+        rc = mData.mProcess.mEnvironment.BuildEnvironmentBlock(&pvEnv, &cbEnv, NULL /* cEnv */);
 
         if (RT_SUCCESS(rc))
@@ -493 +411 @@
             paParms[i++].setUInt32(mData.mProcess.mArguments.size());
             paParms[i++].setPointer((void*)pszArgs, cbArgs);
-            paParms[i++].setUInt32(mData.mProcess.mEnvironment.size());
+            paParms[i++].setUInt32(mData.mProcess.mEnvironment.Size());
             paParms[i++].setUInt32(cbEnv);
             paParms[i++].setPointer((void*)pvEnv, cbEnv);
@@ -529 +447 @@
         }
 
-        if (pvEnv)
-            RTMemFree(pvEnv);
+        GuestEnvironment::FreeEnvironmentBlock(pvEnv);
         if (pszArgs)
             RTStrFree(pszArgs);

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

@@ -28 +28 @@
 #include "Logging.h"
 
+#include <iprt/env.h>
+
 #include <VBox/com/array.h>
 
@@ -223 +225 @@
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    com::SafeArray<BSTR> collection(mData.mEnvironment.size());
-    size_t s = 0;
-    for (SessionEnvironment::const_iterator it = mData.mEnvironment.begin();
-         it != mData.mEnvironment.end();
-         ++it, ++s)
-    {
-        collection[s] = Bstr(it->first + "=" + it->second).raw();
-    }
-
-    collection.detachTo(ComSafeArrayOutArg(aEnvironment));
+    com::SafeArray<BSTR> arguments(mData.mEnvironment.Size());
+    for (size_t i = 0; i < arguments.size(); i++)
+        arguments[i] = Bstr(mData.mEnvironment.Get(i)).raw();
+    arguments.detachTo(ComSafeArrayOutArg(aEnvironment));
 
     return S_OK;
@@ -335 +331 @@
 {
     return mData.mCredentials;
+}
+
+const GuestEnvironment& GuestSession::getEnvironment(void)
+{
+    return mData.mEnvironment;
 }
 
@@ -589 +590 @@
     if (FAILED(autoCaller.rc())) return autoCaller.rc();
 
-    ReturnComNotImplemented();
+    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    mData.mEnvironment.Clear();
+
+    return S_OK;
 #endif /* VBOX_WITH_GUEST_CONTROL */
 }
@@ -601 +606 @@
     if (FAILED(autoCaller.rc())) return autoCaller.rc();
 
-    ReturnComNotImplemented();
+    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    mData.mEnvironment.Set(Utf8Str(aName), Utf8Str(aValue));
+
+    return S_OK;
 #endif /* VBOX_WITH_GUEST_CONTROL */
 }
@@ -613 +622 @@
     if (FAILED(autoCaller.rc())) return autoCaller.rc();
 
-    ReturnComNotImplemented();
+    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    com::SafeArray<IN_BSTR> environment(ComSafeArrayInArg(aValues));
+
+    int rc = VINF_SUCCESS;
+    for (size_t i = 0; i < environment.size() && RT_SUCCESS(rc); i++)
+        rc = mData.mEnvironment.Set(Utf8Str(environment[i]));
+
+    return RT_SUCCESS(rc) ? S_OK : VBOX_E_IPRT_ERROR;
 #endif /* VBOX_WITH_GUEST_CONTROL */
 }
@@ -625 +642 @@
     if (FAILED(autoCaller.rc())) return autoCaller.rc();
 
-    ReturnComNotImplemented();
+    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    mData.mEnvironment.Unset(Utf8Str(aName));
+
+    return S_OK;
 #endif /* VBOX_WITH_GUEST_CONTROL */
 }
@@ -761 +782 @@
         procInfo.mArguments[i] = Utf8Str(Bstr(arguments[i]));
 
+    int rc = VINF_SUCCESS;
+
+    /* Create the process environment:
+     * - Apply the session environment in a first step, and
+     * - Apply environment variables specified by this call to
+     *   have the chance of overwriting/deleting session entries.
+     */
+    procInfo.mEnvironment = mData.mEnvironment;
     com::SafeArray<IN_BSTR> environment(ComSafeArrayInArg(aEnvironment));
-    for (size_t i = 0; i < environment.size(); i++)
-    {
-        Utf8Str strEnv = Bstr(environment[i]);
-        RTCList<RTCString> listPair = strEnv.split("=", RTCString::KeepEmptyParts);
-        size_t p = 0;
-        while(p < listPair.size())
-        {
-            Utf8Str strKey = listPair.at(p++);
-            if (strKey.isEmpty()) /* Skip pairs with empty keys (e.g. "=FOO"). */
-            {
-                p++;
-                continue;
-            }
-            Utf8Str strValue;
-            if (p < listPair.size())
-                strValue = listPair.at(p++);
-            procInfo.mEnvironment[strKey] = strValue;
-        }
-    }
-
-    com::SafeArray<ProcessCreateFlag_T> flags(ComSafeArrayInArg(aFlags));
-    for (size_t i = 0; i < flags.size(); i++)
-        procInfo.mFlags |= flags[i];
-
-    procInfo.mTimeoutMS = aTimeoutMS;
-
-    com::SafeArray<LONG> affinity(ComSafeArrayInArg(aAffinity));
-    procInfo.mAffinity.reserve(affinity.size());
-    for (size_t i = 0; i < affinity.size(); i++)
-        procInfo.mAffinity[i] = affinity[i]; /** @todo Really necessary? Later. */
-
-    procInfo.mPriority = aPriority;
-
-    int rc = processCreateExInteral(procInfo, aProcess);
+    for (size_t i = 0; i < environment.size() && RT_SUCCESS(rc); i++)
+        rc = mData.mEnvironment.Set(Utf8Str(environment[i]));
+
+    if (RT_SUCCESS(rc))
+    {
+
+        com::SafeArray<ProcessCreateFlag_T> flags(ComSafeArrayInArg(aFlags));
+        for (size_t i = 0; i < flags.size(); i++)
+            procInfo.mFlags |= flags[i];
+
+        procInfo.mTimeoutMS = aTimeoutMS;
+
+        com::SafeArray<LONG> affinity(ComSafeArrayInArg(aAffinity));
+        procInfo.mAffinity.reserve(affinity.size());
+        for (size_t i = 0; i < affinity.size(); i++)
+            procInfo.mAffinity[i] = affinity[i]; /** @todo Really necessary? Later. */
+
+        procInfo.mPriority = aPriority;
+
+        rc = processCreateExInteral(procInfo, aProcess);
+    }
     return RT_SUCCESS(rc) ? S_OK : VBOX_E_IPRT_ERROR;
 #endif /* VBOX_WITH_GUEST_CONTROL */