Changeset 48780 in vbox for trunk

Timestamp:

Oct 1, 2013 2:18:49 AM (11 years ago)

Author:

vboxsync

Message:

Started on a XAR file system stream similar to what we have for TAR already.

Location:

trunk

Files:

• include/iprt/err.h (modified) (1 diff)
• include/iprt/formats/xar.h (added)
• include/iprt/zip.h (modified) (1 diff)
• src/VBox/Runtime/Makefile.kmk (modified) (2 diffs)
• src/VBox/Runtime/common/zip/tarcmd.cpp (modified) (7 diffs)
• src/VBox/Runtime/common/zip/xarvfs.cpp (copied) (copied from trunk/src/VBox/Runtime/common/zip/tarvfs.cpp ) (60 diffs)
• src/VBox/Runtime/common/zip/zip.cpp (modified) (1 diff)

trunk/include/iprt/err.h

@@ -1789 +1789 @@
 /** @} */
 
+/** @name RTZipXar status codes.
+ * @{ */
+/** Wrong magic value. */
+#define VERR_XAR_WRONG_MAGIC                        (-22700)
+/** Bad header size. */
+#define VERR_XAR_BAD_HDR_SIZE                       (-22701)
+/** Unsupported version. */
+#define VERR_XAR_UNSUPPORTED_VERSION                (-22702)
+/** Unsupported hashing function. */
+#define VERR_XAR_UNSUPPORTED_HASH_FUNCTION          (-22703)
+/** The table of content (TOC) is too small and therefore can't be valid. */
+#define VERR_XAR_TOC_TOO_SMALL                      (-22704)
+/** The table of content (TOC) is too big. */
+#define VERR_XAR_TOC_TOO_BIG                        (-22705)
+/** The compressed table of content is too big. */
+#define VERR_XAR_TOC_TOO_BIG_COMPRESSED             (-22706)
+/** The uncompressed table of content size in the header didn't match what
+ * ZLib returned. */
+#define VERR_XAR_TOC_UNCOMP_SIZE_MISMATCH           (-22707)
+/** The table of content string length didn't match the size specified in the
+ *  header. */
+#define VERR_XAR_TOC_STRLEN_MISMATCH                (-22708)
+/** The table of content isn't valid UTF-8. */
+#define VERR_XAR_TOC_UTF8_ENCODING                  (-22709)
+/** XML error while parsing the table of content. */
+#define VERR_XAR_TOC_XML_PARSE_ERROR                (-22710)
+/** The table of content XML document does not have a toc element. */
+#define VERR_XML_TOC_ELEMENT_MISSING                (-22711)
+/** The table of content XML element (toc) has sibilings, we expected it to be
+ *  an only child or the root element (xar). */
+#define VERR_XML_TOC_ELEMENT_HAS_SIBLINGS           (-22712)
+/** The XAR table of content digest doesn't match. */
+#define VERR_XAR_TOC_DIGEST_MISMATCH                (-22713)
+/** Bad or missing XAR checksum element. */
+#define VERR_XAR_BAD_CHECKSUM_ELEMENT               (-22714)
+/** The hash function in the header doesn't match the one in the table of
+ *  content. */
+#define VERR_XAR_HASH_FUNCTION_MISMATCH             (-22715)
+/** Bad digest length encountered in the table of content.  */
+#define VERR_XAR_BAD_DIGEST_LENGTH                  (-22716)
+/** The order of elements in the XAR file does not lend it self to expansion
+ *  from via an I/O stream. */
+#define VERR_XAR_NOT_STREAMBLE_ELEMENT_ORDER        (-22717)
+/** Missing offset element in table of content sub-element. */
+#define VERR_XAR_MISSING_OFFSET_ELEMENT             (-22718)
+/** Bad offset element in table of content sub-element. */
+#define VERR_XAR_BAD_OFFSET_ELEMENT                 (-22719)
+/** Missing size element in table of content sub-element. */
+#define VERR_XAR_MISSING_SIZE_ELEMENT               (-22720)
+/** Bad size element in table of content sub-element. */
+#define VERR_XAR_BAD_SIZE_ELEMENT                   (-22721)
+/** @} */
+
 
 /* SED-END */

trunk/include/iprt/zip.h

@@ -271 +271 @@
 RTDECL(RTEXITCODE) RTZipTarCmd(unsigned cArgs, char **papszArgs);
 
+/**
+ * Opens a XAR filesystem stream.
+ *
+ * This is used to extract, list or check a XAR archive.
+ *
+ * @returns IPRT status code.
+ *
+ * @param   hVfsIosIn           The compressed input stream.  The reference is
+ *                              not consumed, instead another one is retained.
+ * @param   fFlags              Flags, MBZ.
+ * @param   phVfsFss            Where to return the handle to the XAR filesystem
+ *                              stream.
+ */
+RTDECL(int) RTZipXarFsStreamFromIoStream(RTVFSIOSTREAM hVfsIosIn, uint32_t fFlags, PRTVFSFSSTREAM phVfsFss);
+
 /** @} */
 

trunk/src/VBox/Runtime/Makefile.kmk

@@ -1290 +1290 @@
 VBoxRT_INST                    = $(INST_DLL) $(INST_TESTCASE)
 endif
-VBoxRT_DEFS                   := $(filter-out RT_NO_GIP,$(RuntimeR3_DEFS)) IN_SUP_R3 IN_SUP_R3
+VBoxRT_DEFS                   := $(filter-out RT_NO_GIP,$(RuntimeR3_DEFS)) IN_SUP_R3 IN_SUP_R3 IPRT_WITH_XAR
 ifn1of ($(KBUILD_TARGET_ARCH), amd64 x86)
  VBoxRT_DEFS                  += RT_NO_GIP
@@ -1303 +1303 @@
         $(filter-out common/checksum/crc32.cpp, $(RuntimeR3_SOURCES)) \
         common/checksum/crc32-zlib.cpp \
-        common/misc/aiomgr.cpp
+        common/misc/aiomgr.cpp \
+        common/zip/xarvfs.cpp
 ifdef VBOX_WITH_LIBCURL
  VBoxRT_SOURCES               += common/misc/s3.cpp

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

@@ -60 +60 @@
 #define RTZIPTARCMD_OPT_DIR_MODE_AND_MASK   1007
 #define RTZIPTARCMD_OPT_DIR_MODE_OR_MASK    1008
+#define RTZIPTARCMD_OPT_FORMAT              1009
+
+/** File format. */
+typedef enum RTZIPTARFORMAT
+{
+    RTZIPTARFORMAT_INVALID = 0,
+    /** Autodetect if possible, defaulting to TAR. */
+    RTZIPTARFORMAT_AUTO_DEFAULT,
+    /** TAR.  */
+    RTZIPTARFORMAT_TAR,
+    /** XAR.  */
+    RTZIPTARFORMAT_XAR
+} RTZIPTARFORMAT;
 
 
@@ -70 +83 @@
 typedef struct RTZIPTARCMDOPS
 {
+    /** The file format. */
+    RTZIPTARFORMAT  enmFormat;
+
     /** The operation (Acdrtux or RTZIPTARCMD_OPT_DELETE). */
     int             iOperation;
@@ -247 +263 @@
 
     /*
-     * Open the tar filesystem stream.
-     */
-    rc = RTZipTarFsStreamFromIoStream(hVfsIos, 0/*fFlags*/, phVfsFss);
+     * Open the filesystem stream.
+     */
+    if (pOpts->enmFormat == RTZIPTARFORMAT_TAR)
+        rc = RTZipTarFsStreamFromIoStream(hVfsIos, 0/*fFlags*/, phVfsFss);
+    else if (pOpts->enmFormat == RTZIPTARFORMAT_XAR)
+#ifdef IPRT_WITH_XAR /* Requires C++ and XML, so only in some configruation of IPRT. */
+        rc = RTZipXarFsStreamFromIoStream(hVfsIos, 0/*fFlags*/, phVfsFss);
+#else
+        rc = VERR_NOT_SUPPORTED;
+#endif
+    else /** @todo make RTZipTarFsStreamFromIoStream fail if not tar file! */
+        rc = RTZipTarFsStreamFromIoStream(hVfsIos, 0/*fFlags*/, phVfsFss);
     RTVfsIoStrmRelease(hVfsIos);
     if (RT_FAILURE(rc))
@@ -950 +975 @@
         { "--owner",                RTZIPTARCMD_OPT_OWNER, RTGETOPT_REQ_STRING },
         { "--group",                RTZIPTARCMD_OPT_GROUP, RTGETOPT_REQ_STRING },
-        { "--utc",                  RTZIPTARCMD_OPT_UTC,  RTGETOPT_REQ_NOTHING },
+        { "--utc",                  RTZIPTARCMD_OPT_UTC,   RTGETOPT_REQ_NOTHING },
 
         /* IPRT extensions */
@@ -958 +983 @@
         { "--dir-mode-and-mask",    RTZIPTARCMD_OPT_DIR_MODE_AND_MASK,  RTGETOPT_REQ_UINT32 | RTGETOPT_FLAG_OCT },
         { "--dir-mode-or-mask",     RTZIPTARCMD_OPT_DIR_MODE_OR_MASK,   RTGETOPT_REQ_UINT32 | RTGETOPT_FLAG_OCT },
+        { "--format",               RTZIPTARCMD_OPT_FORMAT,             RTGETOPT_REQ_STRING },
     };
 
@@ -968 +994 @@
     RTZIPTARCMDOPS Opts;
     RT_ZERO(Opts);
+    Opts.enmFormat = RTZIPTARFORMAT_AUTO_DEFAULT;
     Opts.uidOwner = NIL_RTUID;
     Opts.gidGroup = NIL_RTUID;
@@ -1094 +1121 @@
                 break;
 
+            case RTZIPTARCMD_OPT_FORMAT:
+                if (!strcmp(ValueUnion.psz, "auto") || !strcmp(ValueUnion.psz, "default"))
+                    Opts.enmFormat = RTZIPTARFORMAT_AUTO_DEFAULT;
+                else if (!strcmp(ValueUnion.psz, "tar"))
+                    Opts.enmFormat = RTZIPTARFORMAT_TAR;
+                else if (!strcmp(ValueUnion.psz, "xar"))
+                    Opts.enmFormat = RTZIPTARFORMAT_XAR;
+                else
+                    return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Unknown archive format: '%s'", ValueUnion.psz);
+                break;
 
             /* Standard bits. */

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

@@ -1 +1 @@
 /* $Id$ */
 /** @file
- * IPRT - TAR Virtual Filesystem.
+ * IPRT - XAR Virtual Filesystem.
  */
 
 /*
- * Copyright (C) 2010-2011 Oracle Corporation
+ * Copyright (C) 2010-2013 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -36 +36 @@
 #include <iprt/ctype.h>
 #include <iprt/err.h>
+#include <iprt/md5.h>
 #include <iprt/poll.h>
 #include <iprt/file.h>
+#include <iprt/sha.h>
 #include <iprt/string.h>
 #include <iprt/vfs.h>
 #include <iprt/vfslowlevel.h>
-
-#include "tar.h"
+#include <iprt/formats/xar.h>
+#include <iprt/cpp/xml.h>
+
 
 
@@ -49 +52 @@
 *******************************************************************************/
 /**
- * TAR reader state machine states.
- */
-typedef enum RTZIPTARREADERSTATE
-{
-    /** Invalid state. */
-    RTZIPTARREADERSTATE_INVALID = 0,
-    /** Expecting the next file/dir/whatever entry. */
-    RTZIPTARREADERSTATE_FIRST,
-    /** Expecting more zero headers or the end of the stream. */
-    RTZIPTARREADERSTATE_ZERO,
-    /** Expecting a GNU long name. */
-    RTZIPTARREADERSTATE_GNU_LONGNAME,
-    /** Expecting a GNU long link. */
-    RTZIPTARREADERSTATE_GNU_LONGLINK,
-    /** Expecting a normal header or another GNU specific one. */
-    RTZIPTARREADERSTATE_GNU_NEXT,
-    /** End of valid states (not included). */
-    RTZIPTARREADERSTATE_END
-} RTZIPTARREADERSTATE;
-
-/**
- * Tar reader instance data.
- */
-typedef struct RTZIPTARREADER
-{
-    /** Zero header counter. */
-    uint32_t                cZeroHdrs;
-    /** The state machine state. */
-    RTZIPTARREADERSTATE     enmState;
-    /** The type of the previous TAR header. */
-    RTZIPTARTYPE            enmPrevType;
-    /** The type of the current TAR header. */
-    RTZIPTARTYPE            enmType;
-    /** The current header. */
-    RTZIPTARHDR             Hdr;
-    /** The expected long name/link length (GNU). */
-    uint32_t                cbGnuLongExpect;
-    /** The current long name/link length (GNU). */
-    uint32_t                offGnuLongCur;
-    /** The name of the current object.
-     * This is for handling GNU and PAX long names. */
-    char                    szName[RTPATH_MAX];
-    /** The current link target if symlink or hardlink. */
-    char                    szTarget[RTPATH_MAX];
-} RTZIPTARREADER;
-/** Pointer to the TAR reader instance data. */
-typedef RTZIPTARREADER *PRTZIPTARREADER;
-
-/**
- * Tar directory, character device, block device, fifo socket or symbolic link.
- */
-typedef struct RTZIPTARBASEOBJ
+ * Hash digest value union for the supported XAR hash functions.
+ */
+typedef union RTZIPXARHASHDIGEST
+{
+    uint8_t abMd5[RTMD5_HASH_SIZE];
+    uint8_t abSha1[RTSHA1_HASH_SIZE];
+} RTZIPXARHASHDIGEST;
+/** Pointer to a XAR hash digest union. */
+typedef RTZIPXARHASHDIGEST *PRTZIPXARHASHDIGEST;
+/** Pointer to a const XAR hash digest union. */
+typedef RTZIPXARHASHDIGEST *PCRTZIPXARHASHDIGEST;
+
+/**
+ * XAR reader instance data.
+ */
+typedef struct RTZIPXARREADER
+{
+    /** The TOC XML element. */
+    xml::ElementNode const *pToc;
+    /** The TOC XML document. */
+    xml::Document          *pDoc;
+    /** The current file ID. */
+    uint32_t            idCurFile;
+} RTZIPXARREADER;
+/** Pointer to the XAR reader instance data. */
+typedef RTZIPXARREADER *PRTZIPXARREADER;
+
+/**
+ * Xar directory, character device, block device, fifo socket or symbolic link.
+ */
+typedef struct RTZIPXARBASEOBJ
 {
     /** The stream offset of the (first) header.  */
@@ -107 +89 @@
      * stream).
      * @todo Fix this so it won't go stale... Back ref from this obj to fss? */
-    PRTZIPTARREADER         pTarReader;
+    PRTZIPXARREADER         pXarReader;
     /** The object info with unix attributes. */
     RTFSOBJINFO             ObjInfo;
-} RTZIPTARBASEOBJ;
-/** Pointer to a TAR filesystem stream base object. */
-typedef RTZIPTARBASEOBJ *PRTZIPTARBASEOBJ;
-
-
-/**
- * Tar file represented as a VFS I/O stream.
- */
-typedef struct RTZIPTARIOSTREAM
-{
-    /** The basic TAR object data. */
-    RTZIPTARBASEOBJ         BaseObj;
+} RTZIPXARBASEOBJ;
+/** Pointer to a XAR filesystem stream base object. */
+typedef RTZIPXARBASEOBJ *PRTZIPXARBASEOBJ;
+
+
+/**
+ * Xar file represented as a VFS I/O stream.
+ */
+typedef struct RTZIPXARIOSTREAM
+{
+    /** The basic XAR object data. */
+    RTZIPXARBASEOBJ         BaseObj;
     /** The number of bytes in the file. */
     RTFOFF                  cbFile;
@@ -132 +114 @@
     /** The input I/O stream. */
     RTVFSIOSTREAM           hVfsIos;
-} RTZIPTARIOSTREAM;
-/** Pointer to a the private data of a TAR file I/O stream. */
-typedef RTZIPTARIOSTREAM *PRTZIPTARIOSTREAM;
-
-
-/**
- * Tar filesystem stream private data.
- */
-typedef struct RTZIPTARFSSTREAM
+} RTZIPXARIOSTREAM;
+/** Pointer to a the private data of a XAR file I/O stream. */
+typedef RTZIPXARIOSTREAM *PRTZIPXARIOSTREAM;
+
+
+/**
+ * Xar filesystem stream private data.
+ */
+typedef struct RTZIPXARFSSTREAM
 {
     /** The input I/O stream. */
     RTVFSIOSTREAM           hVfsIos;
+    /** The input file, if the stream is actually a file. */
+    RTVFSFILE               hVfsFile;
 
     /** The current object (referenced). */
     RTVFSOBJ                hVfsCurObj;
     /** Pointer to the private data if hVfsCurObj is representing a file. */
-    PRTZIPTARIOSTREAM       pCurIosData;
-
-    /** The start offset. */
+    PRTZIPXARIOSTREAM       pCurIosData;
+
+    /** The start offset in the input I/O stream. */
     RTFOFF                  offStart;
-    /** The offset of the next header. */
-    RTFOFF                  offNextHdr;
+    /** The zero offset in the file which all others are relative to. */
+    RTFOFF                  offZero;
+
+    /** The hash function we're using (XAR_HASH_XXX). */
+    uint8_t                 uHashFunction;
+    /** The size of the digest produced by the hash function we're using. */
+    uint8_t                 cbHashDigest;
 
     /** Set if we've reached the end of the stream. */
@@ -160 +149 @@
     int                     rcFatal;
 
-    /** The TAR reader instance data. */
-    RTZIPTARREADER          TarReader;
-} RTZIPTARFSSTREAM;
-/** Pointer to a the private data of a TAR filesystem stream. */
-typedef RTZIPTARFSSTREAM *PRTZIPTARFSSTREAM;
-
-
-
-/**
- * Converts a numeric header field to the C native type.
+
+    /** The XAR reader instance data. */
+    RTZIPXARREADER          XarReader;
+} RTZIPXARFSSTREAM;
+/** Pointer to a the private data of a XAR filesystem stream. */
+typedef RTZIPXARFSSTREAM *PRTZIPXARFSSTREAM;
+
+
+/**
+ * Hashes a block of data.
  *
- * @returns IPRT status code.
- *
- * @param   pszField            The TAR header field.
- * @param   cchField            The length of the field.
- * @param   fOctalOnly          Must be octal.
- * @param   pi64                Where to store the value.
- */
-static int rtZipTarHdrFieldToNum(const char *pszField, size_t cchField, bool fOctalOnly, int64_t *pi64)
-{
-    unsigned char const *puchField   = (unsigned char const *)pszField;
-    size_t const         cchFieldOrg = cchField;
-    if (   fOctalOnly
-        || !(*puchField & 0x80))
-    {
-        /*
-         * Skip leading spaces. Include zeros to save a few slower loops below.
-         */
-        unsigned char ch;
-        while (cchField > 0 && ((ch = *puchField) == ' '|| ch == '0'))
-            cchField--, puchField++;
-
-        /*
-         * Convert octal digits.
-         */
-        int64_t i64 = 0;
-        while (cchField > 0)
-        {
-            unsigned char uDigit = *puchField - '0';
-            if (uDigit >= 8)
-                break;
-            i64 <<= 3;
-            i64 |= uDigit;
-
-            puchField++;
-            cchField--;
-        }
-        *pi64 = i64;
-
-        /*
-         * Was it terminated correctly?
-         */
-        while (cchField > 0)
-        {
-            ch = *puchField++;
-            if (ch != 0 && ch != ' ')
-                return cchField < cchFieldOrg
-                     ? VERR_TAR_BAD_NUM_FIELD_TERM
-                     : VERR_TAR_BAD_NUM_FIELD;
-            cchField--;
-        }
-    }
-    else
-    {
-        /*
-         * The first byte has the bit 7 set to indicate base-256, while bit 6
-         * is the signed bit. Bits 5:0 are the most significant value bits.
-         */
-        int64_t i64 = !(0x40 & *puchField) ? 0 : -1;
-        i64 = (i64 << 6) | (*puchField & 0x3f);
-        cchField--;
-        puchField++;
-
-        /*
-         * The remaining bytes are used in full.
-         */
-        while (cchField-- > 0)
-        {
-            if (RT_UNLIKELY(i64 > INT64_MAX / 256))
-                return VERR_TAR_NUM_VALUE_TOO_LARGE;
-            if (RT_UNLIKELY(i64 < INT64_MIN / 256))
-                return VERR_TAR_NUM_VALUE_TOO_LARGE;
-            i64 = (i64 << 8) | *puchField++;
-        }
-        *pi64 = i64;
-    }
+ * @param   uHashFunction   The hash function to use.
+ * @param   pvSrc           The data to hash.
+ * @param   cbSrc           The size of the data to hash.
+ * @param   pHashDigest     Where to return the hash digest.
+ */
+static void rtZipXarCalcHash(uint32_t uHashFunction, void const *pvSrc, size_t cbSrc, PRTZIPXARHASHDIGEST pHashDigest)
+{
+    switch (uHashFunction)
+    {
+        case XAR_HASH_SHA1:
+            RTSha1(pvSrc, cbSrc, pHashDigest->abSha1);
+            break;
+        case XAR_HASH_MD5:
+            RTMd5(pvSrc, cbSrc, pHashDigest->abMd5);
+            break;
+        default:
+            RT_ZERO(*pHashDigest);
+            break;
+    }
+}
+
+
+static int rtZipXarGetOffsetSizeFromElem(xml::ElementNode const *pElement, PRTFOFF poff, uint64_t *pcb)
+{
+    /*
+     * The offset.
+     */
+    xml::ElementNode const *pElem = pElement->findChildElement("offset");
+    if (!pElem)
+        return VERR_XAR_MISSING_OFFSET_ELEMENT;
+    const char *pszValue = pElem->getValue();
+    if (!pszValue)
+        return VERR_XAR_BAD_OFFSET_ELEMENT;
+
+    int rc = RTStrToInt64Full(pszValue, 0, poff);
+    if (   RT_FAILURE(rc)
+        || rc == VWRN_NUMBER_TOO_BIG
+        || *poff > RTFOFF_MAX / 2 /* make sure to not overflow calculating offsets. */
+        || *poff < 0)
+        return VERR_XAR_BAD_OFFSET_ELEMENT;
+
+    /*
+     * The size.
+     */
+    pElem = pElement->findChildElement("size");
+    if (!pElem)
+        return VERR_XAR_MISSING_SIZE_ELEMENT;
+
+    pszValue = pElem->getValue();
+    if (!pszValue)
+        return VERR_XAR_BAD_SIZE_ELEMENT;
+
+    rc = RTStrToUInt64Full(pszValue, 0, pcb);
+    if (   RT_FAILURE(rc)
+        || rc == VWRN_NUMBER_TOO_BIG
+        || *pcb > UINT64_MAX / 2 /* prevent overflow should be use it for calcuations later. */)
+        return VERR_XAR_BAD_SIZE_ELEMENT;
 
     return VINF_SUCCESS;
@@ -252 +223 @@
 
 /**
- * Calculates the TAR header checksums and detects if it's all zeros.
- *
- * @returns true if all zeros, false if not.
- * @param   pHdr                The header to checksum.
- * @param   pi32Unsigned        Where to store the checksum calculated using
- *                              unsigned chars.   This is the one POSIX
- *                              specifies.
- * @param   pi32Signed          Where to store the checksum calculated using
- *                              signed chars.
- *
- * @remarks The reason why we calculate the checksum as both signed and unsigned
- *          has to do with various the char C type being signed on some hosts
- *          and unsigned on others.
- */
-static bool rtZipTarCalcChkSum(PCRTZIPTARHDR pHdr, int32_t *pi32Unsigned, int32_t *pi32Signed)
-{
-    int32_t i32Unsigned = 0;
-    int32_t i32Signed   = 0;
-
-    /*
-     * Sum up the entire header.
-     */
-    const char *pch    = (const char *)pHdr;
-    const char *pchEnd = pch + sizeof(*pHdr);
-    do
-    {
-        i32Unsigned += *(unsigned char *)pch;
-        i32Signed   += *(signed   char *)pch;
-    } while (++pch != pchEnd);
-
-    /*
-     * Check if it's all zeros and replace the chksum field with spaces.
-     */
-    bool const fZeroHdr = i32Unsigned == 0;
-
-    pch    = pHdr->Common.chksum;
-    pchEnd = pch + sizeof(pHdr->Common.chksum);
-    do
-    {
-        i32Unsigned -= *(unsigned char *)pch;
-        i32Signed   -= *(signed   char *)pch;
-    } while (++pch != pchEnd);
-
-    i32Unsigned += (unsigned char)' ' * sizeof(pHdr->Common.chksum);
-    i32Signed   += (signed   char)' ' * sizeof(pHdr->Common.chksum);
-
-    *pi32Unsigned = i32Unsigned;
-    if (pi32Signed)
-        *pi32Signed = i32Signed;
-    return fZeroHdr;
-}
-
-
-/**
- * Validates the TAR header.
- *
- * @returns VINF_SUCCESS if valid, VERR_TAR_ZERO_HEADER if all zeros, and
- *          the appropriate VERR_TAR_XXX otherwise.
- * @param   pTar                The TAR header.
- * @param   penmType            Where to return the type of header on success.
- */
-static int rtZipTarHdrValidate(PCRTZIPTARHDR pTar, PRTZIPTARTYPE penmType)
-{
-    /*
-     * Calc the checksum first since this enables us to detect zero headers.
-     */
-    int32_t i32ChkSum;
-    int32_t i32ChkSumSignedAlt;
-    if (rtZipTarCalcChkSum(pTar, &i32ChkSum, &i32ChkSumSignedAlt))
-        return VERR_TAR_ZERO_HEADER;
-
-    /*
-     * Read the checksum field and match the checksums.
-     */
-    int64_t i64HdrChkSum;
-    int rc = rtZipTarHdrFieldToNum(pTar->Common.chksum, sizeof(pTar->Common.chksum), true /*fOctalOnly*/, &i64HdrChkSum);
-    if (RT_FAILURE(rc))
-        return VERR_TAR_BAD_CHKSUM_FIELD;
-    if (   i32ChkSum          != i64HdrChkSum
-        && i32ChkSumSignedAlt != i64HdrChkSum) /** @todo test this */
-        return VERR_TAR_CHKSUM_MISMATCH;
-
-    /*
-     * Detect the TAR type.
-     */
-    RTZIPTARTYPE enmType;
-    if (   pTar->Common.magic[0] == 'u'
-        && pTar->Common.magic[1] == 's'
-        && pTar->Common.magic[2] == 't'
-        && pTar->Common.magic[3] == 'a'
-        && pTar->Common.magic[4] == 'r')
-    {
-/** @todo detect star headers */
-        if (   pTar->Common.magic[5]   == '\0'
-            && pTar->Common.version[0] == '0'
-            && pTar->Common.version[1] == '0')
-            enmType = RTZIPTARTYPE_POSIX;
-        else if (   pTar->Common.magic[5]   == ' '
-                && pTar->Common.version[0] == ' '
-                && pTar->Common.version[1] == '\0')
-            enmType = RTZIPTARTYPE_GNU;
-        else
-            return VERR_TAR_NOT_USTAR_V00;
-    }
-    else
-        enmType = RTZIPTARTYPE_ANCIENT;
-    *penmType = enmType;
-
-    /*
-     * Perform some basic checks.
-     */
-    switch (enmType)
-    {
-        case RTZIPTARTYPE_POSIX:
-            if (   !RT_C_IS_ALNUM(pTar->Common.typeflag)
-                && !pTar->Common.typeflag == '\0')
-                return VERR_TAR_UNKNOWN_TYPE_FLAG;
-            break;
-
-        case RTZIPTARTYPE_GNU:
-            switch (pTar->Common.typeflag)
-            {
-                case RTZIPTAR_TF_OLDNORMAL:
-                case RTZIPTAR_TF_NORMAL:
-                case RTZIPTAR_TF_CONTIG:
-                case RTZIPTAR_TF_DIR:
-                case RTZIPTAR_TF_CHR:
-                case RTZIPTAR_TF_BLK:
-                case RTZIPTAR_TF_LINK:
-                case RTZIPTAR_TF_SYMLINK:
-                case RTZIPTAR_TF_FIFO:
-                    break;
-
-                case RTZIPTAR_TF_GNU_LONGLINK:
-                case RTZIPTAR_TF_GNU_LONGNAME:
-                    break;
-
-                case RTZIPTAR_TF_GNU_DUMPDIR:
-                case RTZIPTAR_TF_GNU_MULTIVOL:
-                case RTZIPTAR_TF_GNU_SPARSE:
-                case RTZIPTAR_TF_GNU_VOLDHR:
-                    /** @todo Implement full GNU TAR support. .*/
-                    return VERR_TAR_UNSUPPORTED_GNU_HDR_TYPE;
-
-                default:
-                    return VERR_TAR_UNKNOWN_TYPE_FLAG;
-            }
-            break;
-
-        case RTZIPTARTYPE_ANCIENT:
-            switch (pTar->Common.typeflag)
-            {
-                case RTZIPTAR_TF_OLDNORMAL:
-                case RTZIPTAR_TF_NORMAL:
-                case RTZIPTAR_TF_CONTIG:
-                case RTZIPTAR_TF_DIR:
-                case RTZIPTAR_TF_LINK:
-                case RTZIPTAR_TF_SYMLINK:
-                case RTZIPTAR_TF_FIFO:
-                    break;
-                default:
-                    return VERR_TAR_UNKNOWN_TYPE_FLAG;
-            }
-            break;
-        default: /* shut up gcc */
-            AssertFailedReturn(VERR_INTERNAL_ERROR_3);
-    }
-
-    return VINF_SUCCESS;
-}
-
-
-/**
- * Parses and validates the first TAR header of a archive/file/dir/whatever.
- *
- * @returns IPRT status code.
- * @param   pThis               The TAR reader stat.
- * @param   pTar                The TAR header that has been read.
- * @param   fFirst              Set if this is the first header, otherwise
- *                              clear.
- */
-static int rtZipTarReaderParseNextHeader(PRTZIPTARREADER pThis, PCRTZIPTARHDR pHdr, bool fFirst)
-{
-    int rc;
-
-    /*
-     * Basic header validation and detection first.
-     */
-    RTZIPTARTYPE enmType;
-    rc = rtZipTarHdrValidate(pHdr, &enmType);
-    if (RT_FAILURE_NP(rc))
-    {
-        if (rc == VERR_TAR_ZERO_HEADER)
-        {
-            pThis->cZeroHdrs = 1;
-            pThis->enmState = RTZIPTARREADERSTATE_ZERO;
-            return VINF_SUCCESS;
-        }
-        return rc;
-    }
-    if (fFirst)
-        pThis->enmType = enmType;
-
-    /*
-     * Handle the header by type.
-     */
-    switch (pHdr->Common.typeflag)
-    {
-        case RTZIPTAR_TF_OLDNORMAL:
-        case RTZIPTAR_TF_NORMAL:
-        case RTZIPTAR_TF_CONTIG:
-        case RTZIPTAR_TF_LINK:
-        case RTZIPTAR_TF_SYMLINK:
-        case RTZIPTAR_TF_CHR:
-        case RTZIPTAR_TF_BLK:
-        case RTZIPTAR_TF_FIFO:
-        case RTZIPTAR_TF_DIR:
-            /*
-             * Extract the name first.
-             */
-            if (!pHdr->Common.name[0])
-                return VERR_TAR_EMPTY_NAME;
-            if (pThis->enmType == RTZIPTARTYPE_POSIX)
-            {
-                Assert(pThis->offGnuLongCur == 0); Assert(pThis->szName[0] == '\0');
-                pThis->szName[0] = '\0';
-                if (pHdr->Posix.prefix[0])
-                {
-                    rc = RTStrCopyEx(pThis->szName, sizeof(pThis->szName), pHdr->Posix.prefix, sizeof(pHdr->Posix.prefix));
-                    AssertRC(rc); /* shall not fail */
-                    rc = RTStrCat(pThis->szName, sizeof(pThis->szName), "/");
-                    AssertRC(rc); /* ditto */
-                }
-                rc = RTStrCatEx(pThis->szName, sizeof(pThis->szName), pHdr->Common.name, sizeof(pHdr->Common.name));
-                AssertRCReturn(rc, rc);
-            }
-            else if (pThis->enmType == RTZIPTARTYPE_GNU)
-            {
-                if (!pThis->szName[0])
-                {
-                    rc = RTStrCopyEx(pThis->szName, sizeof(pThis->szName), pHdr->Common.name, sizeof(pHdr->Common.name));
-                    AssertRCReturn(rc, rc);
-                }
-            }
-            else
-            {
-                /* Old TAR */
-                Assert(pThis->offGnuLongCur == 0); Assert(pThis->szName[0] == '\0');
-                rc = RTStrCopyEx(pThis->szName, sizeof(pThis->szName), pHdr->Common.name, sizeof(pHdr->Common.name));
-                AssertRCReturn(rc, rc);
-            }
-
-            /*
-             * Extract the link target.
-             */
-            if (   pHdr->Common.typeflag == RTZIPTAR_TF_LINK
-                || pHdr->Common.typeflag == RTZIPTAR_TF_SYMLINK)
-            {
-                if (   pThis->enmType == RTZIPTARTYPE_POSIX
-                    || pThis->enmType == RTZIPTARTYPE_ANCIENT
-                    || (pThis->enmType == RTZIPTARTYPE_GNU && pThis->szTarget[0] == '\0')
-                   )
-                {
-                    Assert(pThis->szTarget[0] == '\0');
-                    rc = RTStrCopyEx(pThis->szTarget, sizeof(pThis->szTarget),
-                                     pHdr->Common.linkname, sizeof(pHdr->Common.linkname));
-                    AssertRCReturn(rc, rc);
-                }
-            }
-            else
-                pThis->szTarget[0] = '\0';
-
-            pThis->Hdr = *pHdr;
-            break;
-
-        case RTZIPTAR_TF_X_HDR:
-        case RTZIPTAR_TF_X_GLOBAL:
-            /** @todo implement PAX */
-            return VERR_TAR_UNSUPPORTED_PAX_TYPE;
-
-        case RTZIPTAR_TF_SOLARIS_XHDR:
-            /** @todo implement solaris / pax attribute lists. */
-            return VERR_TAR_UNSUPPORTED_SOLARIS_HDR_TYPE;
-
-
-        /*
-         * A GNU long name or long link is a dummy record followed by one or
-         * more 512 byte string blocks holding the long name/link.  The name
-         * lenght is encoded in the size field, null terminator included.  If
-         * it is a symlink or hard link the long name may be followed by a
-         * long link sequence.
-         */
-        case RTZIPTAR_TF_GNU_LONGNAME:
-        case RTZIPTAR_TF_GNU_LONGLINK:
-        {
-            if (strcmp(pHdr->Gnu.name, "././@LongLink"))
-                return VERR_TAR_MALFORMED_GNU_LONGXXXX;
-
-            int64_t cb64;
-            rc = rtZipTarHdrFieldToNum(pHdr->Gnu.size, sizeof(pHdr->Gnu.size), false /*fOctalOnly*/, &cb64);
-            if (RT_FAILURE(rc) || cb64 < 0 || cb64 > _1M)
-                return VERR_TAR_MALFORMED_GNU_LONGXXXX;
-            uint32_t cb = (uint32_t)cb64;
-            if (cb >= sizeof(pThis->szName))
-                return VERR_TAR_NAME_TOO_LONG;
-
-            pThis->cbGnuLongExpect  = cb;
-            pThis->offGnuLongCur    = 0;
-            pThis->enmState         = pHdr->Common.typeflag == RTZIPTAR_TF_GNU_LONGNAME
-                                    ? RTZIPTARREADERSTATE_GNU_LONGNAME
-                                    : RTZIPTARREADERSTATE_GNU_LONGLINK;
-            break;
-        }
-
-        case RTZIPTAR_TF_GNU_DUMPDIR:
-        case RTZIPTAR_TF_GNU_MULTIVOL:
-        case RTZIPTAR_TF_GNU_SPARSE:
-        case RTZIPTAR_TF_GNU_VOLDHR:
-            /** @todo Implement or skip GNU headers */
-            return VERR_TAR_UNSUPPORTED_GNU_HDR_TYPE;
-
-        default:
-            return VERR_TAR_UNKNOWN_TYPE_FLAG;
-    }
-
-    return VINF_SUCCESS;
-}
-
-
-/**
- * Parses and validates a TAR header.
- *
- * @returns IPRT status code.
- * @param   pThis               The TAR reader stat.
- * @param   pTar                The TAR header that has been read.
- */
-static int rtZipTarReaderParseHeader(PRTZIPTARREADER pThis, PCRTZIPTARHDR pHdr)
-{
-    switch (pThis->enmState)
-    {
-        /*
-         * The first record for a file/directory/whatever.
-         */
-        case RTZIPTARREADERSTATE_FIRST:
-            pThis->Hdr.Common.typeflag  = 0x7f;
-            pThis->enmPrevType          = pThis->enmType;
-            pThis->enmType              = RTZIPTARTYPE_INVALID;
-            pThis->offGnuLongCur        = 0;
-            pThis->cbGnuLongExpect      = 0;
-            pThis->szName[0]            = '\0';
-            pThis->szTarget[0]          = '\0';
-            return rtZipTarReaderParseNextHeader(pThis, pHdr, true /*fFirst*/);
-
-        /*
-         * There should only be so many zero headers at the end of the file as
-         * it is a function of the block size used when writing.  Don't go on
-         * reading them forever in case someone points us to /dev/zero.
-         */
-        case RTZIPTARREADERSTATE_ZERO:
-            if (ASMMemIsAllU32(pHdr, sizeof(*pHdr), 0) != NULL)
-                return VERR_TAR_ZERO_HEADER;
-            pThis->cZeroHdrs++;
-            if (pThis->cZeroHdrs <= _64K / 512 + 2)
-                return VINF_SUCCESS;
-            return VERR_TAR_ZERO_HEADER;
-
-        case RTZIPTARREADERSTATE_GNU_LONGNAME:
-        case RTZIPTARREADERSTATE_GNU_LONGLINK:
-        {
-            size_t cbIncoming = RTStrNLen((const char *)pHdr->ab, sizeof(*pHdr));
-            if (cbIncoming < sizeof(*pHdr))
-                cbIncoming += 1;
-
-            if (cbIncoming + pThis->offGnuLongCur > pThis->cbGnuLongExpect)
-                return VERR_TAR_MALFORMED_GNU_LONGXXXX;
-            if (   cbIncoming < sizeof(*pHdr)
-                && cbIncoming + pThis->offGnuLongCur != pThis->cbGnuLongExpect)
-                return VERR_TAR_MALFORMED_GNU_LONGXXXX;
-
-            char *pszDst = pThis->enmState == RTZIPTARREADERSTATE_GNU_LONGNAME ? pThis->szName : pThis->szTarget;
-            pszDst += pThis->offGnuLongCur;
-            memcpy(pszDst, pHdr->ab, cbIncoming);
-
-            pThis->offGnuLongCur += (uint32_t)cbIncoming;
-            if (pThis->offGnuLongCur == pThis->cbGnuLongExpect)
-                pThis->enmState = RTZIPTARREADERSTATE_GNU_NEXT;
-            return VINF_SUCCESS;
-        }
-
-        case RTZIPTARREADERSTATE_GNU_NEXT:
-            pThis->enmState = RTZIPTARREADERSTATE_FIRST;
-            return rtZipTarReaderParseNextHeader(pThis, pHdr, false /*fFirst*/);
-
-        default:
-            return VERR_INTERNAL_ERROR_5;
-    }
-}
-
-
-/**
- * Translate a TAR header to an IPRT object info structure with additional UNIX
+ * Translate a XAR header to an IPRT object info structure with additional UNIX
  * attributes.
  *
- * This completes the validation done by rtZipTarHdrValidate.
+ * This completes the validation done by rtZipXarHdrValidate.
  *
- * @returns VINF_SUCCESS if valid, appropriate VERR_TAR_XXX if not.
- * @param   pThis               The TAR reader instance.
+ * @returns VINF_SUCCESS if valid, appropriate VERR_XAR_XXX if not.
+ * @param   pThis               The XAR reader instance.
  * @param   pObjInfo            The object info structure (output).
  */
-static int rtZipTarReaderGetFsObjInfo(PRTZIPTARREADER pThis, PRTFSOBJINFO pObjInfo)
+static int rtZipXarReaderGetFsObjInfo(PRTZIPXARREADER pThis, PRTFSOBJINFO pObjInfo)
 {
     /*
@@ -668 +239 @@
     RT_ZERO(*pObjInfo);
 
-    /*
-     * Convert the TAR field in RTFSOBJINFO order.
+#if 0
+    /*
+     * Convert the XAR field in RTFSOBJINFO order.
      */
     int         rc;
     int64_t     i64Tmp;
-#define GET_TAR_NUMERIC_FIELD_RET(a_Var, a_Field) \
+#define GET_XAR_NUMERIC_FIELD_RET(a_Var, a_Field) \
         do { \
-            rc = rtZipTarHdrFieldToNum(a_Field, sizeof(a_Field), false /*fOctalOnly*/, &i64Tmp); \
+            rc = rtZipXarHdrFieldToNum(a_Field, sizeof(a_Field), false /*fOctalOnly*/, &i64Tmp); \
             if (RT_FAILURE(rc)) \
                 return rc; \
             (a_Var) = i64Tmp; \
             if ((a_Var) != i64Tmp) \
-                return VERR_TAR_NUM_VALUE_TOO_LARGE; \
+                return VERR_XAR_NUM_VALUE_TOO_LARGE; \
         } while (0)
 
-    GET_TAR_NUMERIC_FIELD_RET(pObjInfo->cbObject,        pThis->Hdr.Common.size);
+    GET_XAR_NUMERIC_FIELD_RET(pObjInfo->cbObject,        pThis->Hdr.Common.size);
     pObjInfo->cbAllocated = RT_ALIGN_64(pObjInfo->cbObject, 512);
     int64_t c64SecModTime;
-    GET_TAR_NUMERIC_FIELD_RET(c64SecModTime,             pThis->Hdr.Common.mtime);
+    GET_XAR_NUMERIC_FIELD_RET(c64SecModTime,             pThis->Hdr.Common.mtime);
     RTTimeSpecSetSeconds(&pObjInfo->ChangeTime,          c64SecModTime);
     RTTimeSpecSetSeconds(&pObjInfo->ModificationTime,    c64SecModTime);
@@ -692 +264 @@
     RTTimeSpecSetSeconds(&pObjInfo->BirthTime,           c64SecModTime);
     if (c64SecModTime != RTTimeSpecGetSeconds(&pObjInfo->ModificationTime))
-        return VERR_TAR_NUM_VALUE_TOO_LARGE;
-    GET_TAR_NUMERIC_FIELD_RET(pObjInfo->Attr.fMode,      pThis->Hdr.Common.mode);
+        return VERR_XAR_NUM_VALUE_TOO_LARGE;
+    GET_XAR_NUMERIC_FIELD_RET(pObjInfo->Attr.fMode,      pThis->Hdr.Common.mode);
     pObjInfo->Attr.enmAdditional = RTFSOBJATTRADD_UNIX;
-    GET_TAR_NUMERIC_FIELD_RET(pObjInfo->Attr.u.Unix.uid, pThis->Hdr.Common.uid);
-    GET_TAR_NUMERIC_FIELD_RET(pObjInfo->Attr.u.Unix.gid, pThis->Hdr.Common.gid);
+    GET_XAR_NUMERIC_FIELD_RET(pObjInfo->Attr.u.Unix.uid, pThis->Hdr.Common.uid);
+    GET_XAR_NUMERIC_FIELD_RET(pObjInfo->Attr.u.Unix.gid, pThis->Hdr.Common.gid);
     pObjInfo->Attr.u.Unix.cHardlinks    = 1;
     pObjInfo->Attr.u.Unix.INodeIdDevice = 0;
@@ -705 +277 @@
     switch (pThis->enmType)
     {
-        case RTZIPTARTYPE_POSIX:
-        case RTZIPTARTYPE_GNU:
-            if (   pThis->Hdr.Common.typeflag == RTZIPTAR_TF_CHR
-                || pThis->Hdr.Common.typeflag == RTZIPTAR_TF_BLK)
+        case RTZIPXARTYPE_POSIX:
+        case RTZIPXARTYPE_GNU:
+            if (   pThis->Hdr.Common.typeflag == RTZIPXAR_TF_CHR
+                || pThis->Hdr.Common.typeflag == RTZIPXAR_TF_BLK)
             {
                 uint32_t uMajor, uMinor;
-                GET_TAR_NUMERIC_FIELD_RET(uMajor,        pThis->Hdr.Common.devmajor);
-                GET_TAR_NUMERIC_FIELD_RET(uMinor,        pThis->Hdr.Common.devminor);
+                GET_XAR_NUMERIC_FIELD_RET(uMajor,        pThis->Hdr.Common.devmajor);
+                GET_XAR_NUMERIC_FIELD_RET(uMinor,        pThis->Hdr.Common.devminor);
                 pObjInfo->Attr.u.Unix.Device    = RTDEV_MAKE(uMajor, uMinor);
                 if (   uMajor != RTDEV_MAJOR(pObjInfo->Attr.u.Unix.Device)
                     || uMinor != RTDEV_MINOR(pObjInfo->Attr.u.Unix.Device))
-                    return VERR_TAR_DEV_VALUE_TOO_LARGE;
+                    return VERR_XAR_DEV_VALUE_TOO_LARGE;
             }
             break;
 
         default:
-            if (   pThis->Hdr.Common.typeflag == RTZIPTAR_TF_CHR
-                || pThis->Hdr.Common.typeflag == RTZIPTAR_TF_BLK)
-                return VERR_TAR_UNKNOWN_TYPE_FLAG;
-    }
-
-#undef GET_TAR_NUMERIC_FIELD_RET
+            if (   pThis->Hdr.Common.typeflag == RTZIPXAR_TF_CHR
+                || pThis->Hdr.Common.typeflag == RTZIPXAR_TF_BLK)
+                return VERR_XAR_UNKNOWN_TYPE_FLAG;
+    }
+
+#undef GET_XAR_NUMERIC_FIELD_RET
 
     /*
@@ -733 +305 @@
      */
     if (   (pObjInfo->Attr.fMode & ~RTFS_UNIX_MASK)
-        && pThis->enmType == RTZIPTARTYPE_POSIX)
-        return VERR_TAR_BAD_MODE_FIELD;
+        && pThis->enmType == RTZIPXARTYPE_POSIX)
+        return VERR_XAR_BAD_MODE_FIELD;
     pObjInfo->Attr.fMode &= RTFS_UNIX_MASK;
 
@@ -740 +312 @@
     switch (pThis->Hdr.Common.typeflag)
     {
-        case RTZIPTAR_TF_OLDNORMAL:
-        case RTZIPTAR_TF_NORMAL:
-        case RTZIPTAR_TF_CONTIG:
+        case RTZIPXAR_TF_OLDNORMAL:
+        case RTZIPXAR_TF_NORMAL:
+        case RTZIPXAR_TF_CONTIG:
         {
             const char *pszEnd = strchr(pThis->szName, '\0');
@@ -752 +324 @@
         }
 
-        case RTZIPTAR_TF_LINK:
+        case RTZIPXAR_TF_LINK:
             if (pObjInfo->cbObject != 0)
 #if 0 /* too strict */
-                return VERR_TAR_SIZE_NOT_ZERO;
+                return VERR_XAR_SIZE_NOT_ZERO;
 #else
                 pObjInfo->cbObject = pObjInfo->cbAllocated = 0;
@@ -762 +334 @@
             break;
 
-        case RTZIPTAR_TF_SYMLINK:
+        case RTZIPXAR_TF_SYMLINK:
             fModeType |= RTFS_TYPE_SYMLINK;
             break;
 
-        case RTZIPTAR_TF_CHR:
+        case RTZIPXAR_TF_CHR:
             fModeType |= RTFS_TYPE_DEV_CHAR;
             break;
 
-        case RTZIPTAR_TF_BLK:
+        case RTZIPXAR_TF_BLK:
             fModeType |= RTFS_TYPE_DEV_BLOCK;
             break;
 
-        case RTZIPTAR_TF_DIR:
+        case RTZIPXAR_TF_DIR:
             fModeType |= RTFS_TYPE_DIRECTORY;
             break;
 
-        case RTZIPTAR_TF_FIFO:
+        case RTZIPXAR_TF_FIFO:
             fModeType |= RTFS_TYPE_FIFO;
             break;
 
-        case RTZIPTAR_TF_GNU_LONGLINK:
-        case RTZIPTAR_TF_GNU_LONGNAME:
+        case RTZIPXAR_TF_GNU_LONGLINK:
+        case RTZIPXAR_TF_GNU_LONGNAME:
             /* ASSUMES RTFS_TYPE_XXX uses the same values as GNU stored in the mode field. */
             fModeType = pObjInfo->Attr.fMode & RTFS_TYPE_MASK;
@@ -798 +370 @@
                 default:
                 case 0:
-                    return VERR_TAR_UNKNOWN_TYPE_FLAG; /** @todo new status code */
+                    return VERR_XAR_UNKNOWN_TYPE_FLAG; /** @todo new status code */
             }
 
         default:
-            return VERR_TAR_UNKNOWN_TYPE_FLAG; /* Should've been caught in validate. */
+            return VERR_XAR_UNKNOWN_TYPE_FLAG; /* Should've been caught in validate. */
     }
     if (   (pObjInfo->Attr.fMode & RTFS_TYPE_MASK)
         && (pObjInfo->Attr.fMode & RTFS_TYPE_MASK) != fModeType)
-        return VERR_TAR_MODE_WITH_TYPE;
+        return VERR_XAR_MODE_WITH_TYPE;
     pObjInfo->Attr.fMode &= ~RTFS_TYPE_MASK;
     pObjInfo->Attr.fMode |= fModeType;
@@ -812 +384 @@
     switch (pThis->Hdr.Common.typeflag)
     {
-        case RTZIPTAR_TF_CHR:
-        case RTZIPTAR_TF_BLK:
-        case RTZIPTAR_TF_DIR:
-        case RTZIPTAR_TF_FIFO:
+        case RTZIPXAR_TF_CHR:
+        case RTZIPXAR_TF_BLK:
+        case RTZIPXAR_TF_DIR:
+        case RTZIPXAR_TF_FIFO:
             pObjInfo->cbObject    = 0;
             pObjInfo->cbAllocated = 0;
             break;
     }
+#endif
 
     return VINF_SUCCESS;
 }
 
-
-/**
- * Checks if the reader is expecting more headers.
- *
- * @returns true / false.
- * @param   pThis               The TAR reader instance.
- */
-static bool rtZipTarReaderExpectingMoreHeaders(PRTZIPTARREADER pThis)
-{
-    return pThis->enmState != RTZIPTARREADERSTATE_FIRST;
-}
-
-
-/**
- * Checks if we're at the end of the TAR file.
- *
- * @returns true / false.
- * @param   pThis               The TAR reader instance.
- */
-static bool rtZipTarReaderIsAtEnd(PRTZIPTARREADER pThis)
-{
-    if (!pThis->cZeroHdrs)
-        return false;
-
-    /* Here is a kludge to try deal with archivers not putting at least two
-       zero headers at the end.  Afraid it may require further relaxing
-       later on, but let's try be strict about things for now. */
-    return pThis->cZeroHdrs >= (pThis->enmPrevType == RTZIPTARTYPE_POSIX ? 2U : 1U);
-}
-
-
-/**
- * Checks if the current TAR object is a hard link or not.
- *
- * @returns true if it is, false if not.
- * @param   pThis               The TAR reader instance.
- */
-static bool rtZipTarReaderIsHardlink(PRTZIPTARREADER pThis)
-{
-    return pThis->Hdr.Common.typeflag == RTZIPTAR_TF_LINK;
-}
-
-
-/**
- * Checks if the TAR header includes a POSIX or GNU user name field.
- *
- * @returns true / false.
- * @param   pThis               The TAR reader instance.
- */
-DECLINLINE(bool) rtZipTarReaderHasUserName(PRTZIPTARREADER pThis)
-{
-    return pThis->Hdr.Common.uname[0] != '\0'
-        && (   pThis->enmType == RTZIPTARTYPE_POSIX
-            || pThis->enmType == RTZIPTARTYPE_GNU);
-}
-
-
-/**
- * Checks if the TAR header includes a POSIX or GNU group name field.
- *
- * @returns true / false.
- * @param   pThis               The TAR reader instance.
- */
-DECLINLINE(bool) rtZipTarReaderHasGroupName(PRTZIPTARREADER pThis)
-{
-    return pThis->Hdr.Common.gname[0] != '\0'
-        && (   pThis->enmType == RTZIPTARTYPE_POSIX
-            || pThis->enmType == RTZIPTARTYPE_GNU);
-}
 
 
@@ -906 +410 @@
  * @interface_method_impl{RTVFSOBJOPS,pfnClose}
  */
-static DECLCALLBACK(int) rtZipTarFssBaseObj_Close(void *pvThis)
-{
-    PRTZIPTARBASEOBJ pThis = (PRTZIPTARBASEOBJ)pvThis;
+static DECLCALLBACK(int) rtZipXarFssBaseObj_Close(void *pvThis)
+{
+    PRTZIPXARBASEOBJ pThis = (PRTZIPXARBASEOBJ)pvThis;
 
     /* Currently there is nothing we really have to do here. */
@@ -920 +424 @@
  * @interface_method_impl{RTVFSOBJOPS,pfnQueryInfo}
  */
-static DECLCALLBACK(int) rtZipTarFssBaseObj_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
-{
-    PRTZIPTARBASEOBJ pThis = (PRTZIPTARBASEOBJ)pvThis;
-
+static DECLCALLBACK(int) rtZipXarFssBaseObj_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
+{
+    PRTZIPXARBASEOBJ pThis = (PRTZIPXARBASEOBJ)pvThis;
+
+#if 0
     /*
      * Copy the desired data.
@@ -939 +444 @@
             pObjInfo->Attr.u.UnixOwner.uid       = pThis->ObjInfo.Attr.u.Unix.uid;
             pObjInfo->Attr.u.UnixOwner.szName[0] = '\0';
-            if (rtZipTarReaderHasUserName(pThis->pTarReader))
+            if (rtZipXarReaderHasUserName(pThis->pXarReader))
                 RTStrCopy(pObjInfo->Attr.u.UnixOwner.szName, sizeof(pObjInfo->Attr.u.UnixOwner.szName),
-                          pThis->pTarReader->Hdr.Common.uname);
+                          pThis->pXarReader->Hdr.Common.uname);
             break;
 
@@ -949 +454 @@
             pObjInfo->Attr.u.UnixGroup.gid       = pThis->ObjInfo.Attr.u.Unix.gid;
             pObjInfo->Attr.u.UnixGroup.szName[0] = '\0';
-            if (rtZipTarReaderHasGroupName(pThis->pTarReader))
+            if (rtZipXarReaderHasGroupName(pThis->pXarReader))
                 RTStrCopy(pObjInfo->Attr.u.UnixGroup.szName, sizeof(pObjInfo->Attr.u.UnixGroup.szName),
-                          pThis->pTarReader->Hdr.Common.gname);
+                          pThis->pXarReader->Hdr.Common.gname);
             break;
 
@@ -963 +468 @@
             return VERR_NOT_SUPPORTED;
     }
+#endif
 
     return VINF_SUCCESS;
@@ -969 +475 @@
 
 /**
- * Tar filesystem base object operations.
- */
-static const RTVFSOBJOPS g_rtZipTarFssBaseObjOps =
+ * Xar filesystem base object operations.
+ */
+static const RTVFSOBJOPS g_rtZipXarFssBaseObjOps =
 {
     RTVFSOBJOPS_VERSION,
     RTVFSOBJTYPE_BASE,
-    "TarFsStream::Obj",
-    rtZipTarFssBaseObj_Close,
-    rtZipTarFssBaseObj_QueryInfo,
+    "XarFsStream::Obj",
+    rtZipXarFssBaseObj_Close,
+    rtZipXarFssBaseObj_QueryInfo,
     RTVFSOBJOPS_VERSION
 };
@@ -985 +491 @@
  * @interface_method_impl{RTVFSOBJOPS,pfnClose}
  */
-static DECLCALLBACK(int) rtZipTarFssIos_Close(void *pvThis)
-{
-    PRTZIPTARIOSTREAM pThis = (PRTZIPTARIOSTREAM)pvThis;
+static DECLCALLBACK(int) rtZipXarFssIos_Close(void *pvThis)
+{
+    PRTZIPXARIOSTREAM pThis = (PRTZIPXARIOSTREAM)pvThis;
 
     RTVfsIoStrmRelease(pThis->hVfsIos);
     pThis->hVfsIos = NIL_RTVFSIOSTREAM;
 
-    return rtZipTarFssBaseObj_Close(&pThis->BaseObj);
+    return rtZipXarFssBaseObj_Close(&pThis->BaseObj);
 }
 
@@ -999 +505 @@
  * @interface_method_impl{RTVFSOBJOPS,pfnQueryInfo}
  */
-static DECLCALLBACK(int) rtZipTarFssIos_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
-{
-    PRTZIPTARIOSTREAM pThis = (PRTZIPTARIOSTREAM)pvThis;
-    return rtZipTarFssBaseObj_QueryInfo(&pThis->BaseObj, pObjInfo, enmAddAttr);
+static DECLCALLBACK(int) rtZipXarFssIos_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
+{
+    PRTZIPXARIOSTREAM pThis = (PRTZIPXARIOSTREAM)pvThis;
+    return rtZipXarFssBaseObj_QueryInfo(&pThis->BaseObj, pObjInfo, enmAddAttr);
 }
 
@@ -1016 +522 @@
  * @param   pcbRead         Where to store the number of bytes actually read.
  */
-static int rtZipTarFssIos_ReadOneSeg(PRTZIPTARIOSTREAM pThis, void *pvBuf, size_t cbToRead, bool fBlocking, size_t *pcbRead)
+static int rtZipXarFssIos_ReadOneSeg(PRTZIPXARIOSTREAM pThis, void *pvBuf, size_t cbToRead, bool fBlocking, size_t *pcbRead)
 {
     /*
@@ -1055 +561 @@
  * @interface_method_impl{RTVFSIOSTREAMOPS,pfnRead}
  */
-static DECLCALLBACK(int) rtZipTarFssIos_Read(void *pvThis, RTFOFF off, PCRTSGBUF pSgBuf, bool fBlocking, size_t *pcbRead)
-{
-    PRTZIPTARIOSTREAM pThis = (PRTZIPTARIOSTREAM)pvThis;
+static DECLCALLBACK(int) rtZipXarFssIos_Read(void *pvThis, RTFOFF off, PCRTSGBUF pSgBuf, bool fBlocking, size_t *pcbRead)
+{
+    PRTZIPXARIOSTREAM pThis = (PRTZIPXARIOSTREAM)pvThis;
     int               rc;
     AssertReturn(off == -1, VERR_INVALID_PARAMETER);
 
     if (pSgBuf->cSegs == 1)
-        rc = rtZipTarFssIos_ReadOneSeg(pThis, pSgBuf->paSegs[0].pvSeg, pSgBuf->paSegs[0].cbSeg, fBlocking, pcbRead);
+        rc = rtZipXarFssIos_ReadOneSeg(pThis, pSgBuf->paSegs[0].pvSeg, pSgBuf->paSegs[0].cbSeg, fBlocking, pcbRead);
     else
     {
@@ -1072 +578 @@
         {
             cbReadSeg = 0;
-            rc = rtZipTarFssIos_ReadOneSeg(pThis, pSgBuf->paSegs[iSeg].pvSeg, pSgBuf->paSegs[iSeg].cbSeg, fBlocking, pcbReadSeg);
+            rc = rtZipXarFssIos_ReadOneSeg(pThis, pSgBuf->paSegs[iSeg].pvSeg, pSgBuf->paSegs[iSeg].cbSeg, fBlocking, pcbReadSeg);
             if (RT_FAILURE(rc))
                 break;
@@ -1093 +599 @@
  * @interface_method_impl{RTVFSIOSTREAMOPS,pfnWrite}
  */
-static DECLCALLBACK(int) rtZipTarFssIos_Write(void *pvThis, RTFOFF off, PCRTSGBUF pSgBuf, bool fBlocking, size_t *pcbWritten)
+static DECLCALLBACK(int) rtZipXarFssIos_Write(void *pvThis, RTFOFF off, PCRTSGBUF pSgBuf, bool fBlocking, size_t *pcbWritten)
 {
     /* Cannot write to a read-only I/O stream. */
@@ -1104 +610 @@
  * @interface_method_impl{RTVFSIOSTREAMOPS,pfnFlush}
  */
-static DECLCALLBACK(int) rtZipTarFssIos_Flush(void *pvThis)
+static DECLCALLBACK(int) rtZipXarFssIos_Flush(void *pvThis)
 {
     /* It's a read only stream, nothing dirty to flush. */
@@ -1115 +621 @@
  * @interface_method_impl{RTVFSIOSTREAMOPS,pfnPollOne}
  */
-static DECLCALLBACK(int) rtZipTarFssIos_PollOne(void *pvThis, uint32_t fEvents, RTMSINTERVAL cMillies, bool fIntr,
+static DECLCALLBACK(int) rtZipXarFssIos_PollOne(void *pvThis, uint32_t fEvents, RTMSINTERVAL cMillies, bool fIntr,
                                                 uint32_t *pfRetEvents)
 {
-    PRTZIPTARIOSTREAM pThis = (PRTZIPTARIOSTREAM)pvThis;
+    PRTZIPXARIOSTREAM pThis = (PRTZIPXARIOSTREAM)pvThis;
 
     /* When we've reached the end, read will be set to indicate it. */
@@ -1139 +645 @@
  * @interface_method_impl{RTVFSIOSTREAMOPS,pfnTell}
  */
-static DECLCALLBACK(int) rtZipTarFssIos_Tell(void *pvThis, PRTFOFF poffActual)
-{
-    PRTZIPTARIOSTREAM pThis = (PRTZIPTARIOSTREAM)pvThis;
+static DECLCALLBACK(int) rtZipXarFssIos_Tell(void *pvThis, PRTFOFF poffActual)
+{
+    PRTZIPXARIOSTREAM pThis = (PRTZIPXARIOSTREAM)pvThis;
     *poffActual = pThis->offFile;
     return VINF_SUCCESS;
@@ -1148 +654 @@
 
 /**
- * Tar I/O stream operations.
- */
-static const RTVFSIOSTREAMOPS g_rtZipTarFssIosOps =
+ * Xar I/O stream operations.
+ */
+static const RTVFSIOSTREAMOPS g_rtZipXarFssIosOps =
 {
     { /* Obj */
         RTVFSOBJOPS_VERSION,
         RTVFSOBJTYPE_IO_STREAM,
-        "TarFsStream::IoStream",
-        rtZipTarFssIos_Close,
-        rtZipTarFssIos_QueryInfo,
+        "XarFsStream::IoStream",
+        rtZipXarFssIos_Close,
+        rtZipXarFssIos_QueryInfo,
         RTVFSOBJOPS_VERSION
     },
     RTVFSIOSTREAMOPS_VERSION,
     0,
-    rtZipTarFssIos_Read,
-    rtZipTarFssIos_Write,
-    rtZipTarFssIos_Flush,
-    rtZipTarFssIos_PollOne,
-    rtZipTarFssIos_Tell,
+    rtZipXarFssIos_Read,
+    rtZipXarFssIos_Write,
+    rtZipXarFssIos_Flush,
+    rtZipXarFssIos_PollOne,
+    rtZipXarFssIos_Tell,
     NULL /*Skip*/,
     NULL /*ZeroFill*/,
@@ -1176 +682 @@
  * @interface_method_impl{RTVFSOBJOPS,pfnClose}
  */
-static DECLCALLBACK(int) rtZipTarFssSym_Close(void *pvThis)
-{
-    PRTZIPTARBASEOBJ pThis = (PRTZIPTARBASEOBJ)pvThis;
-    return rtZipTarFssBaseObj_Close(pThis);
+static DECLCALLBACK(int) rtZipXarFssSym_Close(void *pvThis)
+{
+    PRTZIPXARBASEOBJ pThis = (PRTZIPXARBASEOBJ)pvThis;
+    return rtZipXarFssBaseObj_Close(pThis);
 }
 
@@ -1186 +692 @@
  * @interface_method_impl{RTVFSOBJOPS,pfnQueryInfo}
  */
-static DECLCALLBACK(int) rtZipTarFssSym_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
-{
-    PRTZIPTARBASEOBJ pThis = (PRTZIPTARBASEOBJ)pvThis;
-    return rtZipTarFssBaseObj_QueryInfo(pThis, pObjInfo, enmAddAttr);
+static DECLCALLBACK(int) rtZipXarFssSym_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
+{
+    PRTZIPXARBASEOBJ pThis = (PRTZIPXARBASEOBJ)pvThis;
+    return rtZipXarFssBaseObj_QueryInfo(pThis, pObjInfo, enmAddAttr);
 }
 
@@ -1195 +701 @@
  * @interface_method_impl{RTVFSOBJSETOPS,pfnMode}
  */
-static DECLCALLBACK(int) rtZipTarFssSym_SetMode(void *pvThis, RTFMODE fMode, RTFMODE fMask)
+static DECLCALLBACK(int) rtZipXarFssSym_SetMode(void *pvThis, RTFMODE fMode, RTFMODE fMask)
 {
     NOREF(pvThis); NOREF(fMode); NOREF(fMask);
@@ -1205 +711 @@
  * @interface_method_impl{RTVFSOBJSETOPS,pfnSetTimes}
  */
-static DECLCALLBACK(int) rtZipTarFssSym_SetTimes(void *pvThis, PCRTTIMESPEC pAccessTime, PCRTTIMESPEC pModificationTime,
+static DECLCALLBACK(int) rtZipXarFssSym_SetTimes(void *pvThis, PCRTTIMESPEC pAccessTime, PCRTTIMESPEC pModificationTime,
                                                  PCRTTIMESPEC pChangeTime, PCRTTIMESPEC pBirthTime)
 {
@@ -1216 +722 @@
  * @interface_method_impl{RTVFSOBJSETOPS,pfnSetOwner}
  */
-static DECLCALLBACK(int) rtZipTarFssSym_SetOwner(void *pvThis, RTUID uid, RTGID gid)
+static DECLCALLBACK(int) rtZipXarFssSym_SetOwner(void *pvThis, RTUID uid, RTGID gid)
 {
     NOREF(pvThis); NOREF(uid); NOREF(gid);
@@ -1226 +732 @@
  * @interface_method_impl{RTVFSSYMLINKOPS,pfnRead}
  */
-static DECLCALLBACK(int) rtZipTarFssSym_Read(void *pvThis, char *pszTarget, size_t cbTarget)
-{
-    PRTZIPTARBASEOBJ pThis = (PRTZIPTARBASEOBJ)pvThis;
-    return RTStrCopy(pszTarget, cbTarget, pThis->pTarReader->szTarget);
-}
-
-
-/**
- * Tar symbolic (and hardlink) operations.
- */
-static const RTVFSSYMLINKOPS g_rtZipTarFssSymOps =
+static DECLCALLBACK(int) rtZipXarFssSym_Read(void *pvThis, char *pszTarget, size_t cbXarget)
+{
+    PRTZIPXARBASEOBJ pThis = (PRTZIPXARBASEOBJ)pvThis;
+#if 0
+    return RTStrCopy(pszTarget, cbXarget, pThis->pXarReader->szTarget);
+#else
+    return VERR_NOT_IMPLEMENTED;
+#endif
+}
+
+
+/**
+ * Xar symbolic (and hardlink) operations.
+ */
+static const RTVFSSYMLINKOPS g_rtZipXarFssSymOps =
 {
     { /* Obj */
         RTVFSOBJOPS_VERSION,
         RTVFSOBJTYPE_SYMLINK,
-        "TarFsStream::Symlink",
-        rtZipTarFssSym_Close,
-        rtZipTarFssSym_QueryInfo,
+        "XarFsStream::Symlink",
+        rtZipXarFssSym_Close,
+        rtZipXarFssSym_QueryInfo,
         RTVFSOBJOPS_VERSION
     },
@@ -1251 +761 @@
         RTVFSOBJSETOPS_VERSION,
         RT_OFFSETOF(RTVFSSYMLINKOPS, Obj) - RT_OFFSETOF(RTVFSSYMLINKOPS, ObjSet),
-        rtZipTarFssSym_SetMode,
-        rtZipTarFssSym_SetTimes,
-        rtZipTarFssSym_SetOwner,
+        rtZipXarFssSym_SetMode,
+        rtZipXarFssSym_SetTimes,
+        rtZipXarFssSym_SetOwner,
         RTVFSOBJSETOPS_VERSION
     },
-    rtZipTarFssSym_Read,
+    rtZipXarFssSym_Read,
     RTVFSSYMLINKOPS_VERSION
 };
@@ -1264 +774 @@
  * @interface_method_impl{RTVFSOBJOPS,pfnClose}
  */
-static DECLCALLBACK(int) rtZipTarFss_Close(void *pvThis)
-{
-    PRTZIPTARFSSTREAM pThis = (PRTZIPTARFSSTREAM)pvThis;
+static DECLCALLBACK(int) rtZipXarFss_Close(void *pvThis)
+{
+    PRTZIPXARFSSTREAM pThis = (PRTZIPXARFSSTREAM)pvThis;
 
     RTVfsObjRelease(pThis->hVfsCurObj);
@@ -1282 +792 @@
  * @interface_method_impl{RTVFSOBJOPS,pfnQueryInfo}
  */
-static DECLCALLBACK(int) rtZipTarFss_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
-{
-    PRTZIPTARFSSTREAM pThis = (PRTZIPTARFSSTREAM)pvThis;
+static DECLCALLBACK(int) rtZipXarFss_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
+{
+    PRTZIPXARFSSTREAM pThis = (PRTZIPXARFSSTREAM)pvThis;
     /* Take the lazy approach here, with the sideffect of providing some info
        that is actually kind of useful. */
@@ -1294 +804 @@
  * @interface_method_impl{RTVFSFSSTREAMOPS,pfnNext}
  */
-static DECLCALLBACK(int) rtZipTarFss_Next(void *pvThis, char **ppszName, RTVFSOBJTYPE *penmType, PRTVFSOBJ phVfsObj)
-{
-    PRTZIPTARFSSTREAM pThis = (PRTZIPTARFSSTREAM)pvThis;
+static DECLCALLBACK(int) rtZipXarFss_Next(void *pvThis, char **ppszName, RTVFSOBJTYPE *penmType, PRTVFSOBJ phVfsObj)
+{
+    PRTZIPXARFSSTREAM pThis = (PRTZIPXARFSSTREAM)pvThis;
 
     /*
@@ -1322 +832 @@
         return pThis->rcFatal;
 
+#if 0
     /*
      * Make sure the input stream is in the right place.
@@ -1345 +856 @@
 
     /*
-     * Consume TAR headers.
+     * Consume XAR headers.
      */
     size_t cbHdrs = 0;
@@ -1354 +865 @@
          * Read the next header.
          */
-        RTZIPTARHDR Hdr;
+        RTZIPXARHDR Hdr;
         size_t cbRead;
         rc = RTVfsIoStrmRead(pThis->hVfsIos, &Hdr, sizeof(Hdr), true /*fBlocking*/, &cbRead);
@@ -1362 +873 @@
         {
             pThis->fEndOfStream = true;
-            return rtZipTarReaderIsAtEnd(&pThis->TarReader) ? VERR_EOF : VERR_TAR_UNEXPECTED_EOS;
+            return rtZipXarReaderIsAtEnd(&pThis->XarReader) ? VERR_EOF : VERR_XAR_UNEXPECTED_EOS;
         }
         if (cbRead != sizeof(Hdr))
-            return pThis->rcFatal = VERR_TAR_UNEXPECTED_EOS;
+            return pThis->rcFatal = VERR_XAR_UNEXPECTED_EOS;
 
         cbHdrs += sizeof(Hdr);
@@ -1372 +883 @@
          * Parse the it.
          */
-        rc = rtZipTarReaderParseHeader(&pThis->TarReader, &Hdr);
+        rc = rtZipXarReaderParseHeader(&pThis->XarReader, &Hdr);
         if (RT_FAILURE(rc))
             return pThis->rcFatal = rc;
-    } while (rtZipTarReaderExpectingMoreHeaders(&pThis->TarReader));
+    } while (rtZipXarReaderExpectingMoreHeaders(&pThis->XarReader));
 
     pThis->offNextHdr = offHdr + cbHdrs;
 
     /*
-     * Fill an object info structure from the current TAR state.
+     * Fill an object info structure from the current XAR state.
      */
     RTFSOBJINFO Info;
-    rc = rtZipTarReaderGetFsObjInfo(&pThis->TarReader, &Info);
+    rc = rtZipXarReaderGetFsObjInfo(&pThis->XarReader, &Info);
     if (RT_FAILURE(rc))
         return pThis->rcFatal = rc;
@@ -1393 +904 @@
     RTVFSOBJ        hVfsObj;
     RTFMODE         fType = Info.Attr.fMode & RTFS_TYPE_MASK;
-    if (rtZipTarReaderIsHardlink(&pThis->TarReader))
+    if (rtZipXarReaderIsHardlink(&pThis->XarReader))
         fType = RTFS_TYPE_SYMLINK;
     switch (fType)
@@ -1403 +914 @@
         {
             RTVFSIOSTREAM       hVfsIos;
-            PRTZIPTARIOSTREAM   pIosData;
-            rc = RTVfsNewIoStream(&g_rtZipTarFssIosOps,
+            PRTZIPXARIOSTREAM   pIosData;
+            rc = RTVfsNewIoStream(&g_rtZipXarFssIosOps,
                                   sizeof(*pIosData),
                                   RTFILE_O_READ | RTFILE_O_DENY_NONE | RTFILE_O_OPEN,
@@ -1415 +926 @@
 
             pIosData->BaseObj.offHdr    = offHdr;
-            pIosData->BaseObj.pTarReader= &pThis->TarReader;
+            pIosData->BaseObj.pXarReader= &pThis->XarReader;
             pIosData->BaseObj.ObjInfo   = Info;
             pIosData->cbFile            = Info.cbObject;
@@ -1435 +946 @@
         /*
          * We represent hard links using a symbolic link object.  This fits
-         * best with the way TAR stores it and there is currently no better
+         * best with the way XAR stores it and there is currently no better
          * fitting VFS type alternative.
          */
@@ -1441 +952 @@
         {
             RTVFSSYMLINK        hVfsSym;
-            PRTZIPTARBASEOBJ    pBaseObjData;
-            rc = RTVfsNewSymlink(&g_rtZipTarFssSymOps,
+            PRTZIPXARBASEOBJ    pBaseObjData;
+            rc = RTVfsNewSymlink(&g_rtZipXarFssSymOps,
                                  sizeof(*pBaseObjData),
                                  NIL_RTVFS,
@@ -1452 +963 @@
 
             pBaseObjData->offHdr    = offHdr;
-            pBaseObjData->pTarReader= &pThis->TarReader;
+            pBaseObjData->pXarReader= &pThis->XarReader;
             pBaseObjData->ObjInfo   = Info;
 
@@ -1463 +974 @@
         /*
          * All other objects are repesented using a VFS base object since they
-         * carry no data streams (unless some TAR extension implements extended
+         * carry no data streams (unless some XAR extension implements extended
          * attributes / alternative streams).
          */
@@ -1471 +982 @@
         case RTFS_TYPE_FIFO:
         {
-            PRTZIPTARBASEOBJ pBaseObjData;
-            rc = RTVfsNewBaseObj(&g_rtZipTarFssBaseObjOps,
+            PRTZIPXARBASEOBJ pBaseObjData;
+            rc = RTVfsNewBaseObj(&g_rtZipXarFssBaseObjOps,
                                  sizeof(*pBaseObjData),
                                  NIL_RTVFS,
@@ -1482 +993 @@
 
             pBaseObjData->offHdr    = offHdr;
-            pBaseObjData->pTarReader= &pThis->TarReader;
+            pBaseObjData->pXarReader= &pThis->XarReader;
             pBaseObjData->ObjInfo   = Info;
 
@@ -1500 +1011 @@
     if (ppszName)
     {
-        rc = RTStrDupEx(ppszName, pThis->TarReader.szName);
+        rc = RTStrDupEx(ppszName, pThis->XarReader.szName);
         if (RT_FAILURE(rc))
             return rc;
@@ -1513 +1024 @@
     if (penmType)
         *penmType = enmType;
+#endif
 
     return VINF_SUCCESS;
@@ -1520 +1032 @@
 
 /**
- * Tar filesystem stream operations.
- */
-static const RTVFSFSSTREAMOPS rtZipTarFssOps =
+ * Xar filesystem stream operations.
+ */
+static const RTVFSFSSTREAMOPS rtZipXarFssOps =
 {
     { /* Obj */
         RTVFSOBJOPS_VERSION,
         RTVFSOBJTYPE_FS_STREAM,
-        "TarFsStream",
-        rtZipTarFss_Close,
-        rtZipTarFss_QueryInfo,
+        "XarFsStream",
+        rtZipXarFss_Close,
+        rtZipXarFss_QueryInfo,
         RTVFSOBJOPS_VERSION
     },
     RTVFSFSSTREAMOPS_VERSION,
     0,
-    rtZipTarFss_Next,
+    rtZipXarFss_Next,
     RTVFSFSSTREAMOPS_VERSION
 };
 
 
-RTDECL(int) RTZipTarFsStreamFromIoStream(RTVFSIOSTREAM hVfsIosIn, uint32_t fFlags, PRTVFSFSSTREAM phVfsFss)
+
+/**
+ * TOC validation part 2.
+ *
+ * Will advance the input stream past the TOC hash and signature data.
+ *
+ * @returns IPRT status code.
+ * @param   pThis       The FS stream instance being created.
+ * @param   pXarHdr     The XAR header.
+ * @param   pTocDigest  The TOC input data digest.
+ */
+static int rtZipXarValidateTocPart2(PRTZIPXARFSSTREAM pThis, PCXARHEADER pXarHdr, PCRTZIPXARHASHDIGEST pTocDigest)
+{
+    int rc;
+
+    /*
+     * Check that the hash function in the TOC matches the one in the XAR header.
+     */
+    const xml::ElementNode *pChecksumElem = pThis->XarReader.pToc->findChildElement("checksum");
+    if (pChecksumElem)
+    {
+        const xml::AttributeNode *pAttr = pChecksumElem->findAttribute("style");
+        if (!pAttr)
+            return VERR_XAR_BAD_CHECKSUM_ELEMENT;
+
+        const char *pszStyle = pAttr->getValue();
+        if (!pszStyle)
+            return VERR_XAR_BAD_CHECKSUM_ELEMENT;
+
+        uint8_t uHashFunction;
+        if (!strcmp(pszStyle, "sha1"))
+            uHashFunction = XAR_HASH_SHA1;
+        else if (!strcmp(pszStyle, "md5"))
+            uHashFunction = XAR_HASH_MD5;
+        else if (!strcmp(pszStyle, "none"))
+            uHashFunction = XAR_HASH_NONE;
+        else
+            return VERR_XAR_BAD_CHECKSUM_ELEMENT;
+        if (uHashFunction != pThis->uHashFunction)
+            return VERR_XAR_HASH_FUNCTION_MISMATCH;
+
+        /*
+         * Verify the checksum if we got one.
+         */
+        if (pThis->uHashFunction != XAR_HASH_NONE)
+        {
+            RTFOFF   offChecksum;
+            uint64_t cbChecksum;
+            rc = rtZipXarGetOffsetSizeFromElem(pChecksumElem, &offChecksum, &cbChecksum);
+            if (RT_FAILURE(rc))
+                return rc;
+            if (cbChecksum != pThis->cbHashDigest)
+                return VERR_XAR_BAD_DIGEST_LENGTH;
+            if (offChecksum != 0 && pThis->hVfsFile == NIL_RTVFSFILE)
+                return VERR_XAR_NOT_STREAMBLE_ELEMENT_ORDER;
+
+            RTZIPXARHASHDIGEST StoredDigest;
+            rc = RTVfsIoStrmReadAt(pThis->hVfsIos, pThis->offZero + offChecksum, &StoredDigest, cbChecksum,
+                                   true /*fBlocking*/, NULL /*pcbRead*/);
+            if (RT_FAILURE(rc))
+                return rc;
+            if (memcmp(&StoredDigest, pTocDigest, pThis->cbHashDigest))
+                return VERR_XAR_TOC_DIGEST_MISMATCH;
+        }
+    }
+    else if (pThis->uHashFunction != XAR_HASH_NONE)
+        return VERR_XAR_BAD_CHECKSUM_ELEMENT;
+
+    /*
+     * Check the signature, if we got one.
+     */
+    /** @todo signing. */
+
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * Reads and validates the table of content.
+ *
+ * @returns IPRT status code.
+ * @param   hVfsIosIn   The input stream.
+ * @param   pXarHdr     The XAR header.
+ * @param   pDoc        The TOC XML document.
+ * @param   ppTocElem   Where to return the pointer to the TOC element on
+ *                      success.
+ * @param   pTocDigest  Where to return the TOC digest on success.
+ */
+static int rtZipXarReadAndValidateToc(RTVFSIOSTREAM hVfsIosIn, PCXARHEADER pXarHdr,
+                                      xml::Document *pDoc, xml::ElementNode const **ppTocElem, PRTZIPXARHASHDIGEST pTocDigest)
+{
+    /*
+     * Decompress it, calculating the hash while doing so.
+     */
+    char *pszOutput = (char *)RTMemTmpAlloc(pXarHdr->cbTocUncompressed + 1);
+    if (!pszOutput)
+        return VERR_NO_TMP_MEMORY;
+    int rc = VERR_NO_TMP_MEMORY;
+    void *pvInput = RTMemTmpAlloc(pXarHdr->cbTocCompressed);
+    if (pvInput)
+    {
+        rc = RTVfsIoStrmRead(hVfsIosIn, pvInput, pXarHdr->cbTocCompressed, true /*fBlocking*/,  NULL);
+        if (RT_SUCCESS(rc))
+        {
+            rtZipXarCalcHash(pXarHdr->uHashFunction, pvInput, pXarHdr->cbTocCompressed, pTocDigest);
+
+            size_t cbActual;
+            rc = RTZipBlockDecompress(RTZIPTYPE_ZLIB, 0 /*fFlags*/,
+                                      pvInput, pXarHdr->cbTocCompressed, NULL,
+                                      pszOutput, pXarHdr->cbTocUncompressed, &cbActual);
+            if (RT_SUCCESS(rc) && cbActual != pXarHdr->cbTocUncompressed)
+                rc = VERR_XAR_TOC_UNCOMP_SIZE_MISMATCH;
+        }
+        RTMemTmpFree(pvInput);
+    }
+    if (RT_SUCCESS(rc))
+    {
+        pszOutput[pXarHdr->cbTocUncompressed] = '\0';
+
+        /*
+         * Parse the TOC (XML document) and do some basic validations.
+         */
+        size_t cchToc = strlen(pszOutput);
+        if (   cchToc     == pXarHdr->cbTocUncompressed
+            || cchToc + 1 == pXarHdr->cbTocUncompressed)
+        {
+            rc = RTStrValidateEncoding(pszOutput);
+            if (RT_SUCCESS(rc))
+            {
+                xml::XmlMemParser Parser;
+                try
+                {
+                    Parser.read(pszOutput, cchToc, RTCString("xar-toc.xml"), *pDoc);
+                }
+                catch (xml::XmlError Err)
+                {
+                    rc = VERR_XAR_TOC_XML_PARSE_ERROR;
+                }
+                catch (...)
+                {
+                    rc = VERR_NO_MEMORY;
+                }
+                if (RT_SUCCESS(rc))
+                {
+                    xml::ElementNode const *pRootElem = pDoc->getRootElement();
+                    xml::ElementNode const *pTocElem  = NULL;
+                    if (pRootElem && pRootElem->nameEquals("xar"))
+                        pTocElem = pRootElem ? pRootElem->findChildElement(NULL, "toc") : NULL;
+                    if (pTocElem)
+                    {
+#ifndef USE_STD_LIST_FOR_CHILDREN
+                        Assert(pRootElem->getParent() == NULL);
+                        Assert(pTocElem->getParent() == pRootElem);
+                        if (   !pTocElem->getNextSibiling()
+                            && !pTocElem->getPrevSibiling())
+#endif
+                        {
+                            /*
+                             * Further parsing and validation is done after the
+                             * caller has created an file system stream instance.
+                             */
+                            *ppTocElem = pTocElem;
+
+                            RTMemTmpFree(pszOutput);
+                            return VINF_SUCCESS;
+                        }
+
+                        rc = VERR_XML_TOC_ELEMENT_HAS_SIBLINGS;
+                    }
+                    else
+                        rc = VERR_XML_TOC_ELEMENT_MISSING;
+                }
+            }
+            else
+                rc = VERR_XAR_TOC_UTF8_ENCODING;
+        }
+        else
+            rc = VERR_XAR_TOC_STRLEN_MISMATCH;
+    }
+
+    RTMemTmpFree(pszOutput);
+    return rc;
+}
+
+
+/**
+ * Reads and validates the XAR header.
+ *
+ * @returns IPRT status code.
+ * @param   hVfsIosIn   The input stream.
+ * @param   pXarHdr     Where to return the XAR header in host byte order.
+ */
+static int rtZipXarReadAndValidateHeader(RTVFSIOSTREAM hVfsIosIn, PXARHEADER pXarHdr)
+{
+    /*
+     * Read it and check the signature.
+     */
+    int rc = RTVfsIoStrmRead(hVfsIosIn, pXarHdr, sizeof(*pXarHdr), true /*fBlocking*/,  NULL);
+    if (RT_FAILURE(rc))
+        return rc;
+    if (pXarHdr->u32Magic != XAR_HEADER_MAGIC)
+        return VERR_XAR_WRONG_MAGIC;
+
+    /*
+     * Correct the byte order.
+     */
+    pXarHdr->cbHeader             = RT_BE2H_U16(pXarHdr->cbHeader);
+    pXarHdr->uVersion             = RT_BE2H_U16(pXarHdr->uVersion);
+    pXarHdr->cbTocCompressed      = RT_BE2H_U64(pXarHdr->cbTocCompressed);
+    pXarHdr->cbTocUncompressed    = RT_BE2H_U64(pXarHdr->cbTocUncompressed);
+    pXarHdr->uHashFunction        = RT_BE2H_U32(pXarHdr->uHashFunction);
+
+    /*
+     * Validate the header.
+     */
+    if (pXarHdr->uVersion > XAR_HEADER_VERSION)
+        return VERR_XAR_UNSUPPORTED_VERSION;
+    if (pXarHdr->cbHeader < sizeof(XARHEADER))
+        return VERR_XAR_BAD_HDR_SIZE;
+    if (pXarHdr->uHashFunction > XAR_HASH_MAX)
+        return VERR_XAR_UNSUPPORTED_HASH_FUNCTION;
+    if (pXarHdr->cbTocUncompressed < 16)
+        return VERR_XAR_TOC_TOO_SMALL;
+    if (pXarHdr->cbTocUncompressed > _4M)
+        return VERR_XAR_TOC_TOO_BIG;
+    if (pXarHdr->cbTocCompressed > _4M)
+        return VERR_XAR_TOC_TOO_BIG_COMPRESSED;
+
+    /*
+     * Skip over bytes we don't understand (could be padding).
+     */
+    if (pXarHdr->cbHeader > sizeof(XARHEADER))
+    {
+        rc = RTVfsIoStrmSkip(hVfsIosIn, pXarHdr->cbHeader - sizeof(XARHEADER));
+        if (RT_FAILURE(rc))
+            return rc;
+    }
+
+    return VINF_SUCCESS;
+}
+
+
+RTDECL(int) RTZipXarFsStreamFromIoStream(RTVFSIOSTREAM hVfsIosIn, uint32_t fFlags, PRTVFSFSSTREAM phVfsFss)
 {
     /*
@@ -1556 +1310 @@
 
     /*
-     * Retain the input stream and create a new filesystem stream handle.
-     */
-    PRTZIPTARFSSTREAM pThis;
-    RTVFSFSSTREAM     hVfsFss;
-    int rc = RTVfsNewFsStream(&rtZipTarFssOps, sizeof(*pThis), NIL_RTVFS, NIL_RTVFSLOCK, &hVfsFss, (void **)&pThis);
+     * Read and validate the header, then uncompress the TOC.
+     */
+    XARHEADER XarHdr;
+    int rc = rtZipXarReadAndValidateHeader(hVfsIosIn, &XarHdr);
     if (RT_SUCCESS(rc))
     {
-        pThis->hVfsIos              = hVfsIosIn;
-        pThis->hVfsCurObj           = NIL_RTVFSOBJ;
-        pThis->pCurIosData          = NULL;
-        pThis->offStart             = offStart;
-        pThis->offNextHdr           = offStart;
-        pThis->fEndOfStream         = false;
-        pThis->rcFatal              = VINF_SUCCESS;
-        pThis->TarReader.enmPrevType= RTZIPTARTYPE_INVALID;
-        pThis->TarReader.enmType    = RTZIPTARTYPE_INVALID;
-        pThis->TarReader.enmState   = RTZIPTARREADERSTATE_FIRST;
-
-        /* Don't check if it's a TAR stream here, do that in the
-           rtZipTarFss_Next. */
-
-        *phVfsFss = hVfsFss;
-        return VINF_SUCCESS;
+        xml::Document *pDoc = NULL;
+        try         { pDoc = new xml::Document(); }
+        catch (...) { }
+        if (pDoc)
+        {
+            RTZIPXARHASHDIGEST      TocDigest;
+            xml::ElementNode const *pTocElem = NULL;
+            rc = rtZipXarReadAndValidateToc(hVfsIosIn, &XarHdr, pDoc, &pTocElem, &TocDigest);
+            if (RT_SUCCESS(rc))
+            {
+                size_t offZero = RTVfsIoStrmTell(hVfsIosIn);
+                if (offZero > 0)
+                {
+                    /*
+                     * Create a file system stream before we continue the parsing.
+                     */
+                    PRTZIPXARFSSTREAM pThis;
+                    RTVFSFSSTREAM     hVfsFss;
+                    rc = RTVfsNewFsStream(&rtZipXarFssOps, sizeof(*pThis), NIL_RTVFS, NIL_RTVFSLOCK, &hVfsFss, (void **)&pThis);
+                    if (RT_SUCCESS(rc))
+                    {
+                        pThis->hVfsIos              = hVfsIosIn;
+                        pThis->hVfsFile             = RTVfsIoStrmToFile(hVfsIosIn);
+                        pThis->hVfsCurObj           = NIL_RTVFSOBJ;
+                        pThis->pCurIosData          = NULL;
+                        pThis->offStart             = offStart;
+                        pThis->offZero              = offZero;
+                        pThis->uHashFunction        = (uint8_t)XarHdr.uHashFunction;
+                        switch (pThis->uHashFunction)
+                        {
+                            case XAR_HASH_MD5:  pThis->cbHashDigest = sizeof(TocDigest.abMd5); break;
+                            case XAR_HASH_SHA1: pThis->cbHashDigest = sizeof(TocDigest.abSha1); break;
+                            default:            pThis->cbHashDigest = 0; break;
+                        }
+                        pThis->fEndOfStream         = false;
+                        pThis->rcFatal              = VINF_SUCCESS;
+                        pThis->XarReader.pDoc       = pDoc;
+                        pThis->XarReader.pToc       = pTocElem;
+                        pThis->XarReader.idCurFile  = 0; /* Assuming the ID numbering is from 1. */
+
+                        /*
+                         * Next validation step.
+                         */
+                        rc = rtZipXarValidateTocPart2(pThis, &XarHdr, &TocDigest);
+                        if (RT_SUCCESS(rc))
+                        {
+                            *phVfsFss = hVfsFss;
+                            return VINF_SUCCESS;
+                        }
+
+                        RTVfsFsStrmRelease(hVfsFss);
+                        return rc;
+                    }
+                }
+                else
+                    rc = (int)offZero;
+            }
+            delete pDoc;
+        }
+        else
+            rc = VERR_NO_MEMORY;
     }
 

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

@@ -1917 +1917 @@
 
         case RTZIPTYPE_ZLIB:
+        {
+#ifdef RTZIP_USE_ZLIB
+            AssertReturn(cbSrc == (uInt)cbSrc, VERR_TOO_MUCH_DATA);
+            AssertReturn(cbDst == (uInt)cbDst, VERR_OUT_OF_RANGE);
+
+            z_stream ZStrm;
+            RT_ZERO(ZStrm);
+            ZStrm.next_in   = (Bytef *)pvSrc;
+            ZStrm.avail_in  = (uInt)cbSrc;
+            ZStrm.next_out  = (Bytef *)pvDst;
+            ZStrm.avail_out = (uInt)cbDst;
+
+            int rc = inflateInit(&ZStrm);
+            if (RT_UNLIKELY(rc != Z_OK))
+                return zipErrConvertFromZlib(rc, false /*fCompressing*/);
+            rc = inflate(&ZStrm, Z_FINISH);
+            if (rc != Z_STREAM_END)
+            {
+                inflateEnd(&ZStrm);
+                if ((rc == Z_BUF_ERROR && ZStrm.avail_in == 0) || rc == Z_NEED_DICT)
+                    return VERR_ZIP_CORRUPTED;
+                if (rc == Z_BUF_ERROR)
+                    return VERR_BUFFER_OVERFLOW;
+                AssertReturn(rc < Z_OK, VERR_GENERAL_FAILURE);
+                return zipErrConvertFromZlib(rc, false /*fCompressing*/);
+            }
+            rc = inflateEnd(&ZStrm);
+            if (rc != Z_OK)
+                return zipErrConvertFromZlib(rc, false /*fCompressing*/);
+
+            if (pcbSrcActual)
+                *pcbSrcActual = ZStrm.avail_in - cbSrc;
+            if (pcbDstActual)
+                *pcbDstActual = ZStrm.total_out;
+            break;
+#else
+            return VERR_NOT_SUPPORTED;
+#endif
+        }
+
         case RTZIPTYPE_BZLIB:
             return VERR_NOT_SUPPORTED;