Changeset 42160 in vbox for trunk/src/VBox/Main/include

Timestamp:

Jul 16, 2012 11:41:10 AM (13 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

79137

Message:

Guest Control 2.0: Update.

Location:

trunk/src/VBox/Main/include

Files:

• GuestCtrlImplPrivate.h (modified) (4 diffs)
• GuestImpl.h (modified) (4 diffs)
• GuestProcessImpl.h (modified) (3 diffs)
• GuestSessionImpl.h (modified) (5 diffs)

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

@@ -1 +1 @@
 /** @file
  *
- * VirtualBox Guest Control - Private data definitions / classes.
+ * Internal helpers/structures for guest control functionality.
  */
 
 /*
- * Copyright (C) 2011 Oracle Corporation
+ * Copyright (C) 2011-2012 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -19 +19 @@
 #define ____H_GUESTIMPLPRIVATE
 
+#include <iprt/semaphore.h>
+
 #include <VBox/com/com.h>
+#include <VBox/com/ErrorInfo.h>
 #include <VBox/com/string.h>
 #include <VBox/com/VirtualBox.h>
@@ -33 +36 @@
 #endif
 
-class Guest;
-class Progress;
-
-/** Structure representing the "value" side of a "key=value" pair. */
+
+/* Builds a context ID out of the session ID, process ID and an
+ * increasing count. */
+#define VBOX_GUESTCTRL_CONTEXTID_MAKE(uSession, uProcess, uCount) \
+    (  (uint32_t)((uSession) &   0xff) << 24 \
+     | (uint32_t)((uProcess) &   0xff) << 16 \
+     | (uint32_t)((uCount)   & 0xffff)       \
+    )
+
+
+typedef std::vector <LONG> ProcessAffinity;
+typedef std::vector <Utf8Str> ProcessArguments;
+typedef std::map <Utf8Str, Utf8Str> ProcessEnvironmentMap;
+
+
+/**
+ * Generic class for a all guest control callbacks.
+ */
+class GuestCtrlCallback
+{
+public:
+
+    GuestCtrlCallback(void);
+
+    GuestCtrlCallback(eVBoxGuestCtrlCallbackType enmType);
+
+    virtual ~GuestCtrlCallback(void);
+
+    /** @todo Copy/comparison operator? */
+
+public:
+
+    int Init(eVBoxGuestCtrlCallbackType enmType);
+
+    void Destroy(void);
+
+    eVBoxGuestCtrlCallbackType Type(void);
+
+    int Wait(RTMSINTERVAL timeoutMS);
+
+protected:
+
+    /** The callback type. */
+    eVBoxGuestCtrlCallbackType  mType;
+    /** Callback flags. */
+    uint32_t                    mFlags;
+    /** Pointer to user-supplied data. */
+    void                       *pvData;
+    /** Size of user-supplied data. */
+    size_t                      cbData;
+    /** The event semaphore triggering the*/
+    RTSEMEVENT                  mEventSem;
+    /** Extended error information, if any. */
+    ErrorInfo                   mErrorInfo;
+};
+typedef std::map <uint32_t, GuestCtrlCallback> GuestCtrlCallbacks;
+
+/**
+ * Simple structure mantaining guest credentials.
+ */
+class GuestCredentials
+{
+public:
+
+
+public:
+
+    Utf8Str                     mUser;
+    Utf8Str                     mPassword;
+    Utf8Str                     mDomain;
+};
+
+/**
+ * Structure for keeping all the relevant process
+ * starting parameters around.
+ */
+struct GuestProcessInfo
+{
+    Utf8Str                     mCommand;
+    ProcessArguments            mArguments;
+    ProcessEnvironmentMap       mEnvironment;
+    uint32_t                    mFlags;
+    ULONG                       mTimeoutMS;
+    ProcessPriority_T           mPriority;
+    ProcessAffinity             mAffinity;
+};
+
+/**
+ * Class representing the "value" side of a "key=value" pair.
+ */
 class GuestProcessStreamValue
 {
@@ -144 +233 @@
     BYTE *m_pbBuffer;
 };
+
+class Guest;
+class Progress;
 
 class GuestTask

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

@@ -4 +4 @@
 
 /*
- * Copyright (C) 2006-2011 Oracle Corporation
+ * Copyright (C) 2006-2012 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -205 +205 @@
     /** @name Public internal methods.
      * @{ */
-    int sessionClose(ComObjPtr<GuestSession> pSession);
+    Console    *getConsole(void) { return mParent; }
+    int         sessionClose(ComObjPtr<GuestSession> pSession);
+    int         sessionCreate(const Utf8Str &strUser, const Utf8Str &aPassword, const Utf8Str &aDomain,
+                              const Utf8Str &aSessionName, IGuestSession **aGuestSession);
+    inline bool sessionExists(uint32_t uSessionID);
     /** @}  */
 
@@ -303 +307 @@
     typedef std::map< AdditionsFacilityType_T, ComObjPtr<AdditionsFacility> >::const_iterator FacilityMapIterConst;
 
-    typedef std::list <ComObjPtr<GuestSession> > GuestSessions;
+    /** Map for keeping the guest sessions. The primary key marks the guest session ID. */
+    typedef std::map <uint32_t, ComObjPtr<GuestSession> > GuestSessions;
 
     struct Data
@@ -320 +325 @@
         Bstr                    mInterfaceVersion;
         GuestSessions           mGuestSessions;
+        uint32_t                mNextSessionID;
     };
 

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

@@ -21 +21 @@
 
 #include "VirtualBoxBase.h"
+#include "GuestCtrlImplPrivate.h"
 
-#include <vector>
-
-typedef std::vector<Utf8Str> StringsArray;
-
+class Console;
 class GuestSession;
 
@@ -47 +45 @@
     DECLARE_EMPTY_CTOR_DTOR(GuestProcess)
 
-    int     init(GuestSession *pSession,
-                 const Utf8Str &aCommand, const StringsArray &aArguments, const StringsArray &aEnvironment,
-                 ComSafeArrayIn(ProcessCreateFlag_T, aFlags), ULONG aTimeoutMS,
-                 ProcessPriority_T aPriority, ComSafeArrayIn(LONG, aAffinity));
+    int     init(Console *aConsole, GuestSession *aSession, uint32_t aProcessID, const GuestProcessInfo &aProcInfo);
     void    uninit(void);
     HRESULT FinalConstruct(void);
@@ -74 +69 @@
     /** @name Public internal methods.
      * @{ */
+    int callbackAdd(const GuestCtrlCallback& theCallback, uint32_t *puContextID);
+    bool callbackExists(uint32_t uContextID);
+    bool isReady(void);
+    int prepareExecuteEnv(const char *pszEnv, void **ppvList, uint32_t *pcbList, uint32_t *pcEnvVars);
+    int readData(ULONG aHandle, ULONG aSize, ULONG aTimeoutMS, ComSafeArrayOut(BYTE, aData));
+    int startProcess(void);
+    static DECLCALLBACK(int) GuestProcess::startProcessThread(RTTHREAD Thread, void *pvUser);
+    int terminateProcess(void);
+    int waitFor(ComSafeArrayIn(ProcessWaitForFlag_T, aFlags), ULONG aTimeoutMS, ProcessWaitReason_T *aReason);
+    int writeData(ULONG aHandle, ComSafeArrayIn(BYTE, aData), ULONG aTimeoutMS, ULONG *aWritten);
     /** @}  */
 
 private:
 
-    typedef std::map <Utf8Str, Utf8Str> MyStringMap;
-
     struct Data
     {
-        GuestSession        *mParent;
-        Bstr                 mName;
+        /** Pointer to parent session. */
+        GuestSession            *mParent;
+        /** Pointer to the console object. Needed
+         *  for HGCM (VMMDev) communication. */
+        Console                 *mConsole;
+        /** All related callbacks to this process. */
+        GuestCtrlCallbacks       mCallbacks;
+        /** The process start information. */
+        GuestProcessInfo         mProcess;
+        /** Exit code if process has been terminated. */
+        LONG                     mExitCode;
+        /** PID reported from the guest. */
+        ULONG                    mPID;
+        /** Internal, host-side process ID. */
+        uint32_t                 mProcessID;
+        /** The current process status. */
+        ProcessStatus_T          mStatus;
+        /** Flag indicating whether the process has been started. */
+        bool                     mStarted;
+        /** The next upcoming context ID. */
+        uint32_t                 mNextContextID;
     } mData;
 };

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

@@ -22 +22 @@
 #include "VirtualBoxBase.h"
 
+#include "GuestCtrlImplPrivate.h"
 #include "GuestProcessImpl.h"
 #include "GuestDirectoryImpl.h"
 #include "GuestFileImpl.h"
 #include "GuestFsObjInfoImpl.h"
-
-#include <map>
-#include <vector>
-
-typedef std::vector<Utf8Str> StringsArray;
 
 class Guest;
@@ -52 +48 @@
     DECLARE_EMPTY_CTOR_DTOR(GuestSession)
 
-    int     init(Guest *aGuest, Utf8Str aUser, Utf8Str aPassword, Utf8Str aDomain, Utf8Str aName);
+    int     init(Guest *aGuest, uint32_t aSessionID, Utf8Str aUser, Utf8Str aPassword, Utf8Str aDomain, Utf8Str aName);
     void    uninit(void);
     HRESULT FinalConstruct(void);
@@ -115 +111 @@
     /** @name Public internal methods.
      * @{ */
-    int directoryClose(ComObjPtr<GuestDirectory> pDirectory);
-    int fileClose(ComObjPtr<GuestFile> pFile);
-    int processClose(ComObjPtr<GuestProcess> pProcess);
-    int processCreateExInteral(const Utf8Str &aCommand, const StringsArray &aArguments, const StringsArray &aEnvironment,
-                               ComSafeArrayIn(ProcessCreateFlag_T, aFlags), ULONG aTimeoutMS,
-                               ProcessPriority_T aPriority, ComSafeArrayIn(LONG, aAffinity),
-                               IGuestProcess **aProcess);
+    int                     directoryClose(ComObjPtr<GuestDirectory> pDirectory);
+    int                     fileClose(ComObjPtr<GuestFile> pFile);
+    const GuestCredentials &getCredentials(void);
+    int                     processClose(ComObjPtr<GuestProcess> pProcess);
+    int                     processCreateExInteral(GuestProcessInfo &aProcInfo, IGuestProcess **aProcess);
+    inline bool             processExists(uint32_t uProcessID);
     /** @}  */
 
@@ -128 +123 @@
     typedef std::map <Utf8Str, Utf8Str> SessionEnvironment;
 
-    typedef std::list <ComObjPtr<GuestDirectory> > SessionDirectories;
-    typedef std::list <ComObjPtr<GuestFile> > SessionFiles;
-    typedef std::list <ComObjPtr<GuestProcess> > SessionProcesses;
+    typedef std::vector <ComObjPtr<GuestDirectory> > SessionDirectories;
+    typedef std::vector <ComObjPtr<GuestFile> > SessionFiles;
+    typedef std::map <uint32_t, ComObjPtr<GuestProcess> > SessionProcesses;
 
     struct Data
@@ -137 +132 @@
          *  or not. Internal session are not accessible by clients. */
         bool                 fInternal;
-        /** Pointer to the parent (IGuest). */
+        /** Pointer to the parent (Guest). */
         Guest               *mParent;
         /** The session credentials. */
-        Utf8Str              mUser;
-        Utf8Str              mPassword;
-        Utf8Str              mDomain;
+        GuestCredentials     mCredentials;
         /** The (optional) session name. */
         Utf8Str              mName;