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

Timestamp:

Oct 31, 2013 4:40:46 PM (11 years ago)

Author:

vboxsync

Message:

Guest Control:

• Implemented IGuestSession::DirectoryRemove, IGuestSession::DirectoryRemoveRecursive, IGuestSession::DirectoryRename + IGuestSession::FileRename.
• Added appropriate commands to VBoxManage (basic support for now).
• Implemented support for proper guest session process termination via SCM.
• Implemented support for internal anonymous wait events which are not relying on the public API's VBoxEventType_T.
• Various bugfixes.

Location:

trunk/src/VBox/Main/include

Files:

• GuestCtrlImplPrivate.h (modified) (8 diffs)
• GuestDirectoryImpl.h (modified) (4 diffs)
• GuestProcessImpl.h (modified) (4 diffs)
• GuestSessionImpl.h (modified) (3 diffs)

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

@@ -101 +101 @@
 
     std::map <Utf8Str, Utf8Str> mEnvironment;
+};
+
+
+/**
+ * Structure for keeping all the relevant guest directory
+ * information around.
+ */
+struct GuestDirectoryOpenInfo
+{
+    /** The directory path. */
+    Utf8Str                 mPath;
+    /** Then open filter. */
+    Utf8Str                 mFilter;
+    /** Opening flags. */
+    uint32_t                mFlags;
 };
 
@@ -313 +328 @@
 #endif
 
-    uint32_t GetOffset();
-
-    uint32_t GetSize();
+    uint32_t GetOffset() { return m_cbOffset; }
+
+    size_t GetSize() { return m_cbSize; }
 
     int ParseBlock(GuestProcessStreamBlock &streamBlock);
@@ -324 +339 @@
     uint32_t m_cbAllocated;
     /** Currently used size of allocated internal stream buffer. */
-    uint32_t m_cbSize;
+    size_t m_cbSize;
     /** Current offset within the internal stream buffer. */
     uint32_t m_cbOffset;
@@ -378 +393 @@
 };
 
-class GuestWaitEvent
-{
-
-public:
-
-    GuestWaitEvent(uint32_t mCID, const std::list<VBoxEventType_T> &lstEvents);
-    virtual ~GuestWaitEvent(void);
-
-public:
-
-    uint32_t                         ContextID(void) { return mCID; };
-    const ComPtr<IEvent>             Event(void) { return mEvent; };
-    const std::list<VBoxEventType_T> Types(void) { return mEventTypes; };
-    size_t                           TypeCount(void) { return mEventTypes.size(); }
-    virtual int                      Signal(IEvent *pEvent);
-    int                              Wait(RTMSINTERVAL uTimeoutMS);
+class GuestWaitEventPayload
+{
+
+public:
+
+    GuestWaitEventPayload(void)
+        : uType(0),
+          cbData(0),
+          pvData(NULL) { }
+
+    GuestWaitEventPayload(uint32_t uTypePayload,
+                          const void *pvPayload, uint32_t cbPayload)
+    {
+        if (cbPayload)
+        {
+            pvData = RTMemAlloc(cbPayload);
+            if (pvData)
+            {
+                uType = uTypePayload;
+
+                memcpy(pvData, pvPayload, cbPayload);
+                cbData = cbPayload;
+            }
+            else /* Throw IPRT error. */
+                throw VERR_NO_MEMORY;
+        }
+        else
+        {
+            uType = uTypePayload;
+
+            pvData = NULL;
+            cbData = 0;
+        }
+    }
+
+    virtual ~GuestWaitEventPayload(void)
+    {
+        Clear();
+    }
+
+    GuestWaitEventPayload& operator=(const GuestWaitEventPayload &that)
+    {
+        CopyFromDeep(that);
+        return *this;
+    }
+
+public:
+
+    void Clear(void)
+    {
+        if (pvData)
+        {
+            RTMemFree(pvData);
+            cbData = 0;
+        }
+        uType = 0;
+    }
+
+    int CopyFromDeep(const GuestWaitEventPayload &payload)
+    {
+        Clear();
+
+        int rc;
+        if (payload.cbData)
+        {
+            Assert(payload.cbData);
+            pvData = RTMemAlloc(payload.cbData);
+            if (pvData)
+            {
+                memcpy(pvData, payload.pvData, payload.cbData);
+                cbData = payload.cbData;
+                uType = payload.uType;
+            }
+            else
+                rc = VERR_NO_MEMORY;
+        }
+        else
+            rc = VINF_SUCCESS;
+
+        return rc;
+    }
+
+    const void* Raw(void) const { return pvData; }
+
+    size_t Size(void) const { return cbData; }
+
+    uint32_t Type(void) const { return uType; }
+
+    void* MutableRaw(void) { return pvData; }
+
+protected:
+
+    /** Type of payload. */
+    uint32_t uType;
+    /** Size (in bytes) of payload. */
+    uint32_t cbData;
+    /** Pointer to actual payload data. */
+    void *pvData;
+};
+
+class GuestWaitEventBase
+{
+
+protected:
+
+    GuestWaitEventBase(void);
+    virtual ~GuestWaitEventBase(void);
+
+public:
+
+    uint32_t                        ContextID(void) { return mCID; };
+    int                             GuestResult(void) { return mGuestRc; }
+    int                             Result(void) { return mRc; }
+    GuestWaitEventPayload &         Payload(void) { return mPayload; }
+    int                             SignalInternal(int rc, int guestRc, const GuestWaitEventPayload *pPayload);
+    int                             Wait(RTMSINTERVAL uTimeoutMS);
+
+protected:
+
+    int             Init(uint32_t uCID);
 
 protected:
 
     /* Shutdown indicator. */
-    bool                       fAborted;
+    bool                       mfAborted;
     /* Associated context ID (CID). */
     uint32_t                   mCID;
-    /** List of event types this event should
-     *  be signalled on. */
-    std::list<VBoxEventType_T> mEventTypes;
     /** The event semaphore for triggering
      *  the actual event. */
     RTSEMEVENT                 mEventSem;
-    /** Pointer to the actual event. */
+    /** The event's overall result. If
+     *  set to VERR_GSTCTL_GUEST_ERROR,
+     *  mGuestRc will contain the actual
+     *  error code from the guest side. */
+    int                        mRc;
+    /** The event'S overall result from the
+     *  guest side. If used, mRc must be
+     *  set to VERR_GSTCTL_GUEST_ERROR. */
+    int                        mGuestRc;
+    /** The event's payload data. Optional. */
+    GuestWaitEventPayload      mPayload;
+};
+
+/** List of public guest event types. */
+typedef std::list < VBoxEventType_T > GuestEventTypes;
+
+class GuestWaitEvent : public GuestWaitEventBase
+{
+
+public:
+
+    GuestWaitEvent(uint32_t uCID);
+    GuestWaitEvent(uint32_t uCID, const GuestEventTypes &lstEvents);
+    virtual ~GuestWaitEvent(void);
+
+public:
+
+    int                              Cancel(void);
+    const ComPtr<IEvent>             Event(void) { return mEvent; }
+    int                              SignalExternal(IEvent *pEvent);
+    const GuestEventTypes            Types(void) { return mEventTypes; }
+    size_t                           TypeCount(void) { return mEventTypes.size(); }
+
+protected:
+
+    int                              Init(uint32_t uCID);
+
+protected:
+
+    /** List of public event types this event should
+     *  be signalled on. Optional. */
+    GuestEventTypes            mEventTypes;
+    /** Pointer to the actual public event, if any. */
     ComPtr<IEvent>             mEvent;
 };
-typedef std::list < GuestWaitEvent* > GuestWaitEvents;
-typedef std::map < VBoxEventType_T, GuestWaitEvents > GuestWaitEventTypes;
+/** Map of pointers to guest events. The primary key
+ *  contains the context ID. */
+typedef std::map < uint32_t, GuestWaitEvent* > GuestWaitEvents;
+/** Map of wait events per public guest event. Nice for
+ *  faster lookups when signalling a whole event group. */
+typedef std::map < VBoxEventType_T, GuestWaitEvents > GuestEventGroup;
 
 class GuestBase
@@ -423 +585 @@
 public:
 
-    /** For external event listeners. */
-    int signalWaitEvents(VBoxEventType_T aType, IEvent *aEvent);
-
+    /** Signals a wait event using a public guest event; also used for
+     *  for external event listeners. */
+    int signalWaitEvent(VBoxEventType_T aType, IEvent *aEvent);
+    /** Signals a wait event using a guest rc. */
+    int signalWaitEventInternal(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, int guestRc, const GuestWaitEventPayload *pPayload);
+    /** Signals a wait event without letting public guest events know,
+     *  extended director's cut version. */
+    int signalWaitEventInternalEx(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, int rc, int guestRc, const GuestWaitEventPayload *pPayload);
 public:
 
@@ -431 +598 @@
     void baseUninit(void);
     int cancelWaitEvents(void);
+    int dispatchGeneric(PVBOXGUESTCTRLHOSTCBCTX pCtxCb, PVBOXGUESTCTRLHOSTCALLBACK pSvcCb);
     int generateContextID(uint32_t uSessionID, uint32_t uObjectID, uint32_t *puContextID);
-    int registerWaitEvent(uint32_t uSessionID, uint32_t uObjectID, const std::list<VBoxEventType_T> &lstEvents, GuestWaitEvent **ppEvent);
+    int registerWaitEvent(uint32_t uSessionID, uint32_t uObjectID, GuestWaitEvent **ppEvent);
+    int registerWaitEvent(uint32_t uSessionID, uint32_t uObjectID, const GuestEventTypes &lstEvents, GuestWaitEvent **ppEvent);
     void unregisterWaitEvent(GuestWaitEvent *pEvent);
     int waitForEvent(GuestWaitEvent *pEvent, uint32_t uTimeoutMS, VBoxEventType_T *pType, IEvent **ppEvent);
@@ -448 +617 @@
     /** Critical section for wait events access. */
     RTCRITSECT               mWaitEventCritSect;
-    /** Map of internal events to wait for. */
-    GuestWaitEventTypes      mWaitEvents;
+    /** Map of registered wait events per event group. */
+    GuestEventGroup          mWaitEventGroups;
+    /** Map of registered wait events. */
+    GuestWaitEvents          mWaitEvents;
 };
 
@@ -476 +647 @@
 
     int bindToSession(Console *pConsole, GuestSession *pSession, uint32_t uObjectID);
-    int registerWaitEvent(const std::list<VBoxEventType_T> &lstEvents, GuestWaitEvent **ppEvent);
+    int registerWaitEvent(const GuestEventTypes &lstEvents, GuestWaitEvent **ppEvent);
     int sendCommand(uint32_t uFunction, uint32_t uParms, PVBOXHGCMSVCPARM paParms);
 

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

@@ -30 +30 @@
 class ATL_NO_VTABLE GuestDirectory :
     public VirtualBoxBase,
+    public GuestObject,
     VBOX_SCRIPTABLE_IMPL(IGuestDirectory)
 {
@@ -44 +45 @@
     DECLARE_EMPTY_CTOR_DTOR(GuestDirectory)
 
-    int     init(GuestSession *aSession, const Utf8Str &strPath, const Utf8Str &strFilter, uint32_t uFlags);
+    int     init(Console *pConsole, GuestSession *pSession, ULONG uDirID, const GuestDirectoryOpenInfo &openInfo);
     void    uninit(void);
     HRESULT FinalConstruct(void);
@@ -61 +62 @@
     /** @name Public internal methods.
      * @{ */
+    int            callbackDispatcher(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCb);
+    static Utf8Str guestErrorToString(int guestRc);
+    static HRESULT setErrorExternal(VirtualBoxBase *pInterface, int guestRc);
     /** @}  */
 
@@ -71 +75 @@
     struct Data
     {
-        GuestSession              *mSession;
-        Utf8Str                    mName;
-        Utf8Str                    mFilter;
-        uint32_t                   mFlags;
+        /** The directory's open info. */
+        GuestDirectoryOpenInfo     mOpenInfo;
+        /** The directory's ID. */
+        uint32_t                   mID;
         GuestProcessTool           mProcessTool;
     } mData;

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

@@ -82 +82 @@
     int startProcessAsync(void);
     int terminateProcess(uint32_t uTimeoutMS, int *pGuestRc);
-    static ProcessWaitResult_T waitFlagsToResultEx(uint32_t fWaitFlags, ProcessStatus_T procStatus, uint32_t uProcFlags, uint32_t uProtocol);
+    static ProcessWaitResult_T waitFlagsToResultEx(uint32_t fWaitFlags, ProcessStatus_T oldStatus, ProcessStatus_T newStatus, uint32_t uProcFlags, uint32_t uProtocol);
     ProcessWaitResult_T waitFlagsToResult(uint32_t fWaitFlags);
     int waitFor(uint32_t fWaitFlags, ULONG uTimeoutMS, ProcessWaitResult_T &waitResult, int *pGuestRc);
@@ -135 +135 @@
  * Guest process tool flags.
  */
-/** No flags specified. */
+/** No flags specified; wait until process terminates.
+ *  The maximum waiting time is set in the process' startup
+ *  info. */
 #define GUESTPROCESSTOOL_FLAG_NONE            0
-/** Run until next stream block from stdout has been
+/** Wait until next stream block from stdout has been
  *  read in completely, then return.
  */
@@ -169 +171 @@
     bool IsRunning(void);
 
+    static int Run(GuestSession *pGuestSession, const GuestProcessStartupInfo &startupInfo, int *pGuestRc);
+
+    static int RunEx(GuestSession *pGuestSession, const GuestProcessStartupInfo &startupInfo, GuestCtrlStreamObjects *pStrmOutObjects,
+                     uint32_t cStrmOutObjects, int *pGuestRc);
+
     int TerminatedOk(LONG *pExitCode);
 
@@ -175 +182 @@
 protected:
 
-    GuestSession               *pSession;
+    ComObjPtr<GuestSession>     pSession;
     ComObjPtr<GuestProcess>     pProcess;
     GuestProcessStartupInfo     mStartupInfo;

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

@@ -327 +327 @@
 private:
 
-    typedef std::vector <ComObjPtr<GuestDirectory> > SessionDirectories;
+    /** Map of guest directories. The key specifies the internal directory ID. */
+    typedef std::map <uint32_t, ComObjPtr<GuestDirectory> > SessionDirectories;
     /** Map of guest files. The key specifies the internal file ID. */
     typedef std::map <uint32_t, ComObjPtr<GuestFile> > SessionFiles;
@@ -338 +339 @@
      * @{ */
     int                     closeSession(uint32_t uFlags, uint32_t uTimeoutMS, int *pGuestRc);
+    inline bool             directoryExists(uint32_t uDirID, ComObjPtr<GuestDirectory> *pDir);
     int                     directoryRemoveFromList(GuestDirectory *pDirectory);
+    int                     directoryRemoveInternal(const Utf8Str &strPath, uint32_t uFlags, int *pGuestRc);
     int                     directoryCreateInternal(const Utf8Str &strPath, uint32_t uMode, uint32_t uFlags, int *pGuestRc);
     int                     objectCreateTempInternal(const Utf8Str &strTemplate, const Utf8Str &strPath, bool fDirectory, const Utf8Str &strName, int *pGuestRc);
-    int                     directoryOpenInternal(const Utf8Str &strPath, const Utf8Str &strFilter, uint32_t uFlags, ComObjPtr<GuestDirectory> &pDirectory);
+    int                     directoryOpenInternal(const GuestDirectoryOpenInfo &openInfo, ComObjPtr<GuestDirectory> &pDirectory, int *pGuestRc);
     int                     directoryQueryInfoInternal(const Utf8Str &strPath, GuestFsObjData &objData, int *pGuestRc);
+    int                     dispatchToDirectory(PVBOXGUESTCTRLHOSTCBCTX pCtxCb, PVBOXGUESTCTRLHOSTCALLBACK pSvcCb);
     int                     dispatchToFile(PVBOXGUESTCTRLHOSTCBCTX pCtxCb, PVBOXGUESTCTRLHOSTCALLBACK pSvcCb);
+    int                     dispatchToObject(PVBOXGUESTCTRLHOSTCBCTX pCtxCb, PVBOXGUESTCTRLHOSTCALLBACK pSvcCb);
     int                     dispatchToProcess(PVBOXGUESTCTRLHOSTCBCTX pCtxCb, PVBOXGUESTCTRLHOSTCALLBACK pSvcCb);
     int                     dispatchToThis(PVBOXGUESTCTRLHOSTCBCTX pCtxCb, PVBOXGUESTCTRLHOSTCALLBACK pSvcCb);
@@ -367 +372 @@
     Guest                  *getParent(void) { return mParent; }
     uint32_t                getProtocolVersion(void) { return mData.mProtocolVersion; }
+    int                     pathRenameInternal(const Utf8Str &strSource, const Utf8Str &strDest, uint32_t uFlags, int *pGuestRc);
     int                     processRemoveFromList(GuestProcess *pProcess);
     int                     processCreateExInteral(GuestProcessStartupInfo &procInfo, ComObjPtr<GuestProcess> &pProgress);