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

Timestamp:

Jul 24, 2012 12:13:00 PM (13 years ago)

Author:

vboxsync

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

79433

Message:

Guest Control 2.0: Update.

Location:

trunk/src/VBox/Main/include

Files:

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

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

@@ -19 +19 @@
 #define ____H_GUESTIMPLPRIVATE
 
+#include <iprt/asm.h>
 #include <iprt/semaphore.h>
 
@@ -67 +68 @@
 
 /**
- * Generic class for a all guest control callbacks.
- */
-class GuestCtrlCallback
-{
-public:
-
+ * Generic class for a all guest control callbacks/events.
+ */
+class GuestCtrlEvent
+{
+public:
+
+    GuestCtrlEvent(void);
+
+    virtual ~GuestCtrlEvent(void);
+
+    /** @todo Copy/comparison operator? */
+
+public:
+
+    int Cancel(void);
+
+    bool Canceled(void);
+
+    virtual void Destroy(void);
+
+    int Init(void);
+
+    virtual int Signal(int rc = VINF_SUCCESS);
+
+    int GetResultCode(void) { return mRC; }
+
+    int Wait(ULONG uTimeoutMS);
+
+protected:
+
+    /** Was the callback canceled? */
+    bool                        fCanceled;
+    /** Did the callback complete? */
+    bool                        fCompleted;
+    /** The event semaphore for triggering
+     *  the actual event. */
+    RTSEMEVENT                  hEventSem;
+    /** The waiting mutex. */
+    RTSEMMUTEX                  hEventMutex;
+    /** Overall result code. */
+    int                         mRC;
+};
+
+/*
+ * Class representing a guest control callback.
+ */
+class GuestCtrlCallback : public GuestCtrlEvent
+{
+public:
     GuestCtrlCallback(void);
 
@@ -79 +123 @@
     virtual ~GuestCtrlCallback(void);
 
-    /** @todo Copy/comparison operator? */
-
-public:
-
-    int Cancel(void);
-
-    bool Canceled(void);
+public:
+
+    void Destroy(void);
 
     int Init(eVBoxGuestCtrlCallbackType enmType);
 
-    void Destroy(void);
-
-    int Signal(int rc = VINF_SUCCESS, const Utf8Str &strMsg = "");
-
-    Utf8Str GetMessage(void) { return mMessage; }
-
-    int GetResultCode(void) { return mRC; }
-
-    eVBoxGuestCtrlCallbackType GetType(void) { return mType; }
-
-    int Wait(ULONG uTimeoutMS);
-
-protected:
-
+    eVBoxGuestCtrlCallbackType GetCallbackType(void) { return mType; }
+
+protected:
+
+    /** Pointer to user-supplied data. */
+    void                       *pvData;
+    /** Size of user-supplied data. */
+    size_t                      cbData;
     /** The callback type. */
     eVBoxGuestCtrlCallbackType  mType;
     /** Callback flags. */
     uint32_t                    uFlags;
-    /** Was the callback canceled? */
-    bool                        fCanceled;
-    /** Did the callback complete? */
-    bool                        fCompleted;
-    /** Pointer to user-supplied data. */
-    void                       *pvData;
-    /** Size of user-supplied data. */
-    size_t                      cbData;
-    /** The event semaphore triggering the*/
-    RTSEMEVENT                  hEventSem;
-    /** Overall result code. */
+};
+typedef std::map < uint32_t, GuestCtrlCallback* > GuestCtrlCallbacks;
+
+struct GuestProcessWaitResult
+{
+    /** The wait result when returning from the wait call. */
+    ProcessWaitResult_T         mResult;
     int                         mRC;
-    /** Error / information message to the
-     *  result code. */
-    Utf8Str                     mMessage;
-};
-typedef std::map < uint32_t, GuestCtrlCallback* > GuestCtrlCallbacks;
+};
+
+/*
+ * Class representing a guest control process event.
+ */
+class GuestProcessEvent : public GuestCtrlEvent
+{
+public:
+    GuestProcessEvent(void);
+
+    GuestProcessEvent(uint32_t uWaitFlags);
+
+    virtual ~GuestProcessEvent(void);
+
+public:
+
+    void Destroy(void);
+
+    int Init(uint32_t uWaitFlags);
+
+    uint32_t GetWaitFlags(void) { return ASMAtomicReadU32(&mWaitFlags); }
+
+    GuestProcessWaitResult GetResult(void) { return mWaitResult; }
+
+    int Signal(ProcessWaitResult enmResult, int rc = VINF_SUCCESS);
+
+protected:
+
+    /** The waiting flag(s). The specifies what to
+     *  wait for. */
+    uint32_t                    mWaitFlags;
+    /** Structure containing the overall result. */
+    GuestProcessWaitResult      mWaitResult;
+};
 
 /**

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

@@ -209 +209 @@
     int         sessionClose(ComObjPtr<GuestSession> pSession);
     int         sessionCreate(const Utf8Str &strUser, const Utf8Str &aPassword, const Utf8Str &aDomain,
-                              const Utf8Str &aSessionName, IGuestSession **aGuestSession);
+                              const Utf8Str &aSessionName, ComObjPtr<GuestSession> &pGuestSession);
     inline bool sessionExists(uint32_t uSessionID);
     /** @}  */

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

@@ -62 +62 @@
     STDMETHOD(Read)(ULONG aHandle, ULONG aSize, ULONG aTimeoutMS, ComSafeArrayOut(BYTE, aData));
     STDMETHOD(Terminate)(void);
-    STDMETHOD(WaitFor)(ComSafeArrayIn(ProcessWaitForFlag_T, aFlags), ULONG aTimeoutMS, ProcessWaitReason_T *aReason);
+    STDMETHOD(WaitFor)(ComSafeArrayIn(ProcessWaitForFlag_T, aFlags), ULONG aTimeoutMS, ProcessWaitResult_T *aReason);
     STDMETHOD(Write)(ULONG aHandle, ComSafeArrayIn(BYTE, aData), ULONG aTimeoutMS, ULONG *aWritten);
     /** @}  */
@@ -69 +69 @@
     /** @name Public internal methods.
      * @{ */
-    int callbackAdd(GuestCtrlCallback *pCallback, ULONG *puContextID);
     int callbackDispatcher(uint32_t uContextID, uint32_t uFunction, void *pvData, size_t cbData);
     inline bool callbackExists(ULONG uContextID);
+    void close(void);
     bool isReady(void);
     ULONG getPID(void) { return mData.mPID; }
+    int readData(ULONG uHandle, ULONG uSize, ULONG uTimeoutMS, BYTE *pbData, size_t cbData);
+    int startProcess(void);
+    int startProcessAsync(void);
+    int terminateProcess(void);
+    int waitFor(uint32_t fWaitFlags, ULONG uTimeoutMS, GuestProcessWaitResult &guestResult);
+    HRESULT waitResultToErrorEx(const GuestProcessWaitResult &waitResult, bool fLog);
+    int writeData(ULONG uHandle, BYTE const *pbData, size_t cbData, ULONG uTimeoutMS, ULONG *puWritten);
+    /** @}  */
+
+protected:
+    /** @name Protected internal methods.
+     * @{ */
+    inline int callbackAdd(GuestCtrlCallback *pCallback, ULONG *puContextID);
+    inline int callbackRemove(ULONG uContextID);
     int onGuestDisconnected(GuestCtrlCallback *pCallback, PCALLBACKDATACLIENTDISCONNECTED pData);
     int onProcessInputStatus(GuestCtrlCallback *pCallback, PCALLBACKDATAEXECINSTATUS pData);
@@ -79 +93 @@
     int onProcessOutput(GuestCtrlCallback *pCallback, PCALLBACKDATAEXECOUT pData);
     int prepareExecuteEnv(const char *pszEnv, void **ppvList, ULONG *pcbList, ULONG *pcEnvVars);
-    int readData(ULONG uHandle, ULONG uSize, ULONG uTimeoutMS, BYTE *pbData, size_t cbData);
     int sendCommand(uint32_t uFunction, uint32_t uParms, PVBOXHGCMSVCPARM paParms);
-    int signalWaiters(int rc, const Utf8Str strMessage = "");
-    int startProcess(int *pRC = NULL, Utf8Str *pstrMessage = NULL);
+    int signalWaiters(ProcessWaitResult enmWaitResult, int rc = VINF_SUCCESS);
     static DECLCALLBACK(int) startProcessThread(RTTHREAD Thread, void *pvUser);
-    int terminateProcess(void);
-    int waitFor(uint32_t fFlags, ULONG uTimeoutMS, ProcessWaitReason_T *penmReason);
-    int writeData(ULONG uHandle, BYTE const *pbData, size_t cbData, ULONG uTimeoutMS, ULONG *puWritten);
     /** @}  */
 
@@ -110 +119 @@
         /** The current process status. */
         ProcessStatus_T          mStatus;
-        /** Flag indicating whether the process has been started. */
+        /** Flag indicating whether the process has been started
+         *  so that it can't be started a second time. */
         bool                     mStarted;
         /** The next upcoming context ID. */
         ULONG                    mNextContextID;
-        /** Flag indicating someone is waiting for an event. */
-        bool                     mWaiting;
-        /** The waiting mutex. */
-        RTSEMMUTEX               mWaitMutex;
-        /** The waiting flag(s). */
-        uint32_t                 mWaitFlags;
-        /** The waiting event. */
-        RTSEMEVENT               mWaitEvent;
+        /** How many waiters? At the moment there can only
+         *  be one. */
+        uint32_t                 mWaitCount;
+        /** The actual process event for doing the waits.
+         *  At the moment we only support one wait a time. */
+        GuestProcessEvent       *mWaitEvent;
     } mData;
 };

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

@@ -126 +126 @@
     const GuestEnvironment &getEnvironment(void);
     int                     processClose(ComObjPtr<GuestProcess> pProcess);
-    int                     processCreateExInteral(const GuestProcessInfo &aProcInfo, IGuestProcess **aProcess);
+    int                     processCreateExInteral(GuestProcessInfo &procInfo, ComObjPtr<GuestProcess> &pProgress);
     inline bool             processExists(ULONG uProcessID, ComObjPtr<GuestProcess> *pProcess);
     inline int              processGetByPID(ULONG uPID, ComObjPtr<GuestProcess> *pProcess);