Changeset 48797 in vbox for trunk/src/VBox/Runtime/common/zip

Timestamp:

Oct 1, 2013 2:43:17 PM (11 years ago)

Author:

vboxsync

Message:

A bit more XAR hacking.

File:

• trunk/src/VBox/Runtime/common/zip/xarvfs.cpp (modified) (17 diffs)

trunk/src/VBox/Runtime/common/zip/xarvfs.cpp

@@ -73 +73 @@
     /** The TOC XML document. */
     xml::Document          *pDoc;
-    /** The current file ID. */
-    uint32_t            idCurFile;
+
+    /** The current file. */
+    xml::ElementNode const *pCurFile;
+    /** The depth of the current file, with 0 being the root level. */
+    uint32_t                cCurDepth;
+    /** Set if it's the first file. */
+    bool                    fFirstFile;
 } RTZIPXARREADER;
 /** Pointer to the XAR reader instance data. */
@@ -84 +89 @@
 typedef struct RTZIPXARBASEOBJ
 {
-    /** The stream offset of the (first) header.  */
-    RTFOFF                  offHdr;
     /** Pointer to the reader instance data (resides in the filesystem
      * stream).
      * @todo Fix this so it won't go stale... Back ref from this obj to fss? */
     PRTZIPXARREADER         pXarReader;
-    /** The object info with unix attributes. */
-    RTFSOBJINFO             ObjInfo;
+    /** The file TOC element. */
+    xml::ElementNode const *pFileElem;
 } RTZIPXARBASEOBJ;
 /** Pointer to a XAR filesystem stream base object. */
@@ -98 +101 @@
 
 /**
+ * XAR data encoding.
+ */
+typedef enum RTZIPXARENCODING
+{
+    RTZIPXARENCODING_INVALID = 0,
+    RTZIPXARENCODING_STORE,
+    RTZIPXARENCODING_GZIP,
+    RTZIPXARENCODING_UNSUPPORTED,
+    RTZIPXARENCODING_END
+} RTZIPXARENCODING;
+
+
+/**
+ * Data stream attributes.
+ */
+typedef struct RTZIPXARDATASTREAM
+{
+    /** Offset of the data in the stream, relative to XARREADER::offZero. */
+    RTFOFF                  offData;
+    /** The size of the archived data. */
+    RTFOFF                  cbDataArchived;
+    /** The size of the extracted data. */
+    RTFOFF                  cbDataExtracted;
+    /** The encoding of the archived ata. */
+    RTZIPXARENCODING        enmEncoding;
+    /** The hash function used for the archived data. */
+    uint8_t                 uHashFunArchived;
+    /** The hash function used for the extracted data. */
+    uint8_t                 uHashFunExtracted;
+    /** The digest of the archived data. */
+    RTZIPXARHASHDIGEST      DigestArchived;
+    /** The digest of the extracted data. */
+    RTZIPXARHASHDIGEST      DigestExtracted;
+} RTZIPXARDATASTREAM;
+/** Pointer to XAR data stream attributes. */
+typedef RTZIPXARDATASTREAM *PRTZIPXARDATASTREAM;
+
+
+/**
  * Xar file represented as a VFS I/O stream.
  */
@@ -104 +146 @@
     /** The basic XAR object data. */
     RTZIPXARBASEOBJ         BaseObj;
-    /** The number of bytes in the file. */
-    RTFOFF                  cbFile;
+    /** The attributes of the primary data stream. */
+    RTZIPXARDATASTREAM      Data;
     /** The current file position. */
     RTFOFF                  offFile;
-    /** The number of padding bytes following the file. */
-    uint32_t                cbPadding;
+    /** The input I/O stream. */
+    RTVFSIOSTREAM           hVfsIos;
     /** Set if we've reached the end of the file. */
     bool                    fEndOfStream;
-    /** The input I/O stream. */
-    RTVFSIOSTREAM           hVfsIos;
+    /** The size of the file that we've currently hashed.
+     * We use this to check whether the user skips part of the file while reading
+     * and when to compare the digests. */
+    RTFOFF                  cbDigested;
+    /** The digest of the archived data. */
+    RTZIPXARHASHDIGEST      DigestArchived;
+    /** The digest of the extracted data. */
+    RTZIPXARHASHDIGEST      DigestExtracted;
 } RTZIPXARIOSTREAM;
 /** Pointer to a the private data of a XAR file I/O stream. */
 typedef RTZIPXARIOSTREAM *PRTZIPXARIOSTREAM;
+
+
+/**
+ * Xar file represented as a VFS file.
+ */
+typedef struct RTZIPXARFILE
+{
+    /** The XAR I/O stream object. */
+    RTZIPXARIOSTREAM        IosObj;
+    /** The input file. */
+    RTVFSFILE               hVfsFile;
+} RTZIPXARFILE;
+/** Pointer to a the private data of a XAR file. */
+typedef RTZIPXARFILE *PRTZIPXARFILE;
 
 
@@ -184 +246 @@
 static int rtZipXarGetOffsetSizeFromElem(xml::ElementNode const *pElement, PRTFOFF poff, uint64_t *pcb)
 {
+    if (pElement)
+        return VERR_XAR_DATA_NODE_NOT_FOUND;
+
     /*
      * The offset.
@@ -415 +480 @@
 
     /* Currently there is nothing we really have to do here. */
-    pThis->offHdr = -1;
+    NOREF(pThis);
 
     return VINF_SUCCESS;
@@ -530 +595 @@
         return pcbRead ? VINF_EOF : VERR_EOF;
 
-    Assert(pThis->cbFile >= pThis->offFile);
-    uint64_t cbLeft = (uint64_t)(pThis->cbFile - pThis->offFile);
+    Assert(pThis->Data.cbDataExtracted >= pThis->offFile);
+    uint64_t cbLeft = (uint64_t)(pThis->Data.cbDataExtracted - pThis->offFile);
     if (cbToRead > cbLeft)
     {
@@ -547 +612 @@
     int rc = RTVfsIoStrmRead(pThis->hVfsIos, pvBuf, cbToRead, fBlocking, pcbRead);
     pThis->offFile += *pcbRead;
-    if (pThis->offFile >= pThis->cbFile)
-    {
-        Assert(pThis->offFile == pThis->cbFile);
+    if (pThis->offFile >= pThis->Data.cbDataExtracted)
+    {
+        Assert(pThis->offFile == pThis->Data.cbDataExtracted);
         pThis->fEndOfStream = true;
-        RTVfsIoStrmSkip(pThis->hVfsIos, pThis->cbPadding);
+        /// @todo RTVfsIoStrmSkip(pThis->hVfsIos, pThis->cbPadding);
     }
 
@@ -785 +850 @@
     pThis->hVfsIos = NIL_RTVFSIOSTREAM;
 
+    RTVfsFileRelease(pThis->hVfsFile);
+    pThis->hVfsFile = NIL_RTVFSFILE;
+
     return VINF_SUCCESS;
 }
@@ -801 +869 @@
 
 
+static xml::ElementNode const *rtZipXarGetNextFileElement(xml::ElementNode const *pCurFile, uint32_t *pcCurDepth)
+{
+    /*
+     * Consider children first.
+     */
+    xml::ElementNode const *pChild = pCurFile->findChildElement("file");
+    if (pChild)
+    {
+        *pcCurDepth += 1;
+        return pChild;
+    }
+
+    /*
+     * Then siblings.
+     */
+    xml::ElementNode const *pSibling = pCurFile->findNextSibilingElement("file");
+    if (pSibling != NULL)
+        return pSibling;
+
+    /*
+     * Ascend and see if some parent has more siblings.
+     */
+    while (*pcCurDepth > 0)
+    {
+        pCurFile = static_cast<const xml::ElementNode *>(pCurFile->getParent());
+        AssertBreak(pCurFile);
+        Assert(pCurFile->nameEquals("file"));
+        *pcCurDepth -= 1;
+
+        pSibling = pCurFile->findNextSibilingElement("file");
+        if (pSibling != NULL)
+            return pSibling;
+    }
+
+    return NULL;
+}
+
+
 /**
  * @interface_method_impl{RTVFSFSSTREAMOPS,pfnNext}
@@ -816 +922 @@
         {
             pThis->pCurIosData->fEndOfStream = true;
-            pThis->pCurIosData->offFile      = pThis->pCurIosData->cbFile;
+/// @todo            pThis->pCurIosData->offFile      = pThis->pCurIosData->cbFile;
             pThis->pCurIosData = NULL;
         }
@@ -832 +938 @@
         return pThis->rcFatal;
 
+    /*
+     * Get the next file element.
+     */
+    if (pThis->XarReader.fFirstFile)
+    {
+        pThis->XarReader.pCurFile  = pThis->XarReader.pToc->findChildElement("file");
+        pThis->XarReader.cCurDepth = 0;
+    }
+    else if (pThis->XarReader.pCurFile)
+        pThis->XarReader.pCurFile = rtZipXarGetNextFileElement(pThis->XarReader.pCurFile, &pThis->XarReader.cCurDepth);
+    if (!pThis->XarReader.pCurFile)
+    {
+        pThis->fEndOfStream = true;
+        return VERR_EOF;
+    }
+
+    /*
+     * Retrive the fundamental attributes (elements actually).
+     */
+    const char *pszName = pThis->XarReader.pCurFile->findChildElementValueP("name");
+    const char *pszType = pThis->XarReader.pCurFile->findChildElementValueP("type");
+    if (RT_UNLIKELY(!pszName || !pszType))
+        return pThis->rcFatal = VERR_XAR_BAD_FILE_ELEMENT;
+
+    /*
+     * Gather any additional attributes that are essential to the file type,
+     * then create the VFS object we're going to return.
+     */
+    int             rc;
+    RTVFSOBJ        hVfsObj;
+    RTVFSOBJTYPE    enmType;
+    if (!strcmp(pszType, "file"))
+    {
+#if 0 /// @todo continue hacking here
+        rc = rtZipXarGetDataStreamAttributes(pThis->XarReader.pCurFile, &offData, &cbData);
+        if (RT_FAILURE(rc))
+            return pThis->rcFatal = rc;
+
+
+        if (pThis->hVfsFile != NIL_RTVFSFILE)
+        {
+
+        }
+        else
+        {
+            RTVFSIOSTREAM       hVfsIos;
+            PRTZIPXARIOSTREAM   pIosData;
+            rc = RTVfsNewIoStream(&g_rtZipXarFssIosOps,
+                                  sizeof(*pIosData),
+                                  RTFILE_O_READ | RTFILE_O_DENY_NONE | RTFILE_O_OPEN,
+                                  NIL_RTVFS,
+                                  NIL_RTVFSLOCK,
+                                  &hVfsIos,
+                                  (void **)&pIosData);
+            if (RT_FAILURE(rc))
+                return pThis->rcFatal = rc;
+
+            pIosData->BaseObj.pXarReader = &pThis->XarReader;
+            pIosData->BaseObj.pFileElem  = pThis->XarReader.pCurFile;
+            pIosData->cbFile            = cbData;
+            pIosData->offFile           = 0;
+            pIosData->cbPadding         = (uint32_t)(Info.cbAllocated - Info.cbObject);
+            pIosData->fEndOfStream      = false;
+            pIosData->hVfsIos           = pThis->hVfsIos;
+            RTVfsIoStrmRetain(pThis->hVfsIos);
+
+            pThis->pCurIosData = pIosData;
+            pThis->offNextHdr += pIosData->cbFile + pIosData->cbPadding;
+
+            enmType = RTVFSOBJTYPE_IO_STREAM;
+            hVfsObj = RTVfsObjFromIoStream(hVfsIos);
+            RTVfsIoStrmRelease(hVfsIos);
+        }
+#endif
+    }
+    else if (!strcmp(pszType, "directory"))
+    {
+        PRTZIPXARBASEOBJ pBaseObjData;
+        rc = RTVfsNewBaseObj(&g_rtZipXarFssBaseObjOps,
+                             sizeof(*pBaseObjData),
+                             NIL_RTVFS,
+                             NIL_RTVFSLOCK,
+                             &hVfsObj,
+                             (void **)&pBaseObjData);
+        if (RT_FAILURE(rc))
+            return pThis->rcFatal = rc;
+
+        pBaseObjData->pXarReader = &pThis->XarReader;
+        pBaseObjData->pFileElem  = pThis->XarReader.pCurFile;
+
+        enmType = RTVFSOBJTYPE_BASE;
+    }
+    else
+        return pThis->rcFatal = VERR_XAR_BAD_UNKNOWN_FILE_TYPE;
+
 #if 0
-    /*
-     * Make sure the input stream is in the right place.
-     */
-    RTFOFF offHdr = RTVfsIoStrmTell(pThis->hVfsIos);
-    while (   offHdr >= 0
-           && offHdr < pThis->offNextHdr)
-    {
-        int rc = RTVfsIoStrmSkip(pThis->hVfsIos, pThis->offNextHdr - offHdr);
-        if (RT_FAILURE(rc))
-        {
-            /** @todo Ignore if we're at the end of the stream? */
-            return pThis->rcFatal = rc;
-        }
-
-        offHdr = RTVfsIoStrmTell(pThis->hVfsIos);
-    }
-
-    if (offHdr < 0)
-        return pThis->rcFatal = (int)offHdr;
-    if (offHdr > pThis->offNextHdr)
-        return pThis->rcFatal = VERR_INTERNAL_ERROR_3;
-
     /*
      * Consume XAR headers.
@@ -913 +1092 @@
         case RTFS_TYPE_FILE:
         {
-            RTVFSIOSTREAM       hVfsIos;
-            PRTZIPXARIOSTREAM   pIosData;
-            rc = RTVfsNewIoStream(&g_rtZipXarFssIosOps,
-                                  sizeof(*pIosData),
-                                  RTFILE_O_READ | RTFILE_O_DENY_NONE | RTFILE_O_OPEN,
-                                  NIL_RTVFS,
-                                  NIL_RTVFSLOCK,
-                                  &hVfsIos,
-                                  (void **)&pIosData);
-            if (RT_FAILURE(rc))
-                return pThis->rcFatal = rc;
-
-            pIosData->BaseObj.offHdr    = offHdr;
-            pIosData->BaseObj.pXarReader= &pThis->XarReader;
-            pIosData->BaseObj.ObjInfo   = Info;
-            pIosData->cbFile            = Info.cbObject;
-            pIosData->offFile           = 0;
-            pIosData->cbPadding         = (uint32_t)(Info.cbAllocated - Info.cbObject);
-            pIosData->fEndOfStream      = false;
-            pIosData->hVfsIos           = pThis->hVfsIos;
-            RTVfsIoStrmRetain(pThis->hVfsIos);
-
-            pThis->pCurIosData = pIosData;
-            pThis->offNextHdr += pIosData->cbFile + pIosData->cbPadding;
-
-            enmType = RTVFSOBJTYPE_IO_STREAM;
-            hVfsObj = RTVfsObjFromIoStream(hVfsIos);
-            RTVfsIoStrmRelease(hVfsIos);
             break;
         }
@@ -1005 +1156 @@
     }
     pThis->hVfsCurObj = hVfsObj;
+#endif
 
     /*
@@ -1011 +1163 @@
     if (ppszName)
     {
-        rc = RTStrDupEx(ppszName, pThis->XarReader.szName);
+        rc = RTStrDupEx(ppszName, pszName); /** @todo fixme */
         if (RT_FAILURE(rc))
             return rc;
@@ -1024 +1176 @@
     if (penmType)
         *penmType = enmType;
-#endif
 
     return VINF_SUCCESS;
@@ -1354 +1505 @@
                         pThis->XarReader.pDoc       = pDoc;
                         pThis->XarReader.pToc       = pTocElem;
-                        pThis->XarReader.idCurFile  = 0; /* Assuming the ID numbering is from 1. */
+                        pThis->XarReader.pCurFile   = 0;
+                        pThis->XarReader.cCurDepth  = 0;
+                        pThis->XarReader.fFirstFile = true;
 
                         /*