Changeset 45109 in vbox for trunk/src/VBox/Main/src-client

Timestamp:

Mar 20, 2013 4:41:00 PM (12 years ago)

Author:

vboxsync

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

84401

Message:

GuestCtrl: More stuff for IGuestFile and IGuestSession handling (work in progress).

Location:

trunk/src/VBox/Main/src-client

Files:

• GuestCtrlPrivate.cpp (modified) (8 diffs)
• GuestFileImpl.cpp (modified) (18 diffs)
• GuestProcessImpl.cpp (modified) (6 diffs)
• GuestSessionImpl.cpp (modified) (4 diffs)

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

@@ -189 +189 @@
         }
 
+        case CALLBACKTYPE_FILE_NOTIFY:
+        {
+            pvData = (PCALLBACKDATA_FILE_NOTIFY)RTMemAllocZ(sizeof(CALLBACKDATA_FILE_NOTIFY));
+            AssertPtrReturn(pvData, VERR_NO_MEMORY);
+            cbData = sizeof(CALLBACKDATA_FILE_NOTIFY);
+            break;
+        }
+
         default:
             AssertMsgFailed(("Unknown callback type specified (%ld)\n", enmType));
@@ -220 +228 @@
         }
 
-        case CALLBACKTYPE_FILE_READ:
-        {
-            PCALLBACKPAYLOAD_FILE_NOTIFY_READ pThis = (PCALLBACKPAYLOAD_FILE_NOTIFY_READ)pvData;
+        case CALLBACKTYPE_FILE_NOTIFY:
+        {
+            PCALLBACKDATA_FILE_NOTIFY pThis = (PCALLBACKDATA_FILE_NOTIFY)pvData;
             AssertPtr(pThis);
-            if (pThis->pvData)
-                RTMemFree(pThis->pvData);
-            break;
+            switch (pThis->uType)
+            {
+                case GUEST_FILE_NOTIFYTYPE_READ:
+                {
+                    if (pThis->u.read.pvData)
+                    {
+                        RTMemFree(pThis->u.read.pvData);
+                        pThis->u.read.pvData = NULL;
+                    }
+
+                    break;
+                }
+
+                default:
+                    break;
+            }
         }
 
@@ -264 +285 @@
             Assert(cbCallback == sizeof(CALLBACKDATA_SESSION_NOTIFY));
 
-            pThis->uType   = pCB->uType;
-            pThis->uResult = pCB->uResult;
+            memcpy(pThis, pCB, sizeof(CALLBACKDATA_SESSION_NOTIFY));
             break;
         }
@@ -275 +295 @@
             Assert(cbCallback == sizeof(CALLBACKDATA_PROC_STATUS));
 
-            pThis->uFlags  = pCB->uFlags;
-            pThis->uPID    = pCB->uPID;
-            pThis->uStatus = pCB->uStatus;
+            memcpy(pThis, pCB, sizeof(CALLBACKDATA_PROC_STATUS));
             break;
         }
@@ -305 +323 @@
             Assert(cbCallback == sizeof(CALLBACKDATA_PROC_INPUT));
 
-            pThis->uProcessed = pCB->uProcessed;
-            pThis->uFlags     = pCB->uFlags;
-            pThis->uPID       = pCB->uPID;
-            pThis->uStatus    = pCB->uStatus;
-            break;
-        }
-
+            memcpy(pThis, pCB, sizeof(CALLBACKDATA_PROC_INPUT));
+            break;
+        }
+
+        case CALLBACKTYPE_FILE_NOTIFY:
+        {
+            PCALLBACKDATA_FILE_NOTIFY pThis = (PCALLBACKDATA_FILE_NOTIFY)pvData;
+            PCALLBACKDATA_FILE_NOTIFY pCB = (PCALLBACKDATA_FILE_NOTIFY)pvCallback;
+            Assert(cbCallback == sizeof(CALLBACKDATA_FILE_NOTIFY));
+
+            memcpy(pThis, pCB, sizeof(CALLBACKDATA_FILE_NOTIFY));
+
+            switch (pThis->uType)
+            {
+                case GUEST_FILE_NOTIFYTYPE_READ:
+                {
+                    pThis->u.read.pvData   = RTMemAlloc(pCB->u.read.cbData);
+                    AssertPtrReturn(pThis->u.read.pvData, VERR_NO_MEMORY);
+                    memcpy(pThis->u.read.pvData, pCB->u.read.pvData, pCB->u.read.cbData);
+                    pThis->u.read.cbData   = pCB->u.read.cbData;
+                    break;
+                }
+
+                default:
+                    break;
+            }
+            break;
+        }
+
+#if 0
         case CALLBACKTYPE_FILE_OPEN:
         {
@@ -382 +423 @@
             break;
         }
-
+#endif
         default:
             AssertMsgFailed(("Callback type not supported (%ld)\n", mType));
@@ -1287 +1328 @@
 }
 
+void GuestObject::callbackDelete(GuestCtrlCallback *pCallback)
+{
+    if (pCallback)
+    {
+        delete pCallback;
+        pCallback = NULL;
+    }
+}
+
 bool GuestObject::callbackExists(uint32_t uContextID)
 {
@@ -1306 +1356 @@
     if (it != mObject.mCallbacks.end())
     {
-        delete it->second;
         mObject.mCallbacks.erase(it);
 

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

@@ -61 +61 @@
 /////////////////////////////////////////////////////////////////////////////
 
+/**
+ * Initializes a file object but does *not* open the file on the guest
+ * yet. This is done in the dedidcated openFile call.
+ *
+ * @return  IPRT status code.
+ * @param   pConsole                Pointer to console object.
+ * @param   pSession                Pointer to session object.
+ * @param   uFileID                 Host-based file ID (part of the context ID).
+ * @param   openInfo                File opening information.
+ */
 int GuestFile::init(Console *pConsole, GuestSession *pSession, ULONG uFileID, const GuestFileOpenInfo &openInfo)
 {
@@ -76 +86 @@
     if (RT_SUCCESS(vrc))
     {
+        mData.mID = 0;
         mData.mInitialSize = 0;
 
@@ -257 +268 @@
     {
         case GUEST_DISCONNECTED:
-            vrc = onGuestDisconnected(pCbCtx, pCallback, pSvcCb); /* Affects all callbacks. */
+            vrc = onGuestDisconnected(pCbCtx, pSvcCb, pCallback); /* Affects all callbacks. */
             break;
 
         case GUEST_FILE_NOTIFY:
-            vrc = onFileNotify(pCbCtx, pCallback, pSvcCb);
+            vrc = onFileNotify(pCbCtx, pSvcCb, pCallback);
             break;
 
@@ -273 +284 @@
     LogFlowFuncLeaveRC(vrc);
 #endif
+    return vrc;
+}
+
+int GuestFile::closeFile(int *pGuestRc)
+{
+    LogFlowThisFunc(("strFile=%s\n", mData.mOpenInfo.mFileName.c_str()));
+
+    /* Prepare HGCM call. */
+    VBOXHGCMSVCPARM paParms[4];
+    int i = 1; /* Context ID will be set in sendFileComannd(). */
+    paParms[i++].setUInt32(mData.mID /* Guest file ID */);
+
+    int guestRc;
+    int vrc = sendFileCommand(HOST_FILE_CLOSE, i, paParms, 30 * 1000 /* 30s timeout */,
+                              &guestRc, NULL /* ppCallback */);
+    if (pGuestRc)
+        *pGuestRc = guestRc;
+
+    LogFlowFuncLeaveRC(vrc);
     return vrc;
 }
@@ -309 +339 @@
 }
 
-int GuestFile::onFileNotify(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, GuestCtrlCallback *pCallback, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData)
-{
-    AssertPtrReturn(pCallback, VERR_INVALID_POINTER);
+/* static */
+Utf8Str GuestFile::guestErrorToString(int guestRc)
+{
+    Utf8Str strError;
+
+    /** @todo pData->u32Flags: int vs. uint32 -- IPRT errors are *negative* !!! */
+    switch (guestRc)
+    {
+        case VERR_INVALID_VM_HANDLE:
+            strError += Utf8StrFmt(tr("VMM device is not available (is the VM running?)"));
+            break;
+
+        case VERR_HGCM_SERVICE_NOT_FOUND:
+            strError += Utf8StrFmt(tr("The guest execution service is not available"));
+            break;
+
+        case VERR_TIMEOUT:
+            strError += Utf8StrFmt(tr("The guest did not respond within time"));
+            break;
+
+        case VERR_CANCELLED:
+            strError += Utf8StrFmt(tr("The session operation was canceled"));
+            break;
+
+        case VERR_MAX_PROCS_REACHED:
+            strError += Utf8StrFmt(tr("Maximum number of concurrent guest files has been reached"));
+            break;
+
+        case VERR_NOT_EQUAL: /** @todo Imprecise to the user; can mean anything and all. */
+            strError += Utf8StrFmt(tr("Unable to retrieve requested information"));
+            break;
+
+        case VERR_NOT_FOUND:
+            strError += Utf8StrFmt(tr("The guest execution service is not ready (yet)"));
+            break;
+
+        default:
+            strError += Utf8StrFmt("%Rrc", guestRc);
+            break;
+    }
+
+    return strError;
+}
+
+int GuestFile::onFileNotify(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData,
+                            GuestCtrlCallback *pCallback)
+{
+    AssertPtrReturn(pCbCtx, VERR_INVALID_POINTER);
     AssertPtrReturn(pSvcCbData, VERR_INVALID_POINTER);
+    /* pCallback is optional. */
 
     if (pSvcCbData->mParms < 3)
         return VERR_INVALID_PARAMETER;
 
-    uint32_t uType;
-    void *pvData; uint32_t cbData;
+    int vrc = VINF_SUCCESS;
+
+    int idx = 0; /* Current parameter index. */
+    CALLBACKDATA_FILE_NOTIFY dataCb;
     /* pSvcCb->mpaParms[0] always contains the context ID. */
-    pSvcCbData->mpaParms[1].getUInt32(&uType);
-    pSvcCbData->mpaParms[2].getPointer(&pvData, &cbData);
-
-    LogFlowThisFunc(("strName=%s, uType=%RU32, pvData=%p, cbData=%RU32, pCallback=%p\n",
-                     mData.mOpenInfo.mFileName.c_str(), uType, pvData, cbData, pCallback));
+    pSvcCbData->mpaParms[idx++].getUInt32(&dataCb.uType);
+    pSvcCbData->mpaParms[idx++].getUInt32(&dataCb.rc);
+
+    switch (dataCb.uType)
+    {
+        case GUEST_FILE_NOTIFYTYPE_ERROR:
+            /* No extra data. */
+            break;
+
+        case GUEST_FILE_NOTIFYTYPE_OPEN:
+            if (pSvcCbData->mParms == 4)
+            {
+                pSvcCbData->mpaParms[idx++].getUInt32(&dataCb.u.open.uHandle);
+
+                AssertMsg(mData.mID == 0, ("File ID already set to %RU32\n", mData.mID));
+                mData.mID = dataCb.u.open.uHandle;
+                AssertMsg(mData.mID == VBOX_GUESTCTRL_CONTEXTID_GET_OBJECT(pCbCtx->uContextID),
+                          ("File ID %RU32 does not match context ID %RU32\n", mData.mID,
+                           VBOX_GUESTCTRL_CONTEXTID_GET_OBJECT(pCbCtx->uContextID)));
+            }
+            else
+                vrc = VERR_NOT_SUPPORTED;
+            break;
+
+        case GUEST_FILE_NOTIFYTYPE_CLOSE:
+            /* No extra data. */
+            break;
+
+        case GUEST_FILE_NOTIFYTYPE_READ:
+            if (pSvcCbData->mParms == 4)
+            {
+                pSvcCbData->mpaParms[idx++].getPointer(&dataCb.u.read.pvData,
+                                                       &dataCb.u.read.cbData);
+
+                mData.mOffCurrent += dataCb.u.read.cbData;
+            }
+            else
+                vrc = VERR_NOT_SUPPORTED;
+            break;
+
+        case GUEST_FILE_NOTIFYTYPE_WRITE:
+            if (pSvcCbData->mParms == 4)
+            {
+                pSvcCbData->mpaParms[idx++].getUInt32(&dataCb.u.write.cbWritten);
+
+                mData.mOffCurrent += dataCb.u.write.cbWritten;
+            }
+            else
+                vrc = VERR_NOT_SUPPORTED;
+            break;
+
+        case GUEST_FILE_NOTIFYTYPE_SEEK:
+            if (pSvcCbData->mParms == 4)
+            {
+                pSvcCbData->mpaParms[idx++].getUInt64(&dataCb.u.seek.uOffActual);
+
+                mData.mOffCurrent = dataCb.u.seek.uOffActual;
+            }
+            else
+                vrc = VERR_NOT_SUPPORTED;
+            break;
+
+        case GUEST_FILE_NOTIFYTYPE_TELL:
+            if (pSvcCbData->mParms == 4)
+            {
+                pSvcCbData->mpaParms[idx++].getUInt64(&dataCb.u.tell.uOffActual);
+
+                mData.mOffCurrent = dataCb.u.tell.uOffActual;
+            }
+            else
+                vrc = VERR_NOT_SUPPORTED;
+            break;
+
+        default:
+            vrc = VERR_NOT_SUPPORTED;
+            break;
+    }
+
+    LogFlowThisFunc(("strName=%s, uType=%RU32, rc=%Rrc, pCallback=%p\n",
+                     mData.mOpenInfo.mFileName.c_str(), dataCb.uType, dataCb.rc, pCallback));
+
+    int guestRc = (int)dataCb.rc; /* uint32_t vs. int. */
+    if (RT_SUCCESS(vrc))
+    {
+        /* Nothing to do here yet. */
+    }
+    else if (vrc == VERR_NOT_SUPPORTED)
+    {
+        /* Also let the callback know. */
+        guestRc = VERR_NOT_SUPPORTED;
+    }
 
     /* Signal callback in every case (if available). */
-    int vrc = VINF_SUCCESS;
     if (pCallback)
     {
-        vrc = pCallback->SetData(pvData, cbData);
-
-        int rc2 = pCallback->Signal();
+        int rc2 = pCallback->SetData(&dataCb, sizeof(dataCb));
         if (RT_SUCCESS(vrc))
             vrc = rc2;
+        rc2 = pCallback->Signal(guestRc);
+        if (RT_SUCCESS(vrc))
+            vrc = rc2;
     }
 
@@ -341 +505 @@
 }
 
-int GuestFile::onGuestDisconnected(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, GuestCtrlCallback *pCallback, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData)
-{
-    AssertPtrReturn(pCallback, VERR_INVALID_POINTER);
-
-    LogFlowThisFunc(("strFile=%s, pCallback=%p\n", mData.mOpenInfo.mFileName.c_str(), pCallback));
+int GuestFile::onGuestDisconnected(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData,
+                                   GuestCtrlCallback *pCallback)
+{
+    AssertPtrReturn(pCbCtx, VERR_INVALID_POINTER);
+    AssertPtrReturn(pSvcCbData, VERR_INVALID_POINTER);
+    /* pCallback is optional. */
+
+    LogFlowThisFunc(("strFile=%s, pCallback=%p\n",
+                     mData.mOpenInfo.mFileName.c_str(), pCallback));
 
     /* First, signal callback in every case. */
@@ -364 +532 @@
                      mData.mOpenInfo.mDisposition.c_str(), mData.mOpenInfo.mCreationMode));
 
-    /* Wait until the caller function (if kicked off by a thread)
-     * has returned and continue operation. */
+    /* Prepare HGCM call. */
+    VBOXHGCMSVCPARM paParms[8];
+    int i = 1; /* Context ID will be set in sendFileComannd(). */
+    paParms[i++].setPointer((void*)mData.mOpenInfo.mFileName.c_str(),
+                            (ULONG)mData.mOpenInfo.mFileName.length() + 1);
+    paParms[i++].setPointer((void*)mData.mOpenInfo.mOpenMode.c_str(),
+                            (ULONG)mData.mOpenInfo.mOpenMode.length() + 1);
+    paParms[i++].setPointer((void*)mData.mOpenInfo.mDisposition.c_str(),
+                            (ULONG)mData.mOpenInfo.mDisposition.length() + 1);
+    paParms[i++].setUInt32(mData.mOpenInfo.mCreationMode);
+    paParms[i++].setUInt64(mData.mOpenInfo.mInitialOffset);
+
+    int vrc = sendFileCommand(HOST_FILE_OPEN, i, paParms, 30 * 1000 /* 30s timeout */,
+                              pGuestRc, NULL /* ppCallback */);
+
+    LogFlowFuncLeaveRC(vrc);
+    return vrc;
+}
+
+int GuestFile::readData(uint32_t uSize, uint32_t uTimeoutMS, void *pvData, size_t cbData,
+                        size_t *pcbRead, int *pGuestRc)
+{
+    LogFlowThisFunc(("uSize=%RU32, uTimeoutMS=%RU32, pvData=%p, cbData=%zu\n",
+                     uSize, uTimeoutMS, pvData, cbData));
+
+    /* Prepare HGCM call. */
+    VBOXHGCMSVCPARM paParms[4];
+    int i = 1; /* Context ID will be set in sendFileComannd(). */
+    paParms[i++].setUInt32(mData.mID /* File handle */);
+    paParms[i++].setUInt32(uSize /* Size (in bytes) to read */);
+
+    GuestCtrlCallback *pCallback = NULL; int guestRc;
+    int vrc = sendFileCommand(HOST_FILE_READ, i, paParms, uTimeoutMS,
+                              &guestRc, &pCallback);
+
+    if (RT_SUCCESS(vrc))
+    {
+        AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+        Assert(pCallback->GetDataSize() == sizeof(CALLBACKDATA_FILE_NOTIFY));
+        PCALLBACKDATA_FILE_NOTIFY pData = (PCALLBACKDATA_FILE_NOTIFY)pCallback->GetDataRaw();
+        AssertPtr(pData);
+        Assert(pData->uType == GUEST_FILE_NOTIFYTYPE_READ);
+
+        size_t cbRead = pData->u.read.cbData;
+        if (cbRead)
+        {
+            Assert(cbData >= cbRead);
+            memcpy(pvData, pData->u.read.pvData, cbRead);
+        }
+
+        LogFlowThisFunc(("cbRead=%RU32\n", cbRead));
+
+        if (pcbRead)
+            *pcbRead = cbRead;
+    }
+
+    callbackDelete(pCallback);
+
+    if (pGuestRc)
+        *pGuestRc = guestRc;
+
+    LogFlowFuncLeaveRC(vrc);
+    return vrc;
+}
+
+int GuestFile::readDataAt(uint64_t uOffset, uint32_t uSize, uint32_t uTimeoutMS,
+                          void *pvData, size_t cbData,
+                          size_t *pcbRead, int *pGuestRc)
+{
+    LogFlowThisFunc(("uOffset=%RU64, uSize=%RU32, uTimeoutMS=%RU32, pvData=%p, cbData=%zu\n",
+                     uOffset, uSize, uTimeoutMS, pvData, cbData));
+
+    /* Prepare HGCM call. */
+    VBOXHGCMSVCPARM paParms[4];
+    int i = 1; /* Context ID will be set in sendFileComannd(). */
+    paParms[i++].setUInt32(mData.mID /* File handle */);
+    paParms[i++].setUInt64(uOffset /* Offset (in bytes) to start reading */);
+    paParms[i++].setUInt32(uSize /* Size (in bytes) to read */);
+
+    GuestCtrlCallback *pCallback = NULL; int guestRc;
+    int vrc = sendFileCommand(HOST_FILE_READ_AT, i, paParms, uTimeoutMS,
+                              &guestRc, &pCallback);
+
+    if (RT_SUCCESS(vrc))
+    {
+        AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+        Assert(pCallback->GetDataSize() == sizeof(CALLBACKDATA_FILE_NOTIFY));
+        PCALLBACKDATA_FILE_NOTIFY pData = (PCALLBACKDATA_FILE_NOTIFY)pCallback->GetDataRaw();
+        AssertPtr(pData);
+        Assert(pData->uType == GUEST_FILE_NOTIFYTYPE_READ);
+
+        size_t cbRead = pData->u.read.cbData;
+        if (cbRead)
+        {
+            Assert(cbData >= cbRead);
+            memcpy(pvData, pData->u.read.pvData, cbRead);
+        }
+
+        LogFlowThisFunc(("cbRead=%RU32\n", cbRead));
+
+        if (pcbRead)
+            *pcbRead = cbRead;
+    }
+
+    callbackDelete(pCallback);
+
+    if (pGuestRc)
+        *pGuestRc = guestRc;
+
+    LogFlowFuncLeaveRC(vrc);
+    return vrc;
+}
+
+int GuestFile::seekAt(uint64_t uOffset, GUEST_FILE_SEEKTYPE eSeekType,
+                      uint32_t uTimeoutMS, int *pGuestRc)
+{
+    LogFlowThisFunc(("uOffset=%RU64, uTimeoutMS=%RU32\n",
+                     uOffset, uTimeoutMS));
+
+    /* Prepare HGCM call. */
+    VBOXHGCMSVCPARM paParms[4];
+    int i = 1; /* Context ID will be set in sendFileComannd(). */
+    paParms[i++].setUInt32(mData.mID /* File handle */);
+    paParms[i++].setUInt32(eSeekType /* Seek method */);
+    paParms[i++].setUInt64(uOffset /* Offset (in bytes) to start reading */);
+
+    int guestRc;
+    int vrc = sendFileCommand(HOST_FILE_SEEK, i, paParms, uTimeoutMS,
+                              &guestRc, NULL /* ppCallback */);
+    if (pGuestRc)
+        *pGuestRc = guestRc;
+
+    LogFlowFuncLeaveRC(vrc);
+    return vrc;
+}
+
+/**
+ * Handles the common parts of sending a file command to the guest.
+ * If ppCallback is returned it must be removed via callbackRemove()
+ * by the caller in any case.
+ *
+ * @return  IPRT status code.
+ * @param   uFunction               HGCM function of command to send.
+ * @param   uParms                  Number of HGCM parameters to send.
+ *                                  At least one parameter must be present.
+ * @param   paParms                 Array of HGCM parameters to send.
+ *                                  Index [0] must not be used and will be
+ *                                  filled out by the function.
+ * @param   uTimeoutMS              Timeout (in ms).
+ * @param   pGuestRc                Guest result. Optional.
+ * @param   ppCallback              Pointer which will receive the callback for
+ *                                  further processing by the caller. Must
+ *                                  be deleted with callbackDelete() when done. Optional.
+ */
+int GuestFile::sendFileCommand(uint32_t uFunction, uint32_t uParms, PVBOXHGCMSVCPARM paParms,
+                               uint32_t uTimeoutMS, int *pGuestRc, GuestCtrlCallback **ppCallback)
+{
+    AssertReturn(uParms, VERR_INVALID_PARAMETER);
+    AssertPtrReturn(paParms, VERR_INVALID_POINTER);
+    /** pGuestRc is optional. */
+    /** ppCallback is optional. */
+
+    LogFlowThisFunc(("strFile=%s, uFunction=%RU32, uParms=%RU32\n",
+                     mData.mOpenInfo.mFileName.c_str(), uFunction, uParms));
+
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
@@ -376 +709 @@
     uint32_t uContextID = 0;
 
-    GuestCtrlCallback *pCallbackOpen;
+    GuestCtrlCallback *pCallback;
     try
     {
-        pCallbackOpen = new GuestCtrlCallback();
+        pCallback = new GuestCtrlCallback();
     }
     catch(std::bad_alloc &)
@@ -389 +722 @@
     {
         /* Create callback and add it to the map. */
-        vrc = pCallbackOpen->Init(CALLBACKTYPE_FILE_OPEN);
+        vrc = pCallback->Init(CALLBACKTYPE_FILE_NOTIFY);
         if (RT_SUCCESS(vrc))
-            vrc = callbackAdd(pCallbackOpen, &uContextID);
+            vrc = callbackAdd(pCallback, &uContextID);
     }
 
     if (RT_SUCCESS(vrc))
     {
+        /* Assign context ID. */
+        paParms[0].setUInt32(uContextID);
+
         GuestSession *pSession = mData.mSession;
         AssertPtr(pSession);
 
-        const GuestCredentials &sessionCreds = pSession->getCredentials();
-
-        if (RT_SUCCESS(vrc))
-        {
-            /* Prepare HGCM call. */
-            VBOXHGCMSVCPARM paParms[8];
-            int i = 0;
-            paParms[i++].setUInt32(uContextID);
-            paParms[i++].setPointer((void*)mData.mOpenInfo.mFileName.c_str(),
-                                    (ULONG)mData.mOpenInfo.mFileName.length() + 1);
-            paParms[i++].setPointer((void*)mData.mOpenInfo.mOpenMode.c_str(),
-                                    (ULONG)mData.mOpenInfo.mOpenMode.length() + 1);
-            paParms[i++].setPointer((void*)mData.mOpenInfo.mDisposition.c_str(),
-                                    (ULONG)mData.mOpenInfo.mDisposition.length() + 1);
-            paParms[i++].setUInt32(mData.mOpenInfo.mCreationMode);
-            paParms[i++].setUInt64(mData.mOpenInfo.mInitialOffset);
-
-            /* Note: Don't hold the write lock in here. */
-            vrc = sendCommand(HOST_FILE_OPEN, i, paParms);
-        }
-
-        /* Drop the write lock again before waiting. */
-        alock.release();
+        alock.release(); /* Drop the write lock again. */
+
+        /* Note: Don't hold the write lock in here. */
+        vrc = sendCommand(uFunction, uParms, paParms);
 
         if (RT_SUCCESS(vrc))
@@ -429 +746 @@
              * Note: Be sure not keeping a AutoRead/WriteLock here.
              */
-            LogFlowThisFunc(("Waiting for callback (30s) ...\n"));
-            vrc = pCallbackOpen->Wait(30 *  1000 /* Wait 30s max. */);
+            LogFlowThisFunc(("Waiting for callback (%RU32ms) ...\n",
+                             uTimeoutMS));
+            vrc = pCallback->Wait(uTimeoutMS);
             if (RT_SUCCESS(vrc)) /* Wait was successful, check for supplied information. */
             {
-                int guestRc = pCallbackOpen->GetResultCode();
+                int guestRc = pCallback->GetResultCode();
                 if (RT_SUCCESS(guestRc))
                 {
-
+                    /* Nothing to do here yet. */
                 }
+                else
+                    vrc = VERR_GSTCTL_GUEST_ERROR;
 
                 if (pGuestRc)
@@ -443 +763 @@
                 LogFlowThisFunc(("Callback returned rc=%Rrc\n", guestRc));
             }
-            else
-                vrc = VERR_TIMEOUT;
         }
 
-        AutoWriteLock awlock(this COMMA_LOCKVAL_SRC_POS);
-
-        AssertPtr(pCallbackOpen);
+        alock.acquire(); /* Get write lock again. */
+
+        AssertPtr(pCallback);
         int rc2 = callbackRemove(uContextID);
         if (RT_SUCCESS(vrc))
             vrc = rc2;
-    }
+
+        if (ppCallback)
+        {
+            /* Return callback to the caller which then will be
+             * responsible for removing it. Don't forget to lock write
+             * access before using this callback then! */
+            *ppCallback = pCallback;
+        }
+        else
+        {
+            delete pCallback;
+        }
+    }
+
+    LogFlowFuncLeaveRC(vrc);
+    return vrc;
+}
+
+/* static */
+HRESULT GuestFile::setErrorExternal(VirtualBoxBase *pInterface, int guestRc)
+{
+    AssertPtr(pInterface);
+    AssertMsg(RT_FAILURE(guestRc), ("Guest rc does not indicate a failure when setting error\n"));
+
+    return pInterface->setError(VBOX_E_IPRT_ERROR, GuestFile::guestErrorToString(guestRc).c_str());
+}
+
+int GuestFile::writeData(uint32_t uTimeoutMS, void *pvData, size_t cbData,
+                         uint32_t *pcbWritten, int *pGuestRc)
+{
+    AssertPtrReturn(pvData, VERR_INVALID_POINTER);
+    AssertReturn(cbData, VERR_INVALID_PARAMETER);
+
+    LogFlowThisFunc(("uTimeoutMS=%RU32, pvData=%p, cbData=%zu\n",
+                     uTimeoutMS, pvData, cbData));
+
+    /* Prepare HGCM call. */
+    VBOXHGCMSVCPARM paParms[4];
+    int i = 1; /* Context ID will be set in sendFileComannd(). */
+    paParms[i++].setUInt32(mData.mID /* File handle */);
+    paParms[i++].setUInt32(cbData /* Size (in bytes) to write */);
+    paParms[i++].setPointer(pvData, cbData);
+
+    GuestCtrlCallback *pCallback = NULL; int guestRc;
+    int vrc = sendFileCommand(HOST_FILE_WRITE, i, paParms, uTimeoutMS,
+                              &guestRc, &pCallback);
+
+    if (RT_SUCCESS(vrc))
+    {
+        AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+        Assert(pCallback->GetDataSize() == sizeof(CALLBACKDATA_FILE_NOTIFY));
+        PCALLBACKDATA_FILE_NOTIFY pData = (PCALLBACKDATA_FILE_NOTIFY)pCallback->GetDataRaw();
+        AssertPtr(pData);
+        Assert(pData->uType == GUEST_FILE_NOTIFYTYPE_WRITE);
+
+        size_t cbWritten = pData->u.write.cbWritten;
+        LogFlowThisFunc(("cbWritten=%RU32\n", cbWritten));
+
+        if (pcbWritten)
+            *pcbWritten = cbWritten;
+    }
+
+    callbackDelete(pCallback);
+
+    if (pGuestRc)
+        *pGuestRc = guestRc;
+
+    LogFlowFuncLeaveRC(vrc);
+    return vrc;
+}
+
+int GuestFile::writeDataAt(uint64_t uOffset, uint32_t uTimeoutMS,
+                           void *pvData, size_t cbData,
+                           uint32_t *pcbWritten, int *pGuestRc)
+{
+    AssertPtrReturn(pvData, VERR_INVALID_POINTER);
+    AssertReturn(cbData, VERR_INVALID_PARAMETER);
+
+    LogFlowThisFunc(("uOffset=%RU64, uTimeoutMS=%RU32, pvData=%p, cbData=%zu\n",
+                     uOffset, uTimeoutMS, pvData, cbData));
+
+    /* Prepare HGCM call. */
+    VBOXHGCMSVCPARM paParms[4];
+    int i = 1; /* Context ID will be set in sendFileComannd(). */
+    paParms[i++].setUInt32(mData.mID /* File handle */);
+    paParms[i++].setUInt64(uOffset /* Offset where to starting writing */);
+    paParms[i++].setUInt32(cbData /* Size (in bytes) to write */);
+    paParms[i++].setPointer(pvData, cbData);
+
+    GuestCtrlCallback *pCallback = NULL; int guestRc;
+    int vrc = sendFileCommand(HOST_FILE_WRITE_AT, i, paParms, uTimeoutMS,
+                              &guestRc, &pCallback);
+
+    if (RT_SUCCESS(vrc))
+    {
+        AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+        Assert(pCallback->GetDataSize() == sizeof(CALLBACKDATA_FILE_NOTIFY));
+        PCALLBACKDATA_FILE_NOTIFY pData = (PCALLBACKDATA_FILE_NOTIFY)pCallback->GetDataRaw();
+        AssertPtr(pData);
+        Assert(pData->uType == GUEST_FILE_NOTIFYTYPE_WRITE);
+
+        size_t cbWritten = pData->u.write.cbWritten;
+        LogFlowThisFunc(("cbWritten=%RU32\n", cbWritten));
+
+        if (pcbWritten)
+            *pcbWritten = cbWritten;
+    }
+
+    callbackDelete(pCallback);
+
+    if (pGuestRc)
+        *pGuestRc = guestRc;
 
     LogFlowFuncLeaveRC(vrc);
@@ -472 +903 @@
     if (FAILED(autoCaller.rc())) return autoCaller.rc();
 
+    /* Close file on guest. */
+    int guestRc;
+    int rc = closeFile(&guestRc);
+    /* On failure don't return here, instead do all the cleanup
+     * work first and then return an error. */
+
     AssertPtr(mData.mSession);
-    int rc = mData.mSession->fileRemoveFromList(this);
+    int rc2 = mData.mSession->fileRemoveFromList(this);
+    if (RT_SUCCESS(rc))
+        rc = rc2;
 
     /*
@@ -483 +922 @@
 
     LogFlowFuncLeaveRC(rc);
+    if (RT_FAILURE(rc))
+    {
+        if (rc == VERR_GSTCTL_GUEST_ERROR)
+            return GuestFile::setErrorExternal(this, guestRc);
+
+        return setError(VBOX_E_IPRT_ERROR,
+                        tr("Closing guest file failed with %Rrc\n"), rc);
+    }
+
     return S_OK;
 #endif /* VBOX_WITH_GUEST_CONTROL */
@@ -504 +952 @@
     ReturnComNotImplemented();
 #else
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    ReturnComNotImplemented();
+    if (aToRead == 0)
+        return setError(E_INVALIDARG, tr("The size to read is zero"));
+    CheckComArgOutSafeArrayPointerValid(aData);
+
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    com::SafeArray<BYTE> data((size_t)aToRead);
+    Assert(data.size() >= aToRead);
+
+    HRESULT hr = S_OK;
+
+    size_t cbRead; int guestRc;
+    int vrc = readData(aToRead, aTimeoutMS,
+                       data.raw(), aToRead, &cbRead, &guestRc);
+    if (RT_SUCCESS(vrc))
+    {
+        if (data.size() != cbRead)
+            data.resize(cbRead);
+        data.detachTo(ComSafeArrayOutArg(aData));
+    }
+    else
+    {
+        switch (vrc)
+        {
+            case VERR_GSTCTL_GUEST_ERROR:
+                hr = GuestFile::setErrorExternal(this, guestRc);
+                break;
+
+            default:
+                hr = setError(VBOX_E_IPRT_ERROR,
+                              tr("Reading from file \"%s\" failed: %Rrc"),
+                              mData.mOpenInfo.mFileName.c_str(), vrc);
+                break;
+        }
+    }
+
+    LogFlowThisFunc(("rc=%Rrc, cbRead=%RU64\n", vrc, cbRead));
+
+    LogFlowFuncLeaveRC(vrc);
+    return hr;
 #endif /* VBOX_WITH_GUEST_CONTROL */
 }
@@ -516 +1001 @@
     ReturnComNotImplemented();
 #else
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    ReturnComNotImplemented();
+    if (aToRead == 0)
+        return setError(E_INVALIDARG, tr("The size to read is zero"));
+    CheckComArgOutSafeArrayPointerValid(aData);
+
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    com::SafeArray<BYTE> data((size_t)aToRead);
+    Assert(data.size() >= aToRead);
+
+    HRESULT hr = S_OK;
+
+    size_t cbRead; int guestRc;
+    int vrc = readDataAt(aOffset, aToRead, aTimeoutMS,
+                         data.raw(), aToRead, &cbRead, &guestRc);
+    if (RT_SUCCESS(vrc))
+    {
+        if (data.size() != cbRead)
+            data.resize(cbRead);
+        data.detachTo(ComSafeArrayOutArg(aData));
+    }
+    else
+    {
+        switch (vrc)
+        {
+            case VERR_GSTCTL_GUEST_ERROR:
+                hr = GuestFile::setErrorExternal(this, guestRc);
+                break;
+
+            default:
+                hr = setError(VBOX_E_IPRT_ERROR,
+                              tr("Reading from file \"%s\" (at offset %RU64) failed: %Rrc"),
+                              mData.mOpenInfo.mFileName.c_str(), aOffset, vrc);
+                break;
+        }
+    }
+
+    LogFlowThisFunc(("rc=%Rrc, cbRead=%RU64\n", vrc, cbRead));
+
+    LogFlowFuncLeaveRC(vrc);
+    return hr;
 #endif /* VBOX_WITH_GUEST_CONTROL */
 }
@@ -528 +1050 @@
     ReturnComNotImplemented();
 #else
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    ReturnComNotImplemented();
+    LogFlowThisFuncEnter();
+
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    HRESULT hr = S_OK;
+
+    GUEST_FILE_SEEKTYPE eSeekType;
+    switch (aType)
+    {
+        case FileSeekType_Set:
+            eSeekType = GUEST_FILE_SEEKTYPE_BEGIN;
+            break;
+
+        case FileSeekType_Current:
+            eSeekType = GUEST_FILE_SEEKTYPE_CURRENT;
+            break;
+
+        default:
+            return setError(E_INVALIDARG, tr("Invalid seek type specified"));
+            break;
+    }
+
+    int guestRc;
+    int vrc = seekAt(aOffset, eSeekType,
+                     30 * 1000 /* 30s timeout */, &guestRc);
+    if (RT_FAILURE(vrc))
+    {
+        switch (vrc)
+        {
+            case VERR_GSTCTL_GUEST_ERROR:
+                hr = GuestFile::setErrorExternal(this, guestRc);
+                break;
+
+            default:
+                hr = setError(VBOX_E_IPRT_ERROR,
+                              tr("Seeking file \"%s\" (to offset %RU64) failed: %Rrc"),
+                              mData.mOpenInfo.mFileName.c_str(), aOffset, vrc);
+                break;
+        }
+    }
+
+    LogFlowFuncLeaveRC(vrc);
+    return hr;
 #endif /* VBOX_WITH_GUEST_CONTROL */
 }
@@ -552 +1114 @@
     ReturnComNotImplemented();
 #else
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    ReturnComNotImplemented();
+    LogFlowThisFuncEnter();
+
+    CheckComArgOutPointerValid(aWritten);
+
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    HRESULT hr = S_OK;
+
+    com::SafeArray<BYTE> data(ComSafeArrayInArg(aData)); int guestRc;
+    int vrc = writeData(aTimeoutMS, data.raw(), data.size(), (uint32_t*)aWritten, &guestRc);
+    if (RT_FAILURE(vrc))
+    {
+        switch (vrc)
+        {
+            case VERR_GSTCTL_GUEST_ERROR:
+                hr = GuestFile::setErrorExternal(this, guestRc);
+                break;
+
+            default:
+                hr = setError(VBOX_E_IPRT_ERROR,
+                              tr("Writing to file \"%s\" failed: %Rrc"),
+                              mData.mOpenInfo.mFileName.c_str(), vrc);
+                break;
+        }
+    }
+
+    LogFlowThisFunc(("rc=%Rrc, aWritten=%RU32\n", vrc, aWritten));
+
+    LogFlowFuncLeaveRC(vrc);
+    return hr;
 #endif /* VBOX_WITH_GUEST_CONTROL */
 }
@@ -564 +1153 @@
     ReturnComNotImplemented();
 #else
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    ReturnComNotImplemented();
-#endif /* VBOX_WITH_GUEST_CONTROL */
-}
-
+    LogFlowThisFuncEnter();
+
+    CheckComArgOutPointerValid(aWritten);
+
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    HRESULT hr = S_OK;
+
+    com::SafeArray<BYTE> data(ComSafeArrayInArg(aData)); int guestRc;
+    int vrc = writeData(aTimeoutMS, data.raw(), data.size(), (uint32_t*)aWritten, &guestRc);
+    if (RT_FAILURE(vrc))
+    {
+        switch (vrc)
+        {
+            case VERR_GSTCTL_GUEST_ERROR:
+                hr = GuestFile::setErrorExternal(this, guestRc);
+                break;
+
+            default:
+                hr = setError(VBOX_E_IPRT_ERROR,
+                              tr("Writing to file \"%s\" (at offset %RU64) failed: %Rrc"),
+                              mData.mOpenInfo.mFileName.c_str(), aOffset, vrc);
+                break;
+        }
+    }
+
+    LogFlowThisFunc(("rc=%Rrc, aWritten=%RU32\n", vrc, aWritten));
+
+    LogFlowFuncLeaveRC(vrc);
+    return hr;
+#endif /* VBOX_WITH_GUEST_CONTROL */
+}
+

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

@@ -949 +949 @@
     alock.acquire();
 
-    AssertPtr(pCallbackRead);
     int rc2 = callbackRemove(uContextID);
     if (RT_SUCCESS(vrc))
         vrc = rc2;
+
+    callbackDelete(pCallbackRead);
 
     LogFlowFuncLeaveRC(vrc);
@@ -1015 +1016 @@
     uint32_t uContextID = 0;
 
-    GuestCtrlCallback *pCallbackStart;
+    GuestCtrlCallback *pCallbackStart = NULL;
     try
     {
@@ -1174 +1175 @@
         AutoWriteLock awlock(this COMMA_LOCKVAL_SRC_POS);
 
-        AssertPtr(pCallbackStart);
         int rc2 = callbackRemove(uContextID);
         if (RT_SUCCESS(vrc))
             vrc = rc2;
     }
+
+    callbackDelete(pCallbackStart);
 
     LogFlowFuncLeaveRC(vrc);
@@ -1305 +1307 @@
     alock.acquire();
 
-    AssertPtr(pCallbackTerminate);
     int rc2 = callbackRemove(uContextID);
     if (RT_SUCCESS(vrc))
         vrc = rc2;
+
+    callbackDelete(pCallbackTerminate);
 
     LogFlowFuncLeaveRC(vrc);
@@ -1617 +1620 @@
         vrc = rc2;
 
+    callbackDelete(pCallbackWrite);
+
     LogFlowFuncLeaveRC(vrc);
     return vrc;
@@ -1807 +1812 @@
     AutoCaller autoCaller(this);
     if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
     HRESULT hr = S_OK;

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

@@ -968 +968 @@
         return rc;
 
-    /* Add the created file to our vector. */
-    mData.mFiles[uNewFileID] = pFile;
-    mData.mNumObjects++;
-    Assert(mData.mNumObjects <= VBOX_GUESTCTRL_MAX_OBJECTS);
-
-    LogFlowFunc(("Added new file \"%s\" (Session: %RU32) (now total %ld files, %ld objects)\n",
-                 openInfo.mFileName.c_str(), mData.mSession.mID, mData.mFiles.size(), mData.mNumObjects));
+    int guestRc;
+    rc = pFile->openFile(&guestRc);
+    if (RT_SUCCESS(rc))
+    {
+        /* Add the created file to our vector. */
+        mData.mFiles[uNewFileID] = pFile;
+        mData.mNumObjects++;
+        Assert(mData.mNumObjects <= VBOX_GUESTCTRL_MAX_OBJECTS);
+
+        LogFlowFunc(("Added new file \"%s\" (Session: %RU32) (now total %ld files, %ld objects)\n",
+                     openInfo.mFileName.c_str(), mData.mSession.mID, mData.mFiles.size(), mData.mNumObjects));
+    }
+
+    if (pGuestRc)
+        *pGuestRc = guestRc;
 
     LogFlowFuncLeaveRC(rc);
@@ -1794 +1802 @@
     if (FAILED(autoCaller.rc())) return autoCaller.rc();
 
-    /* Close session on guest session. */
+    /* Close session on guest. */
     int guestRc;
     int rc = closeSession(0 /* Flags */, 30 * 1000 /* Timeout */,
@@ -1816 +1824 @@
     if (RT_FAILURE(rc))
     {
-        /** @todo Handle guestRc! */
+        if (rc == VERR_GSTCTL_GUEST_ERROR)
+            return GuestSession::setErrorExternal(this, guestRc);
+
         return setError(VBOX_E_IPRT_ERROR,
                         tr("Closing guest session failed with %Rrc\n"), rc);
@@ -2483 +2493 @@
         {
             case VERR_GSTCTL_GUEST_ERROR:
-                hr = GuestProcess::setErrorExternal(this, guestRc);
+                hr = GuestFile::setErrorExternal(this, guestRc);
                 break;
 
             default:
-                hr = setError(VBOX_E_IPRT_ERROR, tr("Opening file \"%s\" failed: %Rrc"),
+                hr = setError(VBOX_E_IPRT_ERROR, tr("Opening guest file \"%s\" failed: %Rrc"),
                               Utf8Str(aPath).c_str(), vrc);
                 break;