Changeset 100213 in vbox for trunk

Timestamp:

Jun 19, 2023 4:13:40 PM (18 months ago)

Author:

vboxsync

Message:

Shared Clipboard: More code for locking transfers. bugref:9437

Location:

trunk/src/VBox/GuestHost/SharedClipboard

Files:

• clipboard-transfers-http.cpp (modified) (2 diffs)
• clipboard-transfers.cpp (modified) (53 diffs)

trunk/src/VBox/GuestHost/SharedClipboard/clipboard-transfers-http.cpp

@@ -100 +100 @@
 *********************************************************************************************************************************/
 
+/**
+ * Locks an HTTP transfer.
+ *
+ * @param   pSrvTx              HTTP transfer to lock.
+ */
 DECLINLINE(void) shClHttpTransferLock(PSHCLHTTPSERVERTRANSFER pSrvTx)
 {
@@ -106 +111 @@
 }
 
+/**
+ * Unlocks an HTTP transfer.
+ *
+ * @param   pSrvTx              HTTP transfer to unlock.
+ */
 DECLINLINE(void) shClHttpTransferUnlock(PSHCLHTTPSERVERTRANSFER pSrvTx)
 {

trunk/src/VBox/GuestHost/SharedClipboard/clipboard-transfers.cpp

@@ -50 +50 @@
 
 
+/*********************************************************************************************************************************
+ * Transfer List                                                                                                                 *
+ ********************************************************************************************************************************/
+
 /**
  * Initializes a transfer list.
@@ -675 +679 @@
     return true;
 }
+
+
+/*********************************************************************************************************************************
+ * Transfer Object                                                                                                               *
+ ********************************************************************************************************************************/
 
 /**
@@ -1027 +1036 @@
 }
 
+
+/*********************************************************************************************************************************
+ * Transfer                                                                                                                      *
+ ********************************************************************************************************************************/
+
 /**
  * Creates a clipboard transfer, extended version.
@@ -1136 +1150 @@
     ShClTransferReset(pTransfer);
 
+    if (RTCritSectIsInitialized(&pTransfer->CritSect))
+        RTCritSectDelete(&pTransfer->CritSect);
+
     ShClEventSourceDestroy(&pTransfer->Events);
 
@@ -1176 +1193 @@
     pTransfer->CallbackCtx.cbUser    = pTransfer->Callbacks.cbUser;
 
-    int rc = VINF_SUCCESS;
-
-    LogRelFunc(("pfnOnInitialized=%p\n", pTransfer->Callbacks.pfnOnInitialized));
+    int rc = RTCritSectInit(&pTransfer->CritSect);
+    AssertRCReturn(rc, rc);
 
     if (pTransfer->Callbacks.pfnOnInitialized)
@@ -1190 +1206 @@
     LogFlowFuncLeaveRC(rc);
     return rc;
+}
+
+/**
+ * Locks a transfer.
+ *
+ * @param   pTransfer           Transfer to lock.
+ */
+DECLINLINE(void) shClTransferLock(PSHCLTRANSFER pTransfer)
+{
+    int rc2 = RTCritSectEnter(&pTransfer->CritSect);
+    AssertRC(rc2);
+}
+
+/**
+ * Unlocks a transfer.
+ *
+ * @param   pTransfer           Transfer to unlock.
+ */
+DECLINLINE(void) shClTransferUnlock(PSHCLTRANSFER pTransfer)
+{
+    int rc2 = RTCritSectLeave(&pTransfer->CritSect);
+    AssertRC(rc2);
 }
 
@@ -1499 +1537 @@
     AssertPtrReturn(pTransfer, 0);
 
-    LogFlowFunc(("[Transfer %RU32] cRoots=%RU64\n", pTransfer->State.uID, pTransfer->lstRoots.Hdr.cEntries));
-    return (uint32_t)pTransfer->lstRoots.Hdr.cEntries;
+    shClTransferLock(pTransfer);
+
+    uint32_t const cRoots = pTransfer->lstRoots.Hdr.cEntries;
+
+    shClTransferUnlock(pTransfer);
+
+    return cRoots;
 }
 
@@ -1507 +1550 @@
  *
  * @param   pTransfer           Transfer to clear transfer root list for.
+ *
+ * @note    Caller needs to take critical section.
  */
 static void shClTransferRootsReset(PSHCLTRANSFER pTransfer)
 {
     AssertPtrReturnVoid(pTransfer);
+    Assert(RTCritSectIsOwner(&pTransfer->CritSect));
 
     if (pTransfer->pszPathRootAbs)
@@ -1532 +1578 @@
     LogFlowFuncEnter();
 
+    shClTransferLock(pTransfer);
+
     shClTransferRootsReset(pTransfer);
 
@@ -1553 +1601 @@
         RTMemFree(pItObj);
     }
+
+    shClTransferUnlock(pTransfer);
 }
 
@@ -1566 +1616 @@
     AssertPtrReturn(pTransfer, NULL);
 
+    shClTransferLock(pTransfer);
+
     if (uIndex >= pTransfer->lstRoots.Hdr.cEntries)
+    {
+        shClTransferUnlock(pTransfer);
         return NULL;
-
-    return shClTransferListGetEntryById(&pTransfer->lstRoots, uIndex);
+    }
+
+    PCSHCLLISTENTRY pEntry = shClTransferListGetEntryById(&pTransfer->lstRoots, uIndex);
+
+    shClTransferUnlock(pTransfer);
+
+    return pEntry;
 }
 
@@ -1592 +1651 @@
         rc = VERR_NOT_SUPPORTED;
 
+    shClTransferLock(pTransfer);
+
     /* Make sure that we have at least an empty root path set. */
     if (   RT_SUCCESS(rc)
@@ -1599 +1660 @@
             rc = VERR_NO_MEMORY;
     }
+
+    shClTransferUnlock(pTransfer);
 
     LogFlowFuncLeaveRC(rc);
@@ -1628 +1691 @@
     int rc = VINF_SUCCESS;
 
+    shClTransferLock(pTransfer);
+
     shClTransferRootsReset(pTransfer);
 
@@ -1635 +1700 @@
     RTCList<RTCString> lstRootEntries = RTCString(pszRoots, cbRoots - 1).split(SHCL_TRANSFER_URI_LIST_SEP_STR);
     if (!lstRootEntries.size())
+    {
+        shClTransferUnlock(pTransfer);
         return VINF_SUCCESS;
+    }
 
     for (size_t i = 0; i < lstRootEntries.size(); ++i)
@@ -1756 +1824 @@
     }
 
+    shClTransferUnlock(pTransfer);
+
     LogFlowFuncLeaveRC(rc);
     return rc;
@@ -1794 +1864 @@
     AssertPtrReturn(pTransfer, 0);
 
-    return pTransfer->State.uID;
+    shClTransferLock(pTransfer);
+
+    SHCLTRANSFERID const uID = pTransfer->State.uID;
+
+    shClTransferUnlock(pTransfer);
+
+    return uID;
 }
 
@@ -1807 +1883 @@
     AssertPtrReturn(pTransfer, SHCLTRANSFERDIR_UNKNOWN);
 
-    LogFlowFunc(("[Transfer %RU32] enmDir=%RU32\n", pTransfer->State.uID, pTransfer->State.enmDir));
-    return pTransfer->State.enmDir;
+    shClTransferLock(pTransfer);
+
+    SHCLTRANSFERDIR const enmDir = pTransfer->State.enmDir;
+
+    shClTransferUnlock(pTransfer);
+
+    return enmDir;
 }
 
@@ -1822 +1903 @@
 {
     AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
+
+    shClTransferLock(pTransfer);
+
     AssertMsgReturn(pTransfer->pszPathRootAbs, ("Transfer has no root path set (yet)\n"), VERR_WRONG_ORDER);
 
-    return RTStrCopy(pszPath, cbPath, pTransfer->pszPathRootAbs);
+    int const rc = RTStrCopy(pszPath, cbPath, pTransfer->pszPathRootAbs);
+
+    shClTransferUnlock(pTransfer);
+
+    return rc;
 }
 
@@ -1837 +1925 @@
     AssertPtrReturn(pTransfer, SHCLSOURCE_INVALID);
 
-    LogFlowFunc(("[Transfer %RU32] enmSource=%RU32\n", pTransfer->State.uID, pTransfer->State.enmSource));
-    return pTransfer->State.enmSource;
+    shClTransferLock(pTransfer);
+
+    SHCLSOURCE const enmSource = pTransfer->State.enmSource;
+
+    shClTransferUnlock(pTransfer);
+
+    return enmSource;
 }
 
@@ -1846 +1939 @@
  * @returns Current transfer status.
  * @param   pTransfer           Clipboard transfer to return status for.
+ *
+ * @note    Caller needs to take critical section.
+ */
+DECLINLINE(SHCLTRANSFERSTATUS) shClTransferGetStatusLocked(PSHCLTRANSFER pTransfer)
+{
+    Assert(RTCritSectIsOwner(&pTransfer->CritSect));
+
+    shClTransferLock(pTransfer);
+
+    SHCLTRANSFERSTATUS const enmStatus = pTransfer->State.enmStatus;
+
+    shClTransferUnlock(pTransfer);
+
+    return enmStatus;
+}
+
+/**
+ * Returns the current transfer status.
+ *
+ * @returns Current transfer status.
+ * @param   pTransfer           Clipboard transfer to return status for.
  */
 SHCLTRANSFERSTATUS ShClTransferGetStatus(PSHCLTRANSFER pTransfer)
@@ -1851 +1965 @@
     AssertPtrReturn(pTransfer, SHCLTRANSFERSTATUS_NONE);
 
-    return pTransfer->State.enmStatus;
+    shClTransferLock(pTransfer);
+
+    SHCLTRANSFERSTATUS const enmSts = shClTransferGetStatusLocked(pTransfer);
+
+    shClTransferUnlock(pTransfer);
+
+    return enmSts;
 }
 
@@ -1889 +2009 @@
 
     LogFlowFuncEnter();
+
+    shClTransferLock(pTransfer);
 
     /* Ready to start? */
@@ -1902 +2024 @@
     pTransfer->State.enmStatus = SHCLTRANSFERSTATUS_STARTED;
 
+    shClTransferUnlock(pTransfer);
+
     if (pTransfer->Callbacks.pfnOnStarted)
         pTransfer->Callbacks.pfnOnStarted(&pTransfer->CallbackCtx);
@@ -1921 +2045 @@
 {
     AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
+
+    shClTransferLock(pTransfer);
 
     /* Already marked for stopping? */
@@ -1935 +2061 @@
     if (RT_SUCCESS(rc))
     {
+        shClTransferUnlock(pTransfer); /* Leave lock while waiting. */
+
         int rc2 = RTThreadUserWait(pTransfer->Thread.hThread, RT_MS_30SEC /* Timeout in ms */);
         AssertRC(rc2);
+
+        shClTransferLock(pTransfer);
 
         if (pTransfer->Thread.fStarted) /* Did the thread indicate that it started correctly? */
@@ -1946 +2076 @@
     }
 
+    shClTransferUnlock(pTransfer);
+
     LogFlowFuncLeaveRC(rc);
     return rc;
@@ -1961 +2093 @@
     AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
 
+    shClTransferLock(pTransfer);
+
     if (pTransfer->Thread.hThread == NIL_RTTHREAD)
+    {
+        shClTransferUnlock(pTransfer);
         return VINF_SUCCESS;
+    }
 
     LogFlowFuncEnter();
@@ -1969 +2106 @@
     pTransfer->Thread.fStop = true;
 
+    shClTransferUnlock(pTransfer); /* Leave lock while waiting. */
+
     int rcThread = VERR_WRONG_ORDER;
     int rc = RTThreadWait(pTransfer->Thread.hThread, uTimeoutMs, &rcThread);
@@ -1975 +2114 @@
 
     return rc;
+}
+
+
+/*********************************************************************************************************************************
+ * Transfer Context                                                                                                              *
+ ********************************************************************************************************************************/
+
+/**
+ * Locks a transfer context.
+ *
+ * @param   pTransferCtx        Transfer context to lock.
+ */
+DECLINLINE(void) shClTransferCtxLock(PSHCLTRANSFERCTX pTransferCtx)
+{
+    int rc2 = RTCritSectEnter(&pTransferCtx->CritSect);
+    AssertRC(rc2);
+}
+
+/**
+ * Unlocks a transfer context.
+ *
+ * @param   pTransferCtx        Transfer context to unlock.
+ */
+DECLINLINE(void) shClTransferCtxUnlock(PSHCLTRANSFERCTX pTransferCtx)
+{
+    int rc2 = RTCritSectLeave(&pTransferCtx->CritSect);
+    AssertRC(rc2);
 }
 
@@ -2018 +2184 @@
     LogFlowFunc(("pTransferCtx=%p\n", pTransferCtx));
 
+    shClTransferCtxLock(pTransferCtx);
+
+    PSHCLTRANSFER pTransfer, pTransferNext;
+    RTListForEachSafe(&pTransferCtx->List, pTransfer, pTransferNext, SHCLTRANSFER, Node)
+    {
+        ShClTransferDestroy(pTransfer);
+
+        shclTransferCtxTransferRemoveAndUnregister(pTransferCtx, pTransfer);
+
+        RTMemFree(pTransfer);
+        pTransfer = NULL;
+    }
+
+    pTransferCtx->cRunning   = 0;
+    pTransferCtx->cTransfers = 0;
+
+    shClTransferCtxUnlock(pTransferCtx);
+
     if (RTCritSectIsInitialized(&pTransferCtx->CritSect))
         RTCritSectDelete(&pTransferCtx->CritSect);
-
-    PSHCLTRANSFER pTransfer, pTransferNext;
-    RTListForEachSafe(&pTransferCtx->List, pTransfer, pTransferNext, SHCLTRANSFER, Node)
-    {
-        ShClTransferDestroy(pTransfer);
-
-        shclTransferCtxTransferRemoveAndUnregister(pTransferCtx, pTransfer);
-
-        RTMemFree(pTransfer);
-        pTransfer = NULL;
-    }
-
-    pTransferCtx->cRunning   = 0;
-    pTransferCtx->cTransfers = 0;
 }
 
@@ -2044 +2214 @@
 {
     AssertPtrReturnVoid(pTransferCtx);
+
+    shClTransferCtxLock(pTransferCtx);
 
     LogFlowFuncEnter();
@@ -2054 +2226 @@
     /** @todo Anything to do here? */
 #endif
+
+    shClTransferCtxUnlock(pTransferCtx);
 }
 
@@ -2062 +2236 @@
  * @param   pTransferCtx                Transfer context to return transfer for.
  * @param   uID                         ID of the transfer to return.
+ *
+ * @note    Caller needs to take critical section.
  */
 static PSHCLTRANSFER shClTransferCtxGetTransferByIdInternal(PSHCLTRANSFERCTX pTransferCtx, uint32_t uID)
 {
+    Assert(RTCritSectIsOwner(&pTransferCtx->CritSect));
+
     PSHCLTRANSFER pTransfer;
     RTListForEach(&pTransferCtx->List, pTransfer, SHCLTRANSFER, Node) /** @todo Slow, but works for now. */
@@ -2081 +2259 @@
  * @param   pTransferCtx                Transfer context to return transfer for.
  * @param   uIdx                        Index of the transfer to return.
+ *
+ * @note    Caller needs to take critical section.
  */
 static PSHCLTRANSFER shClTransferCtxGetTransferByIndexInternal(PSHCLTRANSFERCTX pTransferCtx, uint32_t uIdx)
 {
+    Assert(RTCritSectIsOwner(&pTransferCtx->CritSect));
+
     uint32_t idx = 0;
 
@@ -2106 +2288 @@
 PSHCLTRANSFER ShClTransferCtxGetTransferById(PSHCLTRANSFERCTX pTransferCtx, uint32_t uID)
 {
-    return shClTransferCtxGetTransferByIdInternal(pTransferCtx, uID);
+    shClTransferCtxLock(pTransferCtx);
+
+    PSHCLTRANSFER const pTransfer = shClTransferCtxGetTransferByIdInternal(pTransferCtx, uID);
+
+    shClTransferCtxUnlock(pTransferCtx);
+
+    return pTransfer;
 }
 
@@ -2118 +2306 @@
 PSHCLTRANSFER ShClTransferCtxGetTransferByIndex(PSHCLTRANSFERCTX pTransferCtx, uint32_t uIdx)
 {
-    return shClTransferCtxGetTransferByIndexInternal(pTransferCtx, uIdx);
+    shClTransferCtxLock(pTransferCtx);
+
+    PSHCLTRANSFER const pTransfer = shClTransferCtxGetTransferByIndexInternal(pTransferCtx, uIdx);
+
+    shClTransferCtxUnlock(pTransferCtx);
+
+    return pTransfer;
 }
 
@@ -2130 +2324 @@
 {
     AssertPtrReturn(pTransferCtx, 0);
-    return pTransferCtx->cRunning;
+
+    shClTransferCtxLock(pTransferCtx);
+
+    uint32_t const cRunning = pTransferCtx->cRunning;
+
+    shClTransferCtxUnlock(pTransferCtx);
+
+    return cRunning;
 }
 
@@ -2142 +2343 @@
 {
     AssertPtrReturn(pTransferCtx, 0);
-    return pTransferCtx->cTransfers;
+
+    shClTransferCtxLock(pTransferCtx);
+
+    uint32_t const cTransfers = pTransferCtx->cTransfers;
+
+    shClTransferCtxUnlock(pTransferCtx);
+
+    return cTransfers;
 }
 
@@ -2160 +2368 @@
     AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
     /* pidTransfer is optional. */
+
+    shClTransferCtxLock(pTransferCtx);
 
     /*
@@ -2183 +2393 @@
     {
         LogFunc(("Maximum number of transfers reached (%RU16 transfers)\n", pTransferCtx->cTransfers));
+        shClTransferCtxUnlock(pTransferCtx);
         return VERR_SHCLPB_MAX_TRANSFERS_REACHED;
     }
@@ -2193 +2404 @@
 
     Log2Func(("pTransfer=%p, idTransfer=%RU32 -- now %RU16 transfer(s)\n", pTransfer, idTransfer, pTransferCtx->cTransfers));
+
+    shClTransferCtxUnlock(pTransferCtx);
 
     if (pTransfer->Callbacks.pfnOnRegistered)
@@ -2216 +2429 @@
 int ShClTransferCtxTransferRegisterById(PSHCLTRANSFERCTX pTransferCtx, PSHCLTRANSFER pTransfer, SHCLTRANSFERID idTransfer)
 {
-    LogFlowFunc(("cTransfers=%RU16, idTransfer=%RU32\n", pTransferCtx->cTransfers, idTransfer));
+    shClTransferCtxLock(pTransferCtx);
 
     if (pTransferCtx->cTransfers < VBOX_SHCL_MAX_TRANSFERS - 2 /* First and last are not used */)
@@ -2226 +2439 @@
             pTransfer->State.uID = idTransfer;
 
+            shClTransferCtxUnlock(pTransferCtx);
+
             if (pTransfer->Callbacks.pfnOnRegistered)
                 pTransfer->Callbacks.pfnOnRegistered(&pTransfer->CallbackCtx, pTransferCtx);
 
+            shClTransferCtxLock(pTransferCtx);
+
             pTransferCtx->cTransfers++;
+
+            LogFunc(("Registered transfer ID %RU16 -- now %RU16 transfers total\n", idTransfer, pTransferCtx->cTransfers));
+
+            shClTransferCtxUnlock(pTransferCtx);
             return VINF_SUCCESS;
         }
@@ -2237 +2458 @@
 
     LogFunc(("Maximum number of transfers reached (%RU16 transfers)\n", pTransferCtx->cTransfers));
+
+    shClTransferCtxUnlock(pTransferCtx);
+
     return VERR_SHCLPB_MAX_TRANSFERS_REACHED;
 }
@@ -2245 +2469 @@
  * @param   pTransferCtx        Transfer context to remove transfer from.
  * @param   pTransfer           Transfer to remove.
+ *
+ * @note    Caller needs to take critical section.
  */
 static void shclTransferCtxTransferRemoveAndUnregister(PSHCLTRANSFERCTX pTransferCtx, PSHCLTRANSFER pTransfer)
 {
+    Assert(RTCritSectIsOwner(&pTransferCtx->CritSect));
+
     RTListNodeRemove(&pTransfer->Node);
 
@@ -2255 +2483 @@
     Assert(pTransferCtx->cTransfers >= pTransferCtx->cRunning);
 
+    shClTransferCtxUnlock(pTransferCtx);
+
     if (pTransfer->Callbacks.pfnOnUnregistered)
         pTransfer->Callbacks.pfnOnUnregistered(&pTransfer->CallbackCtx, pTransferCtx);
+
+    shClTransferCtxLock(pTransferCtx);
 
     LogFlowFunc(("Now %RU32 transfers left\n", pTransferCtx->cTransfers));
@@ -2271 +2503 @@
 int ShClTransferCtxTransferUnregister(PSHCLTRANSFERCTX pTransferCtx, SHCLTRANSFERID idTransfer)
 {
+    AssertPtrReturn(pTransferCtx, VERR_INVALID_POINTER);
+    AssertReturn(idTransfer, VERR_INVALID_PARAMETER);
+
+    shClTransferCtxLock(pTransferCtx);
+
     int rc = VINF_SUCCESS;
     AssertMsgStmt(ASMBitTestAndClear(&pTransferCtx->bmTransferIds, idTransfer), ("idTransfer=%#x\n", idTransfer), rc = VERR_NOT_FOUND);
@@ -2276 +2513 @@
     LogFlowFunc(("idTransfer=%RU32\n", idTransfer));
 
-    PSHCLTRANSFER pTransfer = shClTransferCtxGetTransferByIdInternal(pTransferCtx, idTransfer);
-    if (pTransfer)
-    {
-        shclTransferCtxTransferRemoveAndUnregister(pTransferCtx, pTransfer);
-    }
-    else
-        rc = VERR_NOT_FOUND;
+    if (RT_SUCCESS(rc))
+    {
+        PSHCLTRANSFER pTransfer = shClTransferCtxGetTransferByIdInternal(pTransferCtx, idTransfer);
+        if (pTransfer)
+        {
+            shclTransferCtxTransferRemoveAndUnregister(pTransferCtx, pTransfer);
+        }
+        else
+            rc = VERR_NOT_FOUND;
+    }
+
+    shClTransferCtxUnlock(pTransferCtx);
 
     LogFlowFuncLeaveRC(rc);
@@ -2298 +2540 @@
     AssertPtrReturnVoid(pTransferCtx);
 
+    shClTransferCtxLock(pTransferCtx);
+
     LogFlowFunc(("pTransferCtx=%p, cTransfers=%RU16 cRunning=%RU16\n",
                  pTransferCtx, pTransferCtx->cTransfers, pTransferCtx->cRunning));
 
     if (pTransferCtx->cTransfers == 0)
+    {
+        shClTransferCtxUnlock(pTransferCtx);
         return;
+    }
 
     /* Remove all transfers which are not in a running state (e.g. only announced). */
@@ -2308 +2555 @@
     RTListForEachSafe(&pTransferCtx->List, pTransfer, pTransferNext, SHCLTRANSFER, Node)
     {
-        if (ShClTransferGetStatus(pTransfer) != SHCLTRANSFERSTATUS_STARTED)
+        shClTransferLock(pTransfer);
+
+        SHCLTRANSFERSTATUS const enmStatus = shClTransferGetStatusLocked(pTransfer);
+        LogFlowFunc(("\tTransfer #%RU16: %s\n", pTransfer->State.uID, ShClTransferStatusToStr(enmStatus)));
+
+        if (enmStatus != SHCLTRANSFERSTATUS_STARTED)
         {
             shclTransferCtxTransferRemoveAndUnregister(pTransferCtx, pTransfer);
+
+            shClTransferUnlock(pTransfer);
 
             ShClTransferDestroy(pTransfer);
@@ -2317 +2571 @@
             pTransfer = NULL;
         }
-    }
+        else
+            shClTransferUnlock(pTransfer);
+    }
+
+    shClTransferCtxUnlock(pTransferCtx);
 }
 
@@ -2330 +2588 @@
     AssertPtrReturn(pTransferCtx, true);
 
+    shClTransferCtxLock(pTransferCtx);
+
     LogFlowFunc(("cRunning=%RU32, cMaxRunning=%RU32\n", pTransferCtx->cRunning, pTransferCtx->cMaxRunning));
 
     Assert(pTransferCtx->cRunning <= pTransferCtx->cMaxRunning);
-    return pTransferCtx->cRunning == pTransferCtx->cMaxRunning;
+    bool const fMaximumReached = pTransferCtx->cRunning == pTransferCtx->cMaxRunning;
+
+    shClTransferCtxUnlock(pTransferCtx);
+
+    return fMaximumReached;
 }