Changeset 59620 in vbox for trunk/src/VBox/Runtime/common/checksum

Timestamp:

Feb 10, 2016 12:47:33 AM (9 years ago)

Author:

vboxsync

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

105459

Message:

IPRT: Added 'off' parameter to RTVfsIoStrmSgWrite and RTVfsIoStrmSgRead so it's easier to write passthru layers. Added RTVfsIoStrmReadAll, RTVfsIoStrmReadAllFree, RTVfsIoStrmFromBuffer, RTManifestPtIosIsInstanceOf, RTCrX509Certificate_ReadFromBuffer and RTCrDigestUpdateFromVfsFile. Updated the manifest passthru read code to handle ReadAt requests which skips parts and jumps back to re-read stuff on streams/files which are seekable.

Location:

trunk/src/VBox/Runtime/common/checksum

Files:

• manifest2.cpp (modified) (1 diff)
• manifest3.cpp (modified) (6 diffs)

trunk/src/VBox/Runtime/common/checksum/manifest2.cpp

@@ -527 +527 @@
 
     /*
-     * Ignore this entry.
+     * Ignore this entry?
      */
     char const * const *ppsz = pEquals->papszIgnoreEntries;

trunk/src/VBox/Runtime/common/checksum/manifest3.cpp

@@ -32 +32 @@
 #include <iprt/manifest.h>
 
+#include <iprt/alloca.h>
 #include <iprt/asm.h>
 #include <iprt/assert.h>
@@ -91 +92 @@
     /** The hashes.  */
     PRTMANIFESTHASHES   pHashes;
+    /** The current hash position. */
+    RTFOFF              offCurPos;
     /** Whether we're reading or writing. */
     bool                fReadOrWrite;
@@ -315 +318 @@
 {
     PRTMANIFESTPTIOS pThis = (PRTMANIFESTPTIOS)pvThis;
-    int rc = RTVfsIoStrmSgRead(pThis->hVfsIos, pSgBuf, fBlocking, pcbRead);
+    int rc;
+
+    /*
+     * To make sure we're continuing where we left off, we must have the exact
+     * stream position since a previous read using 'off' may change it.
+     */
+    RTFOFF offActual = off == -1 ? RTVfsIoStrmTell(pThis->hVfsIos) : off;
+    if (offActual == pThis->offCurPos)
+    {
+        rc = RTVfsIoStrmSgRead(pThis->hVfsIos, off, pSgBuf, fBlocking, pcbRead);
+        if (RT_SUCCESS(rc))
+        {
+            rtManifestPtIos_UpdateHashes(pThis, pSgBuf, pcbRead ? *pcbRead : ~(size_t)0);
+            if (!pcbRead)
+                for (uint32_t iSeg = 0; iSeg < pSgBuf->cSegs; iSeg++)
+                    pThis->offCurPos += pSgBuf->paSegs[iSeg].cbSeg;
+            else
+                pThis->offCurPos += *pcbRead;
+        }
+        Assert(RTVfsIoStrmTell(pThis->hVfsIos) == pThis->offCurPos);
+    }
+    else
+    {
+        /*
+         * If we're skipping over stuff, we need to read the gap and hash it.
+         */
+        if (pThis->offCurPos < offActual)
+        {
+            size_t cbBuf = _8K;
+            void  *pvBuf = alloca(cbBuf);
+            do
+            {
+                RTFOFF cbGap = off - pThis->offCurPos;
+                size_t cbThisRead = cbGap >= (RTFOFF)cbBuf ? cbBuf : (size_t)cbGap;
+                size_t cbActual;
+                rc = RTVfsIoStrmReadAt(pThis->hVfsIos, pThis->offCurPos, pvBuf, cbThisRead, fBlocking, &cbActual);
+                if (RT_FAILURE(rc) || rc == VINF_TRY_AGAIN)
+                    return rc;
+
+                rtManifestHashesUpdate(pThis->pHashes, pvBuf, cbActual);
+                pThis->offCurPos += cbActual;
+
+                if (rc == VINF_EOF)
+                {
+                    if (pcbRead)
+                        *pcbRead = 0;
+                    else
+                        rc = VERR_EOF;
+                    return rc;
+                }
+            } while (pThis->offCurPos < offActual);
+            Assert(RTVfsIoStrmTell(pThis->hVfsIos) == offActual);
+        }
+
+        /*
+         * At this point we've eliminated any gap and can execute the requested read.
+         */
+        rc = RTVfsIoStrmSgRead(pThis->hVfsIos, off, pSgBuf, fBlocking, pcbRead);
+        if (RT_SUCCESS(rc))
+        {
+            /* See if there is anything to update the hash with. */
+            size_t cbLeft = pcbRead ? *pcbRead : ~(size_t)0;
+            for (uint32_t iSeg = 0; iSeg < pSgBuf->cSegs; iSeg++)
+            {
+                size_t cbThis = pSgBuf->paSegs[iSeg].cbSeg;
+                if (cbThis > cbLeft)
+                    cbThis = cbLeft;
+
+                if (   offActual >= pThis->offCurPos
+                    && pThis->offCurPos < offActual + (ssize_t)cbThis)
+                {
+                    size_t offSeg = (size_t)(offActual - pThis->offCurPos);
+                    rtManifestHashesUpdate(pThis->pHashes, (uint8_t *)pSgBuf->paSegs[iSeg].pvSeg + offSeg, cbThis - offSeg);
+                    pThis->offCurPos += cbThis - offSeg;
+                }
+
+                cbLeft -= cbThis;
+                if (!cbLeft)
+                    break;
+                offActual += cbThis;
+            }
+        }
+    }
+    return rc;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSIOSTREAMOPS,pfnWrite}
+ */
+static DECLCALLBACK(int) rtManifestPtIos_Write(void *pvThis, RTFOFF off, PCRTSGBUF pSgBuf, bool fBlocking, size_t *pcbWritten)
+{
+    PRTMANIFESTPTIOS pThis = (PRTMANIFESTPTIOS)pvThis;
+    AssertReturn(off == -1 || off == pThis->offCurPos, VERR_WRONG_ORDER);
+    Assert(RTVfsIoStrmTell(pThis->hVfsIos) == pThis->offCurPos);
+
+    int rc = RTVfsIoStrmSgWrite(pThis->hVfsIos, -1 /*off*/, pSgBuf, fBlocking, pcbWritten);
     if (RT_SUCCESS(rc))
-        rtManifestPtIos_UpdateHashes(pThis, pSgBuf, pcbRead ? *pcbRead : ~(size_t)0);
-    Assert(off == -1); NOREF(off);
-    return rc;
-}
-
-
-/**
- * @interface_method_impl{RTVFSIOSTREAMOPS,pfnWrite}
- */
-static DECLCALLBACK(int) rtManifestPtIos_Write(void *pvThis, RTFOFF off, PCRTSGBUF pSgBuf, bool fBlocking, size_t *pcbWritten)
-{
-    PRTMANIFESTPTIOS pThis = (PRTMANIFESTPTIOS)pvThis;
-    int rc = RTVfsIoStrmSgWrite(pThis->hVfsIos, pSgBuf, fBlocking, pcbWritten);
-    if (RT_SUCCESS(rc))
+    {
         rtManifestPtIos_UpdateHashes(pThis, pSgBuf, pcbWritten ? *pcbWritten : ~(size_t)0);
-    Assert(off == -1); NOREF(off);
+        if (!pcbWritten)
+            for (uint32_t iSeg = 0; iSeg < pSgBuf->cSegs; iSeg++)
+                pThis->offCurPos += pSgBuf->paSegs[iSeg].cbSeg;
+        else
+            pThis->offCurPos += *pcbWritten;
+    }
     return rc;
 }
@@ -425 +516 @@
     AssertPtr(pszEntry);
     AssertPtr(phVfsIosPassthru);
+
+    RTFOFF const offCurPos = RTVfsIoStrmTell(hVfsIos);
+    AssertReturn(offCurPos >= 0, (int)offCurPos);
+
     uint32_t cRefs = RTManifestRetain(hManifest);
     AssertReturn(cRefs != UINT32_MAX, VERR_INVALID_HANDLE);
+
     cRefs = RTVfsIoStrmRetain(hVfsIos);
     AssertReturnStmt(cRefs != UINT32_MAX, RTManifestRelease(hManifest), VERR_INVALID_HANDLE);
@@ -441 +537 @@
         pThis->hVfsIos          = hVfsIos;
         pThis->pHashes          = rtManifestHashesCreate(fAttrs);
+        pThis->offCurPos        = offCurPos;
         pThis->hManifest        = hManifest;
         pThis->fReadOrWrite     = fReadOrWrite;
@@ -478 +575 @@
     rtManifestHashesFinal(pThis->pHashes);
     return rtManifestHashesSetAttrs(pThis->pHashes, pThis->hManifest, pThis->pszEntry);
+}
+
+
+/**
+ * Checks if the give I/O stream is a manifest passthru instance or not.
+ *
+ * @returns true if it's a manifest passthru I/O stream, false if not.
+ * @param   hVfsPtIos   Possible the manifest passthru I/O stream handle.
+ */
+RTDECL(bool) RTManifestPtIosIsInstanceOf(RTVFSIOSTREAM hVfsPtIos)
+{
+    if (hVfsPtIos != NIL_RTVFSIOSTREAM)
+    {
+        PRTMANIFESTPTIOS pThis = (PRTMANIFESTPTIOS)RTVfsIoStreamToPrivate(hVfsPtIos, &g_rtManifestPassthruIosOps);
+        if (pThis)
+            return true;
+    }
+    return false;
 }