Adding upstream version 7.0.14-dfsg.upstream/7.0.14-dfsg

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

15 files changed, 15288 insertions, 0 deletions

diff --git a/src/VBox/Runtime/common/zip/Makefile.kup b/src/VBox/Runtime/common/zip/Makefile.kup
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/src/VBox/Runtime/common/zip/Makefile.kup
diff --git a/src/VBox/Runtime/common/zip/cpiovfs.cpp b/src/VBox/Runtime/common/zip/cpiovfs.cpp
new file mode 100644
index 00000000..04dc8675
--- /dev/null
+++ b/src/VBox/Runtime/common/zip/cpiovfs.cpp
@@ -0,0 +1,1146 @@
+/* $Id: cpiovfs.cpp $ */
+/** @file
+ * IPRT - CPIO Virtual Filesystem, Reader.
+ */
+
+/*
+ * Copyright (C) 2020-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * The contents of this file may alternatively be used under the terms
+ * of the Common Development and Distribution License Version 1.0
+ * (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
+ * in the VirtualBox distribution, in which case the provisions of the
+ * CDDL are applicable instead of those of the GPL.
+ *
+ * You may elect to license modified versions of this file under the
+ * terms and conditions of either the GPL or the CDDL or both.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#include "internal/iprt.h"
+#include <iprt/zip.h>
+
+#include <iprt/asm.h>
+#include <iprt/assert.h>
+#include <iprt/ctype.h>
+#include <iprt/err.h>
+#include <iprt/poll.h>
+#include <iprt/file.h>
+#include <iprt/string.h>
+#include <iprt/vfs.h>
+#include <iprt/vfslowlevel.h>
+
+#include "cpiovfsreader.h"
+
+
+/**
+ * Converts a octal numeric header field to the C native type.
+ *
+ * @returns IPRT status code.
+ * @param   pachField           The CPIO header field.
+ * @param   cchField            The length of the field.
+ * @param   pi64                Where to store the value.
+ */
+static int rtZipCpioHdrOctalFieldToNum(const char *pachField, size_t cchField, int64_t *pi64)
+{
+    /*
+     * Skip leading zeros to save a few slower loops below.
+     */
+    while (cchField > 0 && *pachField == '0')
+        cchField--, pachField++;
+
+    /*
+     * Convert octal digits.
+     */
+    int64_t i64 = 0;
+    while (cchField > 0)
+    {
+        unsigned char uDigit = *pachField - '0';
+        if (uDigit >= 8)
+            return VERR_TAR_BAD_NUM_FIELD;
+        i64 <<= 3;
+        i64 |= uDigit;
+
+        pachField++;
+        cchField--;
+    }
+    *pi64 = i64;
+
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * Converts a hex character to the appropriate nibble.
+ *
+ * @returns Nibble of the character.
+ * @param   chVal                   The value to convert.
+ */
+static inline uint8_t rtZipCpioHexToNibble(char chVal)
+{
+    if (chVal >= '0' && chVal <= '9')
+        return chVal - '0';
+    else if (chVal >= 'a' && chVal <= 'f')
+        return chVal - 'a' + 10;
+    else if (chVal >= 'A' && chVal <= 'F')
+        return chVal - 'A' + 10;
+
+    return 0xff;
+}
+
+
+/**
+ * Converts a hexadecimal numeric header field to the C native type.
+ *
+ * @returns IPRT status code.
+ * @param   pachField           The CPIO header field.
+ * @param   cchField            The length of the field.
+ * @param   pi64                Where to store the value.
+ */
+static int rtZipCpioHdrHexFieldToNum(const char *pachField, size_t cchField, int64_t *pi64)
+{
+    uint64_t u64 = 0;
+
+    while (cchField-- > 0)
+    {
+        uint8_t bNb = rtZipCpioHexToNibble(*pachField++);
+
+        if (RT_LIKELY(bNb != 0xff))
+            u64 = (u64 << 4) | bNb;
+        else
+            return VERR_TAR_BAD_NUM_FIELD;
+    }
+
+    *pi64 = (int64_t)u64;
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * Parses the given ancient binary header and converts it to an FS object info structure.
+ *
+ * @returns IPRT status code.
+ * @param   pThis               The CPIO reader state.
+ * @param   pHdr                The header to convert.
+ * @param   pcbFilePath         Where to store the file path size on success.
+ * @param   pcbPad              Where to store the number of bytes padded after the header and file path
+ *                              before the content begins.
+ */
+static int rtZipCpioReaderParseHeaderAncientBin(PRTZIPCPIOREADER pThis, PCCPIOHDRBIN pHdr,
+                                                uint32_t *pcbFilePath, uint32_t *pcbPad)
+{
+    RT_NOREF(pThis, pHdr, pcbFilePath, pcbPad);
+    return VERR_NOT_SUPPORTED;
+}
+
+
+/**
+ * Parses the given SuSv2 ASCII header and converts it to an FS object info structure.
+ *
+ * @returns IPRT status code.
+ * @param   pThis               The CPIO reader state.
+ * @param   pHdr                The header to convert.
+ * @param   pcbFilePath         Where to store the file path size on success.
+ * @param   pcbPad              Where to store the number of bytes padded after the header and file path
+ *                              before the content begins.
+ */
+static int rtZipCpioReaderParseHeaderAsciiSusV2(PRTZIPCPIOREADER pThis, PCCPIOHDRSUSV2 pHdr,
+                                                uint32_t *pcbFilePath, uint32_t *pcbPad)
+{
+    PRTFSOBJINFO pObjInfo = &pThis->ObjInfo;
+    int rc;
+    int64_t i64Tmp;
+    int64_t c64SecModTime;
+
+    pObjInfo->Attr.u.Unix.INodeIdDevice = 0;
+    pObjInfo->Attr.u.Unix.Device        = 0;
+    pObjInfo->Attr.enmAdditional        = RTFSOBJATTRADD_UNIX;
+
+#define GET_CPIO_NUMERIC_FIELD_RET(a_Var, a_Field) \
+        do { \
+            rc = rtZipCpioHdrOctalFieldToNum(a_Field, sizeof(a_Field), &i64Tmp); \
+            if (RT_FAILURE(rc)) \
+                return rc; \
+            (a_Var) = i64Tmp; \
+            if ((a_Var) != i64Tmp) \
+                return VERR_TAR_NUM_VALUE_TOO_LARGE; \
+        } while (0)
+
+#define GET_CPIO_NUMERIC_FIELD_RET_U64(a_Var, a_Field) \
+        do { \
+            rc = rtZipCpioHdrOctalFieldToNum(a_Field, sizeof(a_Field), &i64Tmp); \
+            if (RT_FAILURE(rc)) \
+                return rc; \
+            (a_Var) = (uint64_t)i64Tmp; \
+            if ((a_Var) != (uint64_t)i64Tmp) \
+                return VERR_TAR_NUM_VALUE_TOO_LARGE; \
+        } while (0)
+
+    GET_CPIO_NUMERIC_FIELD_RET(    pObjInfo->Attr.fMode,             pHdr->achMode);
+    GET_CPIO_NUMERIC_FIELD_RET(    pObjInfo->Attr.u.Unix.uid,        pHdr->achUid);
+    GET_CPIO_NUMERIC_FIELD_RET(    pObjInfo->Attr.u.Unix.gid,        pHdr->achGid);
+    GET_CPIO_NUMERIC_FIELD_RET(    pObjInfo->Attr.u.Unix.cHardlinks, pHdr->achNLinks);
+    GET_CPIO_NUMERIC_FIELD_RET_U64(pObjInfo->Attr.u.Unix.INodeId,    pHdr->achInode);
+    GET_CPIO_NUMERIC_FIELD_RET(    pObjInfo->Attr.u.Unix.Device,     pHdr->achDev);
+    GET_CPIO_NUMERIC_FIELD_RET(    pObjInfo->cbObject,               pHdr->achFileSize);
+    pObjInfo->cbAllocated = pObjInfo->cbObject;
+    GET_CPIO_NUMERIC_FIELD_RET(    c64SecModTime,                    pHdr->achMTime);
+    RTTimeSpecSetSeconds(&pObjInfo->ChangeTime,                  c64SecModTime);
+    RTTimeSpecSetSeconds(&pObjInfo->ModificationTime,            c64SecModTime);
+    RTTimeSpecSetSeconds(&pObjInfo->AccessTime,                  c64SecModTime);
+    RTTimeSpecSetSeconds(&pObjInfo->BirthTime,                   c64SecModTime);
+    if (c64SecModTime != RTTimeSpecGetSeconds(&pObjInfo->ModificationTime))
+        return VERR_TAR_NUM_VALUE_TOO_LARGE;
+
+    GET_CPIO_NUMERIC_FIELD_RET(*pcbFilePath, pHdr->achNameSize);
+
+    /* There is never any padding. */
+    *pcbPad = 0;
+
+#undef GET_CPIO_NUMERIC_FIELD_RET
+#undef GET_CPIO_NUMERIC_FIELD_RET_U64
+
+    return rc;
+}
+
+
+/**
+ * Parses the given "new" ASCII header and converts it to an FS object info structure.
+ *
+ * @returns IPRT status code.
+ * @param   pThis               The CPIO reader state.
+ * @param   pHdr                The header to convert.
+ * @param   fWithChksum         Flag whether the header uses the checksum field.
+ * @param   pcbFilePath         Where to store the file path size on success.
+ * @param   pcbPad              Where to store the number of bytes padded after the header and file path
+ *                              before the content begins.
+ */
+static int rtZipCpioReaderParseHeaderAsciiNew(PRTZIPCPIOREADER pThis, PCCPIOHDRNEW pHdr, bool fWithChksum,
+                                              uint32_t *pcbFilePath, uint32_t *pcbPad)
+{
+    RT_NOREF(fWithChksum); /** @todo */
+    PRTFSOBJINFO pObjInfo = &pThis->ObjInfo;
+    int rc;
+    int64_t i64Tmp;
+    int64_t c64SecModTime;
+    uint32_t uMajor, uMinor;
+
+    pObjInfo->Attr.u.Unix.INodeIdDevice = 0;
+    pObjInfo->Attr.u.Unix.Device        = 0;
+    pObjInfo->Attr.enmAdditional        = RTFSOBJATTRADD_UNIX;
+
+#define GET_CPIO_NUMERIC_FIELD_RET(a_Var, a_Field) \
+        do { \
+            rc = rtZipCpioHdrHexFieldToNum(a_Field, sizeof(a_Field), &i64Tmp); \
+            if (RT_FAILURE(rc)) \
+                return rc; \
+            (a_Var) = i64Tmp; \
+            if ((a_Var) != i64Tmp) \
+                return VERR_TAR_NUM_VALUE_TOO_LARGE; \
+        } while (0)
+
+#define GET_CPIO_NUMERIC_FIELD_RET_U64(a_Var, a_Field) \
+        do { \
+            rc = rtZipCpioHdrHexFieldToNum(a_Field, sizeof(a_Field), &i64Tmp); \
+            if (RT_FAILURE(rc)) \
+                return rc; \
+            (a_Var) = (uint64_t)i64Tmp; \
+            if ((a_Var) != (uint64_t)i64Tmp) \
+                return VERR_TAR_NUM_VALUE_TOO_LARGE; \
+        } while (0)
+
+    GET_CPIO_NUMERIC_FIELD_RET(    pObjInfo->Attr.fMode,             pHdr->achMode);
+    GET_CPIO_NUMERIC_FIELD_RET(    pObjInfo->Attr.u.Unix.uid,        pHdr->achUid);
+    GET_CPIO_NUMERIC_FIELD_RET(    pObjInfo->Attr.u.Unix.gid,        pHdr->achGid);
+    GET_CPIO_NUMERIC_FIELD_RET(    pObjInfo->Attr.u.Unix.cHardlinks, pHdr->achNLinks);
+    GET_CPIO_NUMERIC_FIELD_RET_U64(pObjInfo->Attr.u.Unix.INodeId,    pHdr->achInode);
+    GET_CPIO_NUMERIC_FIELD_RET(    uMajor,                           pHdr->achDevMajor);
+    GET_CPIO_NUMERIC_FIELD_RET(    uMinor,                           pHdr->achDevMinor);
+    GET_CPIO_NUMERIC_FIELD_RET(    pObjInfo->cbObject,               pHdr->achFileSize);
+    pObjInfo->cbAllocated = RT_ALIGN_64(pObjInfo->cbObject, 4);
+    GET_CPIO_NUMERIC_FIELD_RET(    c64SecModTime,                    pHdr->achMTime);
+    RTTimeSpecSetSeconds(&pObjInfo->ChangeTime,                  c64SecModTime);
+    RTTimeSpecSetSeconds(&pObjInfo->ModificationTime,            c64SecModTime);
+    RTTimeSpecSetSeconds(&pObjInfo->AccessTime,                  c64SecModTime);
+    RTTimeSpecSetSeconds(&pObjInfo->BirthTime,                   c64SecModTime);
+    if (c64SecModTime != RTTimeSpecGetSeconds(&pObjInfo->ModificationTime))
+        return VERR_TAR_NUM_VALUE_TOO_LARGE;
+    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;
+
+    GET_CPIO_NUMERIC_FIELD_RET(*pcbFilePath, pHdr->achNameSize);
+
+    /* Header and file path are padded with 0 bytes to a 4 byte boundary. */
+    uint32_t cbComp = *pcbFilePath + sizeof(*pHdr);
+    *pcbPad = RT_ALIGN_32(cbComp, 4) - cbComp;
+
+#undef GET_CPIO_NUMERIC_FIELD_RET
+#undef GET_CPIO_NUMERIC_FIELD_RET_U64
+
+    return rc;
+}
+
+
+/**
+ * Parses and validates a CPIO header.
+ *
+ * @returns IPRT status code.
+ * @param   pThis               The CPIO reader state.
+ * @param   enmType             The CPIO header type.
+ * @param   pHdr                The CPIO header that has been read.
+ * @param   pcbFilePath         Where to store the size of the file path on success.
+ * @param   pcbPad              Where to store the number of bytes padded after the header and file path
+ *                              before the content begins.
+ */
+static int rtZipCpioReaderParseHeader(PRTZIPCPIOREADER pThis, RTZIPCPIOTYPE enmType, PCCPIOHDR pHdr,
+                                      uint32_t *pcbFilePath, uint32_t *pcbPad)
+{
+    int rc;
+
+    switch (enmType)
+    {
+        case RTZIPCPIOTYPE_ANCIENT_BIN:
+            rc = rtZipCpioReaderParseHeaderAncientBin(pThis, &pHdr->AncientBin,
+                                                      pcbFilePath, pcbPad);
+            break;
+        case RTZIPCPIOTYPE_ASCII_SUSV2:
+            rc = rtZipCpioReaderParseHeaderAsciiSusV2(pThis, &pHdr->AsciiSuSv2,
+                                                      pcbFilePath, pcbPad);
+            break;
+        case RTZIPCPIOTYPE_ASCII_NEW:
+            rc = rtZipCpioReaderParseHeaderAsciiNew(pThis, &pHdr->AsciiNew, false /*fWithChksum*/,
+                                                    pcbFilePath, pcbPad);
+            break;
+        case RTZIPCPIOTYPE_ASCII_NEW_CHKSUM:
+            rc = rtZipCpioReaderParseHeaderAsciiNew(pThis, &pHdr->AsciiNew, true /*fWithChksum*/,
+                                                    pcbFilePath, pcbPad);
+            break;
+        default:
+            AssertMsgFailedBreakStmt(("Invalid CPIO type %d\n", enmType), rc = VERR_INTERNAL_ERROR);
+    }
+
+    return rc;
+}
+
+
+/**
+ * Reads the file path from the CPIO archive stream.
+ *
+ * @returns IPRT status code.
+ * @param   hVfsIos             The I/O stream to read from.
+ * @param   pThis               The CPIO reader state.
+ * @param   cbFilePath          Size of the file path in bytes.
+ */
+static int rtZipCpioReaderReadPath(RTVFSIOSTREAM hVfsIos, PRTZIPCPIOREADER pThis, size_t cbFilePath)
+{
+    if (cbFilePath >= sizeof(pThis->szName))
+        return VERR_TAR_NAME_TOO_LONG;
+
+    size_t cbRead;
+    int rc = RTVfsIoStrmRead(hVfsIos, &pThis->szName[0], cbFilePath, true /*fBlocking*/, &cbRead);
+    if (RT_FAILURE(rc))
+        return rc;
+    if (cbRead != cbFilePath)
+        return VERR_TAR_UNEXPECTED_EOS;
+
+    /* The read file name should be zero terminated at the end. */
+    if (pThis->szName[cbFilePath - 1] != '\0')
+        return VERR_TAR_MALFORMED_GNU_LONGXXXX;
+
+    return VINF_SUCCESS;
+}
+
+
+/*
+ *
+ * T h e   V F S   F i l e s y s t e m   S t r e a m   B i t s.
+ * T h e   V F S   F i l e s y s t e m   S t r e a m   B i t s.
+ * T h e   V F S   F i l e s y s t e m   S t r e a m   B i t s.
+ *
+ */
+
+/**
+ * @interface_method_impl{RTVFSOBJOPS,pfnClose}
+ */
+static DECLCALLBACK(int) rtZipCpioFssBaseObj_Close(void *pvThis)
+{
+    PRTZIPCPIOBASEOBJ pThis = (PRTZIPCPIOBASEOBJ)pvThis;
+
+    /* Currently there is nothing we really have to do here. */
+    pThis->offHdr = -1;
+
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSOBJOPS,pfnQueryInfo}
+ */
+static DECLCALLBACK(int) rtZipCpioFssBaseObj_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
+{
+    PRTZIPCPIOBASEOBJ pThis = (PRTZIPCPIOBASEOBJ)pvThis;
+
+    /*
+     * Copy the desired data.
+     */
+    switch (enmAddAttr)
+    {
+        case RTFSOBJATTRADD_NOTHING:
+        case RTFSOBJATTRADD_UNIX:
+            *pObjInfo = pThis->ObjInfo;
+            break;
+
+        case RTFSOBJATTRADD_UNIX_OWNER:
+            *pObjInfo = pThis->ObjInfo;
+            pObjInfo->Attr.enmAdditional         = RTFSOBJATTRADD_UNIX_OWNER;
+            pObjInfo->Attr.u.UnixOwner.uid       = pThis->ObjInfo.Attr.u.Unix.uid;
+            pObjInfo->Attr.u.UnixOwner.szName[0] = '\0';
+            break;
+
+        case RTFSOBJATTRADD_UNIX_GROUP:
+            *pObjInfo = pThis->ObjInfo;
+            pObjInfo->Attr.enmAdditional         = RTFSOBJATTRADD_UNIX_GROUP;
+            pObjInfo->Attr.u.UnixGroup.gid       = pThis->ObjInfo.Attr.u.Unix.gid;
+            pObjInfo->Attr.u.UnixGroup.szName[0] = '\0';
+            break;
+
+        case RTFSOBJATTRADD_EASIZE:
+            *pObjInfo = pThis->ObjInfo;
+            pObjInfo->Attr.enmAdditional = RTFSOBJATTRADD_EASIZE;
+            RT_ZERO(pObjInfo->Attr.u);
+            break;
+
+        default:
+            return VERR_NOT_SUPPORTED;
+    }
+
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * Tar filesystem base object operations.
+ */
+static const RTVFSOBJOPS g_rtZipCpioFssBaseObjOps =
+{
+    RTVFSOBJOPS_VERSION,
+    RTVFSOBJTYPE_BASE,
+    "CpioFsStream::Obj",
+    rtZipCpioFssBaseObj_Close,
+    rtZipCpioFssBaseObj_QueryInfo,
+    NULL,
+    RTVFSOBJOPS_VERSION
+};
+
+
+/**
+ * @interface_method_impl{RTVFSOBJOPS,pfnClose}
+ */
+static DECLCALLBACK(int) rtZipCpioFssIos_Close(void *pvThis)
+{
+    PRTZIPCPIOIOSTREAM pThis = (PRTZIPCPIOIOSTREAM)pvThis;
+
+    RTVfsIoStrmRelease(pThis->hVfsIos);
+    pThis->hVfsIos = NIL_RTVFSIOSTREAM;
+
+    return rtZipCpioFssBaseObj_Close(&pThis->BaseObj);
+}
+
+
+/**
+ * @interface_method_impl{RTVFSOBJOPS,pfnQueryInfo}
+ */
+static DECLCALLBACK(int) rtZipCpioFssIos_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
+{
+    PRTZIPCPIOIOSTREAM pThis = (PRTZIPCPIOIOSTREAM)pvThis;
+    return rtZipCpioFssBaseObj_QueryInfo(&pThis->BaseObj, pObjInfo, enmAddAttr);
+}
+
+
+/**
+ * @interface_method_impl{RTVFSIOSTREAMOPS,pfnRead}
+ */
+static DECLCALLBACK(int) rtZipCpioFssIos_Read(void *pvThis, RTFOFF off, PCRTSGBUF pSgBuf, bool fBlocking, size_t *pcbRead)
+{
+    PRTZIPCPIOIOSTREAM pThis = (PRTZIPCPIOIOSTREAM)pvThis;
+    Assert(pSgBuf->cSegs == 1);
+
+    /*
+     * Make offset into a real offset so it's possible to do random access
+     * on CPIO files that are seekable.  Fend of reads beyond the end of the
+     * stream.
+     */
+    if (off < 0)
+        off = pThis->offFile;
+    if (off >= pThis->cbFile)
+        return pcbRead ? VINF_EOF : VERR_EOF;
+
+
+    Assert(pThis->cbFile >= pThis->offFile);
+    uint64_t cbLeft   = (uint64_t)(pThis->cbFile - off);
+    size_t   cbToRead = pSgBuf->paSegs[0].cbSeg;
+    if (cbToRead > cbLeft)
+    {
+        if (!pcbRead)
+            return VERR_EOF;
+        cbToRead = (size_t)cbLeft;
+    }
+
+    /*
+     * Do the reading.
+     */
+    size_t cbReadStack = 0;
+    if (!pcbRead)
+        pcbRead = &cbReadStack;
+    int rc = RTVfsIoStrmReadAt(pThis->hVfsIos, pThis->offStart + off, pSgBuf->paSegs[0].pvSeg, cbToRead, fBlocking, pcbRead);
+    pThis->offFile = off + *pcbRead;
+    if (pThis->offFile >= pThis->cbFile)
+    {
+        Assert(pThis->offFile == pThis->cbFile);
+        pThis->fEndOfStream = true;
+        RTVfsIoStrmSkip(pThis->hVfsIos, pThis->cbPadding);
+    }
+
+    return rc;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSIOSTREAMOPS,pfnWrite}
+ */
+static DECLCALLBACK(int) rtZipCpioFssIos_Write(void *pvThis, RTFOFF off, PCRTSGBUF pSgBuf, bool fBlocking, size_t *pcbWritten)
+{
+    /* Cannot write to a read-only I/O stream. */
+    NOREF(pvThis); NOREF(off); NOREF(pSgBuf); NOREF(fBlocking); NOREF(pcbWritten);
+    return VERR_ACCESS_DENIED;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSIOSTREAMOPS,pfnFlush}
+ */
+static DECLCALLBACK(int) rtZipCpioFssIos_Flush(void *pvThis)
+{
+    /* It's a read only stream, nothing dirty to flush. */
+    NOREF(pvThis);
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSIOSTREAMOPS,pfnPollOne}
+ */
+static DECLCALLBACK(int) rtZipCpioFssIos_PollOne(void *pvThis, uint32_t fEvents, RTMSINTERVAL cMillies, bool fIntr,
+                                                 uint32_t *pfRetEvents)
+{
+    PRTZIPCPIOIOSTREAM pThis = (PRTZIPCPIOIOSTREAM)pvThis;
+
+    /* When we've reached the end, read will be set to indicate it. */
+    if (   (fEvents & RTPOLL_EVT_READ)
+        && pThis->fEndOfStream)
+    {
+        int rc = RTVfsIoStrmPoll(pThis->hVfsIos, fEvents, 0, fIntr, pfRetEvents);
+        if (RT_SUCCESS(rc))
+            *pfRetEvents |= RTPOLL_EVT_READ;
+        else
+            *pfRetEvents = RTPOLL_EVT_READ;
+        return VINF_SUCCESS;
+    }
+
+    return RTVfsIoStrmPoll(pThis->hVfsIos, fEvents, cMillies, fIntr, pfRetEvents);
+}
+
+
+/**
+ * @interface_method_impl{RTVFSIOSTREAMOPS,pfnTell}
+ */
+static DECLCALLBACK(int) rtZipCpioFssIos_Tell(void *pvThis, PRTFOFF poffActual)
+{
+    PRTZIPCPIOIOSTREAM pThis = (PRTZIPCPIOIOSTREAM)pvThis;
+    *poffActual = pThis->offFile;
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * Tar I/O stream operations.
+ */
+static const RTVFSIOSTREAMOPS g_rtZipCpioFssIosOps =
+{
+    { /* Obj */
+        RTVFSOBJOPS_VERSION,
+        RTVFSOBJTYPE_IO_STREAM,
+        "CpioFsStream::IoStream",
+        rtZipCpioFssIos_Close,
+        rtZipCpioFssIos_QueryInfo,
+        NULL,
+        RTVFSOBJOPS_VERSION
+    },
+    RTVFSIOSTREAMOPS_VERSION,
+    RTVFSIOSTREAMOPS_FEAT_NO_SG,
+    rtZipCpioFssIos_Read,
+    rtZipCpioFssIos_Write,
+    rtZipCpioFssIos_Flush,
+    rtZipCpioFssIos_PollOne,
+    rtZipCpioFssIos_Tell,
+    NULL /*Skip*/,
+    NULL /*ZeroFill*/,
+    RTVFSIOSTREAMOPS_VERSION
+};
+
+
+/**
+ * @interface_method_impl{RTVFSOBJOPS,pfnClose}
+ */
+static DECLCALLBACK(int) rtZipCpioFssSym_Close(void *pvThis)
+{
+    PRTZIPCPIOBASEOBJ pThis = (PRTZIPCPIOBASEOBJ)pvThis;
+    return rtZipCpioFssBaseObj_Close(pThis);
+}
+
+
+/**
+ * @interface_method_impl{RTVFSOBJOPS,pfnQueryInfo}
+ */
+static DECLCALLBACK(int) rtZipCpioFssSym_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
+{
+    PRTZIPCPIOBASEOBJ pThis = (PRTZIPCPIOBASEOBJ)pvThis;
+    return rtZipCpioFssBaseObj_QueryInfo(pThis, pObjInfo, enmAddAttr);
+}
+
+/**
+ * @interface_method_impl{RTVFSOBJSETOPS,pfnMode}
+ */
+static DECLCALLBACK(int) rtZipCpioFssSym_SetMode(void *pvThis, RTFMODE fMode, RTFMODE fMask)
+{
+    NOREF(pvThis); NOREF(fMode); NOREF(fMask);
+    return VERR_ACCESS_DENIED;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSOBJSETOPS,pfnSetTimes}
+ */
+static DECLCALLBACK(int) rtZipCpioFssSym_SetTimes(void *pvThis, PCRTTIMESPEC pAccessTime, PCRTTIMESPEC pModificationTime,
+                                                  PCRTTIMESPEC pChangeTime, PCRTTIMESPEC pBirthTime)
+{
+    NOREF(pvThis); NOREF(pAccessTime); NOREF(pModificationTime); NOREF(pChangeTime); NOREF(pBirthTime);
+    return VERR_ACCESS_DENIED;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSOBJSETOPS,pfnSetOwner}
+ */
+static DECLCALLBACK(int) rtZipCpioFssSym_SetOwner(void *pvThis, RTUID uid, RTGID gid)
+{
+    NOREF(pvThis); NOREF(uid); NOREF(gid);
+    return VERR_ACCESS_DENIED;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSSYMLINKOPS,pfnRead}
+ */
+static DECLCALLBACK(int) rtZipCpioFssSym_Read(void *pvThis, char *pszTarget, size_t cbTarget)
+{
+    PRTZIPCPIOBASEOBJ pThis = (PRTZIPCPIOBASEOBJ)pvThis;
+    return RTStrCopy(pszTarget, cbTarget, pThis->pCpioReader->szTarget);
+}
+
+
+/**
+ * CPIO symbolic (and hardlink) operations.
+ */
+static const RTVFSSYMLINKOPS g_rtZipCpioFssSymOps =
+{
+    { /* Obj */
+        RTVFSOBJOPS_VERSION,
+        RTVFSOBJTYPE_SYMLINK,
+        "CpioFsStream::Symlink",
+        rtZipCpioFssSym_Close,
+        rtZipCpioFssSym_QueryInfo,
+        NULL,
+        RTVFSOBJOPS_VERSION
+    },
+    RTVFSSYMLINKOPS_VERSION,
+    0,
+    { /* ObjSet */
+        RTVFSOBJSETOPS_VERSION,
+        RT_UOFFSETOF(RTVFSSYMLINKOPS, ObjSet) - RT_UOFFSETOF(RTVFSSYMLINKOPS, Obj),
+        rtZipCpioFssSym_SetMode,
+        rtZipCpioFssSym_SetTimes,
+        rtZipCpioFssSym_SetOwner,
+        RTVFSOBJSETOPS_VERSION
+    },
+    rtZipCpioFssSym_Read,
+    RTVFSSYMLINKOPS_VERSION
+};
+
+
+/**
+ * @interface_method_impl{RTVFSOBJOPS,pfnClose}
+ */
+static DECLCALLBACK(int) rtZipCpioFss_Close(void *pvThis)
+{
+    PRTZIPCPIOFSSTREAM pThis = (PRTZIPCPIOFSSTREAM)pvThis;
+
+    RTVfsObjRelease(pThis->hVfsCurObj);
+    pThis->hVfsCurObj  = NIL_RTVFSOBJ;
+    pThis->pCurIosData = NULL;
+
+    RTVfsIoStrmRelease(pThis->hVfsIos);
+    pThis->hVfsIos = NIL_RTVFSIOSTREAM;
+
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSOBJOPS,pfnQueryInfo}
+ */
+static DECLCALLBACK(int) rtZipCpioFss_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
+{
+    PRTZIPCPIOFSSTREAM pThis = (PRTZIPCPIOFSSTREAM)pvThis;
+    /* Take the lazy approach here, with the sideffect of providing some info
+       that is actually kind of useful. */
+    return RTVfsIoStrmQueryInfo(pThis->hVfsIos, pObjInfo, enmAddAttr);
+}
+
+
+/**
+ * @interface_method_impl{RTVFSFSSTREAMOPS,pfnNext}
+ */
+DECL_HIDDEN_CALLBACK(int) rtZipCpioFss_Next(void *pvThis, char **ppszName, RTVFSOBJTYPE *penmType, PRTVFSOBJ phVfsObj)
+{
+    PRTZIPCPIOFSSTREAM pThis = (PRTZIPCPIOFSSTREAM)pvThis;
+
+    /*
+     * Dispense with the current object.
+     */
+    if (pThis->hVfsCurObj != NIL_RTVFSOBJ)
+    {
+        if (pThis->pCurIosData)
+        {
+            pThis->pCurIosData->fEndOfStream = true;
+            pThis->pCurIosData->offFile      = pThis->pCurIosData->cbFile;
+            pThis->pCurIosData = NULL;
+        }
+
+        RTVfsObjRelease(pThis->hVfsCurObj);
+        pThis->hVfsCurObj = NIL_RTVFSOBJ;
+    }
+
+    /*
+     * Check if we've already reached the end in some way.
+     */
+    if (pThis->fEndOfStream)
+        return VERR_EOF;
+    if (pThis->rcFatal != VINF_SUCCESS)
+        return pThis->rcFatal;
+
+    /*
+     * 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;
+    Assert(pThis->offNextHdr == offHdr);
+    pThis->offCurHdr = offHdr;
+
+    /*
+     * Consume CPIO headers.
+     */
+    size_t cbHdr = 0;
+    /*
+     * Read the next header.
+     *
+     * Read the first 6 bytes to determine the header type and continue reading the
+     * rest of the header.
+     */
+    CPIOHDR Hdr;
+    RTZIPCPIOTYPE enmHdrType = RTZIPCPIOTYPE_INVALID;
+    size_t cbRead;
+    int rc = RTVfsIoStrmRead(pThis->hVfsIos, &Hdr.ab[0], sizeof(Hdr.AsciiNew.achMagic), true /*fBlocking*/, &cbRead);
+    if (RT_FAILURE(rc))
+        return pThis->rcFatal = rc;
+    if (rc == VINF_EOF && cbRead == 0)
+    {
+        pThis->fEndOfStream = true;
+        return VERR_EOF;
+    }
+    if (cbRead != sizeof(Hdr.AsciiNew.achMagic))
+        return pThis->rcFatal = VERR_TAR_UNEXPECTED_EOS;
+
+    if (Hdr.AncientBin.u16Magic == CPIO_HDR_BIN_MAGIC)
+    {
+        cbHdr = sizeof(Hdr.AncientBin);
+        enmHdrType = RTZIPCPIOTYPE_ANCIENT_BIN;
+    }
+    else if (!strncmp(&Hdr.AsciiSuSv2.achMagic[0], CPIO_HDR_SUSV2_MAGIC, sizeof(Hdr.AsciiSuSv2.achMagic)))
+    {
+        cbHdr = sizeof(Hdr.AsciiSuSv2);
+        enmHdrType = RTZIPCPIOTYPE_ASCII_SUSV2;
+    }
+    else if (!strncmp(&Hdr.AsciiNew.achMagic[0], CPIO_HDR_NEW_MAGIC, sizeof(Hdr.AsciiNew.achMagic)))
+    {
+        cbHdr = sizeof(Hdr.AsciiNew);
+        enmHdrType = RTZIPCPIOTYPE_ASCII_NEW;
+    }
+    else if (!strncmp(&Hdr.AsciiNew.achMagic[0], CPIO_HDR_NEW_CHKSUM_MAGIC, sizeof(Hdr.AsciiNew.achMagic)))
+    {
+        cbHdr = sizeof(Hdr.AsciiNew);
+        enmHdrType = RTZIPCPIOTYPE_ASCII_NEW_CHKSUM;
+    }
+    else
+        return pThis->rcFatal = VERR_TAR_UNKNOWN_TYPE_FLAG; /** @todo Dedicated status code. */
+
+    /* Read the rest of the header. */
+    size_t cbHdrLeft = cbHdr - sizeof(Hdr.AsciiNew.achMagic);
+    rc = RTVfsIoStrmRead(pThis->hVfsIos, &Hdr.ab[sizeof(Hdr.AsciiNew.achMagic)], cbHdr - sizeof(Hdr.AsciiNew.achMagic), true /*fBlocking*/, &cbRead);
+    if (RT_FAILURE(rc))
+        return pThis->rcFatal = rc;
+    if (cbRead != cbHdrLeft)
+        return pThis->rcFatal = VERR_TAR_UNEXPECTED_EOS;
+
+    /*
+     * Parse it.
+     */
+    uint32_t cbFilePath = 0;
+    uint32_t cbPad = 0;
+    rc = rtZipCpioReaderParseHeader(&pThis->CpioReader, enmHdrType, &Hdr, &cbFilePath, &cbPad);
+    if (RT_FAILURE(rc))
+        return pThis->rcFatal = rc;
+
+    /* Read the file path following the header. */
+    rc = rtZipCpioReaderReadPath(pThis->hVfsIos, &pThis->CpioReader, cbFilePath);
+    if (RT_FAILURE(rc))
+        return pThis->rcFatal = rc;
+
+    if (cbPad)
+        RTVfsIoStrmSkip(pThis->hVfsIos, cbPad);
+    pThis->offNextHdr = offHdr + cbHdr + cbFilePath + cbPad;
+
+    /*
+     * CPIO uses a special trailer file record with a 0 mode and size and using a special
+     * marker filename. The filesystem stream is marked EOS When such a record is encountered
+     * to not try to read anything which might come behind it, imagine an initramfs image consisting
+     * of multiple archives which don't need to be necessarily be all of the CPIO kind (yes, this is
+     * a reality with ubuntu for example containing microcode updates as seperate CPIO archives
+     * coming before the main LZ4 compressed CPIO archive...).
+     */
+    PCRTFSOBJINFO pInfo = &pThis->CpioReader.ObjInfo;
+    if (RT_UNLIKELY(   !pInfo->Attr.fMode
+                    && !pInfo->cbAllocated
+                    && !strcmp(&pThis->CpioReader.szName[0], CPIO_EOS_FILE_NAME)))
+    {
+        pThis->fEndOfStream = true;
+        return VERR_EOF;
+    }
+
+    /*
+     * Create an object of the appropriate type.
+     */
+    RTVFSOBJTYPE    enmType;
+    RTVFSOBJ        hVfsObj;
+    RTFMODE         fType = pInfo->Attr.fMode & RTFS_TYPE_MASK;
+    switch (fType)
+    {
+        /*
+         * Files are represented by a VFS I/O stream, hardlinks have their content
+         * embedded as it is another file.
+         */
+        case RTFS_TYPE_FILE:
+        {
+            RTVFSIOSTREAM       hVfsIos;
+            PRTZIPCPIOIOSTREAM  pIosData;
+            rc = RTVfsNewIoStream(&g_rtZipCpioFssIosOps,
+                                  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.offNextHdr  = pThis->offNextHdr;
+            pIosData->BaseObj.pCpioReader = &pThis->CpioReader;
+            pIosData->BaseObj.ObjInfo     = *pInfo;
+            pIosData->cbFile              = pInfo->cbObject;
+            pIosData->offFile             = 0;
+            pIosData->offStart            = RTVfsIoStrmTell(pThis->hVfsIos);
+            pIosData->cbPadding           = (uint32_t)(pInfo->cbAllocated - pInfo->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;
+        }
+
+        case RTFS_TYPE_SYMLINK:
+        {
+            RTVFSSYMLINK        hVfsSym;
+            PRTZIPCPIOBASEOBJ   pBaseObjData;
+            rc = RTVfsNewSymlink(&g_rtZipCpioFssSymOps,
+                                 sizeof(*pBaseObjData),
+                                 NIL_RTVFS,
+                                 NIL_RTVFSLOCK,
+                                 &hVfsSym,
+                                 (void **)&pBaseObjData);
+            if (RT_FAILURE(rc))
+                return pThis->rcFatal = rc;
+
+            pBaseObjData->offHdr      = offHdr;
+            pBaseObjData->offNextHdr  = pThis->offNextHdr;
+            pBaseObjData->pCpioReader = &pThis->CpioReader;
+            pBaseObjData->ObjInfo     = *pInfo;
+
+            /* Read the body of the symlink (as normal file data). */
+            if (pInfo->cbObject + 1 > (RTFOFF)sizeof(pThis->CpioReader.szTarget))
+                return VERR_TAR_NAME_TOO_LONG;
+
+            cbPad = (uint32_t)(pInfo->cbAllocated - pInfo->cbObject);
+            rc = RTVfsIoStrmRead(pThis->hVfsIos, &pThis->CpioReader.szTarget[0], pInfo->cbObject, true /*fBlocking*/, &cbRead);
+            if (RT_FAILURE(rc))
+                return pThis->rcFatal = rc;
+            if (cbRead != (uint32_t)pInfo->cbObject)
+                return pThis->rcFatal = VERR_TAR_UNEXPECTED_EOS;
+
+            pThis->CpioReader.szTarget[pInfo->cbObject] = '\0';
+
+            if (cbPad)
+               rc = RTVfsIoStrmSkip(pThis->hVfsIos, cbPad);
+            if (RT_FAILURE(rc))
+                return pThis->rcFatal = rc;
+
+            pThis->offNextHdr += pInfo->cbAllocated;
+
+            enmType = RTVFSOBJTYPE_SYMLINK;
+            hVfsObj = RTVfsObjFromSymlink(hVfsSym);
+            RTVfsSymlinkRelease(hVfsSym);
+            break;
+        }
+
+        /*
+         * All other objects are repesented using a VFS base object since they
+         * carry no data streams.
+         */
+        case RTFS_TYPE_DEV_BLOCK:
+        case RTFS_TYPE_DEV_CHAR:
+        case RTFS_TYPE_DIRECTORY:
+        case RTFS_TYPE_FIFO:
+        {
+            PRTZIPCPIOBASEOBJ pBaseObjData;
+            rc = RTVfsNewBaseObj(&g_rtZipCpioFssBaseObjOps,
+                                 sizeof(*pBaseObjData),
+                                 NIL_RTVFS,
+                                 NIL_RTVFSLOCK,
+                                 &hVfsObj,
+                                 (void **)&pBaseObjData);
+            if (RT_FAILURE(rc))
+                return pThis->rcFatal = rc;
+
+            pBaseObjData->offHdr      = offHdr;
+            pBaseObjData->offNextHdr  = pThis->offNextHdr;
+            pBaseObjData->pCpioReader = &pThis->CpioReader;
+            pBaseObjData->ObjInfo     = *pInfo;
+
+            enmType = RTVFSOBJTYPE_BASE;
+            break;
+        }
+
+        default:
+            AssertFailed();
+            return pThis->rcFatal = VERR_INTERNAL_ERROR_5;
+    }
+    pThis->hVfsCurObj = hVfsObj;
+
+    /*
+     * Set the return data and we're done.
+     */
+    if (ppszName)
+    {
+        rc = RTStrDupEx(ppszName, pThis->CpioReader.szName);
+        if (RT_FAILURE(rc))
+            return rc;
+    }
+
+    if (phVfsObj)
+    {
+        RTVfsObjRetain(hVfsObj);
+        *phVfsObj = hVfsObj;
+    }
+
+    if (penmType)
+        *penmType = enmType;
+
+    return VINF_SUCCESS;
+}
+
+
+
+/**
+ * CPIO filesystem stream operations.
+ */
+static const RTVFSFSSTREAMOPS rtZipCpioFssOps =
+{
+    { /* Obj */
+        RTVFSOBJOPS_VERSION,
+        RTVFSOBJTYPE_FS_STREAM,
+        "CpioFsStream",
+        rtZipCpioFss_Close,
+        rtZipCpioFss_QueryInfo,
+        NULL,
+        RTVFSOBJOPS_VERSION
+    },
+    RTVFSFSSTREAMOPS_VERSION,
+    0,
+    rtZipCpioFss_Next,
+    NULL,
+    NULL,
+    NULL,
+    RTVFSFSSTREAMOPS_VERSION
+};
+
+
+/**
+ * Internal function use both by RTZipCpioFsStreamFromIoStream() and by
+ * RTZipCpioFsStreamForFile() in updating mode.
+ */
+DECLHIDDEN(void) rtZipCpioReaderInit(PRTZIPCPIOFSSTREAM pThis, RTVFSIOSTREAM hVfsIos, uint64_t offStart)
+{
+    pThis->hVfsIos              = hVfsIos;
+    pThis->hVfsCurObj           = NIL_RTVFSOBJ;
+    pThis->pCurIosData          = NULL;
+    pThis->offStart             = offStart;
+    pThis->offNextHdr           = offStart;
+    pThis->fEndOfStream         = false;
+    pThis->rcFatal              = VINF_SUCCESS;
+
+    /* Don't check if it's a CPIO stream here, do that in the
+       rtZipCpioFss_Next. */
+}
+
+
+RTDECL(int) RTZipCpioFsStreamFromIoStream(RTVFSIOSTREAM hVfsIosIn, uint32_t fFlags, PRTVFSFSSTREAM phVfsFss)
+{
+    /*
+     * Input validation.
+     */
+    AssertPtrReturn(phVfsFss, VERR_INVALID_HANDLE);
+    *phVfsFss = NIL_RTVFSFSSTREAM;
+    AssertPtrReturn(hVfsIosIn, VERR_INVALID_HANDLE);
+    AssertReturn(!fFlags, VERR_INVALID_PARAMETER);
+
+    RTFOFF const offStart = RTVfsIoStrmTell(hVfsIosIn);
+    AssertReturn(offStart >= 0, (int)offStart);
+
+    uint32_t cRefs = RTVfsIoStrmRetain(hVfsIosIn);
+    AssertReturn(cRefs != UINT32_MAX, VERR_INVALID_HANDLE);
+
+    /*
+     * Retain the input stream and create a new filesystem stream handle.
+     */
+    PRTZIPCPIOFSSTREAM pThis;
+    RTVFSFSSTREAM      hVfsFss;
+    int rc = RTVfsNewFsStream(&rtZipCpioFssOps, sizeof(*pThis), NIL_RTVFS, NIL_RTVFSLOCK, RTFILE_O_READ,
+                              &hVfsFss, (void **)&pThis);
+    if (RT_SUCCESS(rc))
+    {
+        rtZipCpioReaderInit(pThis, hVfsIosIn, fFlags);
+        *phVfsFss = hVfsFss;
+        return VINF_SUCCESS;
+    }
+
+    RTVfsIoStrmRelease(hVfsIosIn);
+    return rc;
+}
+
+
+/**
+ * Used by RTZipCpioFsStreamTruncate to resolve @a hVfsObj.
+ */
+DECLHIDDEN(PRTZIPCPIOBASEOBJ) rtZipCpioFsStreamBaseObjToPrivate(PRTZIPCPIOFSSTREAM pThis, RTVFSOBJ hVfsObj)
+{
+    PRTZIPCPIOBASEOBJ pThisObj;
+    RTVFSOBJTYPE enmType = RTVfsObjGetType(hVfsObj);
+    switch (enmType)
+    {
+        case RTVFSOBJTYPE_IO_STREAM:
+        {
+            RTVFSIOSTREAM hVfsIos = RTVfsObjToIoStream(hVfsObj);
+            AssertReturn(hVfsIos != NIL_RTVFSIOSTREAM, NULL);
+            PRTZIPCPIOIOSTREAM pThisStrm = (PRTZIPCPIOIOSTREAM)RTVfsIoStreamToPrivate(hVfsIos, &g_rtZipCpioFssIosOps);
+            RTVfsIoStrmRelease(hVfsIos);
+            pThisObj = &pThisStrm->BaseObj;
+            break;
+        }
+
+        case RTVFSOBJTYPE_SYMLINK:
+        {
+            RTVFSSYMLINK hVfsSymlink = RTVfsObjToSymlink(hVfsObj);
+            AssertReturn(hVfsSymlink != NIL_RTVFSSYMLINK, NULL);
+            pThisObj = (PRTZIPCPIOBASEOBJ)RTVfsSymlinkToPrivate(hVfsSymlink, &g_rtZipCpioFssSymOps);
+            RTVfsSymlinkRelease(hVfsSymlink);
+            break;
+        }
+
+        case RTVFSOBJTYPE_BASE:
+            pThisObj = (PRTZIPCPIOBASEOBJ)RTVfsObjToPrivate(hVfsObj, &g_rtZipCpioFssBaseObjOps);
+            break;
+
+        default:
+            /** @todo implement.   */
+            AssertFailedReturn(NULL);
+    }
+
+    AssertReturn(pThisObj->pCpioReader == &pThis->CpioReader, NULL);
+    return pThisObj;
+}
+
diff --git a/src/VBox/Runtime/common/zip/cpiovfsreader.h b/src/VBox/Runtime/common/zip/cpiovfsreader.h
new file mode 100644
index 00000000..43db36e9
--- /dev/null
+++ b/src/VBox/Runtime/common/zip/cpiovfsreader.h
@@ -0,0 +1,169 @@
+/* $Id: cpiovfsreader.h $ */
+/** @file
+ * IPRT - CPIO Virtual Filesystem.
+ */
+
+/*
+ * Copyright (C) 2020-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * The contents of this file may alternatively be used under the terms
+ * of the Common Development and Distribution License Version 1.0
+ * (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
+ * in the VirtualBox distribution, in which case the provisions of the
+ * CDDL are applicable instead of those of the GPL.
+ *
+ * You may elect to license modified versions of this file under the
+ * terms and conditions of either the GPL or the CDDL or both.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
+ */
+
+#ifndef IPRT_INCLUDED_SRC_common_zip_cpiovfsreader_h
+#define IPRT_INCLUDED_SRC_common_zip_cpiovfsreader_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <iprt/formats/cpio.h>
+
+
+/**
+ * CPIO archive type.
+ */
+typedef enum RTZIPCPIOTYPE
+{
+    /** Invalid type value. */
+    RTZIPCPIOTYPE_INVALID = 0,
+    /** Ancient binary archive.  */
+    RTZIPCPIOTYPE_ANCIENT_BIN,
+    /** Portable ASCII format as defined by SuSV2. */
+    RTZIPCPIOTYPE_ASCII_SUSV2,
+    /** "New" ASCII format. */
+    RTZIPCPIOTYPE_ASCII_NEW,
+    /** "New" ASCII format with checksumming. */
+    RTZIPCPIOTYPE_ASCII_NEW_CHKSUM,
+    /** End of the valid type values (this is not valid).  */
+    RTZIPCPIOTYPE_END,
+    /** The usual type blow up.  */
+    RTZIPCPIOTYPE_32BIT_HACK = 0x7fffffff
+} RTZIPCPIOTYPE;
+typedef RTZIPCPIOTYPE *PRTZIPCPIOTYPE;
+
+
+/**
+ * CPIO reader instance data.
+ */
+typedef struct RTZIPCPIOREADER
+{
+    /** The object info with unix attributes. */
+    RTFSOBJINFO             ObjInfo;
+    /** The path length. */
+    uint32_t                cbPath;
+    /** The name of the current object. */
+    char                    szName[RTPATH_MAX];
+    /** The current link target if symlink. */
+    char                    szTarget[RTPATH_MAX];
+} RTZIPCPIOREADER;
+/** Pointer to the CPIO reader instance data. */
+typedef RTZIPCPIOREADER *PRTZIPCPIOREADER;
+
+/**
+ * CPIO directory, character device, block device, fifo socket or symbolic link.
+ */
+typedef struct RTZIPCPIOBASEOBJ
+{
+    /** The stream offset of the (first) header in the input stream/file.  */
+    RTFOFF                  offHdr;
+    /** The stream offset of the first header of the next object (for truncating the
+     * tar file after this object (updating)). */
+    RTFOFF                  offNextHdr;
+    /** 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? */
+    PRTZIPCPIOREADER        pCpioReader;
+    /** The object info with unix attributes. */
+    RTFSOBJINFO             ObjInfo;
+} RTZIPCPIOBASEOBJ;
+/** Pointer to a CPIO filesystem stream base object. */
+typedef RTZIPCPIOBASEOBJ *PRTZIPCPIOBASEOBJ;
+
+
+/**
+ * CPIO file represented as a VFS I/O stream.
+ */
+typedef struct RTZIPCPIOIOSTREAM
+{
+    /** The basic TAR object data. */
+    RTZIPCPIOBASEOBJ        BaseObj;
+    /** The number of bytes in the file. */
+    RTFOFF                  cbFile;
+    /** The current file position. */
+    RTFOFF                  offFile;
+    /** The start position in the hVfsIos (for seekable hVfsIos). */
+    RTFOFF                  offStart;
+    /** The number of padding bytes following the file. */
+    uint32_t                cbPadding;
+    /** Set if we've reached the end of this file. */
+    bool                    fEndOfStream;
+    /** The input I/O stream. */
+    RTVFSIOSTREAM           hVfsIos;
+} RTZIPCPIOIOSTREAM;
+/** Pointer to a the private data of a CPIO file I/O stream. */
+typedef RTZIPCPIOIOSTREAM *PRTZIPCPIOIOSTREAM;
+
+
+/**
+ * CPIO filesystem stream private data.
+ */
+typedef struct RTZIPCPIOFSSTREAM
+{
+    /** The input I/O stream. */
+    RTVFSIOSTREAM           hVfsIos;
+
+    /** The current object (referenced). */
+    RTVFSOBJ                hVfsCurObj;
+    /** Pointer to the private data if hVfsCurObj is representing a file. */
+    PRTZIPCPIOIOSTREAM      pCurIosData;
+
+    /** The start offset. */
+    RTFOFF                  offStart;
+    /** The offset of the next header. */
+    RTFOFF                  offNextHdr;
+    /** The offset of the first header for the current object.
+     * When reaching the end, this will be the same as offNextHdr which will be
+     * pointing to the first zero header */
+    RTFOFF                  offCurHdr;
+
+    /** Set if we've reached the end of the stream. */
+    bool                    fEndOfStream;
+    /** Set if we've encountered a fatal error. */
+    int                     rcFatal;
+
+    /** The CPIO reader instance data. */
+    RTZIPCPIOREADER         CpioReader;
+} RTZIPCPIOFSSTREAM;
+/** Pointer to a the private data of a CPIO filesystem stream. */
+typedef RTZIPCPIOFSSTREAM *PRTZIPCPIOFSSTREAM;
+
+DECLHIDDEN(void)                rtZipCpioReaderInit(PRTZIPCPIOFSSTREAM pThis, RTVFSIOSTREAM hVfsIos, uint64_t offStart);
+DECL_HIDDEN_CALLBACK(int)       rtZipCpioFss_Next(void *pvThis, char **ppszName, RTVFSOBJTYPE *penmType, PRTVFSOBJ phVfsObj);
+DECLHIDDEN(PRTZIPCPIOBASEOBJ)   rtZipCpioFsStreamBaseObjToPrivate(PRTZIPCPIOFSSTREAM pThis, RTVFSOBJ hVfsObj);
+
+#endif /* !IPRT_INCLUDED_SRC_common_zip_cpiovfsreader_h */
+
diff --git a/src/VBox/Runtime/common/zip/gzipcmd.cpp b/src/VBox/Runtime/common/zip/gzipcmd.cpp
new file mode 100644
index 00000000..0c00bf24
--- /dev/null
+++ b/src/VBox/Runtime/common/zip/gzipcmd.cpp
@@ -0,0 +1,606 @@
+/* $Id: gzipcmd.cpp $ */
+/** @file
+ * IPRT - GZIP Utility.
+ */
+
+/*
+ * Copyright (C) 2010-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * The contents of this file may alternatively be used under the terms
+ * of the Common Development and Distribution License Version 1.0
+ * (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
+ * in the VirtualBox distribution, in which case the provisions of the
+ * CDDL are applicable instead of those of the GPL.
+ *
+ * You may elect to license modified versions of this file under the
+ * terms and conditions of either the GPL or the CDDL or both.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#include <iprt/zip.h>
+
+#include <iprt/buildconfig.h>
+#include <iprt/err.h>
+#include <iprt/file.h>
+#include <iprt/getopt.h>
+#include <iprt/initterm.h>
+#include <iprt/message.h>
+#include <iprt/param.h>
+#include <iprt/path.h>
+#include <iprt/stream.h>
+#include <iprt/string.h>
+#include <iprt/vfs.h>
+#include <iprt/zip.h>
+
+
+/*********************************************************************************************************************************
+*   Structures and Typedefs                                                                                                      *
+*********************************************************************************************************************************/
+/**
+ * Gzip command options.
+ */
+typedef struct RTGZIPCMDOPTS
+{
+    bool            fAscii;
+    bool            fStdOut;
+    bool            fDecompress;
+    bool            fForce;
+    bool            fKeep;
+    bool            fList;
+    bool            fName;
+    bool            fQuiet;
+    bool            fRecursive;
+    const char     *pszSuff;
+    bool            fTest;
+    unsigned        uLevel;
+    /** The current output filename (for deletion). */
+    char            szOutput[RTPATH_MAX];
+    /** The current input filename (for deletion and messages). */
+    const char     *pszInput;
+} RTGZIPCMDOPTS;
+/** Pointer to GZIP options. */
+typedef RTGZIPCMDOPTS *PRTGZIPCMDOPTS;
+/** Pointer to const GZIP options. */
+typedef RTGZIPCMDOPTS const *PCRTGZIPCMDOPTS;
+
+
+
+/**
+ * Checks if the given standard handle is a TTY.
+ *
+ * @returns true / false
+ * @param   enmStdHandle    The standard handle.
+ */
+static bool gzipIsStdHandleATty(RTHANDLESTD enmStdHandle)
+{
+    /** @todo Add isatty() to IPRT. */
+    RT_NOREF1(enmStdHandle);
+    return false;
+}
+
+
+/**
+ * Pushes data from the input to the output I/O streams.
+ *
+ * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE.
+ * @param   hVfsSrc         The source I/O stream.
+ * @param   hVfsDst         The destination I/O stream.
+ */
+static RTEXITCODE gzipPush(RTVFSIOSTREAM hVfsSrc, RTVFSIOSTREAM hVfsDst)
+{
+    for (;;)
+    {
+        uint8_t abBuf[_64K];
+        size_t  cbRead;
+        int rc = RTVfsIoStrmRead(hVfsSrc, abBuf, sizeof(abBuf), true /*fBlocking*/, &cbRead);
+        if (RT_FAILURE(rc))
+            return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTVfsIoStrmRead failed: %Rrc", rc);
+        if (rc == VINF_EOF && cbRead == 0)
+            return RTEXITCODE_SUCCESS;
+
+        rc = RTVfsIoStrmWrite(hVfsDst, abBuf, cbRead, true /*fBlocking*/, NULL /*cbWritten*/);
+        if (RT_FAILURE(rc))
+            return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTVfsIoStrmWrite failed: %Rrc", rc);
+    }
+}
+
+
+/**
+ * Pushes the bytes from the input to the output stream, flushes the output
+ * stream and closes both of them.
+ *
+ * On failure, we will delete the output file, if it's a file.  The input file
+ * may be deleted, if we're not told to keep it (--keep, --to-stdout).
+ *
+ * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE.
+ * @param   phVfsSrc        The input stream. Set to NIL if closed.
+ * @param   pOpts           The options.
+ * @param   phVfsDst        The output stream. Set to NIL if closed.
+ */
+static RTEXITCODE gzipPushFlushAndClose(PRTVFSIOSTREAM phVfsSrc, PCRTGZIPCMDOPTS pOpts, PRTVFSIOSTREAM phVfsDst)
+{
+    /*
+     * Push bytes, flush and close the streams.
+     */
+    RTEXITCODE rcExit = gzipPush(*phVfsSrc, *phVfsDst);
+
+    RTVfsIoStrmRelease(*phVfsSrc);
+    *phVfsSrc = NIL_RTVFSIOSTREAM;
+
+    int rc = RTVfsIoStrmFlush(*phVfsDst);
+    if (RT_FAILURE(rc) && rc != VERR_INVALID_PARAMETER)
+        rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "Failed to flush the output file: %Rrc", rc);
+    RTVfsIoStrmRelease(*phVfsDst);
+    *phVfsDst = NIL_RTVFSIOSTREAM;
+
+    /*
+     * Do the cleaning up, if needed.  Remove the input file, if that's the
+     * desire of the user, or remove the output file on failure.
+     */
+    if (!pOpts->fStdOut)
+    {
+        if (rcExit == RTEXITCODE_SUCCESS)
+        {
+            if (!pOpts->fKeep)
+            {
+                rc = RTFileDelete(pOpts->pszInput);
+                if (RT_FAILURE(rc))
+                    rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "Failed to delete '%s': %Rrc", pOpts->pszInput, rc);
+            }
+        }
+        else
+        {
+            rc = RTFileDelete(pOpts->szOutput);
+            if (RT_FAILURE(rc))
+                RTMsgError("Failed to delete '%s': %Rrc", pOpts->szOutput, rc);
+        }
+    }
+
+    return rcExit;
+}
+
+
+/**
+ * Compresses one stream to another.
+ *
+ * @returns Exit code.
+ * @param   phVfsSrc        The input stream. Set to NIL if closed.
+ * @param   pOpts           The options.
+ * @param   phVfsDst        The output stream. Set to NIL if closed.
+ */
+static RTEXITCODE gzipCompressFile(PRTVFSIOSTREAM phVfsSrc, PCRTGZIPCMDOPTS pOpts, PRTVFSIOSTREAM phVfsDst)
+{
+    /*
+     * Attach the ompressor to the output stream.
+     */
+    RTVFSIOSTREAM hVfsGzip;
+    int rc = RTZipGzipCompressIoStream(*phVfsDst, 0 /*fFlags*/, pOpts->uLevel, &hVfsGzip);
+    if (RT_FAILURE(rc))
+        return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTZipGzipCompressIoStream failed: %Rrc", rc);
+
+    uint32_t cRefs = RTVfsIoStrmRelease(*phVfsDst);
+    Assert(cRefs > 0); RT_NOREF_PV(cRefs);
+    *phVfsDst = hVfsGzip;
+
+    return gzipPushFlushAndClose(phVfsSrc, pOpts, phVfsDst);
+}
+
+
+/**
+ * Attach a decompressor to the given source stream, replacing and releasing the
+ * input handle with the decompressor.
+ *
+ * @returns Exit code.
+ * @param   phVfsSrc        The input stream. Replaced on success.
+ */
+static RTEXITCODE gzipSetupDecompressor(PRTVFSIOSTREAM phVfsSrc)
+{
+    /*
+     * Attach the decompressor to the input stream.
+     */
+    uint32_t fFlags = 0;
+    fFlags |= RTZIPGZIPDECOMP_F_ALLOW_ZLIB_HDR;
+    RTVFSIOSTREAM hVfsGunzip;
+    int rc = RTZipGzipDecompressIoStream(*phVfsSrc, fFlags, &hVfsGunzip);
+    if (RT_FAILURE(rc))
+        return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTZipGzipDecompressIoStream failed: %Rrc", rc);
+
+    uint32_t cRefs = RTVfsIoStrmRelease(*phVfsSrc);
+    Assert(cRefs > 0); RT_NOREF_PV(cRefs);
+    *phVfsSrc = hVfsGunzip;
+
+#if 0
+    /* This is a good place for testing stuff. */
+    rc = RTVfsCreateReadAheadForIoStream(*phVfsSrc, 0, 16, _4K+1, &hVfsGunzip);
+    AssertRC(rc);
+    if (RT_SUCCESS(rc))
+    {
+        uint32_t cRefs = RTVfsIoStrmRelease(*phVfsSrc);
+        Assert(cRefs > 0);
+        *phVfsSrc = hVfsGunzip;
+    }
+#endif
+
+    return RTEXITCODE_SUCCESS;
+}
+
+
+/**
+ * Decompresses one stream to another.
+ *
+ * @returns Exit code.
+ * @param   phVfsSrc        The input stream. Set to NIL if closed.
+ * @param   pOpts           The options.
+ * @param   phVfsDst        The output stream. Set to NIL if closed.
+ */
+static RTEXITCODE gzipDecompressFile(PRTVFSIOSTREAM phVfsSrc, PCRTGZIPCMDOPTS pOpts, PRTVFSIOSTREAM phVfsDst)
+{
+    RTEXITCODE rcExit = gzipSetupDecompressor(phVfsSrc);
+    if (rcExit == RTEXITCODE_SUCCESS)
+        rcExit = gzipPushFlushAndClose(phVfsSrc, pOpts, phVfsDst);
+    return rcExit;
+}
+
+
+/**
+ * For testing the archive (todo).
+ *
+ * @returns Exit code.
+ * @param   phVfsSrc        The input stream. Set to NIL if closed.
+ * @param   pOpts           The options.
+ */
+static RTEXITCODE gzipTestFile(PRTVFSIOSTREAM phVfsSrc, PCRTGZIPCMDOPTS pOpts)
+{
+    RT_NOREF_PV(pOpts);
+
+    /*
+     * Read the whole stream.
+     */
+    RTEXITCODE rcExit = gzipSetupDecompressor(phVfsSrc);
+    if (rcExit == RTEXITCODE_SUCCESS)
+    {
+        for (;;)
+        {
+            uint8_t abBuf[_64K];
+            size_t  cbRead;
+            int rc = RTVfsIoStrmRead(*phVfsSrc, abBuf, sizeof(abBuf), true /*fBlocking*/, &cbRead);
+            if (RT_FAILURE(rc))
+                return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTVfsIoStrmRead failed: %Rrc", rc);
+            if (rc == VINF_EOF && cbRead == 0)
+                return RTEXITCODE_SUCCESS;
+        }
+    }
+    return rcExit;
+}
+
+
+static RTEXITCODE gzipListFile(PRTVFSIOSTREAM phVfsSrc, PCRTGZIPCMDOPTS pOpts)
+{
+    RT_NOREF2(phVfsSrc, pOpts);
+    return RTMsgErrorExit(RTEXITCODE_FAILURE, "Listing has not been implemented");
+}
+
+
+/**
+ * Opens the output file.
+ *
+ * @returns Command exit, error messages written using RTMsg*.
+ *
+ * @param   pszFile             The input filename.
+ * @param   pOpts               The options, szOutput will be filled in by this
+ *                              function on success.
+ * @param   phVfsIos            Where to return the output stream handle.
+ *
+ * @remarks This is actually not quite the way we need to do things.
+ *
+ *          First of all, we need a GZIP file system stream for a real GZIP
+ *          implementation, since there may be more than one file in the gzipped
+ *          file.
+ *
+ *          Second, we need to open the output files as we encounter files in the input
+ *          file system stream. The gzip format contains timestamp and usually a
+ *          filename, the default is to use this name (see the --no-name
+ *          option).
+ */
+static RTEXITCODE gzipOpenOutput(const char *pszFile, PRTGZIPCMDOPTS pOpts, PRTVFSIOSTREAM phVfsIos)
+{
+    int rc;
+    if (!strcmp(pszFile, "-") || pOpts->fStdOut)
+    {
+        strcpy(pOpts->szOutput, "-");
+
+        if (   !pOpts->fForce
+            && !pOpts->fDecompress
+            && gzipIsStdHandleATty(RTHANDLESTD_OUTPUT))
+            return RTMsgErrorExit(RTEXITCODE_SYNTAX,
+                                  "Yeah, right. I'm not writing any compressed data to the terminal without --force.\n");
+
+        rc = RTVfsIoStrmFromStdHandle(RTHANDLESTD_OUTPUT,
+                                      RTFILE_O_WRITE | RTFILE_O_OPEN | RTFILE_O_DENY_NONE,
+                                      true /*fLeaveOpen*/,
+                                      phVfsIos);
+        if (RT_FAILURE(rc))
+            return RTMsgErrorExit(RTEXITCODE_FAILURE, "Error opening standard output: %Rrc", rc);
+    }
+    else
+    {
+        Assert(!RTVfsChainIsSpec(pszFile));
+
+        /* Construct an output filename. */
+        rc = RTStrCopy(pOpts->szOutput, sizeof(pOpts->szOutput), pszFile);
+        if (RT_FAILURE(rc))
+            return RTMsgErrorExit(RTEXITCODE_FAILURE, "Error constructing output filename: %Rrc", rc);
+        if (pOpts->fDecompress)
+        {
+            /** @todo take filename from archive? */
+            size_t cchSuff = strlen(pOpts->pszSuff); Assert(cchSuff > 0);
+            size_t cch = strlen(pOpts->szOutput);
+            if (   cch <= cchSuff
+                || strcmp(&pOpts->szOutput[cch - cchSuff], pOpts->pszSuff))
+                return RTMsgErrorExit(RTEXITCODE_FAILURE, "Input file does not end with: '%s'", pOpts->pszSuff);
+            pOpts->szOutput[cch - cchSuff] = '\0';
+            if (!RTPathFilename(pOpts->szOutput))
+                return RTMsgErrorExit(RTEXITCODE_FAILURE, "Error constructing output filename: Input file name is all suffix.");
+        }
+        else
+        {
+            rc = RTStrCat(pOpts->szOutput, sizeof(pOpts->szOutput), pOpts->pszSuff);
+            if (RT_FAILURE(rc))
+                return RTMsgErrorExit(RTEXITCODE_FAILURE, "Error constructing output filename: %Rrc", rc);
+        }
+
+        /* Open the output file. */
+        uint32_t fOpen = RTFILE_O_WRITE | RTFILE_O_DENY_WRITE;
+        if (pOpts->fForce)
+            fOpen |= RTFILE_O_CREATE_REPLACE;
+        else
+            fOpen |= RTFILE_O_CREATE;
+        rc = RTVfsIoStrmOpenNormal(pOpts->szOutput, fOpen, phVfsIos);
+        if (RT_FAILURE(rc))
+            return RTMsgErrorExit(RTEXITCODE_FAILURE, "Error opening output file '%s': %Rrc", pOpts->szOutput, rc);
+    }
+
+    return RTEXITCODE_SUCCESS;
+}
+
+
+/**
+ * Opens the input file.
+ *
+ * @returns Command exit, error messages written using RTMsg*.
+ *
+ * @param   pszFile             The input filename.
+ * @param   pOpts               The options, szOutput will be filled in by this
+ *                              function on success.
+ * @param   phVfsIos            Where to return the input stream handle.
+ */
+static RTEXITCODE gzipOpenInput(const char *pszFile, PRTGZIPCMDOPTS pOpts, PRTVFSIOSTREAM phVfsIos)
+{
+    int rc;
+
+    pOpts->pszInput = pszFile;
+    if (!strcmp(pszFile, "-"))
+    {
+        if (   !pOpts->fForce
+            && pOpts->fDecompress
+            && gzipIsStdHandleATty(RTHANDLESTD_OUTPUT))
+            return RTMsgErrorExit(RTEXITCODE_SYNTAX,
+                                  "Yeah, right. I'm not reading any compressed data from the terminal without --force.\n");
+
+        rc = RTVfsIoStrmFromStdHandle(RTHANDLESTD_INPUT,
+                                      RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE,
+                                      true /*fLeaveOpen*/,
+                                      phVfsIos);
+        if (RT_FAILURE(rc))
+            return RTMsgErrorExit(RTEXITCODE_FAILURE, "Error opening standard input: %Rrc", rc);
+    }
+    else
+    {
+        uint32_t        offError = 0;
+        RTERRINFOSTATIC ErrInfo;
+        rc = RTVfsChainOpenIoStream(pszFile, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_WRITE,
+                                    phVfsIos, &offError, RTErrInfoInitStatic(&ErrInfo));
+        if (RT_FAILURE(rc))
+            return RTVfsChainMsgErrorExitFailure("RTVfsChainOpenIoStream", pszFile, rc, offError, &ErrInfo.Core);
+    }
+
+    return RTEXITCODE_SUCCESS;
+
+}
+
+
+/**
+ * A mini GZIP program.
+ *
+ * @returns Program exit code.
+ *
+ * @param   cArgs               The number of arguments.
+ * @param   papszArgs           The argument vector.  (Note that this may be
+ *                              reordered, so the memory must be writable.)
+ */
+RTDECL(RTEXITCODE) RTZipGzipCmd(unsigned cArgs, char **papszArgs)
+{
+
+    /*
+     * Parse the command line.
+     */
+    static const RTGETOPTDEF s_aOptions[] =
+    {
+        { "--ascii",        'a', RTGETOPT_REQ_NOTHING },
+        { "--stdout",       'c', RTGETOPT_REQ_NOTHING },
+        { "--to-stdout",    'c', RTGETOPT_REQ_NOTHING },
+        { "--decompress",   'd', RTGETOPT_REQ_NOTHING },
+        { "--uncompress",   'd', RTGETOPT_REQ_NOTHING },
+        { "--force",        'f', RTGETOPT_REQ_NOTHING },
+        { "--keep",         'k', RTGETOPT_REQ_NOTHING },
+        { "--list",         'l', RTGETOPT_REQ_NOTHING },
+        { "--no-name",      'n', RTGETOPT_REQ_NOTHING },
+        { "--name",         'N', RTGETOPT_REQ_NOTHING },
+        { "--quiet",        'q', RTGETOPT_REQ_NOTHING },
+        { "--recursive",    'r', RTGETOPT_REQ_NOTHING },
+        { "--suffix",       'S', RTGETOPT_REQ_STRING  },
+        { "--test",         't', RTGETOPT_REQ_NOTHING },
+        { "--verbose",      'v', RTGETOPT_REQ_NOTHING },
+        { "--fast",         '1', RTGETOPT_REQ_NOTHING },
+        { "-1",             '1', RTGETOPT_REQ_NOTHING },
+        { "-2",             '2', RTGETOPT_REQ_NOTHING },
+        { "-3",             '3', RTGETOPT_REQ_NOTHING },
+        { "-4",             '4', RTGETOPT_REQ_NOTHING },
+        { "-5",             '5', RTGETOPT_REQ_NOTHING },
+        { "-6",             '6', RTGETOPT_REQ_NOTHING },
+        { "-7",             '7', RTGETOPT_REQ_NOTHING },
+        { "-8",             '8', RTGETOPT_REQ_NOTHING },
+        { "-9",             '9', RTGETOPT_REQ_NOTHING },
+        { "--best",         '9', RTGETOPT_REQ_NOTHING }
+    };
+
+    RTGZIPCMDOPTS Opts;
+    Opts.fAscii      = false;
+    Opts.fStdOut     = false;
+    Opts.fDecompress = false;
+    Opts.fForce      = false;
+    Opts.fKeep       = false;
+    Opts.fList       = false;
+    Opts.fName       = true;
+    Opts.fQuiet      = false;
+    Opts.fRecursive  = false;
+    Opts.pszSuff     = ".gz";
+    Opts.fTest       = false;
+    Opts.uLevel      = 6;
+
+    RTEXITCODE  rcExit      = RTEXITCODE_SUCCESS;
+    unsigned    cProcessed  = 0;
+    //RTVFSIOSTREAM hVfsStdOut= NIL_RTVFSIOSTREAM;
+
+    RTGETOPTSTATE GetState;
+    int rc = RTGetOptInit(&GetState, cArgs, papszArgs, s_aOptions, RT_ELEMENTS(s_aOptions), 1,
+                          RTGETOPTINIT_FLAGS_OPTS_FIRST);
+    if (RT_FAILURE(rc))
+        return RTMsgErrorExit(RTEXITCODE_SYNTAX, "RTGetOptInit: %Rrc", rc);
+
+    for (;;)
+    {
+        RTGETOPTUNION ValueUnion;
+        int chOpt = RTGetOpt(&GetState, &ValueUnion);
+        switch (chOpt)
+        {
+            case 0:
+                /*
+                 * If we've processed any files we're done.  Otherwise take
+                 * input from stdin and write the output to stdout.
+                 */
+                if (cProcessed > 0)
+                    return rcExit;
+                ValueUnion.psz = "-";
+                Opts.fStdOut = true;
+                RT_FALL_THRU();
+            case VINF_GETOPT_NOT_OPTION:
+            {
+                if (!*Opts.pszSuff && !Opts.fStdOut)
+                    return RTMsgErrorExit(RTEXITCODE_SYNTAX, "The --suffix option specified an empty string");
+                if (!Opts.fStdOut && RTVfsChainIsSpec(ValueUnion.psz))
+                    return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Must use standard out with VFS chain specifications");
+                if (   Opts.fName
+                    && !Opts.fList
+                    && !Opts.fTest
+                    && !Opts.fDecompress)
+                    return RTMsgErrorExit(RTEXITCODE_SYNTAX, "The --name option has not yet been implemented. Use --no-name.");
+                if (Opts.fAscii)
+                    return RTMsgErrorExit(RTEXITCODE_SYNTAX, "The --ascii option has not yet been implemented.");
+                if (Opts.fRecursive)
+                    return RTMsgErrorExit(RTEXITCODE_SYNTAX, "The --recursive option has not yet been implemented.");
+
+                /* Open the input file. */
+                RTVFSIOSTREAM hVfsSrc;
+                RTEXITCODE rcExit2 = gzipOpenInput(ValueUnion.psz, &Opts, &hVfsSrc);
+                if (rcExit2 == RTEXITCODE_SUCCESS)
+                {
+                    if (Opts.fList)
+                        rcExit2 = gzipListFile(&hVfsSrc, &Opts);
+                    else if (Opts.fTest)
+                        rcExit2 = gzipTestFile(&hVfsSrc, &Opts);
+                    else
+                    {
+                        RTVFSIOSTREAM hVfsDst;
+                        rcExit2 = gzipOpenOutput(ValueUnion.psz, &Opts, &hVfsDst);
+                        if (rcExit2 == RTEXITCODE_SUCCESS)
+                        {
+                            if (Opts.fDecompress)
+                                rcExit2 = gzipDecompressFile(&hVfsSrc, &Opts, &hVfsDst);
+                            else
+                                rcExit2 = gzipCompressFile(&hVfsSrc, &Opts, &hVfsDst);
+                            RTVfsIoStrmRelease(hVfsDst);
+                        }
+                    }
+                    RTVfsIoStrmRelease(hVfsSrc);
+                }
+                if (rcExit2 != RTEXITCODE_SUCCESS)
+                    rcExit = rcExit2;
+
+                cProcessed++;
+                break;
+            }
+
+            case 'a':   Opts.fAscii      = true;  break;
+            case 'c':
+                Opts.fStdOut = true;
+                Opts.fKeep   = true;
+                break;
+            case 'd':   Opts.fDecompress = true;  break;
+            case 'f':   Opts.fForce      = true;  break;
+            case 'k':   Opts.fKeep       = true;  break;
+            case 'l':   Opts.fList       = true;  break;
+            case 'n':   Opts.fName       = false; break;
+            case 'N':   Opts.fName       = true;  break;
+            case 'q':   Opts.fQuiet      = true;  break;
+            case 'r':   Opts.fRecursive  = true;  break;
+            case 'S':   Opts.pszSuff     = ValueUnion.psz; break;
+            case 't':   Opts.fTest       = true;  break;
+            case 'v':   Opts.fQuiet      = false; break;
+            case '1':   Opts.uLevel      = 1;     break;
+            case '2':   Opts.uLevel      = 2;     break;
+            case '3':   Opts.uLevel      = 3;     break;
+            case '4':   Opts.uLevel      = 4;     break;
+            case '5':   Opts.uLevel      = 5;     break;
+            case '6':   Opts.uLevel      = 6;     break;
+            case '7':   Opts.uLevel      = 7;     break;
+            case '8':   Opts.uLevel      = 8;     break;
+            case '9':   Opts.uLevel      = 9;     break;
+
+            case 'h':
+                RTPrintf("Usage: to be written\nOption dump:\n");
+                for (unsigned i = 0; i < RT_ELEMENTS(s_aOptions); i++)
+                    RTPrintf(" -%c,%s\n", s_aOptions[i].iShort, s_aOptions[i].pszLong);
+                return RTEXITCODE_SUCCESS;
+
+            case 'V':
+                RTPrintf("%sr%d\n", RTBldCfgVersion(), RTBldCfgRevision());
+                return RTEXITCODE_SUCCESS;
+
+            default:
+                return RTGetOptPrintError(chOpt, &ValueUnion);
+        }
+    }
+}
+
diff --git a/src/VBox/Runtime/common/zip/gzipvfs.cpp b/src/VBox/Runtime/common/zip/gzipvfs.cpp
new file mode 100644
index 00000000..de38938a
--- /dev/null
+++ b/src/VBox/Runtime/common/zip/gzipvfs.cpp
@@ -0,0 +1,1035 @@
+/* $Id: gzipvfs.cpp $ */
+/** @file
+ * IPRT - GZIP Compressor and Decompressor I/O Stream.
+ */
+
+/*
+ * Copyright (C) 2010-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * The contents of this file may alternatively be used under the terms
+ * of the Common Development and Distribution License Version 1.0
+ * (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
+ * in the VirtualBox distribution, in which case the provisions of the
+ * CDDL are applicable instead of those of the GPL.
+ *
+ * You may elect to license modified versions of this file under the
+ * terms and conditions of either the GPL or the CDDL or both.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
+ */
+
+
+/*********************************************************************************************************************************
+*   Defined Constants And Macros                                                                                                 *
+*********************************************************************************************************************************/
+#include "internal/iprt.h"
+#include <iprt/zip.h>
+
+#include <iprt/assert.h>
+#include <iprt/ctype.h>
+#include <iprt/file.h>
+#include <iprt/err.h>
+#include <iprt/poll.h>
+#include <iprt/string.h>
+#include <iprt/vfslowlevel.h>
+
+#include <zlib.h>
+
+#if defined(RT_OS_OS2) || defined(RT_OS_SOLARIS) || defined(RT_OS_WINDOWS)
+/**
+ * Drag in the missing zlib symbols.
+ */
+PFNRT g_apfnRTZlibDeps[] =
+{
+    (PFNRT)gzrewind,
+    (PFNRT)gzread,
+    (PFNRT)gzopen,
+    (PFNRT)gzwrite,
+    (PFNRT)gzclose,
+    (PFNRT)gzdopen,
+    NULL
+};
+#endif /* RT_OS_OS2 || RT_OS_SOLARIS || RT_OS_WINDOWS */
+
+
+/*********************************************************************************************************************************
+*   Structures and Typedefs                                                                                                      *
+*********************************************************************************************************************************/
+#pragma pack(1)
+typedef struct RTZIPGZIPHDR
+{
+    /** RTZIPGZIPHDR_ID1. */
+    uint8_t     bId1;
+    /** RTZIPGZIPHDR_ID2. */
+    uint8_t     bId2;
+    /** CM - The compression method. */
+    uint8_t     bCompressionMethod;
+    /** FLG - Flags. */
+    uint8_t     fFlags;
+    /** Modification time of the source file or the timestamp at the time the
+     * compression took place. Can also be zero.  Is the number of seconds since
+     * unix epoch. */
+    uint32_t    u32ModTime;
+    /** Flags specific to the compression method. */
+    uint8_t     bXtraFlags;
+    /** An ID indicating which OS or FS gzip ran on. */
+    uint8_t     bOS;
+} RTZIPGZIPHDR;
+#pragma pack()
+AssertCompileSize(RTZIPGZIPHDR, 10);
+/** Pointer to a const gzip header. */
+typedef RTZIPGZIPHDR const *PCRTZIPGZIPHDR;
+
+/** gzip header identification no 1. */
+#define RTZIPGZIPHDR_ID1            0x1f
+/** gzip header identification no 2. */
+#define RTZIPGZIPHDR_ID2            0x8b
+/** gzip deflate compression method. */
+#define RTZIPGZIPHDR_CM_DEFLATE     8
+
+/** @name gzip header flags
+ * @{ */
+/** Probably a text file */
+#define RTZIPGZIPHDR_FLG_TEXT       UINT8_C(0x01)
+/** Header CRC present (crc32 of header cast to uint16_t). */
+#define RTZIPGZIPHDR_FLG_HDR_CRC    UINT8_C(0x02)
+/** Length prefixed xtra field is present. */
+#define RTZIPGZIPHDR_FLG_EXTRA      UINT8_C(0x04)
+/** A name field is present (latin-1). */
+#define RTZIPGZIPHDR_FLG_NAME       UINT8_C(0x08)
+/** A comment field is present (latin-1). */
+#define RTZIPGZIPHDR_FLG_COMMENT    UINT8_C(0x10)
+/** Mask of valid flags. */
+#define RTZIPGZIPHDR_FLG_VALID_MASK UINT8_C(0x1f)
+/** @}  */
+
+/** @name gzip default xtra flag values
+ * @{ */
+#define RTZIPGZIPHDR_XFL_DEFLATE_MAX        UINT8_C(0x02)
+#define RTZIPGZIPHDR_XFL_DEFLATE_FASTEST    UINT8_C(0x04)
+/** @} */
+
+/** @name Operating system / Filesystem IDs
+ * @{ */
+#define RTZIPGZIPHDR_OS_FAT             UINT8_C(0x00)
+#define RTZIPGZIPHDR_OS_AMIGA           UINT8_C(0x01)
+#define RTZIPGZIPHDR_OS_VMS             UINT8_C(0x02)
+#define RTZIPGZIPHDR_OS_UNIX            UINT8_C(0x03)
+#define RTZIPGZIPHDR_OS_VM_CMS          UINT8_C(0x04)
+#define RTZIPGZIPHDR_OS_ATARIS_TOS      UINT8_C(0x05)
+#define RTZIPGZIPHDR_OS_HPFS            UINT8_C(0x06)
+#define RTZIPGZIPHDR_OS_MACINTOSH       UINT8_C(0x07)
+#define RTZIPGZIPHDR_OS_Z_SYSTEM        UINT8_C(0x08)
+#define RTZIPGZIPHDR_OS_CPM             UINT8_C(0x09)
+#define RTZIPGZIPHDR_OS_TOPS_20         UINT8_C(0x0a)
+#define RTZIPGZIPHDR_OS_NTFS            UINT8_C(0x0b)
+#define RTZIPGZIPHDR_OS_QDOS            UINT8_C(0x0c)
+#define RTZIPGZIPHDR_OS_ACORN_RISCOS    UINT8_C(0x0d)
+#define RTZIPGZIPHDR_OS_UNKNOWN         UINT8_C(0xff)
+/** @}  */
+
+
+/**
+ * The internal data of a GZIP I/O stream.
+ */
+typedef struct RTZIPGZIPSTREAM
+{
+    /** The stream we're reading or writing the compressed data from or to. */
+    RTVFSIOSTREAM       hVfsIos;
+    /** Set if it's a decompressor, clear if it's a compressor. */
+    bool                fDecompress;
+    /** Set if zlib reported a fatal error. */
+    bool                fFatalError;
+    /** Set if we've reached the end of the zlib stream. */
+    bool                fEndOfStream;
+    /** The stream offset for pfnTell, always the uncompressed data. */
+    RTFOFF              offStream;
+    /** The zlib stream.  */
+    z_stream            Zlib;
+    /** The data buffer.  */
+    uint8_t             abBuffer[_64K];
+    /** Scatter gather segment describing abBuffer. */
+    RTSGSEG             SgSeg;
+    /** Scatter gather buffer describing abBuffer. */
+    RTSGBUF             SgBuf;
+    /** The original file name (decompressor only). */
+    char               *pszOrgName;
+    /** The comment (decompressor only). */
+    char               *pszComment;
+    /** The gzip header. */
+    RTZIPGZIPHDR        Hdr;
+} RTZIPGZIPSTREAM;
+/** Pointer to a the internal data of a GZIP I/O stream. */
+typedef RTZIPGZIPSTREAM *PRTZIPGZIPSTREAM;
+
+
+/*********************************************************************************************************************************
+*   Internal Functions                                                                                                           *
+*********************************************************************************************************************************/
+static int rtZipGzip_FlushIt(PRTZIPGZIPSTREAM pThis, uint8_t fFlushType);
+
+
+/**
+ * Convert from zlib to IPRT status codes.
+ *
+ * This will also set the fFatalError flag when appropriate.
+ *
+ * @returns IPRT status code.
+ * @param   pThis           The gzip I/O stream instance data.
+ * @param   rc              Zlib error code.
+ */
+static int rtZipGzipConvertErrFromZlib(PRTZIPGZIPSTREAM pThis, int rc)
+{
+    switch (rc)
+    {
+        case Z_OK:
+            return VINF_SUCCESS;
+
+        case Z_BUF_ERROR:
+            /* This isn't fatal. */
+            return VINF_SUCCESS; /** @todo The code in zip.cpp treats Z_BUF_ERROR as fatal... */
+
+        case Z_STREAM_ERROR:
+            pThis->fFatalError = true;
+            return VERR_ZIP_CORRUPTED;
+
+        case Z_DATA_ERROR:
+            pThis->fFatalError = true;
+            return pThis->fDecompress ? VERR_ZIP_CORRUPTED : VERR_ZIP_ERROR;
+
+        case Z_MEM_ERROR:
+            pThis->fFatalError = true;
+            return VERR_ZIP_NO_MEMORY;
+
+        case Z_VERSION_ERROR:
+            pThis->fFatalError = true;
+            return VERR_ZIP_UNSUPPORTED_VERSION;
+
+        case Z_ERRNO: /* We shouldn't see this status! */
+        default:
+            AssertMsgFailed(("%d\n", rc));
+            if (rc >= 0)
+                return VINF_SUCCESS;
+            pThis->fFatalError = true;
+            return VERR_ZIP_ERROR;
+    }
+}
+
+
+/**
+ * @interface_method_impl{RTVFSOBJOPS,pfnClose}
+ */
+static DECLCALLBACK(int) rtZipGzip_Close(void *pvThis)
+{
+    PRTZIPGZIPSTREAM pThis = (PRTZIPGZIPSTREAM)pvThis;
+
+    int rc;
+    if (pThis->fDecompress)
+    {
+        rc = inflateEnd(&pThis->Zlib);
+        if (rc != Z_OK)
+            rc = rtZipGzipConvertErrFromZlib(pThis, rc);
+    }
+    else
+    {
+        /* Flush the compression stream before terminating it. */
+        rc = VINF_SUCCESS;
+        if (!pThis->fFatalError)
+            rc = rtZipGzip_FlushIt(pThis, Z_FINISH);
+
+        int rc2 = deflateEnd(&pThis->Zlib);
+        if (RT_SUCCESS(rc) && rc2 != Z_OK)
+            rc = rtZipGzipConvertErrFromZlib(pThis, rc);
+    }
+
+    RTVfsIoStrmRelease(pThis->hVfsIos);
+    pThis->hVfsIos = NIL_RTVFSIOSTREAM;
+    RTStrFree(pThis->pszOrgName);
+    pThis->pszOrgName = NULL;
+    RTStrFree(pThis->pszComment);
+    pThis->pszComment = NULL;
+
+    return rc;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSOBJOPS,pfnQueryInfo}
+ */
+static DECLCALLBACK(int) rtZipGzip_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
+{
+    PRTZIPGZIPSTREAM pThis = (PRTZIPGZIPSTREAM)pvThis;
+    return RTVfsIoStrmQueryInfo(pThis->hVfsIos, pObjInfo, enmAddAttr);
+}
+
+
+/**
+ * Reads one segment.
+ *
+ * @returns IPRT status code.
+ * @param   pThis           The gzip I/O stream instance data.
+ * @param   pvBuf           Where to put the read bytes.
+ * @param   cbToRead        The number of bytes to read.
+ * @param   fBlocking       Whether to block or not.
+ * @param   pcbRead         Where to store the number of bytes actually read.
+ */
+static int rtZipGzip_ReadOneSeg(PRTZIPGZIPSTREAM pThis, void *pvBuf, size_t cbToRead, bool fBlocking, size_t *pcbRead)
+{
+    /*
+     * This simplifies life a wee bit below.
+     */
+    if (pThis->fEndOfStream)
+        return pcbRead ? VINF_EOF : VERR_EOF;
+
+    /*
+     * Set up the output buffer.
+     */
+    pThis->Zlib.next_out  = (Bytef *)pvBuf;
+    pThis->Zlib.avail_out = (uInt)cbToRead;
+    AssertReturn(pThis->Zlib.avail_out == cbToRead, VERR_OUT_OF_RANGE);
+
+    /*
+     * Be greedy reading input, even if no output buffer is left. It's possible
+     * that it's just the end of stream marker which needs to be read. Happens
+     * for incompressible blocks just larger than the input buffer size.
+     */
+    int rc = VINF_SUCCESS;
+    while (   pThis->Zlib.avail_out > 0
+           || pThis->Zlib.avail_in == 0 /* greedy */)
+    {
+        /*
+         * Read more input?
+         *
+         * N.B. The assertions here validate the RTVfsIoStrmSgRead behavior
+         *      since the API is new and untested.  They could be removed later
+         *      but, better leaving them in.
+         */
+        if (pThis->Zlib.avail_in == 0)
+        {
+            size_t cbReadIn = ~(size_t)0;
+            rc = RTVfsIoStrmSgRead(pThis->hVfsIos, -1 /*off*/, &pThis->SgBuf, fBlocking, &cbReadIn);
+            if (rc != VINF_SUCCESS)
+            {
+                AssertMsg(RT_FAILURE(rc) || rc == VINF_TRY_AGAIN || rc == VINF_EOF, ("%Rrc\n", rc));
+                if (rc == VERR_INTERRUPTED)
+                {
+                    Assert(cbReadIn == 0);
+                    continue;
+                }
+                if (RT_FAILURE(rc) || rc == VINF_TRY_AGAIN || cbReadIn == 0)
+                {
+                    Assert(cbReadIn == 0);
+                    break;
+                }
+                AssertMsg(rc == VINF_EOF, ("%Rrc\n", rc));
+            }
+            AssertMsgBreakStmt(cbReadIn > 0 && cbReadIn <= sizeof(pThis->abBuffer), ("%zu %Rrc\n", cbReadIn, rc),
+                               rc = VERR_INTERNAL_ERROR_4);
+
+            pThis->Zlib.avail_in = (uInt)cbReadIn;
+            pThis->Zlib.next_in  = &pThis->abBuffer[0];
+        }
+
+        /*
+         * Pass it on to zlib.
+         */
+        rc = inflate(&pThis->Zlib, Z_NO_FLUSH);
+        if (rc != Z_OK && rc != Z_BUF_ERROR)
+        {
+            if (rc == Z_STREAM_END)
+            {
+                pThis->fEndOfStream = true;
+                if (pThis->Zlib.avail_out == 0)
+                    rc = VINF_SUCCESS;
+                else
+                    rc = pcbRead ? VINF_EOF : VERR_EOF;
+            }
+            else
+                rc = rtZipGzipConvertErrFromZlib(pThis, rc);
+            break;
+        }
+        rc = VINF_SUCCESS;
+    }
+
+    /*
+     * Update the read counters before returning.
+     */
+    size_t const cbRead = cbToRead - pThis->Zlib.avail_out;
+    pThis->offStream += cbRead;
+    if (pcbRead)
+        *pcbRead      = cbRead;
+
+    return rc;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSIOSTREAMOPS,pfnRead}
+ */
+static DECLCALLBACK(int) rtZipGzip_Read(void *pvThis, RTFOFF off, PCRTSGBUF pSgBuf, bool fBlocking, size_t *pcbRead)
+{
+    PRTZIPGZIPSTREAM pThis = (PRTZIPGZIPSTREAM)pvThis;
+
+    Assert(pSgBuf->cSegs == 1);
+    if (!pThis->fDecompress)
+        return VERR_ACCESS_DENIED;
+    AssertReturn(off == -1 || off == pThis->offStream , VERR_INVALID_PARAMETER);
+
+    return rtZipGzip_ReadOneSeg(pThis, pSgBuf->paSegs[0].pvSeg, pSgBuf->paSegs[0].cbSeg, fBlocking, pcbRead);
+}
+
+
+/**
+ * Internal helper for rtZipGzip_Write, rtZipGzip_Flush and rtZipGzip_Close.
+ *
+ * @returns IPRT status code.
+ * @retval  VINF_SUCCESS
+ * @retval  VINF_TRY_AGAIN - the only informational status.
+ * @retval  VERR_INTERRUPTED - call again.
+ *
+ * @param   pThis           The gzip I/O stream instance data.
+ * @param   fBlocking       Whether to block or not.
+ */
+static int rtZipGzip_WriteOutputBuffer(PRTZIPGZIPSTREAM pThis, bool fBlocking)
+{
+    /*
+     * Anything to write?  No, then just return immediately.
+     */
+    size_t cbToWrite = sizeof(pThis->abBuffer) - pThis->Zlib.avail_out;
+    if (cbToWrite == 0)
+    {
+        Assert(pThis->Zlib.next_out == &pThis->abBuffer[0]);
+        return VINF_SUCCESS;
+    }
+    Assert(cbToWrite <= sizeof(pThis->abBuffer));
+
+    /*
+     * Loop write on VERR_INTERRUPTED.
+     *
+     * Note! Asserting a bit extra here to make sure the
+     *       RTVfsIoStrmSgWrite works correctly.
+     */
+    int    rc;
+    size_t cbWrittenOut;
+    for (;;)
+    {
+        /* Set up the buffer. */
+        pThis->SgSeg.cbSeg = cbToWrite;
+        Assert(pThis->SgSeg.pvSeg == &pThis->abBuffer[0]);
+        RTSgBufReset(&pThis->SgBuf);
+
+        cbWrittenOut = ~(size_t)0;
+        rc = RTVfsIoStrmSgWrite(pThis->hVfsIos, -1 /*off*/, &pThis->SgBuf, fBlocking, &cbWrittenOut);
+        if (rc != VINF_SUCCESS)
+        {
+            AssertMsg(RT_FAILURE(rc) || rc == VINF_TRY_AGAIN, ("%Rrc\n", rc));
+            if (rc == VERR_INTERRUPTED)
+            {
+                Assert(cbWrittenOut == 0);
+                continue;
+            }
+            if (RT_FAILURE(rc) || rc == VINF_TRY_AGAIN || cbWrittenOut == 0)
+            {
+                AssertReturn(cbWrittenOut == 0, VERR_INTERNAL_ERROR_3);
+                AssertReturn(rc != VINF_SUCCESS, VERR_IPE_UNEXPECTED_INFO_STATUS);
+                return rc;
+            }
+        }
+        break;
+    }
+    AssertMsgReturn(cbWrittenOut > 0 && cbWrittenOut <= sizeof(pThis->abBuffer),
+                    ("%zu %Rrc\n", cbWrittenOut, rc),
+                    VERR_INTERNAL_ERROR_4);
+
+    /*
+     * Adjust the Zlib output buffer members.
+     */
+    if (cbWrittenOut == pThis->SgBuf.paSegs[0].cbSeg)
+    {
+        pThis->Zlib.avail_out = sizeof(pThis->abBuffer);
+        pThis->Zlib.next_out  = &pThis->abBuffer[0];
+    }
+    else
+    {
+        Assert(cbWrittenOut <= pThis->SgBuf.paSegs[0].cbSeg);
+        size_t cbLeft = pThis->SgBuf.paSegs[0].cbSeg - cbWrittenOut;
+        memmove(&pThis->abBuffer[0], &pThis->abBuffer[cbWrittenOut], cbLeft);
+        pThis->Zlib.avail_out += (uInt)cbWrittenOut;
+        pThis->Zlib.next_out  = &pThis->abBuffer[cbWrittenOut];
+    }
+
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * Processes all available input.
+ *
+ * @returns IPRT status code.
+ *
+ * @param   pThis           The gzip I/O stream instance data.
+ * @param   fBlocking       Whether to block or not.
+ */
+static int rtZipGzip_CompressIt(PRTZIPGZIPSTREAM pThis, bool fBlocking)
+{
+    /*
+     * Processes all the intput currently lined up for us.
+     */
+    while (pThis->Zlib.avail_in > 0)
+    {
+        /* Make sure there is some space in the output buffer before calling
+           deflate() so we don't waste time filling up the corners. */
+        static const size_t s_cbFlushThreshold = 4096;
+        AssertCompile(sizeof(pThis->abBuffer) >= s_cbFlushThreshold * 4);
+        if (pThis->Zlib.avail_out < s_cbFlushThreshold)
+        {
+            int rc = rtZipGzip_WriteOutputBuffer(pThis, fBlocking);
+            if (rc != VINF_SUCCESS)
+                return rc;
+            Assert(pThis->Zlib.avail_out >= s_cbFlushThreshold);
+        }
+
+        int rcZlib = deflate(&pThis->Zlib, Z_NO_FLUSH);
+        if (rcZlib != Z_OK)
+            return rtZipGzipConvertErrFromZlib(pThis, rcZlib);
+    }
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSIOSTREAMOPS,pfnWrite}
+ */
+static DECLCALLBACK(int) rtZipGzip_Write(void *pvThis, RTFOFF off, PCRTSGBUF pSgBuf, bool fBlocking, size_t *pcbWritten)
+{
+    PRTZIPGZIPSTREAM pThis = (PRTZIPGZIPSTREAM)pvThis;
+
+    Assert(pSgBuf->cSegs == 1); NOREF(fBlocking);
+    if (pThis->fDecompress)
+        return VERR_ACCESS_DENIED;
+    AssertReturn(off == -1 || off == pThis->offStream , VERR_INVALID_PARAMETER);
+
+    /*
+     * Write out the input buffer. Using a loop here because of potential
+     * integer type overflow since avail_in is uInt and cbSeg is size_t.
+     */
+    int             rc        = VINF_SUCCESS;
+    size_t          cbWritten = 0;
+    uint8_t const  *pbSrc     = (uint8_t const *)pSgBuf->paSegs[0].pvSeg;
+    size_t          cbLeft    = pSgBuf->paSegs[0].cbSeg;
+    if (cbLeft > 0)
+        for (;;)
+        {
+            size_t cbThis = cbLeft < ~(uInt)0 ? cbLeft : ~(uInt)0 / 2;
+            pThis->Zlib.next_in  = (Bytef * )pbSrc;
+            pThis->Zlib.avail_in = (uInt)cbThis;
+            rc = rtZipGzip_CompressIt(pThis, fBlocking);
+
+            Assert(cbThis >= pThis->Zlib.avail_in);
+            cbThis -= pThis->Zlib.avail_in;
+            cbWritten += cbThis;
+            if (cbLeft == cbThis || rc != VINF_SUCCESS)
+                break;
+            pbSrc  += cbThis;
+            cbLeft -= cbThis;
+        }
+
+    pThis->offStream += cbWritten;
+    if (pcbWritten)
+        *pcbWritten = cbWritten;
+    return rc;
+}
+
+
+/**
+ * Processes all available input.
+ *
+ * @returns IPRT status code.
+ *
+ * @param   pThis           The gzip I/O stream instance data.
+ * @param   fFlushType      The flush type to pass to deflate().
+ */
+static int rtZipGzip_FlushIt(PRTZIPGZIPSTREAM pThis, uint8_t fFlushType)
+{
+    /*
+     * Tell Zlib to flush until it stops producing more output.
+     */
+    int rc;
+    bool fMaybeMore = true;
+    for (;;)
+    {
+        /* Write the entire output buffer. */
+        do
+        {
+            rc = rtZipGzip_WriteOutputBuffer(pThis, true /*fBlocking*/);
+            if (RT_FAILURE(rc))
+                return rc;
+            Assert(rc == VINF_SUCCESS);
+        } while (pThis->Zlib.avail_out < sizeof(pThis->abBuffer));
+
+        if (!fMaybeMore)
+            return VINF_SUCCESS;
+
+        /* Do the flushing. */
+        pThis->Zlib.next_in  = NULL;
+        pThis->Zlib.avail_in = 0;
+        int rcZlib = deflate(&pThis->Zlib, fFlushType);
+        if (rcZlib == Z_OK)
+            fMaybeMore = pThis->Zlib.avail_out < 64 || fFlushType == Z_FINISH;
+        else if (rcZlib == Z_STREAM_END)
+            fMaybeMore = false;
+        else
+        {
+            rtZipGzip_WriteOutputBuffer(pThis, true /*fBlocking*/);
+            return rtZipGzipConvertErrFromZlib(pThis, rcZlib);
+        }
+    }
+}
+
+
+/**
+ * @interface_method_impl{RTVFSIOSTREAMOPS,pfnFlush}
+ */
+static DECLCALLBACK(int) rtZipGzip_Flush(void *pvThis)
+{
+    PRTZIPGZIPSTREAM pThis = (PRTZIPGZIPSTREAM)pvThis;
+    if (!pThis->fDecompress)
+    {
+        int rc = rtZipGzip_FlushIt(pThis, Z_SYNC_FLUSH);
+        if (RT_FAILURE(rc))
+            return rc;
+    }
+
+    return RTVfsIoStrmFlush(pThis->hVfsIos);
+}
+
+
+/**
+ * @interface_method_impl{RTVFSIOSTREAMOPS,pfnPollOne}
+ */
+static DECLCALLBACK(int) rtZipGzip_PollOne(void *pvThis, uint32_t fEvents, RTMSINTERVAL cMillies, bool fIntr,
+                                           uint32_t *pfRetEvents)
+{
+    PRTZIPGZIPSTREAM pThis = (PRTZIPGZIPSTREAM)pvThis;
+
+    /*
+     * Collect our own events first and see if that satisfies the request.  If
+     * not forward the call to the compressed stream.
+     */
+    uint32_t fRetEvents = 0;
+    if (pThis->fFatalError)
+        fRetEvents |= RTPOLL_EVT_ERROR;
+    if (pThis->fDecompress)
+    {
+        fEvents &= ~RTPOLL_EVT_WRITE;
+        if (pThis->Zlib.avail_in > 0)
+            fRetEvents = RTPOLL_EVT_READ;
+    }
+    else
+    {
+        fEvents &= ~RTPOLL_EVT_READ;
+        if (pThis->Zlib.avail_out > 0)
+            fRetEvents = RTPOLL_EVT_WRITE;
+    }
+
+    int rc = VINF_SUCCESS;
+    fRetEvents &= fEvents;
+    if (!fRetEvents)
+        rc = RTVfsIoStrmPoll(pThis->hVfsIos, fEvents, cMillies, fIntr, pfRetEvents);
+    return rc;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSIOSTREAMOPS,pfnTell}
+ */
+static DECLCALLBACK(int) rtZipGzip_Tell(void *pvThis, PRTFOFF poffActual)
+{
+    PRTZIPGZIPSTREAM pThis = (PRTZIPGZIPSTREAM)pvThis;
+    *poffActual = pThis->offStream;
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * The GZIP I/O stream vtable.
+ */
+static RTVFSIOSTREAMOPS g_rtZipGzipOps =
+{
+    { /* Obj */
+        RTVFSOBJOPS_VERSION,
+        RTVFSOBJTYPE_IO_STREAM,
+        "gzip",
+        rtZipGzip_Close,
+        rtZipGzip_QueryInfo,
+        NULL,
+        RTVFSOBJOPS_VERSION
+    },
+    RTVFSIOSTREAMOPS_VERSION,
+    RTVFSIOSTREAMOPS_FEAT_NO_SG,
+    rtZipGzip_Read,
+    rtZipGzip_Write,
+    rtZipGzip_Flush,
+    rtZipGzip_PollOne,
+    rtZipGzip_Tell,
+    NULL /* Skip */,
+    NULL /*ZeroFill*/,
+    RTVFSIOSTREAMOPS_VERSION,
+};
+
+
+RTDECL(int) RTZipGzipDecompressIoStream(RTVFSIOSTREAM hVfsIosIn, uint32_t fFlags, PRTVFSIOSTREAM phVfsIosOut)
+{
+    AssertPtrReturn(hVfsIosIn, VERR_INVALID_HANDLE);
+    AssertReturn(!(fFlags & ~RTZIPGZIPDECOMP_F_ALLOW_ZLIB_HDR), VERR_INVALID_PARAMETER);
+    AssertPtrReturn(phVfsIosOut, VERR_INVALID_POINTER);
+
+    uint32_t cRefs = RTVfsIoStrmRetain(hVfsIosIn);
+    AssertReturn(cRefs != UINT32_MAX, VERR_INVALID_HANDLE);
+
+    /*
+     * Create the decompression I/O stream.
+     */
+    RTVFSIOSTREAM    hVfsIos;
+    PRTZIPGZIPSTREAM pThis;
+    int rc = RTVfsNewIoStream(&g_rtZipGzipOps, sizeof(RTZIPGZIPSTREAM), RTFILE_O_READ, NIL_RTVFS, NIL_RTVFSLOCK,
+                              &hVfsIos, (void **)&pThis);
+    if (RT_SUCCESS(rc))
+    {
+        pThis->hVfsIos      = hVfsIosIn;
+        pThis->offStream    = 0;
+        pThis->fDecompress  = true;
+        pThis->SgSeg.pvSeg  = &pThis->abBuffer[0];
+        pThis->SgSeg.cbSeg  = sizeof(pThis->abBuffer);
+        RTSgBufInit(&pThis->SgBuf, &pThis->SgSeg, 1);
+
+        memset(&pThis->Zlib, 0, sizeof(pThis->Zlib));
+        pThis->Zlib.opaque  = pThis;
+        rc = inflateInit2(&pThis->Zlib, MAX_WBITS | RT_BIT(5) /* autodetect gzip header */);
+        if (rc >= 0)
+        {
+            /*
+             * Read the gzip header from the input stream to check that it's
+             * a gzip stream as specified by the user.
+             *
+             * Note! Since we've told zlib to check for the gzip header, we
+             *       prebuffer what we read in the input buffer so it can
+             *       be handed on to zlib later on.
+             */
+            rc = RTVfsIoStrmRead(pThis->hVfsIos, pThis->abBuffer, sizeof(RTZIPGZIPHDR), true /*fBlocking*/, NULL /*pcbRead*/);
+            if (RT_SUCCESS(rc))
+            {
+                /* Validate the header and make a copy of it. */
+                PCRTZIPGZIPHDR pHdr = (PCRTZIPGZIPHDR)pThis->abBuffer;
+                if (   pHdr->bId1 == RTZIPGZIPHDR_ID1
+                    && pHdr->bId2 == RTZIPGZIPHDR_ID2
+                    && !(pHdr->fFlags & ~RTZIPGZIPHDR_FLG_VALID_MASK))
+                {
+                    if (pHdr->bCompressionMethod == RTZIPGZIPHDR_CM_DEFLATE)
+                        rc = VINF_SUCCESS;
+                    else
+                        rc = VERR_ZIP_UNSUPPORTED_METHOD;
+                }
+                else if (   (fFlags & RTZIPGZIPDECOMP_F_ALLOW_ZLIB_HDR)
+                         && (RT_MAKE_U16(pHdr->bId2, pHdr->bId1) % 31) == 0
+                         && (pHdr->bId1 & 0xf) == RTZIPGZIPHDR_CM_DEFLATE )
+                {
+                    pHdr = NULL;
+                    rc = VINF_SUCCESS;
+                }
+                else
+                    rc = VERR_ZIP_BAD_HEADER;
+                if (RT_SUCCESS(rc))
+                {
+                    pThis->Zlib.avail_in = sizeof(RTZIPGZIPHDR);
+                    pThis->Zlib.next_in  = &pThis->abBuffer[0];
+                    if (pHdr)
+                    {
+                        pThis->Hdr = *pHdr;
+                        /* Parse on if there are names or comments. */
+                        if (pHdr->fFlags & (RTZIPGZIPHDR_FLG_NAME | RTZIPGZIPHDR_FLG_COMMENT))
+                        {
+                            /** @todo Can implement this when someone needs the
+                             *        name or comment for something useful. */
+                        }
+                    }
+                    if (RT_SUCCESS(rc))
+                    {
+                        *phVfsIosOut = hVfsIos;
+                        return VINF_SUCCESS;
+                    }
+                }
+            }
+        }
+        else
+            rc = rtZipGzipConvertErrFromZlib(pThis, rc); /** @todo cleaning up in this situation is going to go wrong. */
+        RTVfsIoStrmRelease(hVfsIos);
+    }
+    else
+        RTVfsIoStrmRelease(hVfsIosIn);
+    return rc;
+}
+
+
+RTDECL(int) RTZipGzipCompressIoStream(RTVFSIOSTREAM hVfsIosDst, uint32_t fFlags, uint8_t uLevel, PRTVFSIOSTREAM phVfsIosZip)
+{
+    AssertPtrReturn(hVfsIosDst, VERR_INVALID_HANDLE);
+    AssertReturn(!fFlags, VERR_INVALID_PARAMETER);
+    AssertPtrReturn(phVfsIosZip, VERR_INVALID_POINTER);
+    AssertReturn(uLevel > 0 && uLevel <= 9, VERR_INVALID_PARAMETER);
+
+    uint32_t cRefs = RTVfsIoStrmRetain(hVfsIosDst);
+    AssertReturn(cRefs != UINT32_MAX, VERR_INVALID_HANDLE);
+
+    /*
+     * Create the compression I/O stream.
+     */
+    RTVFSIOSTREAM    hVfsIos;
+    PRTZIPGZIPSTREAM pThis;
+    int rc = RTVfsNewIoStream(&g_rtZipGzipOps, sizeof(RTZIPGZIPSTREAM), RTFILE_O_WRITE, NIL_RTVFS, NIL_RTVFSLOCK,
+                              &hVfsIos, (void **)&pThis);
+    if (RT_SUCCESS(rc))
+    {
+        pThis->hVfsIos      = hVfsIosDst;
+        pThis->offStream    = 0;
+        pThis->fDecompress  = false;
+        pThis->SgSeg.pvSeg  = &pThis->abBuffer[0];
+        pThis->SgSeg.cbSeg  = sizeof(pThis->abBuffer);
+        RTSgBufInit(&pThis->SgBuf, &pThis->SgSeg, 1);
+
+        RT_ZERO(pThis->Zlib);
+        pThis->Zlib.opaque    = pThis;
+        pThis->Zlib.next_out  = &pThis->abBuffer[0];
+        pThis->Zlib.avail_out = sizeof(pThis->abBuffer);
+
+        rc = deflateInit2(&pThis->Zlib,
+                          uLevel,
+                          Z_DEFLATED,
+                          15 /* Windows Size */ + 16 /* GZIP header */,
+                          9 /* Max memory level for optimal speed */,
+                          Z_DEFAULT_STRATEGY);
+
+        if (rc >= 0)
+        {
+            *phVfsIosZip = hVfsIos;
+            return VINF_SUCCESS;
+        }
+
+        rc = rtZipGzipConvertErrFromZlib(pThis, rc); /** @todo cleaning up in this situation is going to go wrong. */
+        RTVfsIoStrmRelease(hVfsIos);
+    }
+    else
+        RTVfsIoStrmRelease(hVfsIosDst);
+    return rc;
+}
+
+
+
+/**
+ * @interface_method_impl{RTVFSCHAINELEMENTREG,pfnValidate}
+ */
+static DECLCALLBACK(int) rtVfsChainGunzip_Validate(PCRTVFSCHAINELEMENTREG pProviderReg, PRTVFSCHAINSPEC pSpec,
+                                                   PRTVFSCHAINELEMSPEC pElement, uint32_t *poffError, PRTERRINFO pErrInfo)
+{
+    RT_NOREF(pProviderReg, poffError, pErrInfo);
+
+    if (pElement->enmType != RTVFSOBJTYPE_IO_STREAM)
+        return VERR_VFS_CHAIN_ONLY_IOS;
+    if (pElement->enmTypeIn == RTVFSOBJTYPE_INVALID)
+        return VERR_VFS_CHAIN_CANNOT_BE_FIRST_ELEMENT;
+    if (   pElement->enmTypeIn != RTVFSOBJTYPE_FILE
+        && pElement->enmTypeIn != RTVFSOBJTYPE_IO_STREAM)
+        return VERR_VFS_CHAIN_TAKES_FILE_OR_IOS;
+    if (pSpec->fOpenFile & RTFILE_O_WRITE)
+        return VERR_VFS_CHAIN_READ_ONLY_IOS;
+    if (pElement->cArgs != 0)
+        return VERR_VFS_CHAIN_NO_ARGS;
+
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSCHAINELEMENTREG,pfnInstantiate}
+ */
+static DECLCALLBACK(int) rtVfsChainGunzip_Instantiate(PCRTVFSCHAINELEMENTREG pProviderReg, PCRTVFSCHAINSPEC pSpec,
+                                                      PCRTVFSCHAINELEMSPEC pElement, RTVFSOBJ hPrevVfsObj,
+                                                      PRTVFSOBJ phVfsObj, uint32_t *poffError, PRTERRINFO pErrInfo)
+{
+    RT_NOREF(pProviderReg, pSpec, pElement, poffError, pErrInfo);
+    AssertReturn(hPrevVfsObj != NIL_RTVFSOBJ, VERR_VFS_CHAIN_IPE);
+
+    RTVFSIOSTREAM hVfsIosIn = RTVfsObjToIoStream(hPrevVfsObj);
+    if (hVfsIosIn == NIL_RTVFSIOSTREAM)
+        return VERR_VFS_CHAIN_CAST_FAILED;
+
+    RTVFSIOSTREAM hVfsIos = NIL_RTVFSIOSTREAM;
+    int rc = RTZipGzipDecompressIoStream(hVfsIosIn, 0 /*fFlags*/, &hVfsIos);
+    RTVfsObjFromIoStream(hVfsIosIn);
+    if (RT_SUCCESS(rc))
+    {
+        *phVfsObj = RTVfsObjFromIoStream(hVfsIos);
+        RTVfsIoStrmRelease(hVfsIos);
+        if (*phVfsObj != NIL_RTVFSOBJ)
+            return VINF_SUCCESS;
+        rc = VERR_VFS_CHAIN_CAST_FAILED;
+    }
+    return rc;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSCHAINELEMENTREG,pfnCanReuseElement}
+ */
+static DECLCALLBACK(bool) rtVfsChainGunzip_CanReuseElement(PCRTVFSCHAINELEMENTREG pProviderReg,
+                                                           PCRTVFSCHAINSPEC pSpec, PCRTVFSCHAINELEMSPEC pElement,
+                                                           PCRTVFSCHAINSPEC pReuseSpec, PCRTVFSCHAINELEMSPEC pReuseElement)
+{
+    RT_NOREF(pProviderReg, pSpec, pElement, pReuseSpec, pReuseElement);
+    return false;
+}
+
+
+/** VFS chain element 'gunzip'. */
+static RTVFSCHAINELEMENTREG g_rtVfsChainGunzipReg =
+{
+    /* uVersion = */            RTVFSCHAINELEMENTREG_VERSION,
+    /* fReserved = */           0,
+    /* pszName = */             "gunzip",
+    /* ListEntry = */           { NULL, NULL },
+    /* pszHelp = */             "Takes an I/O stream and gunzips it. No arguments.",
+    /* pfnValidate = */         rtVfsChainGunzip_Validate,
+    /* pfnInstantiate = */      rtVfsChainGunzip_Instantiate,
+    /* pfnCanReuseElement = */  rtVfsChainGunzip_CanReuseElement,
+    /* uEndMarker = */          RTVFSCHAINELEMENTREG_VERSION
+};
+
+RTVFSCHAIN_AUTO_REGISTER_ELEMENT_PROVIDER(&g_rtVfsChainGunzipReg, rtVfsChainGunzipReg);
+
+
+
+/**
+ * @interface_method_impl{RTVFSCHAINELEMENTREG,pfnValidate}
+ */
+static DECLCALLBACK(int) rtVfsChainGzip_Validate(PCRTVFSCHAINELEMENTREG pProviderReg, PRTVFSCHAINSPEC pSpec,
+                                                 PRTVFSCHAINELEMSPEC pElement, uint32_t *poffError, PRTERRINFO pErrInfo)
+{
+    RT_NOREF(pProviderReg);
+
+    /*
+     * Basics.
+     */
+    if (pElement->enmType != RTVFSOBJTYPE_IO_STREAM)
+        return VERR_VFS_CHAIN_ONLY_IOS;
+    if (pElement->enmTypeIn == RTVFSOBJTYPE_INVALID)
+        return VERR_VFS_CHAIN_CANNOT_BE_FIRST_ELEMENT;
+    if (   pElement->enmTypeIn != RTVFSOBJTYPE_FILE
+        && pElement->enmTypeIn != RTVFSOBJTYPE_IO_STREAM)
+        return VERR_VFS_CHAIN_TAKES_FILE_OR_IOS;
+    if (pSpec->fOpenFile & RTFILE_O_READ)
+        return VERR_VFS_CHAIN_WRITE_ONLY_IOS;
+    if (pElement->cArgs > 1)
+        return VERR_VFS_CHAIN_AT_MOST_ONE_ARG;
+
+    /*
+     * Optional argument 1..9 indicating the compression level.
+     * We store it in pSpec->uProvider.
+     */
+    if (pElement->cArgs > 0)
+    {
+        const char *psz = pElement->paArgs[0].psz;
+        if (!*psz || !strcmp(psz, "default"))
+            pElement->uProvider = 6;
+        else if (!strcmp(psz, "fast"))
+            pElement->uProvider = 3;
+        else if (   RT_C_IS_DIGIT(*psz)
+                 && *psz != '0'
+                 && *RTStrStripL(psz + 1) == '\0')
+            pElement->uProvider = *psz - '0';
+        else
+        {
+            *poffError = pElement->paArgs[0].offSpec;
+            return RTErrInfoSet(pErrInfo, VERR_VFS_CHAIN_INVALID_ARGUMENT, "Expected compression level: 1-9, default, or fast");
+        }
+    }
+    else
+        pElement->uProvider = 6;
+
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSCHAINELEMENTREG,pfnInstantiate}
+ */
+static DECLCALLBACK(int) rtVfsChainGzip_Instantiate(PCRTVFSCHAINELEMENTREG pProviderReg, PCRTVFSCHAINSPEC pSpec,
+                                                    PCRTVFSCHAINELEMSPEC pElement, RTVFSOBJ hPrevVfsObj,
+                                                    PRTVFSOBJ phVfsObj, uint32_t *poffError, PRTERRINFO pErrInfo)
+{
+    RT_NOREF(pProviderReg, pSpec, pElement, poffError, pErrInfo);
+    AssertReturn(hPrevVfsObj != NIL_RTVFSOBJ, VERR_VFS_CHAIN_IPE);
+
+    RTVFSIOSTREAM hVfsIosOut = RTVfsObjToIoStream(hPrevVfsObj);
+    if (hVfsIosOut == NIL_RTVFSIOSTREAM)
+        return VERR_VFS_CHAIN_CAST_FAILED;
+
+    RTVFSIOSTREAM hVfsIos = NIL_RTVFSIOSTREAM;
+    int rc = RTZipGzipCompressIoStream(hVfsIosOut, 0 /*fFlags*/, pElement->uProvider, &hVfsIos);
+    RTVfsObjFromIoStream(hVfsIosOut);
+    if (RT_SUCCESS(rc))
+    {
+        *phVfsObj = RTVfsObjFromIoStream(hVfsIos);
+        RTVfsIoStrmRelease(hVfsIos);
+        if (*phVfsObj != NIL_RTVFSOBJ)
+            return VINF_SUCCESS;
+        rc = VERR_VFS_CHAIN_CAST_FAILED;
+    }
+    return rc;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSCHAINELEMENTREG,pfnCanReuseElement}
+ */
+static DECLCALLBACK(bool) rtVfsChainGzip_CanReuseElement(PCRTVFSCHAINELEMENTREG pProviderReg,
+                                                         PCRTVFSCHAINSPEC pSpec, PCRTVFSCHAINELEMSPEC pElement,
+                                                         PCRTVFSCHAINSPEC pReuseSpec, PCRTVFSCHAINELEMSPEC pReuseElement)
+{
+    RT_NOREF(pProviderReg, pSpec, pElement, pReuseSpec, pReuseElement);
+    return false;
+}
+
+
+/** VFS chain element 'gzip'. */
+static RTVFSCHAINELEMENTREG g_rtVfsChainGzipReg =
+{
+    /* uVersion = */            RTVFSCHAINELEMENTREG_VERSION,
+    /* fReserved = */           0,
+    /* pszName = */             "gzip",
+    /* ListEntry = */           { NULL, NULL },
+    /* pszHelp = */             "Takes an I/O stream and gzips it.\n"
+                                "Optional argument specifying compression level: 1-9, default, fast",
+    /* pfnValidate = */         rtVfsChainGzip_Validate,
+    /* pfnInstantiate = */      rtVfsChainGzip_Instantiate,
+    /* pfnCanReuseElement = */  rtVfsChainGzip_CanReuseElement,
+    /* uEndMarker = */          RTVFSCHAINELEMENTREG_VERSION
+};
+
+RTVFSCHAIN_AUTO_REGISTER_ELEMENT_PROVIDER(&g_rtVfsChainGzipReg, rtVfsChainGzipReg);
+
diff --git a/src/VBox/Runtime/common/zip/pkzip.cpp b/src/VBox/Runtime/common/zip/pkzip.cpp
new file mode 100644
index 00000000..fbee651b
--- /dev/null
+++ b/src/VBox/Runtime/common/zip/pkzip.cpp
@@ -0,0 +1,259 @@
+/* $Id: pkzip.cpp $ */
+/** @file
+ * IPRT - PKZIP archive I/O.
+ */
+
+/*
+ * Copyright (C) 2014-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * The contents of this file may alternatively be used under the terms
+ * of the Common Development and Distribution License Version 1.0
+ * (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
+ * in the VirtualBox distribution, in which case the provisions of the
+ * CDDL are applicable instead of those of the GPL.
+ *
+ * You may elect to license modified versions of this file under the
+ * terms and conditions of either the GPL or the CDDL or both.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#include <iprt/zip.h>
+
+#include <iprt/file.h>
+#include <iprt/err.h>
+#include <iprt/fs.h>
+#include <iprt/mem.h>
+#include <iprt/string.h>
+#include <iprt/vfs.h>
+#include <iprt/vfslowlevel.h>
+
+
+/*********************************************************************************************************************************
+*   Structures and Typedefs                                                                                                      *
+*********************************************************************************************************************************/
+/**
+ * Memory stream private data.
+ */
+typedef struct MEMIOSTREAM
+{
+    /** Size of the memory buffer. */
+    size_t      cbBuf;
+    /** Pointer to the memory buffer. */
+    uint8_t     *pu8Buf;
+    /** Current offset. */
+    size_t      off;
+} MEMIOSTREAM;
+typedef MEMIOSTREAM *PMEMIOSTREAM;
+
+
+/**
+ * @interface_method_impl{RTVFSOBJOPS,pfnClose}
+ */
+static DECLCALLBACK(int) memFssIos_Close(void *pvThis)
+{
+    NOREF(pvThis);
+    return VINF_SUCCESS;
+}
+
+/**
+ * @interface_method_impl{RTVFSOBJOPS,pfnQueryInfo}
+ */
+static DECLCALLBACK(int) memFssIos_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
+{
+    PMEMIOSTREAM pThis = (PMEMIOSTREAM)pvThis;
+    switch (enmAddAttr)
+    {
+        case RTFSOBJATTRADD_NOTHING:
+        case RTFSOBJATTRADD_UNIX:
+            RT_ZERO(*pObjInfo);
+            pObjInfo->cbObject = pThis->cbBuf;
+            break;
+        default:
+            return VERR_NOT_SUPPORTED;
+    }
+    return VINF_SUCCESS;
+}
+
+/**
+ * @interface_method_impl{RTVFSIOSTREAMOPS,pfnRead}
+ */
+static DECLCALLBACK(int) memFssIos_Read(void *pvThis, RTFOFF off, PCRTSGBUF pSgBuf, bool fBlocking, size_t *pcbRead)
+{
+    PMEMIOSTREAM pThis = (PMEMIOSTREAM)pvThis;
+    Assert(pSgBuf->cSegs == 1);
+    RT_NOREF_PV(fBlocking);
+
+    if (off < 0)
+        off = pThis->off;
+    if (off >= (RTFOFF)pThis->cbBuf)
+        return pcbRead ? VINF_EOF : VERR_EOF;
+
+    size_t cbLeft = pThis->cbBuf - off;
+    size_t cbToRead = pSgBuf->paSegs[0].cbSeg;
+    if (cbToRead > cbLeft)
+    {
+        if (!pcbRead)
+            return VERR_EOF;
+        cbToRead = (size_t)cbLeft;
+    }
+
+    memcpy(pSgBuf->paSegs[0].pvSeg, pThis->pu8Buf + off, cbToRead);
+    pThis->off = off + cbToRead;
+    if (pcbRead)
+        *pcbRead = cbToRead;
+
+    return VINF_SUCCESS;
+}
+
+/**
+ * @interface_method_impl{RTVFSIOSTREAMOPS,pfnWrite}
+ */
+static DECLCALLBACK(int) memFssIos_Write(void *pvThis, RTFOFF off, PCRTSGBUF pSgBuf, bool fBlocking, size_t *pcbWritten)
+{
+    RT_NOREF_PV(pvThis); RT_NOREF_PV(off); RT_NOREF_PV(pSgBuf); RT_NOREF_PV(fBlocking); RT_NOREF_PV(pcbWritten);
+    return VERR_NOT_IMPLEMENTED;
+}
+
+/**
+ * @interface_method_impl{RTVFSIOSTREAMOPS,pfnFlush}
+ */
+static DECLCALLBACK(int) memFssIos_Flush(void *pvThis)
+{
+    RT_NOREF_PV(pvThis);
+    return VERR_NOT_IMPLEMENTED;
+}
+
+/**
+ * @interface_method_impl{RTVFSIOSTREAMOPS,pfnPollOne}
+ */
+static DECLCALLBACK(int) memFssIos_PollOne(void *pvThis, uint32_t fEvents, RTMSINTERVAL cMillies, bool fIntr, uint32_t *pfRetEvents)
+{
+    RT_NOREF_PV(pvThis); RT_NOREF_PV(fEvents); RT_NOREF_PV(cMillies); RT_NOREF_PV(fIntr); RT_NOREF_PV(pfRetEvents);
+    return VERR_NOT_IMPLEMENTED;
+}
+
+/**
+ * @interface_method_impl{RTVFSIOSTREAMOPS,pfnTell}
+ */
+static DECLCALLBACK(int) memFssIos_Tell(void *pvThis, PRTFOFF poffActual)
+{
+    PMEMIOSTREAM pThis = (PMEMIOSTREAM)pvThis;
+    *poffActual = pThis->off;
+    return VINF_SUCCESS;
+}
+
+/**
+ * Memory I/O object stream operations.
+ */
+static const RTVFSIOSTREAMOPS g_memFssIosOps =
+{
+    { /* Obj */
+        RTVFSOBJOPS_VERSION,
+        RTVFSOBJTYPE_IO_STREAM,
+        "MemFsStream::IoStream",
+        memFssIos_Close,
+        memFssIos_QueryInfo,
+        NULL,
+        RTVFSOBJOPS_VERSION
+    },
+    RTVFSIOSTREAMOPS_VERSION,
+    RTVFSIOSTREAMOPS_FEAT_NO_SG,
+    memFssIos_Read,
+    memFssIos_Write,
+    memFssIos_Flush,
+    memFssIos_PollOne,
+    memFssIos_Tell,
+    NULL /*Skip*/,
+    NULL /*ZeroFill*/,
+    RTVFSIOSTREAMOPS_VERSION
+};
+
+RTDECL(int) RTZipPkzipMemDecompress(void **ppvDst, size_t *pcbDst, const void *pvSrc, size_t cbSrc, const char *pszObject)
+{
+    PMEMIOSTREAM pIosData;
+    RTVFSIOSTREAM hVfsIos;
+    int rc = RTVfsNewIoStream(&g_memFssIosOps,
+                              sizeof(*pIosData),
+                              RTFILE_O_READ | RTFILE_O_DENY_WRITE | RTFILE_O_OPEN,
+                              NIL_RTVFS,
+                              NIL_RTVFSLOCK,
+                              &hVfsIos,
+                              (void **)&pIosData);
+    if (RT_SUCCESS(rc))
+    {
+        pIosData->pu8Buf = (uint8_t*)pvSrc;
+        pIosData->cbBuf  = cbSrc;
+        pIosData->off    = 0;
+        RTVFSFSSTREAM hVfsFss;
+        rc = RTZipPkzipFsStreamFromIoStream(hVfsIos, 0 /*fFlags*/, &hVfsFss);
+        RTVfsIoStrmRelease(hVfsIos);
+        if (RT_SUCCESS(rc))
+        {
+            /*
+             * Loop through all objects. Actually this wouldn't be required
+             * for .zip files but we opened it as I/O stream.
+             */
+            for (bool fFound = false; !fFound;)
+            {
+                char        *pszName;
+                RTVFSOBJ    hVfsObj;
+                rc = RTVfsFsStrmNext(hVfsFss, &pszName, NULL /*penmType*/, &hVfsObj);
+                if (RT_FAILURE(rc))
+                    break;
+                fFound = !strcmp(pszName, pszObject);
+                if (fFound)
+                {
+                    RTFSOBJINFO UnixInfo;
+                    rc = RTVfsObjQueryInfo(hVfsObj, &UnixInfo, RTFSOBJATTRADD_UNIX);
+                    if (RT_SUCCESS(rc))
+                    {
+                        size_t cb = UnixInfo.cbObject;
+                        void *pv = RTMemAlloc(cb);
+                        if (pv)
+                        {
+                            RTVFSIOSTREAM hVfsIosObj = RTVfsObjToIoStream(hVfsObj);
+                            if (hVfsIos != NIL_RTVFSIOSTREAM)
+                            {
+                                rc = RTVfsIoStrmRead(hVfsIosObj, pv, cb, true /*fBlocking*/, NULL);
+                                if (RT_SUCCESS(rc))
+                                {
+                                    *ppvDst = pv;
+                                    *pcbDst = cb;
+                                }
+                            }
+                            else
+                                rc = VERR_INTERNAL_ERROR_4;
+                            if (RT_FAILURE(rc))
+                                RTMemFree(pv);
+                        }
+                    }
+                }
+                RTVfsObjRelease(hVfsObj);
+                RTStrFree(pszName);
+            }
+            RTVfsFsStrmRelease(hVfsFss);
+        }
+    }
+    return rc;
+}
diff --git a/src/VBox/Runtime/common/zip/pkzipvfs.cpp b/src/VBox/Runtime/common/zip/pkzipvfs.cpp
new file mode 100644
index 00000000..5831687a
--- /dev/null
+++ b/src/VBox/Runtime/common/zip/pkzipvfs.cpp
@@ -0,0 +1,1296 @@
+/* $Id: pkzipvfs.cpp $ */
+/** @file
+ * IPRT - PKZIP Virtual Filesystem.
+ */
+
+/*
+ * Copyright (C) 2014-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * The contents of this file may alternatively be used under the terms
+ * of the Common Development and Distribution License Version 1.0
+ * (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
+ * in the VirtualBox distribution, in which case the provisions of the
+ * CDDL are applicable instead of those of the GPL.
+ *
+ * You may elect to license modified versions of this file under the
+ * terms and conditions of either the GPL or the CDDL or both.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#include <iprt/zip.h>
+#include <iprt/assert.h>
+#include <iprt/err.h>
+#include <iprt/file.h>
+#include <iprt/mem.h>
+#include <iprt/poll.h>
+#include <iprt/string.h>
+#include <iprt/vfs.h>
+#include <iprt/vfslowlevel.h>
+#include <iprt/stream.h>
+
+
+/*********************************************************************************************************************************
+*   Structures and Typedefs                                                                                                      *
+*********************************************************************************************************************************/
+/* See http://www.pkware.com/documents/casestudies/APPNOTE.TXT */
+
+/**
+ * PKZip Local File Header.
+ */
+#pragma pack(1)
+typedef struct RTZIPPKZIPLOCALFILEHDR
+{
+    /** Magic value, see RTZIPPKZIPLOCALFILEHDR_MAGIC. */
+    uint32_t                u32Magic;
+    /** Minimum version needed to extract. */
+    uint16_t                u16Version;
+    /** General purpose bit flag. */
+    uint16_t                fFlags;
+    /** Compression method. See RTZIPPKZIP_COMP_METHOD_XXX. */
+    uint16_t                u16ComprMethod;
+    /** Last modified time, MS-DOS format: HHHHHMMM MMMSSSSS, multiply seconds by 2 */
+    uint16_t                u16LastModifiedTime;
+    /** Last modified date, MS-DOS format: YYYYYYYM MMMDDDDD, year starts at 1980 */
+    uint16_t                u16LastModifiedDate;
+    /** Checksum. */
+    uint32_t                u32Crc;
+    /** Compressed size. */
+    uint32_t                cbCompressed;
+    /** Uncompressed size. */
+    uint32_t                cbUncompressed;
+    /** Length of the file name. */
+    uint16_t                cbFilename;
+    /** Length of the extra field. */
+    uint16_t                cbExtra;
+    /** Start of the file name. */
+    uint8_t                 u8Filename;
+} RTZIPPKZIPLOCALFILEHDR;
+#pragma pack()
+AssertCompileSize(RTZIPPKZIPLOCALFILEHDR, 30+1);
+/** Pointer to PKZip Local File Header. */
+typedef RTZIPPKZIPLOCALFILEHDR *PRTZIPPKZIPLOCALFILEHDR;
+
+#define RTZIPPKZIPLOCALFILEHDR_MAGIC        RT_MAKE_U32_FROM_U8('P','K','\003','\004')
+
+/**
+ * PKZip compression method.
+ */
+typedef enum RTZIPPKZIP_COMP_METHOD
+{
+    /** No compression */
+    RTZIPPKZIP_COMP_METHOD_STORED = 0,
+    /** Shrunk */
+    RTZIPPKZIP_COMP_METHOD_SHRUNK = 1,
+    /** Reduced with compression factor 1 */
+    RTZIPPKZIP_COMP_METHOD_REDUCED1 = 2,
+    /** Reduced with compression factor 2 */
+    RTZIPPKZIP_COMP_METHOD_REDUCED2 = 3,
+    /** Reduced with compression factor 3 */
+    RTZIPPKZIP_COMP_METHOD_REDUCED3 = 4,
+    /** Reduced with compression factor 4 */
+    RTZIPPKZIP_COMP_METHOD_REDUCED4 = 5,
+    /** Imploded */
+    RTZIPPKZIP_COMP_METHOD_IMPLODED = 6,
+    /** Deflated */
+    RTZIPPKZIP_COMP_METHOD_DEFLATED = 8,
+    /** Deflated64 */
+    RTZIPPKZIP_COMP_METHOD_DEFLATED64 = 9,
+    /* Compressed using bzip2 */
+    RTZIPPKZIP_COMP_METHOD_BZIP2 = 12,
+    /** Compressed using LZMA */
+    RTZIPPKZIP_COMP_METHOD_LZMA = 14
+} RTZIPPKZIP_COMP_METHOD;
+
+/**
+ * PKZip Central Directory Header.
+ */
+#pragma pack(1)
+typedef struct RTZIPPKZIPCENTRDIRHDR
+{
+    /** The magic value. See RTZIPPKZIPCENTRDIRHDR_MAGIC. */
+    uint32_t                u32Magic;
+    /** The version used for creating the item. */
+    uint16_t                u16VerMade;
+    /** The minimum version required for extracting the item. */
+    uint16_t                u16VerRequired;
+    /** General purpose flags. */
+    uint16_t                fFlags;
+    /** Compresstion method. See RTZIPPKZIP_COMP_METHOD_XXX */
+    uint16_t                u16ComprMethod;
+    /** Last modified time, MS-DOS format: HHHHHMMM MMMSSSSS, multiply seconds by 2 */
+    uint16_t                u16LastModifiedTime;
+    /** Last modified date, MS-DOS format: YYYYYYYM MMMDDDDD, year starts at 1980 */
+    uint16_t                u16LastModifiedDate;
+    /** Checksum. */
+    uint32_t                u32Crc;
+    /** Compressed size. */
+    uint32_t                cbCompressed;
+    /** Uncompressed size. */
+    uint32_t                cbUncompressed;
+    /** Length of the object file name. */
+    uint16_t                cbFilename;
+    /** Length of the extra field. */
+    uint16_t                cbExtra;
+    /** Length of the object comment. */
+    uint16_t                cbComment;
+    /** The number of the disk on which this file begins. */
+    uint16_t                iDiskStart;
+    /** Internal attributes. */
+    uint16_t                u16IntAttrib;
+    /** External attributes. */
+    uint32_t                u32ExtAttrib;
+    /** Offset from the start of the first disk on which this file appears to
+     * where the local file header should be found. */
+    uint32_t                offLocalFileHeader;
+    /** Start of the file name. */
+    uint8_t                 u8Filename;
+} RTZIPPKZIPCENTRDIRHDR;
+#pragma pack()
+AssertCompileSize(RTZIPPKZIPCENTRDIRHDR, 46+1);
+/** Pointer to the PKZip Central Directory Header. */
+typedef RTZIPPKZIPCENTRDIRHDR *PRTZIPPKZIPCENTRDIRHDR;
+
+#define RTZIPPKZIPCENTRDIRHDR_MAGIC         RT_MAKE_U32_FROM_U8('P','K','\001','\002')
+
+/**
+ * PKZip End of Central Directory Record.
+ */
+#pragma pack(1)
+typedef struct RTZIPPKZIPENDOFCENTRDIRREC
+{
+    /** The magic value. See RTZIPPKZIPENDOFCENTRDIRREC_MAGIC. */
+    uint32_t                u32Magic;
+    /** Number of this disk. */
+    uint16_t                iThisDisk;
+    /** Number of the disk with the start of the Central Directory. */
+    uint16_t                iDiskStartCentrDirectory;
+    /** Number of Central Directory entries on this disk. */
+    uint16_t                cCentrDirRecordsThisDisk;
+    /** Number of Central Directory records. */
+    uint16_t                cCentrDirRecords;
+    /** Size of the Central Directory in bytes. */
+    uint32_t                cbCentrDir;
+    /** Offset of the Central Directory. */
+    uint32_t                offCentrDir;
+    /** Size of the comment in bytes. */
+    uint16_t                cbComment;
+    /** Start of the comment. */
+    uint8_t                 u8Comment;
+} RTZIPPKZIPENDOFCENTRDIRREC;
+#pragma pack()
+AssertCompileSize(RTZIPPKZIPENDOFCENTRDIRREC, 22+1);
+/** Pointer to the PKZip End of Central Directory Record. */
+typedef RTZIPPKZIPENDOFCENTRDIRREC const *PCRTZIPPKZIPENDOFCENTRDIRREC;
+
+#define RTZIPPKZIPENDOFCENTRDIRREC_MAGIC    RT_MAKE_U32_FROM_U8('P','K','\005','\006')
+
+/**
+ * PKZip ZIP64 End of Central Directory Record.
+ */
+#pragma pack(1)
+typedef struct RTZIPPKZIP64ENDOFCENTRDIRREC
+{
+    /** The magic value. See RTZIPPKZIP64ENDOFCENTRDIRREC_MAGIC. */
+    uint32_t                u32Magic;
+    /** Size of Zip64 end of Central Directory Record. */
+    uint64_t                cbSizeEocdr;
+    /** The version used for creating the item. */
+    uint16_t                u16VerMade;
+    /** The minimum version required for extracting the item. */
+    uint16_t                u16VerRequired;
+    /** Number of this disk. */
+    uint32_t                iThisDisk;
+    /** Number of the disk with the start of the Central Directory. */
+    uint32_t                iDiskStartCentrDirectory;
+    /** Number of Central Directory entries on this disk. */
+    uint64_t                cCentrDirRecordsThisDisk;
+    /** Number of Central Directory records. */
+    uint64_t                cCentrDirRecords;
+    /** Size of the Central Directory in bytes. */
+    uint64_t                cbCentrDir;
+    /** Offset of the Central Directory. */
+    uint64_t                offCentrDir;
+} RTZIPPKZIP64ENDOFCENTRDIRREC;
+#pragma pack()
+AssertCompileSize(RTZIPPKZIP64ENDOFCENTRDIRREC, 56);
+/** Pointer to the 64-bit PKZip End of Central Directory Record. */
+typedef RTZIPPKZIP64ENDOFCENTRDIRREC *PRTZIPPKZIP64ENDOFCENTRDIRREC;
+
+#define RTZIPPKZIP64ENDOFCENTRDIRREC_MAGIC  RT_MAKE_U32_FROM_U8('P','K','\006','\006')
+
+/**
+ * PKZip ZIP64 End of Central Directory Locator.
+ */
+#pragma pack(1)
+typedef struct RTZIPPKZIP64ENDOFCENTRDIRLOC
+{
+    /** The magic value. See RTZIPPKZIP64ENDOFCENTRDIRLOC_MAGIC. */
+    uint32_t                u32Magic;
+    /** Number of the disk with the start of the ZIP64 End of Central Directory. */
+    uint32_t                iDiskStartCentrDir;
+    /** Relative offset of the ZIP64 End of Central Directory Record. */
+    uint64_t                offEndOfCentrDirRec;
+    /** Total number of disks. */
+    uint32_t                cDisks;
+} RTZIPPKZIP64ENDOFCENTRDIRLOC;
+#pragma pack()
+AssertCompileSize(RTZIPPKZIP64ENDOFCENTRDIRLOC, 20);
+
+#define RTZIPPKZIP64ENDOFCENTRDIRLOC_MAGIC  RT_MAKE_U32_FROM_U8('P','K','\006','\007')
+
+/**
+ * PKZip ZIP64 Extended Information Extra Field.
+ */
+#pragma pack(1)
+typedef struct RTZIPPKZIP64EXTRAFIELD
+{
+    /** Uncompressed size. */
+    uint64_t                cbUncompressed;
+    /** Compressed size. */
+    uint64_t                cbCompressed;
+    /** Offset from the start of the first disk on which this file appears to
+     * where the local file header should be found. */
+    uint64_t                offLocalFileHeader;
+    /** The number of the disk on which this file begins. */
+    uint32_t                iDiskStart;
+} RTZIPPKZIP64EXTRAFIELD;
+#pragma pack()
+/** Pointer to the ZIP64 Extended Information Extra Field. */
+typedef RTZIPPKZIP64EXTRAFIELD *PRTZIPPKZIP64EXTRAFIELD;
+AssertCompileSize(RTZIPPKZIP64EXTRAFIELD, 28);
+
+/**
+ * PKZip reader instance data.
+ */
+typedef struct RTZIPPKZIPREADER
+{
+    /** Set if we have the End of Central Directory record. */
+    bool                    fHaveEocd;
+    /** The Central Directory header. */
+    RTZIPPKZIPCENTRDIRHDR   cdh;
+    /** ZIP64 extended information. */
+    RTZIPPKZIP64EXTRAFIELD  cd64ex;
+    /** Set if ZIP64 End of Central Directory Locator is present (archive setting). */
+    bool                    fZip64Eocd;
+    /** Set if cd64ex is valid for the current file header (object setting). */
+    bool                    fZip64Ex;
+    /* The name of the current object. */
+    char                    szName[RTPATH_MAX];
+} RTZIPPKZIPREADER;
+/** Pointer to the PKZip reader instance data. */
+typedef RTZIPPKZIPREADER *PRTZIPPKZIPREADER;
+
+/**
+ * Pkzip object (directory).
+ */
+typedef struct RTZIPPKZIPBASEOBJ
+{
+    /** Pointer to the reader instance data (resides in the filesystem
+     * stream). */
+    PRTZIPPKZIPREADER       pPkzipReader;
+    /** The object info with unix attributes. */
+    RTFSOBJINFO             ObjInfo;
+} RTZIPPKZIPBASEOBJ;
+/** Pointer to a PKZIP filesystem stream base object. */
+typedef RTZIPPKZIPBASEOBJ *PRTZIPPKZIPBASEOBJ;
+
+/**
+ * Pkzip object (file) represented as a VFS I/O stream.
+ */
+typedef struct RTZIPPKZIPIOSTREAM
+{
+    /** The basic PKZIP object data. */
+    RTZIPPKZIPBASEOBJ       BaseObj;
+    /** The number of (uncompressed) bytes in the file. */
+    uint64_t                cbFile;
+    /** The current file position at uncompressed file data. */
+    uint64_t                offFile;
+    /** The start position of the compressed data in the hVfsIos. */
+    uint64_t                offCompStart;
+    /** The current position for decompressing bytes in the hVfsIos. */
+    uint64_t                offComp;
+    /** The number of compressed bytes starting at offCompStart. */
+    uint64_t                cbComp;
+    /** Set if we have to pass the type function the next time the input
+     * function is called. */
+    bool                    fPassZipType;
+    /** Set if we've reached the end of the file. */
+    bool                    fEndOfStream;
+    /** Pkzip compression method for this object. */
+    RTZIPPKZIP_COMP_METHOD  enmCompMethod;
+    /** Zip compression method. */
+    RTZIPTYPE               enmZipType;
+    /** The decompressor instance. */
+    PRTZIPDECOMP            pZip;
+    /** The input I/O stream. */
+    RTVFSIOSTREAM           hVfsIos;
+} RTZIPPKZIPIOSTREAM;
+/** Pointer to a the private data of a PKZIP file I/O stream. */
+typedef RTZIPPKZIPIOSTREAM *PRTZIPPKZIPIOSTREAM;
+
+
+/**
+ * PKZip filesystem stream private data. The stream must be seekable!
+ */
+typedef struct RTZIPPKZIPFSSTREAM
+{
+    /** The input I/O stream. */
+    RTVFSIOSTREAM           hVfsIos;
+
+    /** The current object (referenced). */
+    RTVFSOBJ                hVfsCurObj;
+    /** Pointer to the private data if hVfsCurObj is representing a file. */
+    PRTZIPPKZIPIOSTREAM     pCurIosData;
+
+    /** The offset of the first Central Directory header. */
+    uint64_t                offFirstCdh;
+    /** The offset of the next Central Directory header. */
+    uint64_t                offNextCdh;
+
+    /** Size of the central directory. */
+    uint64_t                cbCentrDir;
+    /** Current central directory entry. */
+    uint64_t                iCentrDirEntry;
+    /** Number of central directory entries. */
+    uint64_t                cCentrDirEntries;
+
+    /** Set if we have the End of Central Directory Record. */
+    bool                    fHaveEocd;
+    /** Set if we've reached the end of the stream. */
+    bool                    fEndOfStream;
+    /** Set if we've encountered a fatal error. */
+    int                     rcFatal;
+
+    /** The PKZIP reader instance data. */
+    RTZIPPKZIPREADER        PkzipReader;
+} RTZIPPKZIPFSSTREAM;
+/** Pointer to a the private data of a PKZIP filesystem stream. */
+typedef RTZIPPKZIPFSSTREAM *PRTZIPPKZIPFSSTREAM;
+
+
+
+/**
+ * Decode date/time from DOS format as used in PKZip.
+ */
+static int rtZipPkzipReaderDecodeDosTime(PRTTIMESPEC pTimeSpec, uint16_t u16Time, uint16_t u16Date)
+{
+    RTTIME time;
+    RT_ZERO(time);
+    time.i32Year    = ((u16Date & 0xfe00) >>  9) + 1980;
+    time.u8Month    =  (u16Date & 0x01e0) >>  5;
+    time.u8MonthDay =   u16Date & 0x001f;
+    time.u8Hour     =  (u16Time & 0xf800) >> 11;
+    time.u8Minute   =  (u16Time & 0x07e0) >>  5;
+    time.u8Second   =   u16Time & 0x001f;
+    RTTimeNormalize(&time);
+    RTTimeImplode(pTimeSpec, &time);
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * Parse the Local File Header.
+ * Just skip the data as we trust the Central Directory.
+ */
+static int rtZipPkzipParseLocalFileHeader(PRTZIPPKZIPREADER pThis, PRTZIPPKZIPLOCALFILEHDR pLfh, size_t *pcbExtra)
+{
+    RT_NOREF_PV(pThis);
+
+    if (pLfh->cbFilename >= sizeof(pThis->szName))
+        return VERR_PKZIP_NAME_TOO_LONG;
+
+    *pcbExtra = pLfh->cbFilename + pLfh->cbExtra;
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * Parse the Central Directory Header.
+ */
+static int rtZipPkzipParseCentrDirHeader(PRTZIPPKZIPREADER pThis, PRTZIPPKZIPCENTRDIRHDR pCdh, size_t *pcbExtra)
+{
+    if (pCdh->u32Magic != RTZIPPKZIPCENTRDIRHDR_MAGIC)
+        return VERR_PKZIP_BAD_CDF_HEADER;
+
+    if (pCdh->cbFilename >= sizeof(pThis->szName))
+        return VERR_PKZIP_NAME_TOO_LONG;
+
+    *pcbExtra = pCdh->cbFilename + pCdh->cbExtra + pCdh->cbComment;
+
+    pThis->cdh = *pCdh;
+    pThis->fZip64Ex = false;
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * Return the offset of the Local File Header.
+ */
+static uint64_t rtZipPkzipReaderOffLocalHeader(PRTZIPPKZIPREADER pThis)
+{
+    if (pThis->fZip64Ex && pThis->cdh.offLocalFileHeader == (uint32_t)-1)
+        return pThis->cd64ex.offLocalFileHeader;
+
+    return pThis->cdh.offLocalFileHeader;
+}
+
+
+/**
+ * Return the uncompressed object size.
+ */
+static uint64_t rtZipPkzipReaderUncompressed(PRTZIPPKZIPREADER pThis)
+{
+    if (pThis->fZip64Ex && pThis->cdh.cbUncompressed == (uint32_t)-1)
+        return pThis->cd64ex.cbUncompressed;
+
+    return pThis->cdh.cbUncompressed;
+}
+
+
+/**
+ * Return the compressed object size.
+ */
+static uint64_t rtZipPkzipReaderCompressed(PRTZIPPKZIPREADER pThis)
+{
+    if (pThis->fZip64Ex && pThis->cdh.cbCompressed == (uint32_t)-1)
+        return pThis->cd64ex.cbCompressed;
+
+    return pThis->cdh.cbCompressed;
+}
+
+
+/**
+ * Parse the extra part of the Central Directory Header.
+ */
+static int rtZipPkzipParseCentrDirHeaderExtra(PRTZIPPKZIPREADER pThis, uint8_t *pu8Buf, size_t cb,
+                                              RTZIPPKZIP_COMP_METHOD *penmCompMethod, uint64_t *pcbCompressed)
+{
+    int rc = RTStrCopyEx(pThis->szName, sizeof(pThis->szName), (const char*)pu8Buf, pThis->cdh.cbFilename);
+    if (RT_SUCCESS(rc))
+    {
+        pu8Buf += pThis->cdh.cbFilename;
+        cb      = pThis->cdh.cbExtra;
+        while (cb >= 4)
+        {
+            uint16_t idExtra = *(uint16_t*)pu8Buf;
+            pu8Buf += 2;
+            uint16_t cbExtra = *(uint16_t*)pu8Buf;
+            pu8Buf += 2;
+            cb     -= 4;
+
+            if (cb >= cbExtra)
+            {
+                switch (idExtra)
+                {
+                    case 0x0001:
+                        /*
+                         * ZIP64 Extended Information Extra Field.
+                         */
+                        if (!pThis->fZip64Eocd)
+                            return VERR_PKZIP_ZIP64EX_IN_ZIP32;
+                        /* Not all fields are really used. */
+                        RT_ZERO(pThis->cd64ex);
+                        memcpy(&pThis->cd64ex, pu8Buf, cbExtra);
+                        pThis->fZip64Ex = true;
+                        break;
+
+                    default:
+                        /* unknown, just skip */
+                        break;
+                }
+                pu8Buf += cbExtra;
+                cb     -= cbExtra;
+            }
+            else
+            {
+                rc = VERR_PKZIP_BAD_CDF_HEADER;
+                break;
+            }
+        }
+
+        *penmCompMethod = (RTZIPPKZIP_COMP_METHOD)pThis->cdh.u16ComprMethod;
+        *pcbCompressed  = rtZipPkzipReaderCompressed(pThis);
+    }
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * Translate a PKZip header to an IPRT object info structure.
+ */
+static int rtZipPkzipReaderGetFsObjInfo(PRTZIPPKZIPREADER pThis, PRTFSOBJINFO pObjInfo)
+{
+    /*
+     * Zap the whole structure, this takes care of unused space in the union.
+     */
+    RT_ZERO(*pObjInfo);
+    pObjInfo->cbObject = rtZipPkzipReaderUncompressed(pThis);
+    pObjInfo->cbAllocated = rtZipPkzipReaderUncompressed(pThis); /* XXX */
+    RTTIMESPEC ts;
+    rtZipPkzipReaderDecodeDosTime(&ts, pThis->cdh.u16LastModifiedTime, pThis->cdh.u16LastModifiedDate);
+    pObjInfo->ChangeTime = ts;
+    pObjInfo->ModificationTime = ts;
+    pObjInfo->AccessTime = ts;
+    pObjInfo->BirthTime = ts;
+    const char *pszEnd = strchr(pThis->szName, '\0');
+    if (pszEnd == &pThis->szName[0] || pszEnd[-1] != '/')
+        pObjInfo->Attr.fMode = RTFS_TYPE_FILE \
+                             | RTFS_UNIX_IRUSR | RTFS_UNIX_IWUSR \
+                             | RTFS_UNIX_IRGRP \
+                             | RTFS_UNIX_IROTH;
+    else
+        pObjInfo->Attr.fMode = RTFS_TYPE_DIRECTORY \
+                             | RTFS_UNIX_IRWXU \
+                             | RTFS_UNIX_IRGRP | RTFS_UNIX_IXGRP \
+                             | RTFS_UNIX_IROTH | RTFS_UNIX_IXOTH;
+    pObjInfo->Attr.enmAdditional = RTFSOBJATTRADD_UNIX;
+    pObjInfo->Attr.u.Unix.cHardlinks = 1;
+
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * Search the magic value of the End Of Central Directory Record.
+ *
+ * @returns true if found, false otherwise.
+ * @param   pu8Buf      buffer.
+ * @param   cb          size of buffer.
+ * @param   piPos       where to store the position of the magic value.
+ */
+static bool rtZipPkzipReaderScanEocd(const uint8_t *pu8Buf, size_t cb, int *piPos)
+{
+    if (cb < 4)
+        return false;
+    ssize_t i;
+    for (i = (ssize_t)cb - 4; i >= 0; --i)
+        if (*(uint32_t*)(pu8Buf + i) == RTZIPPKZIPENDOFCENTRDIRREC_MAGIC)
+        {
+            *piPos = i;
+            return true;
+        }
+    return false;
+}
+
+
+/**
+ * Read the Local File Header. We ignore the content -- we trust the Central
+ * Directory.
+ */
+static int rtZipPkzipFssIosReadLfh(PRTZIPPKZIPFSSTREAM pThis, uint64_t *poffStartData)
+{
+    RTZIPPKZIPLOCALFILEHDR lfh;
+    uint64_t offLocalFileHeader = rtZipPkzipReaderOffLocalHeader(&pThis->PkzipReader);
+    int rc = RTVfsIoStrmReadAt(pThis->hVfsIos, offLocalFileHeader,
+                               &lfh, sizeof(lfh) - 1, true /*fBlocking*/, NULL);
+    if (RT_SUCCESS(rc))
+    {
+        if (lfh.u32Magic == RTZIPPKZIPLOCALFILEHDR_MAGIC)
+        {
+            size_t cbExtra = 0;
+            rc = rtZipPkzipParseLocalFileHeader(&pThis->PkzipReader, &lfh, &cbExtra);
+            if (RT_SUCCESS(rc))
+            {
+                /* Just skip the file name and and extra field. We use the data
+                 * from the Central Directory Header. */
+                rc = RTVfsIoStrmSkip(pThis->hVfsIos, cbExtra);
+                if (RT_SUCCESS(rc))
+                    *poffStartData = offLocalFileHeader + sizeof(lfh) - 1 + cbExtra;
+            }
+        }
+        else
+            rc = VERR_PKZIP_BAD_LF_HEADER;
+    }
+
+    return rc;
+}
+
+
+/**
+ * Scan the current Central Directory Header.
+ */
+static int rtZipPkzipFssIosReadCdh(PRTZIPPKZIPFSSTREAM pThis, uint64_t *poffStartData,
+                                    RTZIPPKZIP_COMP_METHOD *penmCompMethod, uint64_t *pcbCompressed)
+{
+    int rc;
+
+    uint64_t offCd = pThis->offNextCdh - pThis->offFirstCdh;
+    if (   pThis->iCentrDirEntry < pThis->cCentrDirEntries
+        || offCd + sizeof(RTZIPPKZIPCENTRDIRHDR) - 1 <= pThis->cbCentrDir)
+    {
+        RTZIPPKZIPCENTRDIRHDR cdh;
+        rc = RTVfsIoStrmReadAt(pThis->hVfsIos, pThis->offNextCdh,
+                               &cdh, sizeof(cdh) - 1, true /*fBlocking*/, NULL);
+        if (RT_SUCCESS(rc))
+        {
+            pThis->offNextCdh += sizeof(cdh) - 1;
+            pThis->iCentrDirEntry++;
+            size_t cbExtra = 0;
+            rc = rtZipPkzipParseCentrDirHeader(&pThis->PkzipReader, &cdh, &cbExtra);
+            if (RT_SUCCESS(rc))
+            {
+                if (offCd + sizeof(RTZIPPKZIPCENTRDIRHDR) - 1 + cbExtra <= pThis->cbCentrDir)
+                {
+                    /* extra data up to 64k */
+                    uint8_t *pu8Buf = (uint8_t*)RTMemTmpAlloc(cbExtra);
+                    if (pu8Buf)
+                    {
+                        rc = RTVfsIoStrmRead(pThis->hVfsIos, pu8Buf, cbExtra, true /*fBlocking*/, NULL);
+                        if (RT_SUCCESS(rc))
+                        {
+                            rc = rtZipPkzipParseCentrDirHeaderExtra(&pThis->PkzipReader, pu8Buf, cbExtra,
+                                                                    penmCompMethod, pcbCompressed);
+                            if (RT_SUCCESS(rc))
+                                rc = rtZipPkzipFssIosReadLfh(pThis, poffStartData);
+                        }
+                        pThis->offNextCdh += cbExtra;
+                        RTMemTmpFree(pu8Buf);
+                    }
+                    else
+                        rc = VERR_NO_MEMORY;
+                }
+                else
+                    rc = VERR_EOF;
+            }
+        }
+    }
+    else
+        rc = VERR_EOF;
+
+    return rc;
+}
+
+
+/**
+ * Scan for the End of Central Directory Record. Of course this works not if
+ * the stream is non-seekable (i.e. a pipe).
+ */
+static int rtZipPkzipFssIosReadEocb(PRTZIPPKZIPFSSTREAM pThis)
+{
+    RTFSOBJINFO Info;
+    int rc = RTVfsIoStrmQueryInfo(pThis->hVfsIos, &Info, RTFSOBJATTRADD_UNIX);
+    if (RT_FAILURE(rc))
+        return rc;
+
+    uint64_t cbFile = Info.cbObject;
+    if (cbFile < sizeof(RTZIPPKZIPENDOFCENTRDIRREC)-1)
+        return VERR_PKZIP_NO_EOCB;
+
+    /* search for start of the 'end of Central Directory Record' */
+    size_t cbBuf = RT_MIN(_1K, cbFile);
+    uint8_t *pu8Buf = (uint8_t*)RTMemTmpAlloc(cbBuf);
+    if (!pu8Buf)
+        return VERR_NO_MEMORY;
+
+    /* maximum size of EOCD comment 2^16-1 */
+    const size_t cbHdrMax = 0xffff + sizeof(RTZIPPKZIPENDOFCENTRDIRREC) - 1;
+    uint64_t offMin = cbFile >= cbHdrMax ? cbFile - cbHdrMax : 0;
+
+    uint64_t off = cbFile - cbBuf;
+    while (off >= offMin)
+    {
+        rc = RTVfsIoStrmReadAt(pThis->hVfsIos, off, pu8Buf, cbBuf, true /*fBlocking*/, NULL);
+        if (RT_FAILURE(rc))
+            break;
+        int offMagic;
+        if (rtZipPkzipReaderScanEocd(pu8Buf, cbBuf, &offMagic))
+        {
+            off += offMagic;
+            RTZIPPKZIPENDOFCENTRDIRREC eocd;
+            rc = RTVfsIoStrmReadAt(pThis->hVfsIos, off, &eocd, sizeof(eocd) - 1,
+                                   true /*fBlocking*/, NULL);
+            if (RT_SUCCESS(rc))
+            {
+                /* well, this shouldn't fail if the content didn't change */
+                if (eocd.u32Magic == RTZIPPKZIPENDOFCENTRDIRREC_MAGIC)
+                {
+                    /* sanity check */
+                    if (off + RT_UOFFSETOF(RTZIPPKZIPENDOFCENTRDIRREC, u8Comment) + eocd.cbComment == cbFile)
+                    {
+                        pThis->offFirstCdh = eocd.offCentrDir;
+                        pThis->offNextCdh = eocd.offCentrDir;
+                        pThis->iCentrDirEntry = 0;
+                        pThis->cCentrDirEntries = eocd.cCentrDirRecords;
+                        pThis->cbCentrDir = eocd.cbCentrDir;
+                        pThis->PkzipReader.fHaveEocd = true;
+                    }
+                    else
+                        rc = VERR_PKZIP_NO_EOCB;
+                }
+                else
+                    rc = VERR_PKZIP_NO_EOCB;
+            }
+            if (rc != VERR_PKZIP_NO_EOCB)
+                break;
+        }
+        else
+            rc = VERR_PKZIP_NO_EOCB;
+        /* overlap the following read */
+        off -= cbBuf - 4;
+    }
+
+    RTMemTmpFree(pu8Buf);
+
+    /*
+     * Now check for the presence of the Zip64 End of Central Directory Locator.
+     */
+    if (   RT_SUCCESS(rc)
+        && off > (unsigned)sizeof(RTZIPPKZIP64ENDOFCENTRDIRLOC))
+    {
+        off -= sizeof(RTZIPPKZIP64ENDOFCENTRDIRLOC);
+
+        RTZIPPKZIP64ENDOFCENTRDIRLOC eocd64loc;
+        rc = RTVfsIoStrmReadAt(pThis->hVfsIos, off, &eocd64loc, sizeof(eocd64loc), true /*fBlocking*/, NULL);
+        if (RT_SUCCESS(rc))
+        {
+            if (eocd64loc.u32Magic == RTZIPPKZIP64ENDOFCENTRDIRLOC_MAGIC)
+                pThis->PkzipReader.fZip64Eocd = true;
+        }
+    }
+    return rc;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSOBJOPS,pfnClose}
+ */
+static DECLCALLBACK(int) rtZipPkzipFssBaseObj_Close(void *pvThis)
+{
+    NOREF(pvThis);
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSOBJOPS,pfnQueryInfo}
+ */
+static DECLCALLBACK(int) rtZipPkzipFssBaseObj_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
+{
+    PRTZIPPKZIPBASEOBJ pThis = (PRTZIPPKZIPBASEOBJ)pvThis;
+
+    /*
+     * Copy the desired data.
+     */
+    switch (enmAddAttr)
+    {
+        case RTFSOBJATTRADD_NOTHING:
+        case RTFSOBJATTRADD_UNIX:
+            *pObjInfo = pThis->ObjInfo;
+            break;
+
+        case RTFSOBJATTRADD_UNIX_OWNER:
+            *pObjInfo = pThis->ObjInfo;
+            break;
+
+        case RTFSOBJATTRADD_UNIX_GROUP:
+            *pObjInfo = pThis->ObjInfo;
+            break;
+
+        case RTFSOBJATTRADD_EASIZE:
+            *pObjInfo = pThis->ObjInfo;
+            break;
+
+        default:
+            return VERR_NOT_SUPPORTED;
+    }
+
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * PKZip filesystem base object operations (directory objects).
+ */
+static const RTVFSOBJOPS g_rtZipPkzipFssBaseObjOps =
+{
+    RTVFSOBJOPS_VERSION,
+    RTVFSOBJTYPE_BASE,
+    "PkzipFsStream::Obj",
+    rtZipPkzipFssBaseObj_Close,
+    rtZipPkzipFssBaseObj_QueryInfo,
+    NULL,
+    RTVFSOBJOPS_VERSION
+};
+
+
+/**
+ * @interface_method_impl{RTVFSOBJOPS,pfnClose}
+ */
+static DECLCALLBACK(int) rtZipPkzipFssIos_Close(void *pvThis)
+{
+    PRTZIPPKZIPIOSTREAM pThis = (PRTZIPPKZIPIOSTREAM)pvThis;
+
+    RTVfsIoStrmRelease(pThis->hVfsIos);
+    pThis->hVfsIos = NIL_RTVFSIOSTREAM;
+
+    if (pThis->pZip)
+    {
+        RTZipDecompDestroy(pThis->pZip);
+        pThis->pZip = NULL;
+    }
+
+    return rtZipPkzipFssBaseObj_Close(&pThis->BaseObj);
+}
+
+
+/**
+ * @interface_method_impl{RTVFSOBJOPS,pfnQueryInfo}
+ */
+static DECLCALLBACK(int) rtZipPkzipFssIos_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
+{
+    PRTZIPPKZIPIOSTREAM pThis = (PRTZIPPKZIPIOSTREAM)pvThis;
+    return rtZipPkzipFssBaseObj_QueryInfo(&pThis->BaseObj, pObjInfo, enmAddAttr);
+}
+
+
+/**
+ * Callback function for rtZipPkzipFssIos_Read. For feeding compressed data
+ * into the decompressor function.
+ */
+static DECLCALLBACK(int) rtZipPkzipFssIosReadHelper(void *pvThis, void *pvBuf, size_t cbToRead, size_t *pcbRead)
+{
+    PRTZIPPKZIPIOSTREAM pThis = (PRTZIPPKZIPIOSTREAM)pvThis;
+    int rc = VINF_SUCCESS;
+    if (!cbToRead)
+        return rc;
+    if (   pThis->fPassZipType
+        && cbToRead > 0)
+    {
+        uint8_t *pu8Buf = (uint8_t*)pvBuf;
+        pu8Buf[0] = pThis->enmZipType;
+        pvBuf = &pu8Buf[1];
+        cbToRead--;
+        pThis->fPassZipType = false;
+    }
+    if (cbToRead > 0)
+    {
+        size_t cbRead = 0;
+        const size_t cbAvail = pThis->cbComp;
+        rc = RTVfsIoStrmReadAt(pThis->hVfsIos, pThis->offComp, pvBuf,
+                               RT_MIN(cbToRead, cbAvail), true /*fBlocking*/, &cbRead);
+        if (   RT_SUCCESS(rc)
+            && cbToRead > cbAvail)
+            rc = pcbRead ? VINF_EOF : VERR_EOF;
+        if (   rc == VINF_EOF
+            && !pcbRead)
+            rc = VERR_EOF;
+        pThis->offComp += cbRead;
+        if (pcbRead)
+            *pcbRead = cbRead;
+    }
+    return rc;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSIOSTREAMOPS,pfnRead}
+ */
+static DECLCALLBACK(int) rtZipPkzipFssIos_Read(void *pvThis, RTFOFF off, PCRTSGBUF pSgBuf, bool fBlocking, size_t *pcbRead)
+{
+    PRTZIPPKZIPIOSTREAM pThis = (PRTZIPPKZIPIOSTREAM)pvThis;
+    Assert(pSgBuf->cSegs == 1);
+    RT_NOREF_PV(fBlocking);
+
+    if (off < 0)
+        off = pThis->offFile;
+    if (off >= (RTFOFF)pThis->cbFile)
+        return pcbRead ? VINF_EOF : VERR_EOF;
+
+    Assert(pThis->cbFile >= pThis->offFile);
+    uint64_t cbLeft   = (uint64_t)(pThis->cbFile - pThis->offFile);
+    size_t   cbToRead = pSgBuf->paSegs[0].cbSeg;
+    if (cbToRead > cbLeft)
+    {
+        if (!pcbRead)
+            return VERR_EOF;
+        cbToRead = (size_t)cbLeft;
+    }
+
+    /*
+     * Restart decompression at start of stream or on backward seeking.
+     */
+    if (   !pThis->pZip
+        || !off
+        || off < (RTFOFF)pThis->offFile)
+    {
+        switch (pThis->enmCompMethod)
+        {
+            case RTZIPPKZIP_COMP_METHOD_STORED:
+                pThis->enmZipType = RTZIPTYPE_STORE;
+                break;
+
+            case RTZIPPKZIP_COMP_METHOD_DEFLATED:
+                pThis->enmZipType = RTZIPTYPE_ZLIB_NO_HEADER;
+                break;
+
+            default:
+                pThis->enmZipType = RTZIPTYPE_INVALID;
+                break;
+        }
+
+        if (pThis->pZip)
+        {
+            RTZipDecompDestroy(pThis->pZip);
+            pThis->pZip = NULL;
+        }
+        int rc = RTZipDecompCreate(&pThis->pZip, (void*)pThis, rtZipPkzipFssIosReadHelper);
+        if (RT_FAILURE(rc))
+            return rc;
+    }
+
+    /*
+     * Skip bytes if necessary.
+     */
+    if (off > (RTFOFF)pThis->offFile)
+    {
+        uint8_t u8Buf[_1K];
+        while (off > (RTFOFF)pThis->offFile)
+        {
+            size_t cbSkip = off - pThis->offFile;
+            if (cbSkip > sizeof(u8Buf))
+                cbSkip = sizeof(u8Buf);
+            int rc = RTZipDecompress(pThis->pZip, u8Buf, cbSkip, NULL);
+            if (RT_FAILURE(rc))
+                return rc;
+            pThis->offFile += cbSkip;
+        }
+    }
+
+    /*
+     * Do the actual reading.
+     */
+    size_t cbReadStack = 0;
+    if (!pcbRead)
+        pcbRead = &cbReadStack;
+    int rc = RTZipDecompress(pThis->pZip, pSgBuf->paSegs[0].pvSeg, cbToRead, pcbRead);
+    pThis->offFile = off + *pcbRead;
+    if (pThis->offFile >= pThis->cbFile)
+    {
+        Assert(pThis->offFile == pThis->cbFile);
+        pThis->fEndOfStream = true;
+    }
+
+    return rc;
+}
+
+static DECLCALLBACK(int) rtZipPkzipFssIos_Write(void *pvThis, RTFOFF off, PCRTSGBUF pSgBuf, bool fBlocking, size_t *pcbWritten)
+{
+    RT_NOREF_PV(pvThis); RT_NOREF_PV(off); RT_NOREF_PV(pSgBuf); RT_NOREF_PV(fBlocking); RT_NOREF_PV(pcbWritten);
+    return VERR_NOT_IMPLEMENTED;
+}
+
+static DECLCALLBACK(int) rtZipPkzipFssIos_Flush(void *pvThis)
+{
+    RT_NOREF_PV(pvThis);
+    return VERR_NOT_IMPLEMENTED;
+}
+
+/**
+ * @interface_method_impl{RTVFSIOSTREAMOPS,pfnPollOne}
+ */
+static DECLCALLBACK(int) rtZipPkzipFssIos_PollOne(void *pvThis, uint32_t fEvents, RTMSINTERVAL cMillies,
+                                                  bool fIntr, uint32_t *pfRetEvents)
+{
+    PRTZIPPKZIPIOSTREAM pThis = (PRTZIPPKZIPIOSTREAM)pvThis;
+
+    /* When we've reached the end, read will be set to indicate it. */
+    if (   (fEvents & RTPOLL_EVT_READ)
+        && pThis->fEndOfStream)
+    {
+        int rc = RTVfsIoStrmPoll(pThis->hVfsIos, fEvents, 0, fIntr, pfRetEvents);
+        if (RT_SUCCESS(rc))
+            *pfRetEvents |= RTPOLL_EVT_READ;
+        else
+            *pfRetEvents = RTPOLL_EVT_READ;
+        return VINF_SUCCESS;
+    }
+
+    return RTVfsIoStrmPoll(pThis->hVfsIos, fEvents, cMillies, fIntr, pfRetEvents);
+}
+
+
+/**
+ * @interface_method_impl{RTVFSIOSTREAMOPS,pfnTell}
+ */
+static DECLCALLBACK(int) rtZipPkzipFssIos_Tell(void *pvThis, PRTFOFF poffActual)
+{
+    PRTZIPPKZIPIOSTREAM pThis = (PRTZIPPKZIPIOSTREAM)pvThis;
+    *poffActual = pThis->offFile;
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * Pkzip I/O object stream operations.
+ */
+static const RTVFSIOSTREAMOPS g_rtZipPkzipFssIosOps =
+{
+    { /* Obj */
+        RTVFSOBJOPS_VERSION,
+        RTVFSOBJTYPE_IO_STREAM,
+        "PkzipFsStream::IoStream",
+        rtZipPkzipFssIos_Close,
+        rtZipPkzipFssIos_QueryInfo,
+        NULL,
+        RTVFSOBJOPS_VERSION
+    },
+    RTVFSIOSTREAMOPS_VERSION,
+    RTVFSIOSTREAMOPS_FEAT_NO_SG,
+    rtZipPkzipFssIos_Read,
+    rtZipPkzipFssIos_Write,
+    rtZipPkzipFssIos_Flush,
+    rtZipPkzipFssIos_PollOne,
+    rtZipPkzipFssIos_Tell,
+    NULL /*Skip*/,
+    NULL /*ZeroFill*/,
+    RTVFSIOSTREAMOPS_VERSION
+};
+
+/**
+ * @interface_method_impl{RTVFSOBJOPS,pfnClose}
+ */
+static DECLCALLBACK(int) rtZipPkzipFss_Close(void *pvThis)
+{
+    PRTZIPPKZIPFSSTREAM pThis = (PRTZIPPKZIPFSSTREAM)pvThis;
+
+    RTVfsObjRelease(pThis->hVfsCurObj);
+    pThis->hVfsCurObj  = NIL_RTVFSOBJ;
+    pThis->pCurIosData = NULL;
+
+    RTVfsIoStrmRelease(pThis->hVfsIos);
+    pThis->hVfsIos = NIL_RTVFSIOSTREAM;
+
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSOBJOPS,pfnQueryInfo}
+ */
+static DECLCALLBACK(int) rtZipPkzipFss_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
+{
+    PRTZIPPKZIPFSSTREAM pThis = (PRTZIPPKZIPFSSTREAM)pvThis;
+    /* Take the lazy approach here, with the sideffect of providing some info
+       that is actually kind of useful. */
+    return RTVfsIoStrmQueryInfo(pThis->hVfsIos, pObjInfo, enmAddAttr);
+}
+
+
+/**
+ * @interface_method_impl{RTVFSFSSTREAMOPS,pfnNext}
+ */
+static DECLCALLBACK(int) rtZipPkzipFss_Next(void *pvThis, char **ppszName, RTVFSOBJTYPE *penmType, PRTVFSOBJ phVfsObj)
+{
+    PRTZIPPKZIPFSSTREAM pThis = (PRTZIPPKZIPFSSTREAM)pvThis;
+
+    /*
+     * Dispense with the current object.
+     */
+    if (pThis->hVfsCurObj != NIL_RTVFSOBJ)
+    {
+        if (pThis->pCurIosData)
+        {
+            pThis->pCurIosData->fEndOfStream = true;
+            pThis->pCurIosData->offFile      = pThis->pCurIosData->cbFile;
+            pThis->pCurIosData = NULL;
+        }
+
+        RTVfsObjRelease(pThis->hVfsCurObj);
+        pThis->hVfsCurObj = NIL_RTVFSOBJ;
+    }
+
+    /*
+     * Check if we've already reached the end in some way.
+     */
+    if (pThis->fEndOfStream)
+        return VERR_EOF;
+    if (pThis->rcFatal != VINF_SUCCESS)
+        return pThis->rcFatal;
+
+    int rc = VINF_SUCCESS;
+
+    /*
+     * Read the end of Central Directory Record once.
+     */
+    if (!pThis->PkzipReader.fHaveEocd)
+        rc = rtZipPkzipFssIosReadEocb(pThis);
+    uint64_t offData = 0;
+
+    /*
+     * Parse the current Central Directory Header.
+     */
+    RTZIPPKZIP_COMP_METHOD enmCompMethod = RTZIPPKZIP_COMP_METHOD_STORED;
+    uint64_t cbCompressed = 0;
+    if (RT_SUCCESS(rc))
+        rc = rtZipPkzipFssIosReadCdh(pThis, &offData, &enmCompMethod, &cbCompressed);
+    if (RT_FAILURE(rc))
+        return pThis->rcFatal = rc;
+
+    /*
+     * Fill an object info structure from the current Pkzip state.
+     */
+    RTFSOBJINFO Info;
+    rc = rtZipPkzipReaderGetFsObjInfo(&pThis->PkzipReader, &Info);
+    if (RT_FAILURE(rc))
+        return pThis->rcFatal = rc;
+
+    /*
+     * Create an object of the appropriate type.
+     */
+    RTVFSOBJTYPE enmType;
+    RTVFSOBJ hVfsObj;
+    RTFMODE fType = Info.Attr.fMode & RTFS_TYPE_MASK;
+    switch (fType)
+    {
+        case RTFS_TYPE_FILE:
+            RTVFSIOSTREAM hVfsIos;
+            PRTZIPPKZIPIOSTREAM pIosData;
+            rc = RTVfsNewIoStream(&g_rtZipPkzipFssIosOps,
+                                  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.pPkzipReader = &pThis->PkzipReader;
+            pIosData->BaseObj.ObjInfo      = Info;
+            pIosData->cbFile               = Info.cbObject;
+            pIosData->offFile              = 0;
+            pIosData->offComp              = offData;
+            pIosData->offCompStart         = offData;
+            pIosData->cbComp               = cbCompressed;
+            pIosData->enmCompMethod        = enmCompMethod;
+            pIosData->fPassZipType         = true;
+            pIosData->hVfsIos              = pThis->hVfsIos;
+            RTVfsIoStrmRetain(pThis->hVfsIos);
+            pThis->pCurIosData = pIosData;
+            enmType = RTVFSOBJTYPE_IO_STREAM;
+            hVfsObj = RTVfsObjFromIoStream(hVfsIos);
+            RTVfsIoStrmRelease(hVfsIos);
+            break;
+
+        case RTFS_TYPE_DIRECTORY:
+            PRTZIPPKZIPBASEOBJ pBaseObjData;
+            rc = RTVfsNewBaseObj(&g_rtZipPkzipFssBaseObjOps,
+                                 sizeof(*pBaseObjData),
+                                 NIL_RTVFS,
+                                 NIL_RTVFSLOCK,
+                                 &hVfsObj,
+                                 (void **)&pBaseObjData);
+            if (RT_FAILURE(rc))
+                return pThis->rcFatal = rc;
+
+            pBaseObjData->pPkzipReader = &pThis->PkzipReader;
+            pBaseObjData->ObjInfo      = Info;
+            enmType = RTVFSOBJTYPE_BASE;
+            break;
+
+        default:
+            return pThis->rcFatal = VERR_PKZIP_UNKNOWN_TYPE_FLAG;
+    }
+    pThis->hVfsCurObj = hVfsObj;
+
+    if (ppszName)
+    {
+        rc = RTStrDupEx(ppszName, pThis->PkzipReader.szName);
+        if (RT_FAILURE(rc))
+            return pThis->rcFatal = rc;
+    }
+
+    if (phVfsObj)
+    {
+        RTVfsObjRetain(hVfsObj);
+        *phVfsObj = hVfsObj;
+    }
+
+    if (penmType)
+        *penmType = enmType;
+
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * PKZip filesystem stream operations.
+ */
+static const RTVFSFSSTREAMOPS rtZipPkzipFssOps =
+{
+    { /* Obj */
+        RTVFSOBJOPS_VERSION,
+        RTVFSOBJTYPE_FS_STREAM,
+        "PkzipFsStream",
+        rtZipPkzipFss_Close,
+        rtZipPkzipFss_QueryInfo,
+        NULL,
+        RTVFSOBJOPS_VERSION
+    },
+    RTVFSFSSTREAMOPS_VERSION,
+    0,
+    rtZipPkzipFss_Next,
+    NULL,
+    NULL,
+    NULL,
+    RTVFSFSSTREAMOPS_VERSION
+};
+
+
+RTDECL(int) RTZipPkzipFsStreamFromIoStream(RTVFSIOSTREAM hVfsIosIn, uint32_t fFlags, PRTVFSFSSTREAM phVfsFss)
+{
+    /*
+     * Input validation.
+     */
+    AssertPtrReturn(phVfsFss, VERR_INVALID_HANDLE);
+    *phVfsFss = NIL_RTVFSFSSTREAM;
+    AssertPtrReturn(hVfsIosIn, VERR_INVALID_HANDLE);
+    AssertReturn(!fFlags, VERR_INVALID_PARAMETER);
+
+    uint32_t cRefs = RTVfsIoStrmRetain(hVfsIosIn);
+    AssertReturn(cRefs != UINT32_MAX, VERR_INVALID_HANDLE);
+
+    /*
+     * Retain the input stream and create a new filesystem stream handle.
+     */
+    PRTZIPPKZIPFSSTREAM pThis;
+    RTVFSFSSTREAM     hVfsFss;
+    int rc = RTVfsNewFsStream(&rtZipPkzipFssOps, sizeof(*pThis), NIL_RTVFS, NIL_RTVFSLOCK, RTFILE_O_READ,
+                              &hVfsFss, (void **)&pThis);
+    if (RT_SUCCESS(rc))
+    {
+        pThis->hVfsIos              = hVfsIosIn;
+        pThis->hVfsCurObj           = NIL_RTVFSOBJ;
+        pThis->pCurIosData          = NULL;
+        pThis->fEndOfStream         = false;
+        pThis->rcFatal              = VINF_SUCCESS;
+        pThis->fHaveEocd            = false;
+
+        *phVfsFss = hVfsFss;
+        return VINF_SUCCESS;
+    }
+
+    RTVfsIoStrmRelease(hVfsIosIn);
+    return rc;
+}
diff --git a/src/VBox/Runtime/common/zip/tar.h b/src/VBox/Runtime/common/zip/tar.h
new file mode 100644
index 00000000..b247b777
--- /dev/null
+++ b/src/VBox/Runtime/common/zip/tar.h
@@ -0,0 +1,146 @@
+/* $Id: tar.h $ */
+/** @file
+ * IPRT - TAR Virtual Filesystem.
+ */
+
+/*
+ * Copyright (C) 2010-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * The contents of this file may alternatively be used under the terms
+ * of the Common Development and Distribution License Version 1.0
+ * (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
+ * in the VirtualBox distribution, in which case the provisions of the
+ * CDDL are applicable instead of those of the GPL.
+ *
+ * You may elect to license modified versions of this file under the
+ * terms and conditions of either the GPL or the CDDL or both.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
+ */
+
+#ifndef IPRT_INCLUDED_SRC_common_zip_tar_h
+#define IPRT_INCLUDED_SRC_common_zip_tar_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <iprt/assert.h>
+#include <iprt/formats/tar.h>
+
+/**
+ * Tar header union.
+ */
+typedef union RTZIPTARHDR
+{
+    /** Byte view. */
+    char                ab[512];
+    /** The standard header. */
+    RTZIPTARHDRANCIENT      Ancient;
+    /** The standard header. */
+    RTZIPTARHDRPOSIX        Posix;
+    /** The GNU header. */
+    RTZIPTARHDRGNU          Gnu;
+    /** The bits common to both GNU and the standard header. */
+    RTZIPTARHDRCOMMON       Common;
+    /** GNU sparse header. */
+    RTZIPTARHDRGNUSPARSE    GnuSparse;
+} RTZIPTARHDR;
+AssertCompileSize(RTZIPTARHDR, 512);
+/** Pointer to a tar file header. */
+typedef RTZIPTARHDR *PRTZIPTARHDR;
+/** Pointer to a const tar file header. */
+typedef RTZIPTARHDR const *PCRTZIPTARHDR;
+
+
+/**
+ * Tar header type.
+ */
+typedef enum RTZIPTARTYPE
+{
+    /** Invalid type value. */
+    RTZIPTARTYPE_INVALID = 0,
+    /** Posix header.  */
+    RTZIPTARTYPE_POSIX,
+    /** The old GNU header, has layout conflicting with posix. */
+    RTZIPTARTYPE_GNU,
+    /** Ancient tar header which does not use anything beyond the magic. */
+    RTZIPTARTYPE_ANCIENT,
+    /** End of the valid type values (this is not valid).  */
+    RTZIPTARTYPE_END,
+    /** The usual type blow up.  */
+    RTZIPTARTYPE_32BIT_HACK = 0x7fffffff
+} RTZIPTARTYPE;
+typedef RTZIPTARTYPE *PRTZIPTARTYPE;
+
+
+/**
+ * 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.
+ */
+DECLINLINE(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;
+}
+
+
+#endif /* !IPRT_INCLUDED_SRC_common_zip_tar_h */
+
diff --git a/src/VBox/Runtime/common/zip/tarcmd.cpp b/src/VBox/Runtime/common/zip/tarcmd.cpp
new file mode 100644
index 00000000..5c4f62bb
--- /dev/null
+++ b/src/VBox/Runtime/common/zip/tarcmd.cpp
@@ -0,0 +1,1960 @@
+/* $Id: tarcmd.cpp $ */
+/** @file
+ * IPRT - A mini TAR Command.
+ */
+
+/*
+ * Copyright (C) 2010-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * The contents of this file may alternatively be used under the terms
+ * of the Common Development and Distribution License Version 1.0
+ * (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
+ * in the VirtualBox distribution, in which case the provisions of the
+ * CDDL are applicable instead of those of the GPL.
+ *
+ * You may elect to license modified versions of this file under the
+ * terms and conditions of either the GPL or the CDDL or both.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#include <iprt/zip.h>
+
+#include <iprt/asm.h>
+#include <iprt/buildconfig.h>
+#include <iprt/ctype.h>
+#include <iprt/dir.h>
+#include <iprt/err.h>
+#include <iprt/file.h>
+#include <iprt/getopt.h>
+#include <iprt/initterm.h>
+#include <iprt/mem.h>
+#include <iprt/message.h>
+#include <iprt/param.h>
+#include <iprt/path.h>
+#include <iprt/stream.h>
+#include <iprt/string.h>
+#include <iprt/symlink.h>
+#include <iprt/vfs.h>
+
+
+/*********************************************************************************************************************************
+*   Defined Constants And Macros                                                                                                 *
+*********************************************************************************************************************************/
+#define RTZIPTARCMD_OPT_DELETE              1000
+#define RTZIPTARCMD_OPT_OWNER               1001
+#define RTZIPTARCMD_OPT_GROUP               1002
+#define RTZIPTARCMD_OPT_UTC                 1003
+#define RTZIPTARCMD_OPT_PREFIX              1004
+#define RTZIPTARCMD_OPT_FILE_MODE_AND_MASK  1005
+#define RTZIPTARCMD_OPT_FILE_MODE_OR_MASK   1006
+#define RTZIPTARCMD_OPT_DIR_MODE_AND_MASK   1007
+#define RTZIPTARCMD_OPT_DIR_MODE_OR_MASK    1008
+#define RTZIPTARCMD_OPT_FORMAT              1009
+#define RTZIPTARCMD_OPT_READ_AHEAD          1010
+#define RTZIPTARCMD_OPT_USE_PUSH_FILE       1011
+#define RTZIPTARCMD_OPT_NO_RECURSION        1012
+
+/** File format. */
+typedef enum RTZIPTARCMDFORMAT
+{
+    RTZIPTARCMDFORMAT_INVALID = 0,
+    /** Autodetect if possible, defaulting to TAR. */
+    RTZIPTARCMDFORMAT_AUTO_DEFAULT,
+    /** TAR.  */
+    RTZIPTARCMDFORMAT_TAR,
+    /** XAR.  */
+    RTZIPTARCMDFORMAT_XAR,
+    /** CPIO. */
+    RTZIPTARCMDFORMAT_CPIO
+} RTZIPTARCMDFORMAT;
+
+
+/*********************************************************************************************************************************
+*   Structures and Typedefs                                                                                                      *
+*********************************************************************************************************************************/
+/**
+ * IPRT TAR option structure.
+ */
+typedef struct RTZIPTARCMDOPS
+{
+    /** The file format. */
+    RTZIPTARCMDFORMAT enmFormat;
+
+    /** The operation (Acdrtux or RTZIPTARCMD_OPT_DELETE). */
+    int             iOperation;
+    /** The long operation option name. */
+    const char     *pszOperation;
+
+    /** The directory to change into when packing and unpacking. */
+    const char     *pszDirectory;
+    /** The tar file name. */
+    const char     *pszFile;
+    /** Whether we're verbose or quiet. */
+    bool            fVerbose;
+    /** Whether to preserve the original file owner when restoring. */
+    bool            fPreserveOwner;
+    /** Whether to preserve the original file group when restoring. */
+    bool            fPreserveGroup;
+    /** Whether to skip restoring the modification time (only time stored by the
+     * traditional TAR format). */
+    bool            fNoModTime;
+    /** Whether to add a read ahead thread. */
+    bool            fReadAhead;
+    /** Use RTVfsFsStrmPushFile instead of RTVfsFsStrmAdd for files. */
+    bool            fUsePushFile;
+    /** Whether to handle directories recursively or not. Defaults to \c true. */
+    bool            fRecursive;
+    /** The compressor/decompressor method to employ (0, z or j). */
+    char            chZipper;
+
+    /** The owner to set. NULL if not applicable.
+     * Always resolved into uidOwner for extraction. */
+    const char     *pszOwner;
+    /** The owner ID to set. NIL_RTUID if not applicable. */
+    RTUID           uidOwner;
+    /** The group to set. NULL if not applicable.
+     * Always resolved into gidGroup for extraction. */
+    const char     *pszGroup;
+    /** The group ID to set. NIL_RTGUID if not applicable. */
+    RTGID           gidGroup;
+    /** Display the modification times in UTC instead of local time. */
+    bool            fDisplayUtc;
+    /** File mode AND mask. */
+    RTFMODE         fFileModeAndMask;
+    /** File mode OR mask. */
+    RTFMODE         fFileModeOrMask;
+    /** Directory mode AND mask. */
+    RTFMODE         fDirModeAndMask;
+    /** Directory mode OR mask. */
+    RTFMODE         fDirModeOrMask;
+
+    /** What to prefix all names with when creating, adding, whatever. */
+    const char     *pszPrefix;
+
+    /** The number of files(, directories or whatever) specified. */
+    uint32_t        cFiles;
+    /** Array of files(, directories or whatever).
+     * Terminated by a NULL entry. */
+    const char * const *papszFiles;
+
+    /** The TAR format to create. */
+    RTZIPTARFORMAT  enmTarFormat;
+    /** TAR creation flags. */
+    uint32_t        fTarCreate;
+
+} RTZIPTARCMDOPS;
+/** Pointer to the IPRT tar options. */
+typedef RTZIPTARCMDOPS *PRTZIPTARCMDOPS;
+
+/** The size of the directory entry buffer we're using. */
+#define RTZIPTARCMD_DIRENTRY_BUF_SIZE (sizeof(RTDIRENTRYEX) + RTPATH_MAX)
+
+/**
+ * Callback used by rtZipTarDoWithMembers
+ *
+ * @returns rcExit or RTEXITCODE_FAILURE.
+ * @param   pOpts               The tar options.
+ * @param   hVfsObj             The tar object to display
+ * @param   pszName             The name.
+ * @param   rcExit              The current exit code.
+ */
+typedef RTEXITCODE (*PFNDOWITHMEMBER)(PRTZIPTARCMDOPS pOpts, RTVFSOBJ hVfsObj, const char *pszName, RTEXITCODE rcExit);
+
+
+/**
+ * Checks if @a pszName is a member of @a papszNames, optionally returning the
+ * index.
+ *
+ * @returns true if the name is in the list, otherwise false.
+ * @param   pszName             The name to find.
+ * @param   papszNames          The array of names.
+ * @param   piName              Where to optionally return the array index.
+ */
+static bool rtZipTarCmdIsNameInArray(const char *pszName, const char * const *papszNames, uint32_t *piName)
+{
+    for (uint32_t iName = 0; papszNames[iName]; iName++)
+        if (!strcmp(papszNames[iName], pszName))
+        {
+            if (piName)
+                *piName = iName;
+            return true;
+        }
+    return false;
+}
+
+
+/**
+ * Queries information about a VFS object.
+ *
+ * @returns VBox status code.
+ * @param   pszSpec             VFS object spec to use.
+ * @param   paObjInfo           Where to store the queried object information.
+ *                              Must at least provide 3 structs, namely for UNIX, UNIX_OWNER and UNIX_GROUP attributes.
+ * @param   cObjInfo            Number of objection information structs handed in.
+ */
+static int rtZipTarCmdQueryObjInfo(const char *pszSpec, PRTFSOBJINFO paObjInfo, unsigned cObjInfo)
+{
+    AssertPtrReturn(paObjInfo, VERR_INVALID_POINTER);
+    AssertReturn(cObjInfo >= 3, VERR_INVALID_PARAMETER);
+
+    RTERRINFOSTATIC ErrInfo;
+    uint32_t        offError;
+    int rc = RTVfsChainQueryInfo(pszSpec, &paObjInfo[0], RTFSOBJATTRADD_UNIX, RTPATH_F_ON_LINK,
+                                 &offError, RTErrInfoInitStatic(&ErrInfo));
+    if (RT_SUCCESS(rc))
+    {
+        rc = RTVfsChainQueryInfo(pszSpec, &paObjInfo[1], RTFSOBJATTRADD_UNIX_OWNER, RTPATH_F_ON_LINK,
+                                 &offError, RTErrInfoInitStatic(&ErrInfo));
+        if (RT_SUCCESS(rc))
+        {
+            rc = RTVfsChainQueryInfo(pszSpec, &paObjInfo[2], RTFSOBJATTRADD_UNIX_GROUP, RTPATH_F_ON_LINK,
+                                     &offError, RTErrInfoInitStatic(&ErrInfo));
+            if (RT_FAILURE(rc))
+                RT_BZERO(&paObjInfo[2], sizeof(RTFSOBJINFO));
+        }
+        else
+        {
+            RT_BZERO(&paObjInfo[1], sizeof(RTFSOBJINFO));
+            RT_BZERO(&paObjInfo[2], sizeof(RTFSOBJINFO));
+        }
+
+        rc = VINF_SUCCESS; /* aObjInfo[1] + aObjInfo[2] are optional. */
+    }
+    else
+        RTVfsChainMsgError("RTVfsChainQueryInfo", pszSpec, rc, offError, &ErrInfo.Core);
+
+    return rc;
+}
+
+
+/**
+ * Archives a file.
+ *
+ * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE + printed message.
+ * @param   pOpts           The options.
+ * @param   hVfsFss         The TAR filesystem stream handle.
+ * @param   pszSrc          The file path or VFS spec.
+ * @param   paObjInfo[3]    Array of three FS object info structures.  The first
+ *                          one is always filled with RTFSOBJATTRADD_UNIX info.
+ *                          The next two may contain owner and group names if
+ *                          available.  Buffers can be modified.
+ * @param   pszDst          The name to archive the file under.
+ * @param   pErrInfo        Error info buffer (saves stack space).
+ */
+static RTEXITCODE rtZipTarCmdArchiveFile(PRTZIPTARCMDOPS pOpts, RTVFSFSSTREAM hVfsFss, const char *pszSrc,
+                                         RTFSOBJINFO paObjInfo[3], const char *pszDst, PRTERRINFOSTATIC pErrInfo)
+{
+    if (pOpts->fVerbose)
+        RTPrintf("%s\n", pszDst);
+
+    /* Open the file. */
+    uint32_t        offError;
+    RTVFSIOSTREAM   hVfsIosSrc;
+    int rc = RTVfsChainOpenIoStream(pszSrc, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE,
+                                    &hVfsIosSrc, &offError, RTErrInfoInitStatic(pErrInfo));
+    if (RT_FAILURE(rc))
+        return RTVfsChainMsgErrorExitFailure("RTVfsChainOpenIoStream", pszSrc, rc, offError, &pErrInfo->Core);
+
+    /* I/O stream to base object. */
+    RTVFSOBJ hVfsObjSrc = RTVfsObjFromIoStream(hVfsIosSrc);
+    if (hVfsObjSrc != NIL_RTVFSOBJ)
+    {
+        /*
+         * Add it to the stream.  Got to variants here so we can test the
+         * RTVfsFsStrmPushFile API too.
+         */
+        if (!pOpts->fUsePushFile)
+            rc = RTVfsFsStrmAdd(hVfsFss, pszDst, hVfsObjSrc, 0 /*fFlags*/);
+        else
+        {
+            uint32_t cObjInfo = 1 + (paObjInfo[1].Attr.enmAdditional == RTFSOBJATTRADD_UNIX_OWNER)
+                                  + (paObjInfo[2].Attr.enmAdditional == RTFSOBJATTRADD_UNIX_GROUP);
+            RTVFSIOSTREAM hVfsIosDst;
+            rc = RTVfsFsStrmPushFile(hVfsFss, pszDst, paObjInfo[0].cbObject, paObjInfo, cObjInfo, 0 /*fFlags*/, &hVfsIosDst);
+            if (RT_SUCCESS(rc))
+            {
+                rc = RTVfsUtilPumpIoStreams(hVfsIosSrc, hVfsIosDst, 0);
+                RTVfsIoStrmRelease(hVfsIosDst);
+            }
+        }
+        RTVfsIoStrmRelease(hVfsIosSrc);
+        RTVfsObjRelease(hVfsObjSrc);
+
+        if (RT_SUCCESS(rc))
+        {
+            if (rc != VINF_SUCCESS)
+                RTMsgWarning("%Rrc adding '%s'", rc, pszDst);
+            return RTEXITCODE_SUCCESS;
+        }
+        return RTMsgErrorExitFailure("%Rrc adding '%s'", rc, pszDst);
+    }
+    RTVfsIoStrmRelease(hVfsIosSrc);
+    return RTMsgErrorExitFailure("RTVfsObjFromIoStream failed unexpectedly!");
+}
+
+
+/**
+ * Sub-directory helper for creating archives.
+ *
+ * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE + printed message.
+ * @param   pOpts           The options.
+ * @param   hVfsFss         The TAR filesystem stream handle.
+ * @param   pszSrc          The directory path or VFS spec.  We append to the
+ *                          buffer as we decend.
+ * @param   cchSrc          The length of the input.
+ * @param   paObjInfo[3]    Array of three FS object info structures.  The first
+ *                          one is always filled with RTFSOBJATTRADD_UNIX info.
+ *                          The next two may contain owner and group names if
+ *                          available.  The three buffers can be reused.
+ * @param   pszDst          The name to archive it the under.  We append to the
+ *                          buffer as we decend.
+ * @param   cchDst          The length of the input.
+ * @param   pDirEntry       Directory entry to use for the directory to handle.
+ * @param   pErrInfo        Error info buffer (saves stack space).
+ */
+static RTEXITCODE rtZipTarCmdArchiveDirSub(PRTZIPTARCMDOPS pOpts, RTVFSFSSTREAM hVfsFss,
+                                           char *pszSrc, size_t cchSrc, RTFSOBJINFO paObjInfo[3],
+                                           char pszDst[RTPATH_MAX], size_t cchDst, PRTDIRENTRYEX pDirEntry,
+                                           PRTERRINFOSTATIC pErrInfo)
+{
+    if (pOpts->fVerbose)
+        RTPrintf("%s\n", pszDst);
+
+    uint32_t offError;
+    RTVFSDIR hVfsIoDir;
+    int rc = RTVfsChainOpenDir(pszSrc, 0 /*fFlags*/,
+                               &hVfsIoDir, &offError, RTErrInfoInitStatic(pErrInfo));
+    if (RT_FAILURE(rc))
+        return RTVfsChainMsgErrorExitFailure("RTVfsChainOpenDir", pszSrc, rc, offError, &pErrInfo->Core);
+
+    /* Make sure we've got some room in the path, to save us extra work further down. */
+    if (cchSrc + 3 >= RTPATH_MAX)
+        return RTMsgErrorExitFailure("Source path too long: '%s'\n", pszSrc);
+
+    /* Ensure we've got a trailing slash (there is space for it see above). */
+    if (!RTPATH_IS_SEP(pszSrc[cchSrc - 1]))
+    {
+        pszSrc[cchSrc++] = RTPATH_SLASH;
+        pszSrc[cchSrc]   = '\0';
+    }
+
+    /* Ditto for destination. */
+    if (cchDst + 3 >= RTPATH_MAX)
+        return RTMsgErrorExitFailure("Destination path too long: '%s'\n", pszDst);
+
+    if (!RTPATH_IS_SEP(pszDst[cchDst - 1]))
+    {
+        pszDst[cchDst++] = RTPATH_SLASH;
+        pszDst[cchDst]   = '\0';
+    }
+
+    /*
+     * Process the files and subdirs.
+     */
+    for (;;)
+    {
+        size_t cbDirEntry = RTZIPTARCMD_DIRENTRY_BUF_SIZE;
+        rc = RTVfsDirReadEx(hVfsIoDir, pDirEntry, &cbDirEntry, RTFSOBJATTRADD_UNIX);
+        if (RT_FAILURE(rc))
+            break;
+
+        /* Check length. */
+        if (pDirEntry->cbName + cchSrc + 3 >= RTPATH_MAX)
+        {
+            rc = VERR_BUFFER_OVERFLOW;
+            break;
+        }
+
+        switch (pDirEntry->Info.Attr.fMode & RTFS_TYPE_MASK)
+        {
+            case RTFS_TYPE_DIRECTORY:
+            {
+                if (RTDirEntryExIsStdDotLink(pDirEntry))
+                    continue;
+
+                if (!pOpts->fRecursive)
+                    continue;
+
+                memcpy(&pszSrc[cchSrc], pDirEntry->szName, pDirEntry->cbName + 1);
+                if (RT_SUCCESS(rc))
+                {
+                    memcpy(&pszDst[cchDst], pDirEntry->szName, pDirEntry->cbName + 1);
+                    rc = rtZipTarCmdArchiveDirSub(pOpts, hVfsFss, pszSrc, cchSrc + pDirEntry->cbName, paObjInfo,
+                                                  pszDst, cchDst + pDirEntry->cbName, pDirEntry, pErrInfo);
+                }
+
+                break;
+            }
+
+            case RTFS_TYPE_FILE:
+            {
+                memcpy(&pszSrc[cchSrc], pDirEntry->szName, pDirEntry->cbName + 1);
+                rc = rtZipTarCmdQueryObjInfo(pszSrc, paObjInfo, 3 /* cObjInfo */);
+                if (RT_SUCCESS(rc))
+                {
+                    memcpy(&pszDst[cchDst], pDirEntry->szName, pDirEntry->cbName + 1);
+                    rc = rtZipTarCmdArchiveFile(pOpts, hVfsFss, pszSrc, paObjInfo, pszDst, pErrInfo);
+                }
+                break;
+            }
+
+            default:
+            {
+                if (pOpts->fVerbose)
+                    RTPrintf("Warning: File system type %#x for '%s' not implemented yet, sorry! Skipping ...\n",
+                             pDirEntry->Info.Attr.fMode & RTFS_TYPE_MASK, pDirEntry->szName);
+                break;
+            }
+        }
+    }
+
+    RTVfsDirRelease(hVfsIoDir);
+
+    if (rc != VERR_NO_MORE_FILES)
+        return RTMsgErrorExitFailure("RTVfsDirReadEx failed unexpectedly!");
+
+    return RTEXITCODE_SUCCESS;
+}
+
+
+/**
+ * Archives a directory recursively.
+ *
+ * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE + printed message.
+ * @param   pOpts           The options.
+ * @param   hVfsFss         The TAR filesystem stream handle.
+ * @param   pszSrc          The directory path or VFS spec.  We append to the
+ *                          buffer as we decend.
+ * @param   cchSrc          The length of the input.
+ * @param   paObjInfo[3]    Array of three FS object info structures.  The first
+ *                          one is always filled with RTFSOBJATTRADD_UNIX info.
+ *                          The next two may contain owner and group names if
+ *                          available.  The three buffers can be reused.
+ * @param   pszDst          The name to archive it the under.  We append to the
+ *                          buffer as we decend.
+ * @param   cchDst          The length of the input.
+ * @param   pErrInfo        Error info buffer (saves stack space).
+ */
+static RTEXITCODE rtZipTarCmdArchiveDir(PRTZIPTARCMDOPS pOpts, RTVFSFSSTREAM hVfsFss, char pszSrc[RTPATH_MAX], size_t cchSrc,
+                                        RTFSOBJINFO paObjInfo[3], char pszDst[RTPATH_MAX], size_t cchDst,
+                                        PRTERRINFOSTATIC pErrInfo)
+{
+    RT_NOREF(cchSrc);
+
+    char szSrcAbs[RTPATH_MAX];
+    int rc = RTPathAbs(pszSrc, szSrcAbs, sizeof(szSrcAbs));
+    if (RT_FAILURE(rc))
+        return RTMsgErrorExitFailure("RTPathAbs failed on '%s': %Rrc\n", pszSrc, rc);
+
+    union
+    {
+        uint8_t         abPadding[RTZIPTARCMD_DIRENTRY_BUF_SIZE];
+        RTDIRENTRYEX    DirEntry;
+    } uBuf;
+
+    return rtZipTarCmdArchiveDirSub(pOpts, hVfsFss, szSrcAbs, strlen(szSrcAbs), paObjInfo, pszDst, cchDst, &uBuf.DirEntry, pErrInfo);
+}
+
+
+/**
+ * Opens the output archive specified by the options.
+ *
+ * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE + printed message.
+ * @param   pOpts           The options.
+ * @param   phVfsFss        Where to return the TAR filesystem stream handle.
+ */
+static RTEXITCODE rtZipTarCmdOpenOutputArchive(PRTZIPTARCMDOPS pOpts, PRTVFSFSSTREAM phVfsFss)
+{
+    int rc;
+    *phVfsFss = NIL_RTVFSFSSTREAM;
+
+    /*
+     * Open the output file.
+     */
+    RTVFSIOSTREAM   hVfsIos;
+    if (   pOpts->pszFile
+        && strcmp(pOpts->pszFile, "-") != 0)
+    {
+        uint32_t        offError = 0;
+        RTERRINFOSTATIC ErrInfo;
+        rc = RTVfsChainOpenIoStream(pOpts->pszFile, RTFILE_O_WRITE | RTFILE_O_DENY_WRITE | RTFILE_O_CREATE_REPLACE,
+                                    &hVfsIos, &offError, RTErrInfoInitStatic(&ErrInfo));
+        if (RT_FAILURE(rc))
+            return RTVfsChainMsgErrorExitFailure("RTVfsChainOpenIoStream", pOpts->pszFile, rc, offError, &ErrInfo.Core);
+    }
+    else
+    {
+        rc = RTVfsIoStrmFromStdHandle(RTHANDLESTD_OUTPUT,
+                                      RTFILE_O_WRITE | RTFILE_O_DENY_WRITE | RTFILE_O_OPEN,
+                                      true /*fLeaveOpen*/,
+                                      &hVfsIos);
+        if (RT_FAILURE(rc))
+            return RTMsgErrorExitFailure("Failed to prepare standard output for writing: %Rrc", rc);
+    }
+
+    /*
+     * Pass it thru a compressor?
+     */
+    RTVFSIOSTREAM hVfsIosComp = NIL_RTVFSIOSTREAM;
+    switch (pOpts->chZipper)
+    {
+        /* no */
+        case '\0':
+            rc = VINF_SUCCESS;
+            break;
+
+        /* gunzip */
+        case 'z':
+            rc = RTZipGzipCompressIoStream(hVfsIos, 0 /*fFlags*/, 6, &hVfsIosComp);
+            if (RT_FAILURE(rc))
+                RTMsgError("Failed to open gzip decompressor: %Rrc", rc);
+            break;
+
+        /* bunzip2 */
+        case 'j':
+            rc = VERR_NOT_SUPPORTED;
+            RTMsgError("bzip2 is not supported by this build");
+            break;
+
+        /* bug */
+        default:
+            rc = VERR_INTERNAL_ERROR_2;
+            RTMsgError("unknown decompression method '%c'",  pOpts->chZipper);
+            break;
+    }
+    if (RT_FAILURE(rc))
+    {
+        RTVfsIoStrmRelease(hVfsIos);
+        return RTEXITCODE_FAILURE;
+    }
+
+    if (hVfsIosComp != NIL_RTVFSIOSTREAM)
+    {
+        RTVfsIoStrmRelease(hVfsIos);
+        hVfsIos = hVfsIosComp;
+        hVfsIosComp = NIL_RTVFSIOSTREAM;
+    }
+
+    /*
+     * Open the filesystem stream creator.
+     */
+    if (   pOpts->enmFormat == RTZIPTARCMDFORMAT_TAR
+        || pOpts->enmFormat == RTZIPTARCMDFORMAT_AUTO_DEFAULT)
+    {
+        RTVFSFSSTREAM hVfsFss;
+        rc = RTZipTarFsStreamToIoStream(hVfsIos, pOpts->enmTarFormat, pOpts->fTarCreate, &hVfsFss);
+        if (RT_SUCCESS(rc))
+        {
+            /*
+             * Set transformation options.
+             */
+            rc = RTZipTarFsStreamSetFileMode(hVfsFss, pOpts->fFileModeAndMask, pOpts->fFileModeOrMask);
+            if (RT_SUCCESS(rc))
+            {
+                rc = RTZipTarFsStreamSetDirMode(hVfsFss, pOpts->fDirModeAndMask, pOpts->fDirModeOrMask);
+                if (RT_FAILURE(rc))
+                    RTMsgError("RTZipTarFsStreamSetDirMode(%o,%o) failed: %Rrc", pOpts->fDirModeAndMask, pOpts->fDirModeOrMask, rc);
+            }
+            else
+                RTMsgError("RTZipTarFsStreamSetFileMode(%o,%o) failed: %Rrc", pOpts->fFileModeAndMask, pOpts->fFileModeOrMask, rc);
+            if ((pOpts->pszOwner || pOpts->uidOwner != NIL_RTUID) && RT_SUCCESS(rc))
+            {
+                rc = RTZipTarFsStreamSetOwner(hVfsFss, pOpts->uidOwner, pOpts->pszOwner);
+                if (RT_FAILURE(rc))
+                    RTMsgError("RTZipTarFsStreamSetOwner(%d,%s) failed: %Rrc", pOpts->uidOwner, pOpts->pszOwner, rc);
+            }
+            if ((pOpts->pszGroup || pOpts->gidGroup != NIL_RTGID) && RT_SUCCESS(rc))
+            {
+                rc = RTZipTarFsStreamSetGroup(hVfsFss, pOpts->gidGroup, pOpts->pszGroup);
+                if (RT_FAILURE(rc))
+                    RTMsgError("RTZipTarFsStreamSetGroup(%d,%s) failed: %Rrc", pOpts->gidGroup, pOpts->pszGroup, rc);
+            }
+            if (RT_SUCCESS(rc))
+                *phVfsFss = hVfsFss;
+            else
+            {
+                RTVfsFsStrmRelease(hVfsFss);
+                *phVfsFss = NIL_RTVFSFSSTREAM;
+            }
+        }
+        else
+            rc = RTMsgErrorExitFailure("Failed to open tar filesystem stream: %Rrc", rc);
+    }
+    else
+        rc = VERR_NOT_SUPPORTED;
+    RTVfsIoStrmRelease(hVfsIos);
+    if (RT_FAILURE(rc))
+        return RTMsgErrorExitFailure("Failed to open tar filesystem stream: %Rrc", rc);
+
+    return RTEXITCODE_SUCCESS;
+}
+
+
+/**
+ * Implements archive creation.
+ *
+ * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE + printed message.
+ * @param   pOpts           The options.
+ */
+static RTEXITCODE rtZipTarCreate(PRTZIPTARCMDOPS pOpts)
+{
+    /*
+     * Refuse to create empty archive.
+     */
+    if (pOpts->cFiles == 0)
+        return RTMsgErrorExitFailure("Nothing to archive - refusing to create empty archive!");
+
+    /*
+     * First open the output file.
+     */
+    RTVFSFSSTREAM hVfsFss;
+    RTEXITCODE rcExit = rtZipTarCmdOpenOutputArchive(pOpts, &hVfsFss);
+    if (rcExit != RTEXITCODE_SUCCESS)
+        return rcExit;
+
+    /*
+     * Process the input files.
+     */
+    for (uint32_t iFile = 0; iFile < pOpts->cFiles; iFile++)
+    {
+        const char *pszFile = pOpts->papszFiles[iFile];
+
+        /*
+         * Construct/copy the source name.
+         */
+        int         rc = VINF_SUCCESS;
+        char        szSrc[RTPATH_MAX];
+        if (   RTPathStartsWithRoot(pszFile)
+            || RTVfsChainIsSpec(pszFile))
+            rc = RTStrCopy(szSrc, sizeof(szSrc), pszFile);
+        else
+            rc = RTPathJoin(szSrc, sizeof(szSrc), pOpts->pszDirectory ? pOpts->pszDirectory : ".", pOpts->papszFiles[iFile]);
+        if (RT_SUCCESS(rc))
+        {
+            /*
+             * Construct the archived name.  We must strip leading root specifier.
+             */
+            char *pszFinalPath = NULL;
+            char  szDst[RTPATH_MAX];
+            const char *pszDst = pszFile;
+            if (RTVfsChainIsSpec(pszFile))
+            {
+                uint32_t offError;
+                rc = RTVfsChainQueryFinalPath(pszFile, &pszFinalPath, &offError);
+                if (RT_SUCCESS(rc))
+                    pszDst = pszFinalPath;
+                else
+                    rcExit = RTVfsChainMsgErrorExitFailure("RTVfsChainQueryFinalPath", pszFile, rc, offError, NULL);
+            }
+            if (RT_SUCCESS(rc))
+            {
+                pszDst = RTPathSkipRootSpec(pszDst);
+                if (*pszDst == '\0')
+                {
+                    pszDst = pOpts->pszPrefix ? pOpts->pszPrefix : ".";
+                    rc = RTStrCopy(szDst, sizeof(szDst), pszDst);
+                }
+                else
+                {
+                    if (pOpts->pszPrefix)
+                        rc = RTPathJoin(szDst, sizeof(szDst), pOpts->pszPrefix, pszDst);
+                    else
+                        rc = RTStrCopy(szDst, sizeof(szDst), pszDst);
+                }
+                if (RT_SUCCESS(rc))
+                {
+                    /*
+                     * What kind of object is this and what affiliations does it have?
+                     */
+                    RTFSOBJINFO aObjInfo[3];
+                    rc = rtZipTarCmdQueryObjInfo(szSrc, aObjInfo, RT_ELEMENTS(aObjInfo));
+                    if (RT_SUCCESS(rc))
+                    {
+                        RTERRINFOSTATIC ErrInfo;
+
+                        /*
+                         * Process on an object type basis.
+                         */
+                        RTEXITCODE rcExit2;
+                        if (RTFS_IS_DIRECTORY(aObjInfo[0].Attr.fMode))
+                            rcExit2 = rtZipTarCmdArchiveDir(pOpts, hVfsFss, szSrc, strlen(szSrc), aObjInfo,
+                                                            szDst, strlen(szDst), &ErrInfo);
+                        else if (RTFS_IS_FILE(aObjInfo[0].Attr.fMode))
+                            rcExit2 = rtZipTarCmdArchiveFile(pOpts, hVfsFss, szSrc, aObjInfo, szDst, &ErrInfo);
+                        else if (RTFS_IS_SYMLINK(aObjInfo[0].Attr.fMode))
+                            rcExit2 = RTMsgErrorExitFailure("Symlink archiving is not implemented");
+                        else if (RTFS_IS_FIFO(aObjInfo[0].Attr.fMode))
+                            rcExit2 = RTMsgErrorExitFailure("FIFO archiving is not implemented");
+                        else if (RTFS_IS_SOCKET(aObjInfo[0].Attr.fMode))
+                            rcExit2 = RTMsgErrorExitFailure("Socket archiving is not implemented");
+                        else if (RTFS_IS_DEV_CHAR(aObjInfo[0].Attr.fMode) || RTFS_IS_DEV_BLOCK(aObjInfo[0].Attr.fMode))
+                            rcExit2 = RTMsgErrorExitFailure("Device archiving is not implemented");
+                        else if (RTFS_IS_WHITEOUT(aObjInfo[0].Attr.fMode))
+                            rcExit2 = RTEXITCODE_SUCCESS;
+                        else
+                            rcExit2 = RTMsgErrorExitFailure("Unknown file type: %#x\n", aObjInfo[0].Attr.fMode);
+                        if (rcExit2 != RTEXITCODE_SUCCESS)
+                            rcExit = rcExit2;
+                    }
+                    else
+                        rcExit = RTMsgErrorExitFailure("querying object information for '%s' failed (%s)", szSrc, pszFile);
+                }
+                else
+                    rcExit = RTMsgErrorExitFailure("archived file name is too long, skipping '%s' (%s)", pszDst, pszFile);
+            }
+        }
+        else
+            rcExit = RTMsgErrorExitFailure("input file name is too long, skipping '%s'",  pszFile);
+    }
+
+    /*
+     * Finalize the archive.
+     */
+    int rc = RTVfsFsStrmEnd(hVfsFss);
+    if (RT_FAILURE(rc))
+        rcExit = RTMsgErrorExitFailure("RTVfsFsStrmEnd failed: %Rrc", rc);
+
+    RTVfsFsStrmRelease(hVfsFss);
+    return rcExit;
+}
+
+
+/**
+ * Opens the input archive specified by the options.
+ *
+ * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE + printed message.
+ * @param   pOpts           The options.
+ * @param   phVfsFss        Where to return the TAR filesystem stream handle.
+ */
+static RTEXITCODE rtZipTarCmdOpenInputArchive(PRTZIPTARCMDOPS pOpts, PRTVFSFSSTREAM phVfsFss)
+{
+    int rc;
+
+    /*
+     * Open the input file.
+     */
+    RTVFSIOSTREAM   hVfsIos;
+    if (   pOpts->pszFile
+        && strcmp(pOpts->pszFile, "-") != 0)
+    {
+        uint32_t        offError = 0;
+        RTERRINFOSTATIC ErrInfo;
+        rc = RTVfsChainOpenIoStream(pOpts->pszFile, RTFILE_O_READ | RTFILE_O_DENY_WRITE | RTFILE_O_OPEN,
+                                    &hVfsIos, &offError, RTErrInfoInitStatic(&ErrInfo));
+        if (RT_FAILURE(rc))
+            return RTVfsChainMsgErrorExitFailure("RTVfsChainOpenIoStream", pOpts->pszFile, rc, offError, &ErrInfo.Core);
+    }
+    else
+    {
+        rc = RTVfsIoStrmFromStdHandle(RTHANDLESTD_INPUT,
+                                      RTFILE_O_READ | RTFILE_O_DENY_WRITE | RTFILE_O_OPEN,
+                                      true /*fLeaveOpen*/,
+                                      &hVfsIos);
+        if (RT_FAILURE(rc))
+            return RTMsgErrorExitFailure("Failed to prepare standard in for reading: %Rrc", rc);
+    }
+
+    /*
+     * Pass it thru a decompressor?
+     */
+    RTVFSIOSTREAM hVfsIosDecomp = NIL_RTVFSIOSTREAM;
+    switch (pOpts->chZipper)
+    {
+        /* no */
+        case '\0':
+            rc = VINF_SUCCESS;
+            break;
+
+        /* gunzip */
+        case 'z':
+            rc = RTZipGzipDecompressIoStream(hVfsIos, 0 /*fFlags*/, &hVfsIosDecomp);
+            if (RT_FAILURE(rc))
+                RTMsgError("Failed to open gzip decompressor: %Rrc", rc);
+            break;
+
+        /* bunzip2 */
+        case 'j':
+            rc = VERR_NOT_SUPPORTED;
+            RTMsgError("bzip2 is not supported by this build");
+            break;
+
+        /* bug */
+        default:
+            rc = VERR_INTERNAL_ERROR_2;
+            RTMsgError("unknown decompression method '%c'",  pOpts->chZipper);
+            break;
+    }
+    if (RT_FAILURE(rc))
+    {
+        RTVfsIoStrmRelease(hVfsIos);
+        return RTEXITCODE_FAILURE;
+    }
+
+    if (hVfsIosDecomp != NIL_RTVFSIOSTREAM)
+    {
+        RTVfsIoStrmRelease(hVfsIos);
+        hVfsIos = hVfsIosDecomp;
+        hVfsIosDecomp = NIL_RTVFSIOSTREAM;
+    }
+
+    /*
+     * Open the filesystem stream.
+     */
+    if (pOpts->enmFormat == RTZIPTARCMDFORMAT_TAR)
+        rc = RTZipTarFsStreamFromIoStream(hVfsIos, 0/*fFlags*/, phVfsFss);
+    else if (pOpts->enmFormat == RTZIPTARCMDFORMAT_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 if (pOpts->enmFormat == RTZIPTARCMDFORMAT_CPIO)
+        rc = RTZipCpioFsStreamFromIoStream(hVfsIos, 0/*fFlags*/, phVfsFss);
+    else /** @todo make RTZipTarFsStreamFromIoStream fail if not tar file! */
+        rc = RTZipTarFsStreamFromIoStream(hVfsIos, 0/*fFlags*/, phVfsFss);
+    RTVfsIoStrmRelease(hVfsIos);
+    if (RT_FAILURE(rc))
+        return RTMsgErrorExitFailure("Failed to open tar filesystem stream: %Rrc", rc);
+
+    return RTEXITCODE_SUCCESS;
+}
+
+
+/**
+ * Worker for the --list and --extract commands.
+ *
+ * @returns The appropriate exit code.
+ * @param   pOpts               The tar options.
+ * @param   pfnCallback         The command specific callback.
+ */
+static RTEXITCODE rtZipTarDoWithMembers(PRTZIPTARCMDOPS pOpts, PFNDOWITHMEMBER pfnCallback)
+{
+    /*
+     * Allocate a bitmap to go with the file list.  This will be used to
+     * indicate which files we've processed and which not.
+     */
+    uint32_t *pbmFound = NULL;
+    if (pOpts->cFiles)
+    {
+        pbmFound = (uint32_t *)RTMemAllocZ(((pOpts->cFiles + 31) / 32) * sizeof(uint32_t));
+        if (!pbmFound)
+            return RTMsgErrorExitFailure("Failed to allocate the found-file-bitmap");
+    }
+
+
+    /*
+     * Open the input archive.
+     */
+    RTVFSFSSTREAM hVfsFssIn;
+    RTEXITCODE rcExit = rtZipTarCmdOpenInputArchive(pOpts, &hVfsFssIn);
+    if (rcExit == RTEXITCODE_SUCCESS)
+    {
+        /*
+         * Process the stream.
+         */
+        for (;;)
+        {
+            /*
+             * Retrive the next object.
+             */
+            char       *pszName;
+            RTVFSOBJ    hVfsObj;
+            int rc = RTVfsFsStrmNext(hVfsFssIn, &pszName, NULL, &hVfsObj);
+            if (RT_FAILURE(rc))
+            {
+                if (rc != VERR_EOF)
+                    rcExit = RTMsgErrorExitFailure("RTVfsFsStrmNext returned %Rrc", rc);
+                break;
+            }
+
+            /*
+             * Should we process this entry?
+             */
+            uint32_t    iFile = UINT32_MAX;
+            if (   !pOpts->cFiles
+                || rtZipTarCmdIsNameInArray(pszName, pOpts->papszFiles, &iFile) )
+            {
+                if (pbmFound)
+                    ASMBitSet(pbmFound, iFile);
+
+                rcExit = pfnCallback(pOpts, hVfsObj, pszName, rcExit);
+            }
+
+            /*
+             * Release the current object and string.
+             */
+            RTVfsObjRelease(hVfsObj);
+            RTStrFree(pszName);
+        }
+
+        /*
+         * Complain about any files we didn't find.
+         */
+        for (uint32_t iFile = 0; iFile < pOpts->cFiles; iFile++)
+            if (!ASMBitTest(pbmFound, iFile))
+            {
+                RTMsgError("%s: Was not found in the archive", pOpts->papszFiles[iFile]);
+                rcExit = RTEXITCODE_FAILURE;
+            }
+
+        RTVfsFsStrmRelease(hVfsFssIn);
+    }
+    RTMemFree(pbmFound);
+    return rcExit;
+}
+
+
+/**
+ * Checks if the name contains any escape sequences.
+ *
+ * An escape sequence would generally be one or more '..' references.  On DOS
+ * like system, something that would make up a drive letter reference is also
+ * considered an escape sequence.
+ *
+ * @returns true / false.
+ * @param   pszName     The name to consider.
+ */
+static bool rtZipTarHasEscapeSequence(const char *pszName)
+{
+#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
+    if (pszName[0] == ':')
+        return true;
+#endif
+    while (*pszName)
+    {
+        while (RTPATH_IS_SEP(*pszName))
+            pszName++;
+        if (   pszName[0] == '.'
+            && pszName[1] == '.'
+            && (pszName[2] == '\0' || RTPATH_IS_SLASH(pszName[2])) )
+            return true;
+        while (*pszName && !RTPATH_IS_SEP(*pszName))
+            pszName++;
+    }
+
+    return false;
+}
+
+
+#if !defined(RT_OS_WINDOWS) && !defined(RT_OS_OS2)
+
+/**
+ * Queries the user ID to use when extracting a member.
+ *
+ * @returns rcExit or RTEXITCODE_FAILURE.
+ * @param   pOpts               The tar options.
+ * @param   pUser               The user info.
+ * @param   pszName             The file name to use when complaining.
+ * @param   rcExit              The current exit code.
+ * @param   pUid                Where to return the user ID.
+ */
+static RTEXITCODE rtZipTarQueryExtractOwner(PRTZIPTARCMDOPS pOpts, PCRTFSOBJINFO pOwner, const char *pszName, RTEXITCODE rcExit,
+                                            PRTUID pUid)
+{
+    if (pOpts->uidOwner != NIL_RTUID)
+        *pUid = pOpts->uidOwner;
+    else if (pOpts->fPreserveGroup)
+    {
+        if (!pOwner->Attr.u.UnixGroup.szName[0])
+             *pUid = pOwner->Attr.u.UnixOwner.uid;
+        else
+        {
+            *pUid = NIL_RTUID;
+            return RTMsgErrorExitFailure("%s: User resolving is not implemented.", pszName);
+        }
+    }
+    else
+        *pUid = NIL_RTUID;
+    return rcExit;
+}
+
+
+/**
+ * Queries the group ID to use when extracting a member.
+ *
+ * @returns rcExit or RTEXITCODE_FAILURE.
+ * @param   pOpts               The tar options.
+ * @param   pGroup              The group info.
+ * @param   pszName             The file name to use when complaining.
+ * @param   rcExit              The current exit code.
+ * @param   pGid                Where to return the group ID.
+ */
+static RTEXITCODE rtZipTarQueryExtractGroup(PRTZIPTARCMDOPS pOpts, PCRTFSOBJINFO pGroup, const char *pszName, RTEXITCODE rcExit,
+                                            PRTGID pGid)
+{
+    if (pOpts->gidGroup != NIL_RTGID)
+        *pGid = pOpts->gidGroup;
+    else if (pOpts->fPreserveGroup)
+    {
+        if (!pGroup->Attr.u.UnixGroup.szName[0])
+            *pGid = pGroup->Attr.u.UnixGroup.gid;
+        else
+        {
+            *pGid = NIL_RTGID;
+            return RTMsgErrorExitFailure("%s: Group resolving is not implemented.", pszName);
+        }
+    }
+    else
+        *pGid = NIL_RTGID;
+    return rcExit;
+}
+
+#endif /* !defined(RT_OS_WINDOWS) && !defined(RT_OS_OS2) */
+
+
+/**
+ * Corrects the file mode and other attributes.
+ *
+ * Common worker for rtZipTarCmdExtractFile and rtZipTarCmdExtractHardlink.
+ *
+ * @returns rcExit or RTEXITCODE_FAILURE.
+ * @param   pOpts               The tar options.
+ * @param   rcExit              The current exit code.
+ * @param   hFile               The handle to the destination file.
+ * @param   pszDst              The destination path (for error reporting).
+ * @param   pUnixInfo           The unix fs object info.
+ * @param   pOwner              The owner info.
+ * @param   pGroup              The group info.
+ */
+static RTEXITCODE rtZipTarCmdExtractSetAttribs(PRTZIPTARCMDOPS pOpts, RTEXITCODE rcExit, RTFILE hFile, const char *pszDst,
+                                               PCRTFSOBJINFO pUnixInfo, PCRTFSOBJINFO pOwner, PCRTFSOBJINFO pGroup)
+{
+    int rc;
+
+    if (!pOpts->fNoModTime)
+    {
+        rc = RTFileSetTimes(hFile, NULL, &pUnixInfo->ModificationTime, NULL, NULL);
+        if (RT_FAILURE(rc))
+            rcExit = RTMsgErrorExitFailure("%s: Error setting times: %Rrc", pszDst, rc);
+    }
+
+#if !defined(RT_OS_WINDOWS) && !defined(RT_OS_OS2)
+    if (   pOpts->uidOwner != NIL_RTUID
+        || pOpts->gidGroup != NIL_RTGID
+        || pOpts->fPreserveOwner
+        || pOpts->fPreserveGroup)
+    {
+        RTUID uidFile;
+        rcExit = rtZipTarQueryExtractOwner(pOpts, pOwner, pszDst, rcExit, &uidFile);
+
+        RTGID gidFile;
+        rcExit = rtZipTarQueryExtractGroup(pOpts, pGroup, pszDst, rcExit, &gidFile);
+        if (uidFile != NIL_RTUID || gidFile != NIL_RTGID)
+        {
+            rc = RTFileSetOwner(hFile, uidFile, gidFile);
+            if (RT_FAILURE(rc))
+                rcExit = RTMsgErrorExitFailure("%s: Error owner/group: %Rrc", pszDst, rc);
+        }
+    }
+#else
+    RT_NOREF_PV(pOwner); RT_NOREF_PV(pGroup);
+#endif
+
+    RTFMODE fMode = (pUnixInfo->Attr.fMode & pOpts->fFileModeAndMask) | pOpts->fFileModeOrMask;
+    rc = RTFileSetMode(hFile, fMode | RTFS_TYPE_FILE);
+    if (RT_FAILURE(rc))
+        rcExit = RTMsgErrorExitFailure("%s: Error changing mode: %Rrc", pszDst, rc);
+
+    return rcExit;
+}
+
+
+/**
+ * Extracts a hard linked file.
+ *
+ * @returns rcExit or RTEXITCODE_FAILURE.
+ * @param   pOpts               The tar options.
+ * @param   rcExit              The current exit code.
+ * @param   pszDst              The destination path.
+ * @param   pszTarget           The target relative path.
+ * @param   pUnixInfo           The unix fs object info.
+ * @param   pOwner              The owner info.
+ * @param   pGroup              The group info.
+ */
+static RTEXITCODE rtZipTarCmdExtractHardlink(PRTZIPTARCMDOPS pOpts, RTEXITCODE rcExit, const char *pszDst,
+                                             const char *pszTarget, PCRTFSOBJINFO pUnixInfo, PCRTFSOBJINFO pOwner,
+                                             PCRTFSOBJINFO pGroup)
+{
+    /*
+     * Construct full target path and check that it exists.
+     */
+    char szFullTarget[RTPATH_MAX];
+    int rc = RTPathJoin(szFullTarget, sizeof(szFullTarget), pOpts->pszDirectory ? pOpts->pszDirectory : ".", pszTarget);
+    if (RT_FAILURE(rc))
+        return RTMsgErrorExitFailure("%s: Failed to construct full hardlink target path for %s: %Rrc",
+                                     pszDst, pszTarget, rc);
+
+    if (!RTFileExists(szFullTarget))
+        return RTMsgErrorExitFailure("%s: Hardlink target not found (or not a file): %s", pszDst, szFullTarget);
+
+    /*
+     * Try hardlink the file, falling back on copying.
+     */
+    /** @todo actual hardlinking */
+    if (true)
+    {
+        RTMsgWarning("%s: Hardlinking not available, copying '%s' instead.", pszDst, szFullTarget);
+
+        RTFILE hSrcFile;
+        rc = RTFileOpen(&hSrcFile, szFullTarget, RTFILE_O_READ | RTFILE_O_DENY_WRITE | RTFILE_O_OPEN);
+        if (RT_SUCCESS(rc))
+        {
+            uint32_t fOpen = RTFILE_O_READWRITE | RTFILE_O_DENY_WRITE | RTFILE_O_CREATE_REPLACE | RTFILE_O_ACCESS_ATTR_DEFAULT
+                           | ((RTFS_UNIX_IWUSR | RTFS_UNIX_IRUSR) << RTFILE_O_CREATE_MODE_SHIFT);
+            RTFILE hDstFile;
+            rc = RTFileOpen(&hDstFile, pszDst, fOpen);
+            if (RT_SUCCESS(rc))
+            {
+                rc = RTFileCopyByHandles(hSrcFile, hDstFile);
+                if (RT_SUCCESS(rc))
+                {
+                    rcExit = rtZipTarCmdExtractSetAttribs(pOpts, rcExit, hDstFile, pszDst, pUnixInfo, pOwner, pGroup);
+                    rc = RTFileClose(hDstFile);
+                    if (RT_FAILURE(rc))
+                    {
+                        rcExit = RTMsgErrorExitFailure("%s: Error closing hardlinked file copy: %Rrc", pszDst, rc);
+                        RTFileDelete(pszDst);
+                    }
+                }
+                else
+                {
+                    rcExit = RTMsgErrorExitFailure("%s: Failed copying hardlinked file '%s': %Rrc", pszDst, szFullTarget, rc);
+                    rc = RTFileClose(hDstFile);
+                    RTFileDelete(pszDst);
+                }
+            }
+            else
+                rcExit = RTMsgErrorExitFailure("%s: Error creating file: %Rrc", pszDst, rc);
+            RTFileClose(hSrcFile);
+        }
+        else
+            rcExit = RTMsgErrorExitFailure("%s: Error opening file '%s' for reading (hardlink target): %Rrc",
+                                           pszDst, szFullTarget, rc);
+    }
+
+    return rcExit;
+}
+
+
+
+/**
+ * Extracts a file.
+ *
+ * Since we can restore permissions and attributes more efficiently by working
+ * directly on the file handle, we have special code path for files.
+ *
+ * @returns rcExit or RTEXITCODE_FAILURE.
+ * @param   pOpts               The tar options.
+ * @param   hVfsObj             The tar object to display
+ * @param   rcExit              The current exit code.
+ * @param   pszDst              The destination path.
+ * @param   pUnixInfo           The unix fs object info.
+ * @param   pOwner              The owner info.
+ * @param   pGroup              The group info.
+ */
+static RTEXITCODE rtZipTarCmdExtractFile(PRTZIPTARCMDOPS pOpts, RTVFSOBJ hVfsObj, RTEXITCODE rcExit,
+                                         const char *pszDst, PCRTFSOBJINFO pUnixInfo, PCRTFSOBJINFO pOwner, PCRTFSOBJINFO pGroup)
+{
+    /*
+     * Open the destination file and create a stream object for it.
+     */
+    uint32_t fOpen = RTFILE_O_READWRITE | RTFILE_O_DENY_WRITE | RTFILE_O_CREATE_REPLACE | RTFILE_O_ACCESS_ATTR_DEFAULT
+                   | ((RTFS_UNIX_IWUSR | RTFS_UNIX_IRUSR) << RTFILE_O_CREATE_MODE_SHIFT);
+    RTFILE hFile;
+    int rc = RTFileOpen(&hFile, pszDst, fOpen);
+    if (RT_FAILURE(rc))
+        return RTMsgErrorExitFailure("%s: Error creating file: %Rrc", pszDst, rc);
+
+    RTVFSIOSTREAM hVfsIosDst;
+    rc = RTVfsIoStrmFromRTFile(hFile, fOpen, true /*fLeaveOpen*/, &hVfsIosDst);
+    if (RT_SUCCESS(rc))
+    {
+        /*
+         * Convert source to a stream and optionally add a read ahead stage.
+         */
+        RTVFSIOSTREAM hVfsIosSrc = RTVfsObjToIoStream(hVfsObj);
+        if (pOpts->fReadAhead)
+        {
+            RTVFSIOSTREAM hVfsReadAhead;
+            rc = RTVfsCreateReadAheadForIoStream(hVfsIosSrc, 0 /*fFlag*/, 16 /*cBuffers*/, _256K /*cbBuffer*/, &hVfsReadAhead);
+            if (RT_SUCCESS(rc))
+            {
+                RTVfsIoStrmRelease(hVfsIosSrc);
+                hVfsIosSrc = hVfsReadAhead;
+            }
+            else
+                AssertRC(rc); /* can be ignored in release builds. */
+        }
+
+        /*
+         * Pump the data thru and correct the file attributes.
+         */
+        rc = RTVfsUtilPumpIoStreams(hVfsIosSrc, hVfsIosDst, (uint32_t)RT_MIN(pUnixInfo->cbObject, _1M));
+        if (RT_SUCCESS(rc))
+            rcExit = rtZipTarCmdExtractSetAttribs(pOpts, rcExit, hFile, pszDst, pUnixInfo, pOwner, pGroup);
+        else
+            rcExit = RTMsgErrorExitFailure("%s: Error writing out file: %Rrc", pszDst, rc);
+        RTVfsIoStrmRelease(hVfsIosSrc);
+        RTVfsIoStrmRelease(hVfsIosDst);
+    }
+    else
+        rcExit = RTMsgErrorExitFailure("%s: Error creating I/O stream for file: %Rrc", pszDst, rc);
+    RTFileClose(hFile);
+    return rcExit;
+}
+
+
+/**
+ * @callback_method_impl{PFNDOWITHMEMBER, Implements --extract.}
+ */
+static RTEXITCODE rtZipTarCmdExtractCallback(PRTZIPTARCMDOPS pOpts, RTVFSOBJ hVfsObj, const char *pszName, RTEXITCODE rcExit)
+{
+    if (pOpts->fVerbose)
+        RTPrintf("%s\n", pszName);
+
+    /*
+     * Query all the information.
+     */
+    RTFSOBJINFO UnixInfo;
+    int rc = RTVfsObjQueryInfo(hVfsObj, &UnixInfo, RTFSOBJATTRADD_UNIX);
+    if (RT_FAILURE(rc))
+        return RTMsgErrorExitFailure("RTVfsObjQueryInfo returned %Rrc on '%s'", rc, pszName);
+
+    RTFSOBJINFO Owner;
+    rc = RTVfsObjQueryInfo(hVfsObj, &Owner, RTFSOBJATTRADD_UNIX_OWNER);
+    if (RT_FAILURE(rc))
+        return RTMsgErrorExit(RTEXITCODE_FAILURE,
+                              "RTVfsObjQueryInfo(,,UNIX_OWNER) returned %Rrc on '%s'",
+                              rc, pszName);
+
+    RTFSOBJINFO Group;
+    rc = RTVfsObjQueryInfo(hVfsObj, &Group, RTFSOBJATTRADD_UNIX_GROUP);
+    if (RT_FAILURE(rc))
+        return RTMsgErrorExit(RTEXITCODE_FAILURE,
+                              "RTVfsObjQueryInfo(,,UNIX_OWNER) returned %Rrc on '%s'",
+                              rc, pszName);
+
+    bool fIsHardLink = false;
+    char szTarget[RTPATH_MAX];
+    szTarget[0] = '\0';
+    RTVFSSYMLINK hVfsSymlink = RTVfsObjToSymlink(hVfsObj);
+    if (hVfsSymlink != NIL_RTVFSSYMLINK)
+    {
+        rc = RTVfsSymlinkRead(hVfsSymlink, szTarget, sizeof(szTarget));
+        RTVfsSymlinkRelease(hVfsSymlink);
+        if (RT_FAILURE(rc))
+            return RTMsgErrorExitFailure("%s: RTVfsSymlinkRead failed: %Rrc", pszName, rc);
+        if (!szTarget[0])
+            return RTMsgErrorExitFailure("%s: Link target is empty.", pszName);
+        if (!RTFS_IS_SYMLINK(UnixInfo.Attr.fMode))
+        {
+            fIsHardLink = true;
+            if (!RTFS_IS_FILE(UnixInfo.Attr.fMode))
+                return RTMsgErrorExitFailure("%s: Hardlinks are only supported for regular files (target=%s).",
+                                             pszName, szTarget);
+            if (rtZipTarHasEscapeSequence(pszName))
+                return RTMsgErrorExitFailure("%s: Hardlink target '%s' contains an escape sequence.",
+                                             pszName, szTarget);
+        }
+    }
+    else if (RTFS_IS_SYMLINK(UnixInfo.Attr.fMode))
+        return RTMsgErrorExitFailure("Failed to get symlink object for '%s'", pszName);
+
+    if (rtZipTarHasEscapeSequence(pszName))
+        return RTMsgErrorExitFailure("Name '%s' contains an escape sequence.", pszName);
+
+    /*
+     * Construct the path to the extracted member.
+     */
+    char szDst[RTPATH_MAX];
+    rc = RTPathJoin(szDst, sizeof(szDst), pOpts->pszDirectory ? pOpts->pszDirectory : ".", pszName);
+    if (RT_FAILURE(rc))
+        return RTMsgErrorExitFailure("%s: Failed to construct destination path for: %Rrc", pszName, rc);
+
+    /*
+     * Extract according to the type.
+     */
+    if (!fIsHardLink)
+        switch (UnixInfo.Attr.fMode & RTFS_TYPE_MASK)
+        {
+            case RTFS_TYPE_FILE:
+                return rtZipTarCmdExtractFile(pOpts, hVfsObj, rcExit, szDst, &UnixInfo, &Owner, &Group);
+
+            case RTFS_TYPE_DIRECTORY:
+                rc = RTDirCreateFullPath(szDst, UnixInfo.Attr.fMode & RTFS_UNIX_ALL_ACCESS_PERMS);
+                if (RT_FAILURE(rc))
+                    return RTMsgErrorExitFailure("%s: Error creating directory: %Rrc", szDst, rc);
+                break;
+
+            case RTFS_TYPE_SYMLINK:
+                rc = RTSymlinkCreate(szDst, szTarget, RTSYMLINKTYPE_UNKNOWN, 0);
+                if (RT_FAILURE(rc))
+                    return RTMsgErrorExitFailure("%s: Error creating symbolic link: %Rrc", szDst, rc);
+                break;
+
+            case RTFS_TYPE_FIFO:
+                return RTMsgErrorExitFailure("%s: FIFOs are not supported.", pszName);
+            case RTFS_TYPE_DEV_CHAR:
+                return RTMsgErrorExitFailure("%s: FIFOs are not supported.", pszName);
+            case RTFS_TYPE_DEV_BLOCK:
+                return RTMsgErrorExitFailure("%s: Block devices are not supported.", pszName);
+            case RTFS_TYPE_SOCKET:
+                return RTMsgErrorExitFailure("%s: Sockets are not supported.", pszName);
+            case RTFS_TYPE_WHITEOUT:
+                return RTMsgErrorExitFailure("%s: Whiteouts are not support.", pszName);
+            default:
+                return RTMsgErrorExitFailure("%s: Unknown file type.", pszName);
+        }
+    else
+        return rtZipTarCmdExtractHardlink(pOpts, rcExit, szDst, szTarget, &UnixInfo, &Owner, &Group);
+
+    /*
+     * Set other attributes as requested.
+     *
+     * Note! File extraction does get here.
+     */
+    if (!pOpts->fNoModTime)
+    {
+        rc = RTPathSetTimesEx(szDst, NULL, &UnixInfo.ModificationTime, NULL, NULL, RTPATH_F_ON_LINK);
+        if (RT_FAILURE(rc) && rc != VERR_NOT_SUPPORTED && rc != VERR_NS_SYMLINK_SET_TIME)
+            rcExit = RTMsgErrorExitFailure("%s: Error changing modification time: %Rrc.", pszName, rc);
+    }
+
+#if !defined(RT_OS_WINDOWS) && !defined(RT_OS_OS2)
+    if (   pOpts->uidOwner != NIL_RTUID
+        || pOpts->gidGroup != NIL_RTGID
+        || pOpts->fPreserveOwner
+        || pOpts->fPreserveGroup)
+    {
+        RTUID uidFile;
+        rcExit = rtZipTarQueryExtractOwner(pOpts, &Owner, szDst, rcExit, &uidFile);
+
+        RTGID gidFile;
+        rcExit = rtZipTarQueryExtractGroup(pOpts, &Group, szDst, rcExit, &gidFile);
+        if (uidFile != NIL_RTUID || gidFile != NIL_RTGID)
+        {
+            rc = RTPathSetOwnerEx(szDst, uidFile, gidFile, RTPATH_F_ON_LINK);
+            if (RT_FAILURE(rc))
+                rcExit = RTMsgErrorExitFailure("%s: Error owner/group: %Rrc", szDst, rc);
+        }
+    }
+#endif
+
+#if !defined(RT_OS_WINDOWS) /** @todo implement RTPathSetMode on windows... */
+    if (!RTFS_IS_SYMLINK(UnixInfo.Attr.fMode)) /* RTPathSetMode follows symbolic links atm. */
+    {
+        RTFMODE fMode;
+        if (RTFS_IS_DIRECTORY(UnixInfo.Attr.fMode))
+            fMode = (UnixInfo.Attr.fMode & (pOpts->fDirModeAndMask  | RTFS_TYPE_MASK)) | pOpts->fDirModeOrMask;
+        else
+            fMode = (UnixInfo.Attr.fMode & (pOpts->fFileModeAndMask | RTFS_TYPE_MASK)) | pOpts->fFileModeOrMask;
+        rc = RTPathSetMode(szDst, fMode);
+        if (RT_FAILURE(rc))
+            rcExit = RTMsgErrorExitFailure("%s: Error changing mode: %Rrc", szDst, rc);
+    }
+#endif
+
+    return rcExit;
+}
+
+
+/**
+ * @callback_method_impl{PFNDOWITHMEMBER, Implements --list.}
+ */
+static RTEXITCODE rtZipTarCmdListCallback(PRTZIPTARCMDOPS pOpts, RTVFSOBJ hVfsObj, const char *pszName, RTEXITCODE rcExit)
+{
+    /*
+     * This is very simple in non-verbose mode.
+     */
+    if (!pOpts->fVerbose)
+    {
+        RTPrintf("%s\n", pszName);
+        return rcExit;
+    }
+
+    /*
+     * Query all the information.
+     */
+    RTFSOBJINFO UnixInfo;
+    int rc = RTVfsObjQueryInfo(hVfsObj, &UnixInfo, RTFSOBJATTRADD_UNIX);
+    if (RT_FAILURE(rc))
+    {
+        rcExit = RTMsgErrorExitFailure("RTVfsObjQueryInfo returned %Rrc on '%s'", rc, pszName);
+        RT_ZERO(UnixInfo);
+    }
+
+    RTFSOBJINFO Owner;
+    rc = RTVfsObjQueryInfo(hVfsObj, &Owner, RTFSOBJATTRADD_UNIX_OWNER);
+    if (RT_FAILURE(rc))
+    {
+        rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE,
+                                "RTVfsObjQueryInfo(,,UNIX_OWNER) returned %Rrc on '%s'",
+                                rc, pszName);
+        RT_ZERO(Owner);
+    }
+
+    RTFSOBJINFO Group;
+    rc = RTVfsObjQueryInfo(hVfsObj, &Group, RTFSOBJATTRADD_UNIX_GROUP);
+    if (RT_FAILURE(rc))
+    {
+        rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE,
+                                "RTVfsObjQueryInfo(,,UNIX_OWNER) returned %Rrc on '%s'",
+                                rc, pszName);
+        RT_ZERO(Group);
+    }
+
+    const char *pszLinkType = NULL;
+    char szTarget[RTPATH_MAX];
+    szTarget[0] = '\0';
+    RTVFSSYMLINK hVfsSymlink = RTVfsObjToSymlink(hVfsObj);
+    if (hVfsSymlink != NIL_RTVFSSYMLINK)
+    {
+        rc = RTVfsSymlinkRead(hVfsSymlink, szTarget, sizeof(szTarget));
+        if (RT_FAILURE(rc))
+            rcExit = RTMsgErrorExitFailure("RTVfsSymlinkRead returned %Rrc on '%s'", rc, pszName);
+        RTVfsSymlinkRelease(hVfsSymlink);
+        pszLinkType = RTFS_IS_SYMLINK(UnixInfo.Attr.fMode) ? "->" : "link to";
+    }
+    else if (RTFS_IS_SYMLINK(UnixInfo.Attr.fMode))
+        rcExit = RTMsgErrorExitFailure("Failed to get symlink object for '%s'", pszName);
+
+    /*
+     * Translate the mode mask.
+     */
+    char szMode[16];
+    switch (UnixInfo.Attr.fMode & RTFS_TYPE_MASK)
+    {
+        case RTFS_TYPE_FIFO:        szMode[0] = 'f'; break;
+        case RTFS_TYPE_DEV_CHAR:    szMode[0] = 'c'; break;
+        case RTFS_TYPE_DIRECTORY:   szMode[0] = 'd'; break;
+        case RTFS_TYPE_DEV_BLOCK:   szMode[0] = 'b'; break;
+        case RTFS_TYPE_FILE:        szMode[0] = '-'; break;
+        case RTFS_TYPE_SYMLINK:     szMode[0] = 'l'; break;
+        case RTFS_TYPE_SOCKET:      szMode[0] = 's'; break;
+        case RTFS_TYPE_WHITEOUT:    szMode[0] = 'w'; break;
+        default:                    szMode[0] = '?'; break;
+    }
+    if (pszLinkType && szMode[0] != 's')
+        szMode[0] = 'h';
+
+    szMode[1] = UnixInfo.Attr.fMode & RTFS_UNIX_IRUSR ? 'r' : '-';
+    szMode[2] = UnixInfo.Attr.fMode & RTFS_UNIX_IWUSR ? 'w' : '-';
+    szMode[3] = UnixInfo.Attr.fMode & RTFS_UNIX_IXUSR ? 'x' : '-';
+
+    szMode[4] = UnixInfo.Attr.fMode & RTFS_UNIX_IRGRP ? 'r' : '-';
+    szMode[5] = UnixInfo.Attr.fMode & RTFS_UNIX_IWGRP ? 'w' : '-';
+    szMode[6] = UnixInfo.Attr.fMode & RTFS_UNIX_IXGRP ? 'x' : '-';
+
+    szMode[7] = UnixInfo.Attr.fMode & RTFS_UNIX_IROTH ? 'r' : '-';
+    szMode[8] = UnixInfo.Attr.fMode & RTFS_UNIX_IWOTH ? 'w' : '-';
+    szMode[9] = UnixInfo.Attr.fMode & RTFS_UNIX_IXOTH ? 'x' : '-';
+    szMode[10] = '\0';
+
+    /** @todo sticky and set-uid/gid bits. */
+
+    /*
+     * Make sure we've got valid owner and group strings.
+     */
+    if (!Owner.Attr.u.UnixGroup.szName[0])
+        RTStrPrintf(Owner.Attr.u.UnixOwner.szName, sizeof(Owner.Attr.u.UnixOwner.szName),
+                    "%u", UnixInfo.Attr.u.Unix.uid);
+
+    if (!Group.Attr.u.UnixOwner.szName[0])
+        RTStrPrintf(Group.Attr.u.UnixGroup.szName, sizeof(Group.Attr.u.UnixGroup.szName),
+                    "%u", UnixInfo.Attr.u.Unix.gid);
+
+    /*
+     * Format the modification time.
+     */
+    char       szModTime[32];
+    RTTIME     ModTime;
+    PRTTIME    pTime;
+    if (!pOpts->fDisplayUtc)
+        pTime = RTTimeLocalExplode(&ModTime, &UnixInfo.ModificationTime);
+    else
+        pTime = RTTimeExplode(&ModTime, &UnixInfo.ModificationTime);
+    if (!pTime)
+        RT_ZERO(ModTime);
+    RTStrPrintf(szModTime, sizeof(szModTime), "%04d-%02u-%02u %02u:%02u",
+                ModTime.i32Year, ModTime.u8Month, ModTime.u8MonthDay, ModTime.u8Hour, ModTime.u8Minute);
+
+    /*
+     * Format the size and figure how much space is needed between the
+     * user/group and the size.
+     */
+    char   szSize[64];
+    size_t cchSize;
+    switch (UnixInfo.Attr.fMode & RTFS_TYPE_MASK)
+    {
+        case RTFS_TYPE_DEV_CHAR:
+        case RTFS_TYPE_DEV_BLOCK:
+            cchSize = RTStrPrintf(szSize, sizeof(szSize), "%u,%u",
+                                  RTDEV_MAJOR(UnixInfo.Attr.u.Unix.Device), RTDEV_MINOR(UnixInfo.Attr.u.Unix.Device));
+            break;
+        default:
+            cchSize = RTStrPrintf(szSize, sizeof(szSize), "%RU64", UnixInfo.cbObject);
+            break;
+    }
+
+    size_t cchUserGroup = strlen(Owner.Attr.u.UnixOwner.szName)
+                        + 1
+                        + strlen(Group.Attr.u.UnixGroup.szName);
+    ssize_t cchPad = cchUserGroup + cchSize + 1 < 19
+                   ? 19 - (cchUserGroup + cchSize + 1)
+                   : 0;
+
+    /*
+     * Go to press.
+     */
+    if (pszLinkType)
+        RTPrintf("%s %s/%s%*s %s %s %s %s %s\n",
+                 szMode,
+                 Owner.Attr.u.UnixOwner.szName, Group.Attr.u.UnixGroup.szName,
+                 cchPad, "",
+                 szSize,
+                 szModTime,
+                 pszName,
+                 pszLinkType,
+                 szTarget);
+    else
+        RTPrintf("%s %s/%s%*s %s %s %s\n",
+                 szMode,
+                 Owner.Attr.u.UnixOwner.szName, Group.Attr.u.UnixGroup.szName,
+                 cchPad, "",
+                 szSize,
+                 szModTime,
+                 pszName);
+
+    return rcExit;
+}
+
+
+/**
+ * Display usage.
+ *
+ * @param   pszProgName         The program name.
+ */
+static void rtZipTarUsage(const char *pszProgName)
+{
+    /*
+     *        0         1         2         3         4         5         6         7         8
+     *        012345678901234567890123456789012345678901234567890123456789012345678901234567890
+     */
+    RTPrintf("Usage: %s [options]\n"
+             "\n",
+             pszProgName);
+    RTPrintf("Operations:\n"
+             "    -A, --concatenate, --catenate\n"
+             "        Append the content of one tar archive to another. (not impl)\n"
+             "    -c, --create\n"
+             "        Create a new tar archive. (not impl)\n"
+             "    -d, --diff, --compare\n"
+             "        Compare atar archive with the file system. (not impl)\n"
+             "    -r, --append\n"
+             "        Append more files to the tar archive. (not impl)\n"
+             "    -t, --list\n"
+             "        List the contents of the tar archive.\n"
+             "    -u, --update\n"
+             "        Update the archive, adding files that are newer than the\n"
+             "        ones in the archive. (not impl)\n"
+             "    -x, --extract, --get\n"
+             "        Extract the files from the tar archive.\n"
+             "    --delete\n"
+             "        Delete files from the tar archive.\n"
+             "\n"
+             );
+    RTPrintf("Basic Options:\n"
+             "    -C <dir>, --directory <dir>           (-A, -c, -d, -r, -u, -x)\n"
+             "        Sets the base directory for input and output file members.\n"
+             "        This does not apply to --file, even if it preceeds it.\n"
+             "    -f <archive>, --file <archive>        (all)\n"
+             "        The tar file to create or process. '-' indicates stdout/stdin,\n"
+             "        which is is the default.\n"
+             "    -v, --verbose                         (all)\n"
+             "        Verbose operation.\n"
+             "    -p, --preserve-permissions            (-x)\n"
+             "        Preserve all permissions when extracting.  Must be used\n"
+             "        before the mode mask options as it will change some of these.\n"
+             "    -j, --bzip2                           (all)\n"
+             "        Compress/decompress the archive with bzip2.\n"
+             "    -z, --gzip, --gunzip, --ungzip        (all)\n"
+             "        Compress/decompress the archive with gzip.\n"
+             "\n");
+    RTPrintf("Misc Options:\n"
+             "    --owner <uid/username>                (-A, -c, -d, -r, -u, -x)\n"
+             "        Set the owner of extracted and archived files to the user specified.\n"
+             "    --group <uid/username>                (-A, -c, -d, -r, -u, -x)\n"
+             "        Set the group of extracted and archived files to the group specified.\n"
+             "    --utc                                 (-t)\n"
+             "        Display timestamps as UTC instead of local time.\n"
+             "    -S, --sparse                          (-A, -c, -u)\n"
+             "        Detect sparse files and store them (gnu tar extension).\n"
+             "    --format <format>                     (-A, -c, -u, but also -d, -r, -x)\n"
+             "        The file format:\n"
+             "                  auto (gnu tar)\n"
+             "                  default (gnu tar)\n"
+             "                  tar (gnu tar)"
+             "                  gnu (tar v1.13+), "
+             "                  ustar (tar POSIX.1-1988), "
+             "                  pax (tar POSIX.1-2001),\n"
+             "                  xar\n"
+             "                  cpio\n"
+             "        Note! Because XAR/TAR/CPIO detection isn't implemented yet, it\n"
+             "              is necessary to specifcy --format=xar when reading a\n"
+             "              XAR file or --format=cpio for a CPIO file.\n"
+             "              Otherwise this option is only for creation.\n"
+             "\n");
+    RTPrintf("IPRT Options:\n"
+             "    --prefix <dir-prefix>                 (-A, -c, -d, -r, -u)\n"
+             "        Directory prefix to give the members added to the archive.\n"
+             "    --file-mode-and-mask <octal-mode>     (-A, -c, -d, -r, -u, -x)\n"
+             "        Restrict the access mode of regular and special files.\n"
+             "    --file-mode-or-mask <octal-mode>      (-A, -c, -d, -r, -u, -x)\n"
+             "        Include the given access mode for regular and special files.\n"
+             "    --dir-mode-and-mask <octal-mode>      (-A, -c, -d, -r, -u, -x)\n"
+             "        Restrict the access mode of directories.\n"
+             "    --dir-mode-or-mask <octal-mode>       (-A, -c, -d, -r, -u, -x)\n"
+             "        Include the given access mode for directories.\n"
+             "    --read-ahead                          (-x)\n"
+             "        Enabled read ahead thread when extracting files.\n"
+             "    --push-file                           (-A, -c, -u)\n"
+             "        Use RTVfsFsStrmPushFile instead of RTVfsFsStrmAdd.\n"
+             "\n");
+    RTPrintf("Standard Options:\n"
+             "    -h, -?, --help\n"
+             "        Display this help text.\n"
+             "    -V, --version\n"
+             "        Display version number.\n");
+}
+
+
+RTDECL(RTEXITCODE) RTZipTarCmd(unsigned cArgs, char **papszArgs)
+{
+    /*
+     * Parse the command line.
+     *
+     * N.B. This is less flexible that your regular tar program in that it
+     *      requires the operation to be specified as an option.  On the other
+     *      hand, you can specify it where ever you like in the command line.
+     */
+    static const RTGETOPTDEF s_aOptions[] =
+    {
+        /* operations */
+        { "--concatenate",          'A',                                RTGETOPT_REQ_NOTHING },
+        { "--catenate",             'A',                                RTGETOPT_REQ_NOTHING },
+        { "--create",               'c',                                RTGETOPT_REQ_NOTHING },
+        { "--diff",                 'd',                                RTGETOPT_REQ_NOTHING },
+        { "--compare",              'd',                                RTGETOPT_REQ_NOTHING },
+        { "--append",               'r',                                RTGETOPT_REQ_NOTHING },
+        { "--list",                 't',                                RTGETOPT_REQ_NOTHING },
+        { "--update",               'u',                                RTGETOPT_REQ_NOTHING },
+        { "--extract",              'x',                                RTGETOPT_REQ_NOTHING },
+        { "--get",                  'x',                                RTGETOPT_REQ_NOTHING },
+        { "--delete",               RTZIPTARCMD_OPT_DELETE,             RTGETOPT_REQ_NOTHING },
+
+        /* basic options */
+        { "--directory",            'C',                                RTGETOPT_REQ_STRING },
+        { "--file",                 'f',                                RTGETOPT_REQ_STRING },
+        { "--verbose",              'v',                                RTGETOPT_REQ_NOTHING },
+        { "--preserve-permissions", 'p',                                RTGETOPT_REQ_NOTHING },
+        { "--bzip2",                'j',                                RTGETOPT_REQ_NOTHING },
+        { "--gzip",                 'z',                                RTGETOPT_REQ_NOTHING },
+        { "--gunzip",               'z',                                RTGETOPT_REQ_NOTHING },
+        { "--ungzip",               'z',                                RTGETOPT_REQ_NOTHING },
+
+        /* other options. */
+        { "--owner",                RTZIPTARCMD_OPT_OWNER,              RTGETOPT_REQ_STRING },
+        { "--group",                RTZIPTARCMD_OPT_GROUP,              RTGETOPT_REQ_STRING },
+        { "--utc",                  RTZIPTARCMD_OPT_UTC,                RTGETOPT_REQ_NOTHING },
+        { "--sparse",               'S',                                RTGETOPT_REQ_NOTHING },
+        { "--format",               RTZIPTARCMD_OPT_FORMAT,             RTGETOPT_REQ_STRING },
+        { "--no-recursion",         RTZIPTARCMD_OPT_NO_RECURSION,       RTGETOPT_REQ_NOTHING },
+
+        /* IPRT extensions */
+        { "--prefix",               RTZIPTARCMD_OPT_PREFIX,             RTGETOPT_REQ_STRING },
+        { "--file-mode-and-mask",   RTZIPTARCMD_OPT_FILE_MODE_AND_MASK, RTGETOPT_REQ_UINT32 | RTGETOPT_FLAG_OCT },
+        { "--file-mode-or-mask",    RTZIPTARCMD_OPT_FILE_MODE_OR_MASK,  RTGETOPT_REQ_UINT32 | RTGETOPT_FLAG_OCT },
+        { "--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 },
+        { "--read-ahead",           RTZIPTARCMD_OPT_READ_AHEAD,         RTGETOPT_REQ_NOTHING },
+        { "--use-push-file",        RTZIPTARCMD_OPT_USE_PUSH_FILE,      RTGETOPT_REQ_NOTHING },
+    };
+
+    RTGETOPTSTATE GetState;
+    int rc = RTGetOptInit(&GetState, cArgs, papszArgs, s_aOptions, RT_ELEMENTS(s_aOptions), 1,
+                          RTGETOPTINIT_FLAGS_OPTS_FIRST);
+    if (RT_FAILURE(rc))
+        return RTMsgErrorExitFailure("RTGetOpt failed: %Rrc", rc);
+
+    RTZIPTARCMDOPS Opts;
+    RT_ZERO(Opts);
+    Opts.enmFormat = RTZIPTARCMDFORMAT_AUTO_DEFAULT;
+    Opts.uidOwner = NIL_RTUID;
+    Opts.gidGroup = NIL_RTUID;
+    Opts.fFileModeAndMask = RTFS_UNIX_ALL_ACCESS_PERMS;
+    Opts.fDirModeAndMask  = RTFS_UNIX_ALL_ACCESS_PERMS;
+#if 0
+    if (RTPermIsSuperUser())
+    {
+        Opts.fFileModeAndMask = RTFS_UNIX_ALL_PERMS;
+        Opts.fDirModeAndMask  = RTFS_UNIX_ALL_PERMS;
+        Opts.fPreserveOwner   = true;
+        Opts.fPreserveGroup   = true;
+    }
+#endif
+    Opts.enmTarFormat = RTZIPTARFORMAT_DEFAULT;
+    Opts.fRecursive   = true; /* Recursion is implicit unless otherwise specified. */
+
+    RTGETOPTUNION   ValueUnion;
+    while (   (rc = RTGetOpt(&GetState, &ValueUnion)) != 0
+           && rc != VINF_GETOPT_NOT_OPTION)
+    {
+        switch (rc)
+        {
+            /* operations */
+            case 'A':
+            case 'c':
+            case 'd':
+            case 'r':
+            case 't':
+            case 'u':
+            case 'x':
+            case RTZIPTARCMD_OPT_DELETE:
+                if (Opts.iOperation)
+                    return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Conflicting tar operation (%s already set, now %s)",
+                                          Opts.pszOperation, ValueUnion.pDef->pszLong);
+                Opts.iOperation   = rc;
+                Opts.pszOperation = ValueUnion.pDef->pszLong;
+                break;
+
+            /* basic options */
+            case 'C':
+                if (Opts.pszDirectory)
+                    return RTMsgErrorExit(RTEXITCODE_SYNTAX, "You may only specify -C/--directory once");
+                Opts.pszDirectory = ValueUnion.psz;
+                break;
+
+            case 'f':
+                if (Opts.pszFile)
+                    return RTMsgErrorExit(RTEXITCODE_SYNTAX, "You may only specify -f/--file once");
+                Opts.pszFile = ValueUnion.psz;
+                break;
+
+            case 'v':
+                Opts.fVerbose = true;
+                break;
+
+            case 'p':
+                Opts.fFileModeAndMask   = RTFS_UNIX_ALL_PERMS;
+                Opts.fDirModeAndMask    = RTFS_UNIX_ALL_PERMS;
+                Opts.fPreserveOwner     = true;
+                Opts.fPreserveGroup     = true;
+                break;
+
+            case 'j':
+            case 'z':
+                if (Opts.chZipper)
+                    return RTMsgErrorExit(RTEXITCODE_SYNTAX, "You may only specify one compressor / decompressor");
+                Opts.chZipper = rc;
+                break;
+
+            case RTZIPTARCMD_OPT_OWNER:
+                if (Opts.pszOwner)
+                    return RTMsgErrorExit(RTEXITCODE_SYNTAX, "You may only specify --owner once");
+                Opts.pszOwner = ValueUnion.psz;
+
+                rc = RTStrToUInt32Full(Opts.pszOwner, 0, &ValueUnion.u32);
+                if (RT_SUCCESS(rc) && rc != VINF_SUCCESS)
+                    return RTMsgErrorExit(RTEXITCODE_SYNTAX,
+                                          "Error convering --owner '%s' into a number: %Rrc", Opts.pszOwner, rc);
+                if (RT_SUCCESS(rc))
+                {
+                    Opts.uidOwner = ValueUnion.u32;
+                    Opts.pszOwner = NULL;
+                }
+                break;
+
+            case RTZIPTARCMD_OPT_GROUP:
+                if (Opts.pszGroup)
+                    return RTMsgErrorExit(RTEXITCODE_SYNTAX, "You may only specify --group once");
+                Opts.pszGroup = ValueUnion.psz;
+
+                rc = RTStrToUInt32Full(Opts.pszGroup, 0, &ValueUnion.u32);
+                if (RT_SUCCESS(rc) && rc != VINF_SUCCESS)
+                    return RTMsgErrorExit(RTEXITCODE_SYNTAX,
+                                          "Error convering --group '%s' into a number: %Rrc", Opts.pszGroup, rc);
+                if (RT_SUCCESS(rc))
+                {
+                    Opts.gidGroup = ValueUnion.u32;
+                    Opts.pszGroup = NULL;
+                }
+                break;
+
+            case RTZIPTARCMD_OPT_UTC:
+                Opts.fDisplayUtc = true;
+                break;
+
+            case RTZIPTARCMD_OPT_NO_RECURSION:
+                Opts.fRecursive = false;
+                break;
+
+            /* GNU */
+            case 'S':
+                Opts.fTarCreate |= RTZIPTAR_C_SPARSE;
+                break;
+
+            /* iprt extensions */
+            case RTZIPTARCMD_OPT_PREFIX:
+                if (Opts.pszPrefix)
+                    return RTMsgErrorExit(RTEXITCODE_SYNTAX, "You may only specify --prefix once");
+                Opts.pszPrefix = ValueUnion.psz;
+                break;
+
+            case RTZIPTARCMD_OPT_FILE_MODE_AND_MASK:
+                Opts.fFileModeAndMask = ValueUnion.u32 & RTFS_UNIX_ALL_PERMS;
+                break;
+
+            case RTZIPTARCMD_OPT_FILE_MODE_OR_MASK:
+                Opts.fFileModeOrMask  = ValueUnion.u32 & RTFS_UNIX_ALL_PERMS;
+                break;
+
+            case RTZIPTARCMD_OPT_DIR_MODE_AND_MASK:
+                Opts.fDirModeAndMask  = ValueUnion.u32 & RTFS_UNIX_ALL_PERMS;
+                break;
+
+            case RTZIPTARCMD_OPT_DIR_MODE_OR_MASK:
+                Opts.fDirModeOrMask   = ValueUnion.u32 & RTFS_UNIX_ALL_PERMS;
+                break;
+
+            case RTZIPTARCMD_OPT_FORMAT:
+                if (!strcmp(ValueUnion.psz, "auto") || !strcmp(ValueUnion.psz, "default"))
+                {
+                    Opts.enmFormat    = RTZIPTARCMDFORMAT_AUTO_DEFAULT;
+                    Opts.enmTarFormat = RTZIPTARFORMAT_DEFAULT;
+                }
+                else if (!strcmp(ValueUnion.psz, "tar"))
+                {
+                    Opts.enmFormat    = RTZIPTARCMDFORMAT_TAR;
+                    Opts.enmTarFormat = RTZIPTARFORMAT_DEFAULT;
+                }
+                else if (!strcmp(ValueUnion.psz, "gnu"))
+                {
+                    Opts.enmFormat    = RTZIPTARCMDFORMAT_TAR;
+                    Opts.enmTarFormat = RTZIPTARFORMAT_GNU;
+                }
+                else if (!strcmp(ValueUnion.psz, "ustar"))
+                {
+                    Opts.enmFormat    = RTZIPTARCMDFORMAT_TAR;
+                    Opts.enmTarFormat = RTZIPTARFORMAT_USTAR;
+                }
+                else if (   !strcmp(ValueUnion.psz, "posix")
+                         || !strcmp(ValueUnion.psz, "pax"))
+                {
+                    Opts.enmFormat    = RTZIPTARCMDFORMAT_TAR;
+                    Opts.enmTarFormat = RTZIPTARFORMAT_PAX;
+                }
+                else if (!strcmp(ValueUnion.psz, "xar"))
+                    Opts.enmFormat    = RTZIPTARCMDFORMAT_XAR;
+                else if (!strcmp(ValueUnion.psz, "cpio"))
+                    Opts.enmFormat    = RTZIPTARCMDFORMAT_CPIO;
+                else
+                    return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Unknown archive format: '%s'", ValueUnion.psz);
+                break;
+
+            case RTZIPTARCMD_OPT_READ_AHEAD:
+                Opts.fReadAhead = true;
+                break;
+
+            case RTZIPTARCMD_OPT_USE_PUSH_FILE:
+                Opts.fUsePushFile = true;
+                break;
+
+            /* Standard bits. */
+            case 'h':
+                rtZipTarUsage(RTPathFilename(papszArgs[0]));
+                return RTEXITCODE_SUCCESS;
+
+            case 'V':
+                RTPrintf("%sr%d\n", RTBldCfgVersion(), RTBldCfgRevision());
+                return RTEXITCODE_SUCCESS;
+
+            default:
+                return RTGetOptPrintError(rc, &ValueUnion);
+        }
+    }
+
+    if (rc == VINF_GETOPT_NOT_OPTION)
+    {
+        /* this is kind of ugly. */
+        Assert((unsigned)GetState.iNext - 1 <= cArgs);
+        Opts.papszFiles = (const char * const *)&papszArgs[GetState.iNext - 1];
+        Opts.cFiles     = cArgs - GetState.iNext + 1;
+    }
+
+    if (!Opts.pszFile)
+        return RTMsgErrorExitFailure("No archive specified");
+
+    /*
+     * Post proceess the options.
+     */
+    if (Opts.iOperation == 0)
+    {
+        Opts.iOperation   = 't';
+        Opts.pszOperation = "--list";
+    }
+
+    if (   Opts.iOperation == 'x'
+        && Opts.pszOwner)
+        return RTMsgErrorExitFailure("The use of --owner with %s has not implemented yet", Opts.pszOperation);
+
+    if (   Opts.iOperation == 'x'
+        && Opts.pszGroup)
+        return RTMsgErrorExitFailure("The use of --group with %s has not implemented yet", Opts.pszOperation);
+
+    /*
+     * Do the job.
+     */
+    switch (Opts.iOperation)
+    {
+        case 't':
+            return rtZipTarDoWithMembers(&Opts, rtZipTarCmdListCallback);
+
+        case 'x':
+            return rtZipTarDoWithMembers(&Opts, rtZipTarCmdExtractCallback);
+
+        case 'c':
+            return rtZipTarCreate(&Opts);
+
+        case 'A':
+        case 'd':
+        case 'r':
+        case 'u':
+        case RTZIPTARCMD_OPT_DELETE:
+            return RTMsgErrorExitFailure("The operation %s is not implemented yet", Opts.pszOperation);
+
+        default:
+            return RTMsgErrorExitFailure("Internal error");
+    }
+}
+
diff --git a/src/VBox/Runtime/common/zip/tarvfs.cpp b/src/VBox/Runtime/common/zip/tarvfs.cpp
new file mode 100644
index 00000000..72db1dc7
--- /dev/null
+++ b/src/VBox/Runtime/common/zip/tarvfs.cpp
@@ -0,0 +1,1477 @@
+/* $Id: tarvfs.cpp $ */
+/** @file
+ * IPRT - TAR Virtual Filesystem, Reader.
+ */
+
+/*
+ * Copyright (C) 2010-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * The contents of this file may alternatively be used under the terms
+ * of the Common Development and Distribution License Version 1.0
+ * (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
+ * in the VirtualBox distribution, in which case the provisions of the
+ * CDDL are applicable instead of those of the GPL.
+ *
+ * You may elect to license modified versions of this file under the
+ * terms and conditions of either the GPL or the CDDL or both.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#include "internal/iprt.h"
+#include <iprt/zip.h>
+
+#include <iprt/asm.h>
+#include <iprt/assert.h>
+#include <iprt/ctype.h>
+#include <iprt/err.h>
+#include <iprt/poll.h>
+#include <iprt/file.h>
+#include <iprt/string.h>
+#include <iprt/vfs.h>
+#include <iprt/vfslowlevel.h>
+
+#include "tarvfsreader.h"
+
+
+/**
+ * Converts a numeric header field to the C native type.
+ *
+ * @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.
+         */
+        uint64_t u64;
+        if (!(0x40 & *puchField))
+        {
+            /* Positive or zero value. */
+            u64 = *puchField & 0x3f;
+            cchField--;
+            puchField++;
+
+            while (cchField-- > 0)
+            {
+                if (RT_LIKELY(u64 <= (uint64_t)INT64_MAX / 256))
+                    u64 = (u64 << 8) | *puchField++;
+                else
+                    return VERR_TAR_NUM_VALUE_TOO_LARGE;
+            }
+        }
+        else
+        {
+            /* Negative value (could be used in timestamp). We do manual sign extending here. */
+            u64 = (UINT64_MAX << 6) | (*puchField & 0x3f);
+            cchField--;
+            puchField++;
+
+            while (cchField-- > 0)
+            {
+                if (RT_LIKELY(u64 >= (uint64_t)(INT64_MIN / 256)))
+                    u64 = (u64 << 8) | *puchField++;
+                else
+                    return VERR_TAR_NUM_VALUE_TOO_LARGE;
+            }
+        }
+        *pi64 = (int64_t)u64;
+    }
+
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * 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 if (   pTar->Common.magic[5]   == '\0' /* VMWare ambiguity - they probably mean posix but */
+                 && pTar->Common.version[0] == ' '  /*                    got the version wrong. */
+                 && pTar->Common.version[1] == '\0')
+            enmType = RTZIPTARTYPE_POSIX;
+        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;
+        if (pThis->enmPrevType == RTZIPTARTYPE_INVALID)
+            pThis->enmPrevType = 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 (!ASMMemIsZero(pHdr, sizeof(*pHdr)))
+                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
+ * attributes.
+ *
+ * This completes the validation done by rtZipTarHdrValidate.
+ *
+ * @returns VINF_SUCCESS if valid, appropriate VERR_TAR_XXX if not.
+ * @param   pThis               The TAR reader instance.
+ * @param   pObjInfo            The object info structure (output).
+ */
+static int rtZipTarReaderGetFsObjInfo(PRTZIPTARREADER pThis, PRTFSOBJINFO pObjInfo)
+{
+    /*
+     * Zap the whole structure, this takes care of unused space in the union.
+     */
+    RT_ZERO(*pObjInfo);
+
+    /*
+     * Convert the TAR field in RTFSOBJINFO order.
+     */
+    int         rc;
+    int64_t     i64Tmp;
+#define GET_TAR_NUMERIC_FIELD_RET(a_Var, a_Field) \
+        do { \
+            rc = rtZipTarHdrFieldToNum(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; \
+        } while (0)
+
+    GET_TAR_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);
+    RTTimeSpecSetSeconds(&pObjInfo->ChangeTime,          c64SecModTime);
+    RTTimeSpecSetSeconds(&pObjInfo->ModificationTime,    c64SecModTime);
+    RTTimeSpecSetSeconds(&pObjInfo->AccessTime,          c64SecModTime);
+    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);
+    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);
+    pObjInfo->Attr.u.Unix.cHardlinks    = 1;
+    pObjInfo->Attr.u.Unix.INodeIdDevice = 0;
+    pObjInfo->Attr.u.Unix.INodeId       = 0;
+    pObjInfo->Attr.u.Unix.fFlags        = 0;
+    pObjInfo->Attr.u.Unix.GenerationId  = 0;
+    pObjInfo->Attr.u.Unix.Device        = 0;
+    switch (pThis->enmType)
+    {
+        case RTZIPTARTYPE_POSIX:
+        case RTZIPTARTYPE_GNU:
+            if (   pThis->Hdr.Common.typeflag == RTZIPTAR_TF_CHR
+                || pThis->Hdr.Common.typeflag == RTZIPTAR_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);
+                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;
+            }
+            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
+
+    /*
+     * Massage the result a little bit.
+     * Also validate some more now that we've got the numbers to work with.
+     */
+    if (   (pObjInfo->Attr.fMode & ~RTFS_UNIX_MASK)
+        && pThis->enmType == RTZIPTARTYPE_POSIX)
+        return VERR_TAR_BAD_MODE_FIELD;
+    pObjInfo->Attr.fMode &= RTFS_UNIX_MASK;
+
+    RTFMODE fModeType = 0;
+    switch (pThis->Hdr.Common.typeflag)
+    {
+        case RTZIPTAR_TF_OLDNORMAL:
+        case RTZIPTAR_TF_NORMAL:
+        case RTZIPTAR_TF_CONTIG:
+        {
+            const char *pszEnd = strchr(pThis->szName, '\0');
+            if (pszEnd == &pThis->szName[0] || pszEnd[-1] != '/')
+                fModeType |= RTFS_TYPE_FILE;
+            else
+                fModeType |= RTFS_TYPE_DIRECTORY;
+            break;
+        }
+
+        case RTZIPTAR_TF_LINK:
+            if (pObjInfo->cbObject != 0)
+#if 0 /* too strict */
+                return VERR_TAR_SIZE_NOT_ZERO;
+#else
+                pObjInfo->cbObject = pObjInfo->cbAllocated = 0;
+#endif
+            fModeType |= RTFS_TYPE_FILE; /* no better idea for now */
+            break;
+
+        case RTZIPTAR_TF_SYMLINK:
+            fModeType |= RTFS_TYPE_SYMLINK;
+            break;
+
+        case RTZIPTAR_TF_CHR:
+            fModeType |= RTFS_TYPE_DEV_CHAR;
+            break;
+
+        case RTZIPTAR_TF_BLK:
+            fModeType |= RTFS_TYPE_DEV_BLOCK;
+            break;
+
+        case RTZIPTAR_TF_DIR:
+            fModeType |= RTFS_TYPE_DIRECTORY;
+            break;
+
+        case RTZIPTAR_TF_FIFO:
+            fModeType |= RTFS_TYPE_FIFO;
+            break;
+
+        case RTZIPTAR_TF_GNU_LONGLINK:
+        case RTZIPTAR_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;
+            switch (fModeType)
+            {
+                case RTFS_TYPE_FILE:
+                case RTFS_TYPE_DIRECTORY:
+                case RTFS_TYPE_SYMLINK:
+                case RTFS_TYPE_DEV_BLOCK:
+                case RTFS_TYPE_DEV_CHAR:
+                case RTFS_TYPE_FIFO:
+                    break;
+
+                default:
+                case 0:
+                    return VERR_TAR_UNKNOWN_TYPE_FLAG; /** @todo new status code */
+            }
+            break;
+
+        default:
+            return VERR_TAR_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;
+    pObjInfo->Attr.fMode &= ~RTFS_TYPE_MASK;
+    pObjInfo->Attr.fMode |= fModeType;
+
+    switch (pThis->Hdr.Common.typeflag)
+    {
+        case RTZIPTAR_TF_CHR:
+        case RTZIPTAR_TF_BLK:
+        case RTZIPTAR_TF_DIR:
+        case RTZIPTAR_TF_FIFO:
+            pObjInfo->cbObject    = 0;
+            pObjInfo->cbAllocated = 0;
+            break;
+    }
+
+    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)
+{
+    /*
+     * In theory there shall always be two zero headers at the end of the
+     * archive, but life isn't that simple.   We've been creating archives
+     * without any zero headers at the end ourselves for a long long time
+     * (old tar.cpp).
+     *
+     * So, we're fine if the state is 'FIRST' or 'ZERO' here, but we'll barf
+     * if we're in the middle of a multi-header stream (long GNU names, sparse
+     * files, PAX, etc).
+     */
+    return pThis->enmState == RTZIPTARREADERSTATE_FIRST
+        || pThis->enmState == RTZIPTARREADERSTATE_ZERO;
+}
+
+
+/**
+ * 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);
+}
+
+
+/*
+ *
+ * T h e   V F S   F i l e s y s t e m   S t r e a m   B i t s.
+ * T h e   V F S   F i l e s y s t e m   S t r e a m   B i t s.
+ * T h e   V F S   F i l e s y s t e m   S t r e a m   B i t s.
+ *
+ */
+
+/**
+ * @interface_method_impl{RTVFSOBJOPS,pfnClose}
+ */
+static DECLCALLBACK(int) rtZipTarFssBaseObj_Close(void *pvThis)
+{
+    PRTZIPTARBASEOBJ pThis = (PRTZIPTARBASEOBJ)pvThis;
+
+    /* Currently there is nothing we really have to do here. */
+    pThis->offHdr = -1;
+
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSOBJOPS,pfnQueryInfo}
+ */
+static DECLCALLBACK(int) rtZipTarFssBaseObj_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
+{
+    PRTZIPTARBASEOBJ pThis = (PRTZIPTARBASEOBJ)pvThis;
+
+    /*
+     * Copy the desired data.
+     */
+    switch (enmAddAttr)
+    {
+        case RTFSOBJATTRADD_NOTHING:
+        case RTFSOBJATTRADD_UNIX:
+            *pObjInfo = pThis->ObjInfo;
+            break;
+
+        case RTFSOBJATTRADD_UNIX_OWNER:
+            *pObjInfo = pThis->ObjInfo;
+            pObjInfo->Attr.enmAdditional         = RTFSOBJATTRADD_UNIX_OWNER;
+            pObjInfo->Attr.u.UnixOwner.uid       = pThis->ObjInfo.Attr.u.Unix.uid;
+            pObjInfo->Attr.u.UnixOwner.szName[0] = '\0';
+            if (rtZipTarReaderHasUserName(pThis->pTarReader))
+                RTStrCopy(pObjInfo->Attr.u.UnixOwner.szName, sizeof(pObjInfo->Attr.u.UnixOwner.szName),
+                          pThis->pTarReader->Hdr.Common.uname);
+            break;
+
+        case RTFSOBJATTRADD_UNIX_GROUP:
+            *pObjInfo = pThis->ObjInfo;
+            pObjInfo->Attr.enmAdditional         = RTFSOBJATTRADD_UNIX_GROUP;
+            pObjInfo->Attr.u.UnixGroup.gid       = pThis->ObjInfo.Attr.u.Unix.gid;
+            pObjInfo->Attr.u.UnixGroup.szName[0] = '\0';
+            if (rtZipTarReaderHasGroupName(pThis->pTarReader))
+                RTStrCopy(pObjInfo->Attr.u.UnixGroup.szName, sizeof(pObjInfo->Attr.u.UnixGroup.szName),
+                          pThis->pTarReader->Hdr.Common.gname);
+            break;
+
+        case RTFSOBJATTRADD_EASIZE:
+            *pObjInfo = pThis->ObjInfo;
+            pObjInfo->Attr.enmAdditional = RTFSOBJATTRADD_EASIZE;
+            RT_ZERO(pObjInfo->Attr.u);
+            break;
+
+        default:
+            return VERR_NOT_SUPPORTED;
+    }
+
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * Tar filesystem base object operations.
+ */
+static const RTVFSOBJOPS g_rtZipTarFssBaseObjOps =
+{
+    RTVFSOBJOPS_VERSION,
+    RTVFSOBJTYPE_BASE,
+    "TarFsStream::Obj",
+    rtZipTarFssBaseObj_Close,
+    rtZipTarFssBaseObj_QueryInfo,
+    NULL,
+    RTVFSOBJOPS_VERSION
+};
+
+
+/**
+ * @interface_method_impl{RTVFSOBJOPS,pfnClose}
+ */
+static DECLCALLBACK(int) rtZipTarFssIos_Close(void *pvThis)
+{
+    PRTZIPTARIOSTREAM pThis = (PRTZIPTARIOSTREAM)pvThis;
+
+    RTVfsIoStrmRelease(pThis->hVfsIos);
+    pThis->hVfsIos = NIL_RTVFSIOSTREAM;
+
+    return rtZipTarFssBaseObj_Close(&pThis->BaseObj);
+}
+
+
+/**
+ * @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);
+}
+
+
+/**
+ * @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;
+    Assert(pSgBuf->cSegs == 1);
+
+    /*
+     * Make offset into a real offset so it's possible to do random access
+     * on TAR files that are seekable.  Fend of reads beyond the end of the
+     * stream.
+     */
+    if (off < 0)
+        off = pThis->offFile;
+    if (off >= pThis->cbFile)
+        return pcbRead ? VINF_EOF : VERR_EOF;
+
+
+    Assert(pThis->cbFile >= pThis->offFile);
+    uint64_t cbLeft   = (uint64_t)(pThis->cbFile - off);
+    size_t   cbToRead = pSgBuf->paSegs[0].cbSeg;
+    if (cbToRead > cbLeft)
+    {
+        if (!pcbRead)
+            return VERR_EOF;
+        cbToRead = (size_t)cbLeft;
+    }
+
+    /*
+     * Do the reading.
+     */
+    size_t cbReadStack = 0;
+    if (!pcbRead)
+        pcbRead = &cbReadStack;
+    int rc = RTVfsIoStrmReadAt(pThis->hVfsIos, pThis->offStart + off, pSgBuf->paSegs[0].pvSeg, cbToRead, fBlocking, pcbRead);
+    pThis->offFile = off + *pcbRead;
+    if (pThis->offFile >= pThis->cbFile)
+    {
+        Assert(pThis->offFile == pThis->cbFile);
+        pThis->fEndOfStream = true;
+        RTVfsIoStrmSkip(pThis->hVfsIos, pThis->cbPadding);
+    }
+
+    return rc;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSIOSTREAMOPS,pfnWrite}
+ */
+static DECLCALLBACK(int) rtZipTarFssIos_Write(void *pvThis, RTFOFF off, PCRTSGBUF pSgBuf, bool fBlocking, size_t *pcbWritten)
+{
+    /* Cannot write to a read-only I/O stream. */
+    NOREF(pvThis); NOREF(off); NOREF(pSgBuf); NOREF(fBlocking); NOREF(pcbWritten);
+    return VERR_ACCESS_DENIED;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSIOSTREAMOPS,pfnFlush}
+ */
+static DECLCALLBACK(int) rtZipTarFssIos_Flush(void *pvThis)
+{
+    /* It's a read only stream, nothing dirty to flush. */
+    NOREF(pvThis);
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSIOSTREAMOPS,pfnPollOne}
+ */
+static DECLCALLBACK(int) rtZipTarFssIos_PollOne(void *pvThis, uint32_t fEvents, RTMSINTERVAL cMillies, bool fIntr,
+                                                uint32_t *pfRetEvents)
+{
+    PRTZIPTARIOSTREAM pThis = (PRTZIPTARIOSTREAM)pvThis;
+
+    /* When we've reached the end, read will be set to indicate it. */
+    if (   (fEvents & RTPOLL_EVT_READ)
+        && pThis->fEndOfStream)
+    {
+        int rc = RTVfsIoStrmPoll(pThis->hVfsIos, fEvents, 0, fIntr, pfRetEvents);
+        if (RT_SUCCESS(rc))
+            *pfRetEvents |= RTPOLL_EVT_READ;
+        else
+            *pfRetEvents = RTPOLL_EVT_READ;
+        return VINF_SUCCESS;
+    }
+
+    return RTVfsIoStrmPoll(pThis->hVfsIos, fEvents, cMillies, fIntr, pfRetEvents);
+}
+
+
+/**
+ * @interface_method_impl{RTVFSIOSTREAMOPS,pfnTell}
+ */
+static DECLCALLBACK(int) rtZipTarFssIos_Tell(void *pvThis, PRTFOFF poffActual)
+{
+    PRTZIPTARIOSTREAM pThis = (PRTZIPTARIOSTREAM)pvThis;
+    *poffActual = pThis->offFile;
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * Tar I/O stream operations.
+ */
+static const RTVFSIOSTREAMOPS g_rtZipTarFssIosOps =
+{
+    { /* Obj */
+        RTVFSOBJOPS_VERSION,
+        RTVFSOBJTYPE_IO_STREAM,
+        "TarFsStream::IoStream",
+        rtZipTarFssIos_Close,
+        rtZipTarFssIos_QueryInfo,
+        NULL,
+        RTVFSOBJOPS_VERSION
+    },
+    RTVFSIOSTREAMOPS_VERSION,
+    RTVFSIOSTREAMOPS_FEAT_NO_SG,
+    rtZipTarFssIos_Read,
+    rtZipTarFssIos_Write,
+    rtZipTarFssIos_Flush,
+    rtZipTarFssIos_PollOne,
+    rtZipTarFssIos_Tell,
+    NULL /*Skip*/,
+    NULL /*ZeroFill*/,
+    RTVFSIOSTREAMOPS_VERSION
+};
+
+
+/**
+ * @interface_method_impl{RTVFSOBJOPS,pfnClose}
+ */
+static DECLCALLBACK(int) rtZipTarFssSym_Close(void *pvThis)
+{
+    PRTZIPTARBASEOBJ pThis = (PRTZIPTARBASEOBJ)pvThis;
+    return rtZipTarFssBaseObj_Close(pThis);
+}
+
+
+/**
+ * @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);
+}
+
+/**
+ * @interface_method_impl{RTVFSOBJSETOPS,pfnMode}
+ */
+static DECLCALLBACK(int) rtZipTarFssSym_SetMode(void *pvThis, RTFMODE fMode, RTFMODE fMask)
+{
+    NOREF(pvThis); NOREF(fMode); NOREF(fMask);
+    return VERR_ACCESS_DENIED;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSOBJSETOPS,pfnSetTimes}
+ */
+static DECLCALLBACK(int) rtZipTarFssSym_SetTimes(void *pvThis, PCRTTIMESPEC pAccessTime, PCRTTIMESPEC pModificationTime,
+                                                 PCRTTIMESPEC pChangeTime, PCRTTIMESPEC pBirthTime)
+{
+    NOREF(pvThis); NOREF(pAccessTime); NOREF(pModificationTime); NOREF(pChangeTime); NOREF(pBirthTime);
+    return VERR_ACCESS_DENIED;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSOBJSETOPS,pfnSetOwner}
+ */
+static DECLCALLBACK(int) rtZipTarFssSym_SetOwner(void *pvThis, RTUID uid, RTGID gid)
+{
+    NOREF(pvThis); NOREF(uid); NOREF(gid);
+    return VERR_ACCESS_DENIED;
+}
+
+
+/**
+ * @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 =
+{
+    { /* Obj */
+        RTVFSOBJOPS_VERSION,
+        RTVFSOBJTYPE_SYMLINK,
+        "TarFsStream::Symlink",
+        rtZipTarFssSym_Close,
+        rtZipTarFssSym_QueryInfo,
+        NULL,
+        RTVFSOBJOPS_VERSION
+    },
+    RTVFSSYMLINKOPS_VERSION,
+    0,
+    { /* ObjSet */
+        RTVFSOBJSETOPS_VERSION,
+        RT_UOFFSETOF(RTVFSSYMLINKOPS, ObjSet) - RT_UOFFSETOF(RTVFSSYMLINKOPS, Obj),
+        rtZipTarFssSym_SetMode,
+        rtZipTarFssSym_SetTimes,
+        rtZipTarFssSym_SetOwner,
+        RTVFSOBJSETOPS_VERSION
+    },
+    rtZipTarFssSym_Read,
+    RTVFSSYMLINKOPS_VERSION
+};
+
+
+/**
+ * @interface_method_impl{RTVFSOBJOPS,pfnClose}
+ */
+static DECLCALLBACK(int) rtZipTarFss_Close(void *pvThis)
+{
+    PRTZIPTARFSSTREAM pThis = (PRTZIPTARFSSTREAM)pvThis;
+
+    RTVfsObjRelease(pThis->hVfsCurObj);
+    pThis->hVfsCurObj  = NIL_RTVFSOBJ;
+    pThis->pCurIosData = NULL;
+
+    RTVfsIoStrmRelease(pThis->hVfsIos);
+    pThis->hVfsIos = NIL_RTVFSIOSTREAM;
+
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSOBJOPS,pfnQueryInfo}
+ */
+static DECLCALLBACK(int) rtZipTarFss_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
+{
+    PRTZIPTARFSSTREAM pThis = (PRTZIPTARFSSTREAM)pvThis;
+    /* Take the lazy approach here, with the sideffect of providing some info
+       that is actually kind of useful. */
+    return RTVfsIoStrmQueryInfo(pThis->hVfsIos, pObjInfo, enmAddAttr);
+}
+
+
+/**
+ * @interface_method_impl{RTVFSFSSTREAMOPS,pfnNext}
+ */
+DECL_HIDDEN_CALLBACK(int) rtZipTarFss_Next(void *pvThis, char **ppszName, RTVFSOBJTYPE *penmType, PRTVFSOBJ phVfsObj)
+{
+    PRTZIPTARFSSTREAM pThis = (PRTZIPTARFSSTREAM)pvThis;
+
+    /*
+     * Dispense with the current object.
+     */
+    if (pThis->hVfsCurObj != NIL_RTVFSOBJ)
+    {
+        if (pThis->pCurIosData)
+        {
+            pThis->pCurIosData->fEndOfStream = true;
+            pThis->pCurIosData->offFile      = pThis->pCurIosData->cbFile;
+            pThis->pCurIosData = NULL;
+        }
+
+        RTVfsObjRelease(pThis->hVfsCurObj);
+        pThis->hVfsCurObj = NIL_RTVFSOBJ;
+    }
+
+    /*
+     * Check if we've already reached the end in some way.
+     */
+    if (pThis->fEndOfStream)
+        return VERR_EOF;
+    if (pThis->rcFatal != VINF_SUCCESS)
+        return pThis->rcFatal;
+
+    /*
+     * 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;
+    Assert(pThis->offNextHdr == offHdr);
+    pThis->offCurHdr = offHdr;
+
+    /*
+     * Consume TAR headers.
+     */
+    size_t cbHdrs = 0;
+    int rc;
+    do
+    {
+        /*
+         * Read the next header.
+         */
+        RTZIPTARHDR Hdr;
+        size_t cbRead;
+        rc = RTVfsIoStrmRead(pThis->hVfsIos, &Hdr, sizeof(Hdr), true /*fBlocking*/, &cbRead);
+        if (RT_FAILURE(rc))
+            return pThis->rcFatal = rc;
+        if (rc == VINF_EOF && cbRead == 0)
+        {
+            pThis->fEndOfStream = true;
+            return rtZipTarReaderIsAtEnd(&pThis->TarReader) ? VERR_EOF : VERR_TAR_UNEXPECTED_EOS;
+        }
+        if (cbRead != sizeof(Hdr))
+            return pThis->rcFatal = VERR_TAR_UNEXPECTED_EOS;
+
+        cbHdrs += sizeof(Hdr);
+
+        /*
+         * Parse the it.
+         */
+        rc = rtZipTarReaderParseHeader(&pThis->TarReader, &Hdr);
+        if (RT_FAILURE(rc))
+            return pThis->rcFatal = rc;
+    } while (rtZipTarReaderExpectingMoreHeaders(&pThis->TarReader));
+
+    pThis->offNextHdr = offHdr + cbHdrs;
+
+    /*
+     * Fill an object info structure from the current TAR state.
+     */
+    RTFSOBJINFO Info;
+    rc = rtZipTarReaderGetFsObjInfo(&pThis->TarReader, &Info);
+    if (RT_FAILURE(rc))
+        return pThis->rcFatal = rc;
+
+    /*
+     * Create an object of the appropriate type.
+     */
+    RTVFSOBJTYPE    enmType;
+    RTVFSOBJ        hVfsObj;
+    RTFMODE         fType = Info.Attr.fMode & RTFS_TYPE_MASK;
+    if (rtZipTarReaderIsHardlink(&pThis->TarReader))
+        fType = RTFS_TYPE_SYMLINK;
+    switch (fType)
+    {
+        /*
+         * Files are represented by a VFS I/O stream.
+         */
+        case RTFS_TYPE_FILE:
+        {
+            RTVFSIOSTREAM       hVfsIos;
+            PRTZIPTARIOSTREAM   pIosData;
+            rc = RTVfsNewIoStream(&g_rtZipTarFssIosOps,
+                                  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.offNextHdr = pThis->offNextHdr;
+            pIosData->BaseObj.pTarReader = &pThis->TarReader;
+            pIosData->BaseObj.ObjInfo    = Info;
+            pIosData->cbFile             = Info.cbObject;
+            pIosData->offFile            = 0;
+            pIosData->offStart           = RTVfsIoStrmTell(pThis->hVfsIos);
+            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;
+        }
+
+        /*
+         * We represent hard links using a symbolic link object.  This fits
+         * best with the way TAR stores it and there is currently no better
+         * fitting VFS type alternative.
+         */
+        case RTFS_TYPE_SYMLINK:
+        {
+            RTVFSSYMLINK        hVfsSym;
+            PRTZIPTARBASEOBJ    pBaseObjData;
+            rc = RTVfsNewSymlink(&g_rtZipTarFssSymOps,
+                                 sizeof(*pBaseObjData),
+                                 NIL_RTVFS,
+                                 NIL_RTVFSLOCK,
+                                 &hVfsSym,
+                                 (void **)&pBaseObjData);
+            if (RT_FAILURE(rc))
+                return pThis->rcFatal = rc;
+
+            pBaseObjData->offHdr     = offHdr;
+            pBaseObjData->offNextHdr = pThis->offNextHdr;
+            pBaseObjData->pTarReader = &pThis->TarReader;
+            pBaseObjData->ObjInfo    = Info;
+
+            enmType = RTVFSOBJTYPE_SYMLINK;
+            hVfsObj = RTVfsObjFromSymlink(hVfsSym);
+            RTVfsSymlinkRelease(hVfsSym);
+            break;
+        }
+
+        /*
+         * All other objects are repesented using a VFS base object since they
+         * carry no data streams (unless some TAR extension implements extended
+         * attributes / alternative streams).
+         */
+        case RTFS_TYPE_DEV_BLOCK:
+        case RTFS_TYPE_DEV_CHAR:
+        case RTFS_TYPE_DIRECTORY:
+        case RTFS_TYPE_FIFO:
+        {
+            PRTZIPTARBASEOBJ pBaseObjData;
+            rc = RTVfsNewBaseObj(&g_rtZipTarFssBaseObjOps,
+                                 sizeof(*pBaseObjData),
+                                 NIL_RTVFS,
+                                 NIL_RTVFSLOCK,
+                                 &hVfsObj,
+                                 (void **)&pBaseObjData);
+            if (RT_FAILURE(rc))
+                return pThis->rcFatal = rc;
+
+            pBaseObjData->offHdr     = offHdr;
+            pBaseObjData->offNextHdr = pThis->offNextHdr;
+            pBaseObjData->pTarReader = &pThis->TarReader;
+            pBaseObjData->ObjInfo    = Info;
+
+            enmType = RTVFSOBJTYPE_BASE;
+            break;
+        }
+
+        default:
+            AssertFailed();
+            return pThis->rcFatal = VERR_INTERNAL_ERROR_5;
+    }
+    pThis->hVfsCurObj = hVfsObj;
+
+    /*
+     * Set the return data and we're done.
+     */
+    if (ppszName)
+    {
+        rc = RTStrDupEx(ppszName, pThis->TarReader.szName);
+        if (RT_FAILURE(rc))
+            return rc;
+    }
+
+    if (phVfsObj)
+    {
+        RTVfsObjRetain(hVfsObj);
+        *phVfsObj = hVfsObj;
+    }
+
+    if (penmType)
+        *penmType = enmType;
+
+    return VINF_SUCCESS;
+}
+
+
+
+/**
+ * Tar filesystem stream operations.
+ */
+static const RTVFSFSSTREAMOPS rtZipTarFssOps =
+{
+    { /* Obj */
+        RTVFSOBJOPS_VERSION,
+        RTVFSOBJTYPE_FS_STREAM,
+        "TarFsStream",
+        rtZipTarFss_Close,
+        rtZipTarFss_QueryInfo,
+        NULL,
+        RTVFSOBJOPS_VERSION
+    },
+    RTVFSFSSTREAMOPS_VERSION,
+    0,
+    rtZipTarFss_Next,
+    NULL,
+    NULL,
+    NULL,
+    RTVFSFSSTREAMOPS_VERSION
+};
+
+
+/**
+ * Internal function use both by RTZipTarFsStreamFromIoStream() and by
+ * RTZipTarFsStreamForFile() in updating mode.
+ */
+DECLHIDDEN(void) rtZipTarReaderInit(PRTZIPTARFSSTREAM pThis, RTVFSIOSTREAM hVfsIos, uint64_t offStart)
+{
+    pThis->hVfsIos              = hVfsIos;
+    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. */
+}
+
+
+RTDECL(int) RTZipTarFsStreamFromIoStream(RTVFSIOSTREAM hVfsIosIn, uint32_t fFlags, PRTVFSFSSTREAM phVfsFss)
+{
+    /*
+     * Input validation.
+     */
+    AssertPtrReturn(phVfsFss, VERR_INVALID_HANDLE);
+    *phVfsFss = NIL_RTVFSFSSTREAM;
+    AssertPtrReturn(hVfsIosIn, VERR_INVALID_HANDLE);
+    AssertReturn(!fFlags, VERR_INVALID_PARAMETER);
+
+    RTFOFF const offStart = RTVfsIoStrmTell(hVfsIosIn);
+    AssertReturn(offStart >= 0, (int)offStart);
+
+    uint32_t cRefs = RTVfsIoStrmRetain(hVfsIosIn);
+    AssertReturn(cRefs != UINT32_MAX, VERR_INVALID_HANDLE);
+
+    /*
+     * 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, RTFILE_O_READ,
+                              &hVfsFss, (void **)&pThis);
+    if (RT_SUCCESS(rc))
+    {
+        rtZipTarReaderInit(pThis, hVfsIosIn, fFlags);
+        *phVfsFss = hVfsFss;
+        return VINF_SUCCESS;
+    }
+
+    RTVfsIoStrmRelease(hVfsIosIn);
+    return rc;
+}
+
+
+/**
+ * Used by RTZipTarFsStreamTruncate to resolve @a hVfsObj.
+ */
+DECLHIDDEN(PRTZIPTARBASEOBJ) rtZipTarFsStreamBaseObjToPrivate(PRTZIPTARFSSTREAM pThis, RTVFSOBJ hVfsObj)
+{
+    PRTZIPTARBASEOBJ pThisObj;
+    RTVFSOBJTYPE enmType = RTVfsObjGetType(hVfsObj);
+    switch (enmType)
+    {
+        case RTVFSOBJTYPE_IO_STREAM:
+        {
+            RTVFSIOSTREAM hVfsIos = RTVfsObjToIoStream(hVfsObj);
+            AssertReturn(hVfsIos != NIL_RTVFSIOSTREAM, NULL);
+            PRTZIPTARIOSTREAM pThisStrm = (PRTZIPTARIOSTREAM)RTVfsIoStreamToPrivate(hVfsIos, &g_rtZipTarFssIosOps);
+            RTVfsIoStrmRelease(hVfsIos);
+            pThisObj = &pThisStrm->BaseObj;
+            break;
+        }
+
+        case RTVFSOBJTYPE_SYMLINK:
+        {
+            RTVFSSYMLINK hVfsSymlink = RTVfsObjToSymlink(hVfsObj);
+            AssertReturn(hVfsSymlink != NIL_RTVFSSYMLINK, NULL);
+            pThisObj = (PRTZIPTARBASEOBJ)RTVfsSymlinkToPrivate(hVfsSymlink, &g_rtZipTarFssSymOps);
+            RTVfsSymlinkRelease(hVfsSymlink);
+            break;
+        }
+
+        case RTVFSOBJTYPE_BASE:
+            pThisObj = (PRTZIPTARBASEOBJ)RTVfsObjToPrivate(hVfsObj, &g_rtZipTarFssBaseObjOps);
+            break;
+
+        default:
+            /** @todo implement.   */
+            AssertFailedReturn(NULL);
+    }
+
+    AssertReturn(pThisObj->pTarReader == &pThis->TarReader, NULL);
+    return pThisObj;
+}
+
diff --git a/src/VBox/Runtime/common/zip/tarvfsreader.h b/src/VBox/Runtime/common/zip/tarvfsreader.h
new file mode 100644
index 00000000..ebe74fbc
--- /dev/null
+++ b/src/VBox/Runtime/common/zip/tarvfsreader.h
@@ -0,0 +1,179 @@
+/* $Id: tarvfsreader.h $ */
+/** @file
+ * IPRT - TAR Virtual Filesystem.
+ */
+
+/*
+ * Copyright (C) 2010-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * The contents of this file may alternatively be used under the terms
+ * of the Common Development and Distribution License Version 1.0
+ * (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
+ * in the VirtualBox distribution, in which case the provisions of the
+ * CDDL are applicable instead of those of the GPL.
+ *
+ * You may elect to license modified versions of this file under the
+ * terms and conditions of either the GPL or the CDDL or both.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
+ */
+
+#ifndef IPRT_INCLUDED_SRC_common_zip_tarvfsreader_h
+#define IPRT_INCLUDED_SRC_common_zip_tarvfsreader_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "tar.h"
+
+
+/**
+ * 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.
+     * @remarks Same a enmType for the first header in the TAR stream. */
+    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
+{
+    /** The stream offset of the (first) header in the input stream/file.  */
+    RTFOFF                  offHdr;
+    /** The stream offset of the first header of the next object (for truncating the
+     * tar file after this object (updating)). */
+    RTFOFF                  offNextHdr;
+    /** 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? */
+    PRTZIPTARREADER         pTarReader;
+    /** 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;
+    /** The number of bytes in the file. */
+    RTFOFF                  cbFile;
+    /** The current file position. */
+    RTFOFF                  offFile;
+    /** The start position in the hVfsIos (for seekable hVfsIos). */
+    RTFOFF                  offStart;
+    /** The number of padding bytes following the file. */
+    uint32_t                cbPadding;
+    /** Set if we've reached the end of this file. */
+    bool                    fEndOfStream;
+    /** 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
+{
+    /** The input I/O stream. */
+    RTVFSIOSTREAM           hVfsIos;
+
+    /** The current object (referenced). */
+    RTVFSOBJ                hVfsCurObj;
+    /** Pointer to the private data if hVfsCurObj is representing a file. */
+    PRTZIPTARIOSTREAM       pCurIosData;
+
+    /** The start offset. */
+    RTFOFF                  offStart;
+    /** The offset of the next header. */
+    RTFOFF                  offNextHdr;
+    /** The offset of the first header for the current object.
+     * When reaching the end, this will be the same as offNextHdr which will be
+     * pointing to the first zero header */
+    RTFOFF                  offCurHdr;
+
+    /** Set if we've reached the end of the stream. */
+    bool                    fEndOfStream;
+    /** Set if we've encountered a fatal error. */
+    int                     rcFatal;
+
+    /** The TAR reader instance data. */
+    RTZIPTARREADER          TarReader;
+} RTZIPTARFSSTREAM;
+/** Pointer to a the private data of a TAR filesystem stream. */
+typedef RTZIPTARFSSTREAM *PRTZIPTARFSSTREAM;
+
+DECLHIDDEN(void)                rtZipTarReaderInit(PRTZIPTARFSSTREAM pThis, RTVFSIOSTREAM hVfsIos, uint64_t offStart);
+DECL_HIDDEN_CALLBACK(int)       rtZipTarFss_Next(void *pvThis, char **ppszName, RTVFSOBJTYPE *penmType, PRTVFSOBJ phVfsObj);
+DECLHIDDEN(PRTZIPTARBASEOBJ)    rtZipTarFsStreamBaseObjToPrivate(PRTZIPTARFSSTREAM pThis, RTVFSOBJ hVfsObj);
+
+#endif /* !IPRT_INCLUDED_SRC_common_zip_tarvfsreader_h */
+
diff --git a/src/VBox/Runtime/common/zip/tarvfswriter.cpp b/src/VBox/Runtime/common/zip/tarvfswriter.cpp
new file mode 100644
index 00000000..ac5d603a
--- /dev/null
+++ b/src/VBox/Runtime/common/zip/tarvfswriter.cpp
@@ -0,0 +1,2363 @@
+/* $Id: tarvfswriter.cpp $ */
+/** @file
+ * IPRT - TAR Virtual Filesystem, Writer.
+ */
+
+/*
+ * Copyright (C) 2010-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * The contents of this file may alternatively be used under the terms
+ * of the Common Development and Distribution License Version 1.0
+ * (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
+ * in the VirtualBox distribution, in which case the provisions of the
+ * CDDL are applicable instead of those of the GPL.
+ *
+ * You may elect to license modified versions of this file under the
+ * terms and conditions of either the GPL or the CDDL or both.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#include "internal/iprt.h"
+#include <iprt/zip.h>
+
+#include <iprt/asm.h>
+#include <iprt/assert.h>
+#include <iprt/err.h>
+#include <iprt/file.h>
+#include <iprt/mem.h>
+#include <iprt/path.h>
+#include <iprt/string.h>
+#include <iprt/vfs.h>
+#include <iprt/vfslowlevel.h>
+#include <iprt/zero.h>
+
+#include "tarvfsreader.h"
+
+
+/*********************************************************************************************************************************
+*   Defined Constants And Macros                                                                                                 *
+*********************************************************************************************************************************/
+/** The TAR block size we're using in this implementation.
+ * @remarks Should technically be user configurable, but we don't currently need that. */
+#define RTZIPTAR_BLOCKSIZE      sizeof(RTZIPTARHDR)
+
+/** Minimum file size we consider for sparse files. */
+#define RTZIPTAR_MIN_SPARSE     _64K
+
+
+/*********************************************************************************************************************************
+*   Structures and Typedefs                                                                                                      *
+*********************************************************************************************************************************/
+/**
+ * A data span descriptor in a sparse file.
+ */
+typedef struct RTZIPTARSPARSESPAN
+{
+    /** Byte offset into the file of the data. */
+    uint64_t        off;
+    /** Number of bytes of data, rounded up to a multiple of blocksize. */
+    uint64_t        cb;
+} RTZIPTARSPARSESPAN;
+/** Pointer to a data span. */
+typedef RTZIPTARSPARSESPAN *PRTZIPTARSPARSESPAN;
+/** Pointer to a const data span. */
+typedef RTZIPTARSPARSESPAN const *PCRTZIPTARSPARSESPAN;
+
+/**
+ * Chunk of TAR sparse file data spans.
+ */
+typedef struct RTZIPTARSPARSECHUNK
+{
+    /** List entry. */
+    RTLISTNODE          Entry;
+    /** Array of data spans. */
+    RTZIPTARSPARSESPAN  aSpans[63];
+} RTZIPTARSPARSECHUNK;
+AssertCompile(sizeof(RTZIPTARSPARSECHUNK) <= 1024);
+AssertCompile(sizeof(RTZIPTARSPARSECHUNK) >= 1008);
+/** Pointer to a chunk of TAR data spans. */
+typedef RTZIPTARSPARSECHUNK *PRTZIPTARSPARSECHUNK;
+/** Pointer to a const chunk of TAR data spans. */
+typedef RTZIPTARSPARSECHUNK const *PCRTZIPTARSPARSECHUNK;
+
+/**
+ * TAR sparse file info.
+ */
+typedef struct RTZIPTARSPARSE
+{
+    /** Number of data bytes (real size).  */
+    uint64_t            cbDataSpans;
+    /** Number of data spans. */
+    uint32_t            cDataSpans;
+    /** The index of the next span in the tail chunk (to avoid modulus 63). */
+    uint32_t            iNextSpan;
+    /** Head of the data span chunk list (PRTZIPTARSPARSECHUNK). */
+    RTLISTANCHOR        ChunkHead;
+} RTZIPTARSPARSE;
+/** Pointer to TAR sparse file info. */
+typedef RTZIPTARSPARSE *PRTZIPTARSPARSE;
+/** Pointer to a const TAR sparse file info. */
+typedef RTZIPTARSPARSE const *PCRTZIPTARSPARSE;
+
+
+/** Pointer to a the private data of a TAR filesystem stream. */
+typedef struct RTZIPTARFSSTREAMWRITER *PRTZIPTARFSSTREAMWRITER;
+
+
+/**
+ * Instance data for a file or I/O stream returned by
+ * RTVFSFSSTREAMOPS::pfnPushFile.
+ */
+typedef struct RTZIPTARFSSTREAMWRITERPUSH
+{
+    /** Pointer to the parent FS stream writer instance.
+     * This is set to NULL should the push object live longer than the stream. */
+    PRTZIPTARFSSTREAMWRITER pParent;
+    /** The header offset, UINT64_MAX if non-seekable output. */
+    uint64_t                offHdr;
+    /** The data offset, UINT64_MAX if non-seekable output. */
+    uint64_t                offData;
+    /** The current I/O stream position (relative to offData). */
+    uint64_t                offCurrent;
+    /** The expected size amount of file content, or max file size if open-ended. */
+    uint64_t                cbExpected;
+    /** The current amount of file content written. */
+    uint64_t                cbCurrent;
+    /** Object info copy for rtZipTarWriterPush_QueryInfo. */
+    RTFSOBJINFO             ObjInfo;
+    /** Set if open-ended file size requiring a tar header update when done. */
+    bool                    fOpenEnded;
+} RTZIPTARFSSTREAMWRITERPUSH;
+/** Pointer to a push I/O instance. */
+typedef RTZIPTARFSSTREAMWRITERPUSH *PRTZIPTARFSSTREAMWRITERPUSH;
+
+
+/**
+ * Tar filesystem stream private data.
+ */
+typedef struct RTZIPTARFSSTREAMWRITER
+{
+    /** The output I/O stream. */
+    RTVFSIOSTREAM           hVfsIos;
+    /** Non-nil if the output is a file.  */
+    RTVFSFILE               hVfsFile;
+
+    /** The current push file.  NULL if none. */
+    PRTZIPTARFSSTREAMWRITERPUSH pPush;
+
+    /** The TAR format. */
+    RTZIPTARFORMAT          enmFormat;
+    /** Set if we've encountered a fatal error. */
+    int                     rcFatal;
+    /** Flags, RTZIPTAR_C_XXX. */
+    uint32_t                fFlags;
+
+    /** Number of bytes written. */
+    uint64_t                cbWritten;
+
+    /** @name Attribute overrides.
+     * @{
+     */
+    RTUID                   uidOwner;           /**< Owner, NIL_RTUID if no change. */
+    char                   *pszOwner;           /**< Owner, NULL if no change. */
+    RTGID                   gidGroup;           /**< Group, NIL_RTGID if no change. */
+    char                   *pszGroup;           /**< Group, NULL if no change. */
+    char                   *pszPrefix;          /**< Path prefix, NULL if no change. */
+    size_t                  cchPrefix;          /**< The length of pszPrefix. */
+    PRTTIMESPEC             pModTime;           /**< Modification time, NULL of no change. */
+    RTTIMESPEC              ModTime;            /**< pModTime points to this. */
+    RTFMODE                 fFileModeAndMask;   /**< File mode AND mask. */
+    RTFMODE                 fFileModeOrMask;    /**< File mode OR mask. */
+    RTFMODE                 fDirModeAndMask;    /**< Directory mode AND mask. */
+    RTFMODE                 fDirModeOrMask;     /**< Directory mode OR mask. */
+    /** @} */
+
+    /** When in update mode (RTZIPTAR_C_UPDATE) we have an reader FSS instance,
+     * though w/o the RTVFSFSSTREAM bits. (Allocated after this structure.) */
+    PRTZIPTARFSSTREAM       pRead;
+    /** Set if we're in writing mode and pfnNext shall fail. */
+    bool                    fWriting;
+
+
+    /** Number of headers returned by rtZipTarFssWriter_ObjInfoToHdr. */
+    uint32_t                cHdrs;
+    /** Header buffers returned by rtZipTarFssWriter_ObjInfoToHdr. */
+    RTZIPTARHDR             aHdrs[3];
+} RTZIPTARFSSTREAMWRITER;
+
+
+/*********************************************************************************************************************************
+*   Internal Functions                                                                                                           *
+*********************************************************************************************************************************/
+static DECLCALLBACK(int) rtZipTarWriterPush_Seek(void *pvThis, RTFOFF offSeek, unsigned uMethod, PRTFOFF poffActual);
+static int rtZipTarFssWriter_CompleteCurrentPushFile(PRTZIPTARFSSTREAMWRITER pThis);
+static int rtZipTarFssWriter_AddFile(PRTZIPTARFSSTREAMWRITER pThis, const char *pszPath, RTVFSIOSTREAM hVfsIos,
+                                     PCRTFSOBJINFO pObjInfo, const char *pszOwnerNm, const char *pszGroupNm);
+
+
+/**
+ * Calculates the header checksum and stores it in the chksum field.
+ *
+ * @returns IPRT status code.
+ * @param   pHdr                The header.
+ */
+static int rtZipTarFssWriter_ChecksumHdr(PRTZIPTARHDR pHdr)
+{
+    int32_t iUnsignedChksum;
+    rtZipTarCalcChkSum(pHdr, &iUnsignedChksum, NULL);
+
+    int rc = RTStrFormatU32(pHdr->Common.chksum, sizeof(pHdr->Common.chksum), iUnsignedChksum,
+                            8 /*uBase*/, -1 /*cchWidth*/, sizeof(pHdr->Common.chksum) - 1, RTSTR_F_ZEROPAD | RTSTR_F_PRECISION);
+    AssertRCReturn(rc, VERR_TAR_NUM_VALUE_TOO_LARGE);
+    return VINF_SUCCESS;
+}
+
+
+
+/**
+ * Formats a 12 character wide file offset or size field.
+ *
+ * This is mainly used for RTZIPTARHDR::Common.size, but also for formatting the
+ * sparse map.
+ *
+ * @returns IPRT status code.
+ * @param   pach12Field     The 12 character wide destination field.
+ * @param   off             The offset to set.
+ */
+static int rtZipTarFssWriter_FormatOffset(char pach12Field[12], uint64_t off)
+{
+    /*
+     * Is the size small enough for the standard octal string encoding?
+     *
+     * Note! We could actually use the terminator character as well if we liked,
+     *       but let not do that as it's easier to test this way.
+     */
+    if (off < _4G * 2U)
+    {
+        int rc = RTStrFormatU64(pach12Field, 12, off, 8 /*uBase*/, -1 /*cchWidth*/, 12 - 1, RTSTR_F_ZEROPAD | RTSTR_F_PRECISION);
+        AssertRCReturn(rc, rc);
+    }
+    /*
+     * No, use the base 256 extension. Set the highest bit of the left most
+     * character.  We don't deal with negatives here, cause the size have to
+     * be greater than zero.
+     *
+     * Note! The base-256 extension are never used by gtar or libarchive
+     *       with the "ustar  \0" format version, only the later
+     *       "ustar\000" version.  However, this shouldn't cause much
+     *       trouble as they are not picky about what they read.
+     */
+    /** @todo above note is wrong:  GNU tar only uses base-256 with the GNU tar
+     * format, i.e. "ustar   \0", see create.c line 303 in v1.29. */
+    else
+    {
+        size_t         cchField  = 12 - 1;
+        unsigned char *puchField = (unsigned char *)pach12Field;
+        puchField[0] = 0x80;
+        do
+        {
+            puchField[cchField--] = off & 0xff;
+            off >>= 8;
+        } while (cchField);
+    }
+
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * Creates one or more tar headers for the object.
+ *
+ * Returns RTZIPTARFSSTREAMWRITER::aHdrs and RTZIPTARFSSTREAMWRITER::cHdrs.
+ *
+ * @returns IPRT status code.
+ * @param   pThis           The TAR writer instance.
+ * @param   pszPath         The path to the file.
+ * @param   hVfsIos         The I/O stream of the file.
+ * @param   fFlags          The RTVFSFSSTREAMOPS::pfnAdd flags.
+ * @param   pObjInfo        The object information.
+ * @param   pszOwnerNm      The owner name.
+ * @param   pszGroupNm      The group name.
+ * @param   chType          The tar record type, UINT8_MAX for default.
+ */
+static int rtZipTarFssWriter_ObjInfoToHdr(PRTZIPTARFSSTREAMWRITER pThis, const char *pszPath, PCRTFSOBJINFO pObjInfo,
+                                          const char *pszOwnerNm, const char *pszGroupNm, uint8_t chType)
+{
+    pThis->cHdrs = 0;
+    RT_ZERO(pThis->aHdrs[0]);
+
+    /*
+     * The path name first.  Make sure to flip DOS slashes.
+     */
+    size_t cchPath = strlen(pszPath);
+    if (cchPath < sizeof(pThis->aHdrs[0].Common.name))
+    {
+        memcpy(pThis->aHdrs[0].Common.name, pszPath, cchPath + 1);
+#if RTPATH_STYLE != RTPATH_STR_F_STYLE_UNIX
+        char *pszDosSlash = strchr(pThis->aHdrs[0].Common.name, '\\');
+        while (pszDosSlash)
+        {
+            *pszDosSlash = '/';
+            pszDosSlash = strchr(pszDosSlash + 1, '\\');
+        }
+#endif
+    }
+    else
+    {
+        /** @todo implement gnu and pax long name extensions. */
+        return VERR_TAR_NAME_TOO_LONG;
+    }
+
+    /*
+     * File mode.  ASSUME that the unix part of the IPRT mode mask is
+     * compatible with the TAR/Unix world.
+     */
+    uint32_t uValue = pObjInfo->Attr.fMode & RTFS_UNIX_MASK;
+    if (RTFS_IS_DIRECTORY(pObjInfo->Attr.fMode))
+        uValue = (uValue & pThis->fDirModeAndMask) | pThis->fDirModeOrMask;
+    else
+        uValue = (uValue & pThis->fFileModeAndMask) | pThis->fFileModeOrMask;
+    int rc = RTStrFormatU32(pThis->aHdrs[0].Common.mode, sizeof(pThis->aHdrs[0].Common.mode), uValue, 8 /*uBase*/,
+                            -1 /*cchWidth*/, sizeof(pThis->aHdrs[0].Common.mode) - 1, RTSTR_F_ZEROPAD | RTSTR_F_PRECISION);
+    AssertRCReturn(rc, VERR_TAR_NUM_VALUE_TOO_LARGE);
+
+    /*
+     * uid & gid.  Just guard against NIL values as they won't fit.
+     */
+    uValue = pThis->uidOwner != NIL_RTUID ? pThis->uidOwner
+           : pObjInfo->Attr.u.Unix.uid != NIL_RTUID ? pObjInfo->Attr.u.Unix.uid : 0;
+    rc = RTStrFormatU32(pThis->aHdrs[0].Common.uid, sizeof(pThis->aHdrs[0].Common.uid), uValue,
+                        8 /*uBase*/, -1 /*cchWidth*/, sizeof(pThis->aHdrs[0].Common.uid) - 1, RTSTR_F_ZEROPAD | RTSTR_F_PRECISION);
+    AssertRCReturn(rc, VERR_TAR_NUM_VALUE_TOO_LARGE);
+
+    uValue = pThis->gidGroup != NIL_RTGID ? pThis->gidGroup
+           : pObjInfo->Attr.u.Unix.gid != NIL_RTGID ? pObjInfo->Attr.u.Unix.gid : 0;
+    rc = RTStrFormatU32(pThis->aHdrs[0].Common.gid, sizeof(pThis->aHdrs[0].Common.gid), uValue,
+                        8 /*uBase*/, -1 /*cchWidth*/, sizeof(pThis->aHdrs[0].Common.gid) - 1, RTSTR_F_ZEROPAD | RTSTR_F_PRECISION);
+    AssertRCReturn(rc, VERR_TAR_NUM_VALUE_TOO_LARGE);
+
+    /*
+     * The file size.
+     */
+    rc = rtZipTarFssWriter_FormatOffset(pThis->aHdrs[0].Common.size, pObjInfo->cbObject);
+    AssertRCReturn(rc, rc);
+
+    /*
+     * Modification time relative to unix epoc.
+     */
+    rc = RTStrFormatU64(pThis->aHdrs[0].Common.mtime, sizeof(pThis->aHdrs[0].Common.mtime),
+                        RTTimeSpecGetSeconds(pThis->pModTime ? pThis->pModTime : &pObjInfo->ModificationTime),
+                        8 /*uBase*/, -1 /*cchWidth*/, sizeof(pThis->aHdrs[0].Common.mtime) - 1, RTSTR_F_ZEROPAD | RTSTR_F_PRECISION);
+    AssertRCReturn(rc, rc);
+
+    /* Skipping checksum for now */
+
+    /*
+     * The type flag.
+     */
+    if (chType == UINT8_MAX)
+        switch (pObjInfo->Attr.fMode & RTFS_TYPE_MASK)
+        {
+            case RTFS_TYPE_FIFO:        chType = RTZIPTAR_TF_FIFO; break;
+            case RTFS_TYPE_DEV_CHAR:    chType = RTZIPTAR_TF_CHR; break;
+            case RTFS_TYPE_DIRECTORY:   chType = RTZIPTAR_TF_DIR; break;
+            case RTFS_TYPE_DEV_BLOCK:   chType = RTZIPTAR_TF_BLK; break;
+            case RTFS_TYPE_FILE:        chType = RTZIPTAR_TF_NORMAL; break;
+            case RTFS_TYPE_SYMLINK:     chType = RTZIPTAR_TF_SYMLINK; break;
+            case RTFS_TYPE_SOCKET:      chType = RTZIPTAR_TF_FIFO; break;
+            case RTFS_TYPE_WHITEOUT:    AssertFailedReturn(VERR_WRONG_TYPE);
+        }
+    pThis->aHdrs[0].Common.typeflag = chType;
+
+    /* No link name, at least not for now.  Caller might set it. */
+
+    /*
+     * Set TAR record magic and version.
+     */
+    if (pThis->enmFormat == RTZIPTARFORMAT_GNU)
+        memcpy(pThis->aHdrs[0].Gnu.magic, RTZIPTAR_GNU_MAGIC, sizeof(pThis->aHdrs[0].Gnu.magic));
+    else if (   pThis->enmFormat == RTZIPTARFORMAT_USTAR
+             || pThis->enmFormat == RTZIPTARFORMAT_PAX)
+    {
+        memcpy(pThis->aHdrs[0].Common.magic, RTZIPTAR_USTAR_MAGIC, sizeof(pThis->aHdrs[0].Common.magic));
+        memcpy(pThis->aHdrs[0].Common.version, RTZIPTAR_USTAR_VERSION, sizeof(pThis->aHdrs[0].Common.version));
+    }
+    else
+        AssertFailedReturn(VERR_INTERNAL_ERROR_4);
+
+    /*
+     * Owner and group names.  Silently truncate them for now.
+     */
+    RTStrCopy(pThis->aHdrs[0].Common.uname, sizeof(pThis->aHdrs[0].Common.uname), pThis->pszOwner ? pThis->pszOwner : pszOwnerNm);
+    RTStrCopy(pThis->aHdrs[0].Common.gname, sizeof(pThis->aHdrs[0].Common.uname), pThis->pszGroup ? pThis->pszGroup : pszGroupNm);
+
+    /*
+     * Char/block device numbers.
+     */
+    if (   RTFS_IS_DEV_BLOCK(pObjInfo->Attr.fMode)
+        || RTFS_IS_DEV_CHAR(pObjInfo->Attr.fMode) )
+    {
+        rc = RTStrFormatU32(pThis->aHdrs[0].Common.devmajor, sizeof(pThis->aHdrs[0].Common.devmajor),
+                            RTDEV_MAJOR(pObjInfo->Attr.u.Unix.Device),
+                            8 /*uBase*/, -1 /*cchWidth*/, sizeof(pThis->aHdrs[0].Common.devmajor) - 1, RTSTR_F_ZEROPAD | RTSTR_F_PRECISION);
+        AssertRCReturn(rc, VERR_TAR_NUM_VALUE_TOO_LARGE);
+
+        rc = RTStrFormatU32(pThis->aHdrs[0].Common.devminor, sizeof(pThis->aHdrs[0].Common.devmajor),
+                            RTDEV_MINOR(pObjInfo->Attr.u.Unix.Device),
+                            8 /*uBase*/, -1 /*cchWidth*/, sizeof(pThis->aHdrs[0].Common.devmajor) - 1, RTSTR_F_ZEROPAD | RTSTR_F_PRECISION);
+        AssertRCReturn(rc, VERR_TAR_NUM_VALUE_TOO_LARGE);
+    }
+
+#if 0 /** @todo why doesn't this work? */
+    /*
+     * Set GNU specific stuff.
+     */
+    if (pThis->enmFormat == RTZIPTARFORMAT_GNU)
+    {
+        rc = RTStrFormatU64(pThis->aHdrs[0].Gnu.ctime, sizeof(pThis->aHdrs[0].Gnu.ctime),
+                            RTTimeSpecGetSeconds(&pObjInfo->ChangeTime),
+                            8 /*uBase*/, -1 /*cchWidth*/, sizeof(pThis->aHdrs[0].Gnu.ctime) - 1, RTSTR_F_ZEROPAD | RTSTR_F_PRECISION);
+        AssertRCReturn(rc, rc);
+
+        rc = RTStrFormatU64(pThis->aHdrs[0].Gnu.atime, sizeof(pThis->aHdrs[0].Gnu.atime),
+                            RTTimeSpecGetSeconds(&pObjInfo->ChangeTime),
+                            8 /*uBase*/, -1 /*cchWidth*/, sizeof(pThis->aHdrs[0].Gnu.atime) - 1, RTSTR_F_ZEROPAD | RTSTR_F_PRECISION);
+        AssertRCReturn(rc, rc);
+    }
+#endif
+
+    /*
+     * Finally the checksum.
+     */
+    pThis->cHdrs = 1;
+    return rtZipTarFssWriter_ChecksumHdr(&pThis->aHdrs[0]);
+}
+
+
+
+
+/**
+ * @interface_method_impl{RTVFSOBJOPS,pfnClose}
+ */
+static DECLCALLBACK(int) rtZipTarWriterPush_Close(void *pvThis)
+{
+    PRTZIPTARFSSTREAMWRITERPUSH pPush   = (PRTZIPTARFSSTREAMWRITERPUSH)pvThis;
+    PRTZIPTARFSSTREAMWRITER     pParent = pPush->pParent;
+    if (pParent)
+    {
+        if (pParent->pPush == pPush)
+            rtZipTarFssWriter_CompleteCurrentPushFile(pParent);
+        else
+            AssertFailedStmt(pPush->pParent = NULL);
+    }
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSOBJOPS,pfnQueryInfo}
+ */
+static DECLCALLBACK(int) rtZipTarWriterPush_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
+{
+    PRTZIPTARFSSTREAMWRITERPUSH pPush = (PRTZIPTARFSSTREAMWRITERPUSH)pvThis;
+
+    /* Basic info (w/ additional unix attribs). */
+    *pObjInfo = pPush->ObjInfo;
+    pObjInfo->cbObject = pPush->cbCurrent;
+    pObjInfo->cbAllocated = RT_ALIGN_64(pPush->cbCurrent, RTZIPTAR_BLOCKSIZE);
+
+    /* Additional info. */
+    switch (enmAddAttr)
+    {
+        case RTFSOBJATTRADD_NOTHING:
+        case RTFSOBJATTRADD_UNIX:
+            Assert(pObjInfo->Attr.enmAdditional == RTFSOBJATTRADD_UNIX);
+            break;
+
+        case RTFSOBJATTRADD_UNIX_OWNER:
+            pObjInfo->Attr.u.UnixOwner.uid = pPush->ObjInfo.Attr.u.Unix.uid;
+            if (pPush->pParent)
+                strcpy(pObjInfo->Attr.u.UnixOwner.szName, pPush->pParent->aHdrs[0].Common.uname);
+            else
+                pObjInfo->Attr.u.UnixOwner.szName[0] = '\0';
+            pObjInfo->Attr.enmAdditional = enmAddAttr;
+            break;
+
+        case RTFSOBJATTRADD_UNIX_GROUP:
+            pObjInfo->Attr.u.UnixGroup.gid = pPush->ObjInfo.Attr.u.Unix.gid;
+            if (pPush->pParent)
+                strcpy(pObjInfo->Attr.u.UnixGroup.szName, pPush->pParent->aHdrs[0].Common.uname);
+            else
+                pObjInfo->Attr.u.UnixGroup.szName[0] = '\0';
+            pObjInfo->Attr.enmAdditional = enmAddAttr;
+            break;
+
+        case RTFSOBJATTRADD_EASIZE:
+            pObjInfo->Attr.u.EASize.cb = 0;
+            pObjInfo->Attr.enmAdditional = enmAddAttr;
+            break;
+
+        default:
+        AssertFailed();
+    }
+
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSIOSTREAMOPS,pfnRead}
+ */
+static DECLCALLBACK(int) rtZipTarWriterPush_Read(void *pvThis, RTFOFF off, PCRTSGBUF pSgBuf, bool fBlocking, size_t *pcbRead)
+{
+    /* No read support, sorry. */
+    RT_NOREF(pvThis, off, pSgBuf, fBlocking, pcbRead);
+    AssertFailed();
+    return VERR_ACCESS_DENIED;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSIOSTREAMOPS,pfnWrite}
+ */
+static DECLCALLBACK(int) rtZipTarWriterPush_Write(void *pvThis, RTFOFF off, PCRTSGBUF pSgBuf, bool fBlocking, size_t *pcbWritten)
+{
+    PRTZIPTARFSSTREAMWRITERPUSH pPush   = (PRTZIPTARFSSTREAMWRITERPUSH)pvThis;
+    PRTZIPTARFSSTREAMWRITER     pParent = pPush->pParent;
+    AssertPtrReturn(pParent, VERR_WRONG_ORDER);
+
+    int rc = pParent->rcFatal;
+    AssertRCReturn(rc, rc);
+
+    /*
+     * Single segment at a time.
+     */
+    Assert(pSgBuf->cSegs == 1);
+    size_t      cbToWrite = pSgBuf->paSegs[0].cbSeg;
+    void const *pvToWrite = pSgBuf->paSegs[0].pvSeg;
+
+    /*
+     * Hopefully we don't need to seek.  But if we do, let the seek method do
+     * it as it's not entirely trivial.
+     */
+    if (   off < 0
+        || (uint64_t)off == pPush->offCurrent)
+        rc = VINF_SUCCESS;
+    else
+        rc = rtZipTarWriterPush_Seek(pvThis, off, RTFILE_SEEK_BEGIN, NULL);
+    if (RT_SUCCESS(rc))
+    {
+        Assert(pPush->offCurrent <= pPush->cbExpected);
+        Assert(pPush->offCurrent <= pPush->cbCurrent);
+        AssertMsgReturn(cbToWrite <= pPush->cbExpected - pPush->offCurrent,
+                        ("offCurrent=%#RX64 + cbToWrite=%#zx = %#RX64; cbExpected=%RX64\n",
+                         pPush->offCurrent, cbToWrite, pPush->offCurrent + cbToWrite, pPush->cbExpected),
+                        VERR_DISK_FULL);
+        size_t cbWritten = 0;
+        rc = RTVfsIoStrmWrite(pParent->hVfsIos, pvToWrite, cbToWrite, fBlocking, &cbWritten);
+        if (RT_SUCCESS(rc))
+        {
+            pPush->offCurrent += cbWritten;
+            if (pPush->offCurrent > pPush->cbCurrent)
+            {
+                pParent->cbWritten = pPush->offCurrent - pPush->cbCurrent;
+                pPush->cbCurrent   = pPush->offCurrent;
+            }
+            if (pcbWritten)
+                *pcbWritten = cbWritten;
+        }
+    }
+
+    /*
+     * Fatal errors get down here, non-fatal ones returns earlier.
+     */
+    if (RT_SUCCESS(rc))
+        return VINF_SUCCESS;
+    pParent->rcFatal = rc;
+    return rc;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSIOSTREAMOPS,pfnFlush}
+ */
+static DECLCALLBACK(int) rtZipTarWriterPush_Flush(void *pvThis)
+{
+    PRTZIPTARFSSTREAMWRITERPUSH pPush   = (PRTZIPTARFSSTREAMWRITERPUSH)pvThis;
+    PRTZIPTARFSSTREAMWRITER     pParent = pPush->pParent;
+    AssertPtrReturn(pParent, VERR_WRONG_ORDER);
+    int rc = pParent->rcFatal;
+    if (RT_SUCCESS(rc))
+        pParent->rcFatal = rc = RTVfsIoStrmFlush(pParent->hVfsIos);
+    return rc;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSIOSTREAMOPS,pfnPollOne}
+ */
+static DECLCALLBACK(int) rtZipTarWriterPush_PollOne(void *pvThis, uint32_t fEvents, RTMSINTERVAL cMillies, bool fIntr,
+                                                    uint32_t *pfRetEvents)
+{
+    PRTZIPTARFSSTREAMWRITERPUSH pPush = (PRTZIPTARFSSTREAMWRITERPUSH)pvThis;
+    PRTZIPTARFSSTREAMWRITER     pParent = pPush->pParent;
+    AssertPtrReturn(pParent, VERR_WRONG_ORDER);
+    return RTVfsIoStrmPoll(pParent->hVfsIos, fEvents, cMillies, fIntr, pfRetEvents);
+}
+
+
+/**
+ * @interface_method_impl{RTVFSIOSTREAMOPS,pfnTell}
+ */
+static DECLCALLBACK(int) rtZipTarWriterPush_Tell(void *pvThis, PRTFOFF poffActual)
+{
+    PRTZIPTARFSSTREAMWRITERPUSH pPush = (PRTZIPTARFSSTREAMWRITERPUSH)pvThis;
+    *poffActual = (RTFOFF)pPush->offCurrent;
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSIOSTREAMOPS,pfnSkip}
+ */
+static DECLCALLBACK(int) rtZipTarWriterPush_Skip(void *pvThis, RTFOFF cb)
+{
+    RT_NOREF(pvThis, cb);
+    AssertFailed();
+    return VERR_ACCESS_DENIED;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSOBJSETOPS,pfnMode}
+ */
+static DECLCALLBACK(int) rtZipTarWriterPush_SetMode(void *pvThis, RTFMODE fMode, RTFMODE fMask)
+{
+    RT_NOREF(pvThis, fMode, fMask);
+    AssertFailed();
+    return VERR_ACCESS_DENIED;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSOBJSETOPS,pfnSetTimes}
+ */
+static DECLCALLBACK(int) rtZipTarWriterPush_SetTimes(void *pvThis, PCRTTIMESPEC pAccessTime, PCRTTIMESPEC pModificationTime,
+                                                     PCRTTIMESPEC pChangeTime, PCRTTIMESPEC pBirthTime)
+{
+    RT_NOREF(pvThis, pAccessTime, pModificationTime, pChangeTime, pBirthTime);
+    AssertFailed();
+    return VERR_ACCESS_DENIED;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSOBJSETOPS,pfnSetOwner}
+ */
+static DECLCALLBACK(int) rtZipTarWriterPush_SetOwner(void *pvThis, RTUID uid, RTGID gid)
+{
+    RT_NOREF(pvThis, uid, gid);
+    AssertFailed();
+    return VERR_ACCESS_DENIED;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSFILEOPS,pfnSeek}
+ */
+static DECLCALLBACK(int) rtZipTarWriterPush_Seek(void *pvThis, RTFOFF offSeek, unsigned uMethod, PRTFOFF poffActual)
+{
+    PRTZIPTARFSSTREAMWRITERPUSH pPush   = (PRTZIPTARFSSTREAMWRITERPUSH)pvThis;
+    PRTZIPTARFSSTREAMWRITER     pParent = pPush->pParent;
+    AssertPtrReturn(pParent, VERR_WRONG_ORDER);
+
+    int rc = pParent->rcFatal;
+    AssertRCReturn(rc, rc);
+    Assert(pPush->offCurrent <= pPush->cbCurrent);
+
+    /*
+     * Calculate the new file offset.
+     */
+    RTFOFF offNewSigned;
+    switch (uMethod)
+    {
+        case RTFILE_SEEK_BEGIN:
+            offNewSigned = offSeek;
+            break;
+        case RTFILE_SEEK_CURRENT:
+            offNewSigned = pPush->offCurrent + offSeek;
+            break;
+        case RTFILE_SEEK_END:
+            offNewSigned = pPush->cbCurrent + offSeek;
+            break;
+        default:
+            AssertFailedReturn(VERR_INVALID_PARAMETER);
+    }
+
+    /*
+     * Check the new file offset against expectations.
+     */
+    AssertMsgReturn(offNewSigned >= 0, ("offNewSigned=%RTfoff\n", offNewSigned), VERR_NEGATIVE_SEEK);
+
+    uint64_t offNew = (uint64_t)offNewSigned;
+    AssertMsgReturn(offNew <= pPush->cbExpected, ("offNew=%#RX64 cbExpected=%#Rx64\n", offNew, pPush->cbExpected), VERR_SEEK);
+
+    /*
+     * Any change at all?  We can always hope...
+     */
+    if (offNew == pPush->offCurrent)
+    { }
+    /*
+     * Gap that needs zero filling?
+     */
+    else if (offNew > pPush->cbCurrent)
+    {
+        if (pPush->offCurrent != pPush->cbCurrent)
+        {
+            AssertReturn(pParent->hVfsFile != NIL_RTVFSFILE, VERR_NOT_A_FILE);
+            rc = RTVfsFileSeek(pParent->hVfsFile, pPush->offData + pPush->cbCurrent, RTFILE_SEEK_BEGIN, NULL);
+            if (RT_FAILURE(rc))
+                return pParent->rcFatal = rc;
+            pPush->offCurrent = pPush->cbCurrent;
+        }
+
+        uint64_t cbToZero = offNew - pPush->cbCurrent;
+        rc = RTVfsIoStrmZeroFill(pParent->hVfsIos, cbToZero);
+        if (RT_FAILURE(rc))
+            return pParent->rcFatal = rc;
+        pParent->cbWritten += cbToZero;
+        pPush->cbCurrent = pPush->offCurrent = offNew;
+    }
+    /*
+     * Just change the file position to somewhere we've already written.
+     */
+    else
+    {
+        AssertReturn(pParent->hVfsFile != NIL_RTVFSFILE, VERR_NOT_A_FILE);
+        rc = RTVfsFileSeek(pParent->hVfsFile, pPush->offData + offNew, RTFILE_SEEK_BEGIN, NULL);
+        if (RT_FAILURE(rc))
+            return pParent->rcFatal = rc;
+        pPush->offCurrent = offNew;
+    }
+    Assert(pPush->offCurrent <= pPush->cbCurrent);
+
+    if (poffActual)
+        *poffActual = pPush->offCurrent;
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSFILEOPS,pfnQuerySize}
+ */
+static DECLCALLBACK(int) rtZipTarWriterPush_QuerySize(void *pvThis, uint64_t *pcbFile)
+{
+    PRTZIPTARFSSTREAMWRITERPUSH pPush = (PRTZIPTARFSSTREAMWRITERPUSH)pvThis;
+    *pcbFile = pPush->cbCurrent;
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * TAR writer push I/O stream operations.
+ */
+DECL_HIDDEN_CONST(const RTVFSIOSTREAMOPS) g_rtZipTarWriterIoStrmOps =
+{
+    { /* Obj */
+        RTVFSOBJOPS_VERSION,
+        RTVFSOBJTYPE_IO_STREAM,
+        "TAR push I/O Stream",
+        rtZipTarWriterPush_Close,
+        rtZipTarWriterPush_QueryInfo,
+        NULL,
+        RTVFSOBJOPS_VERSION
+    },
+    RTVFSIOSTREAMOPS_VERSION,
+    RTVFSIOSTREAMOPS_FEAT_NO_SG,
+    rtZipTarWriterPush_Read,
+    rtZipTarWriterPush_Write,
+    rtZipTarWriterPush_Flush,
+    rtZipTarWriterPush_PollOne,
+    rtZipTarWriterPush_Tell,
+    rtZipTarWriterPush_Skip,
+    NULL /*ZeroFill*/,
+    RTVFSIOSTREAMOPS_VERSION,
+};
+
+
+/**
+ * TAR writer push file operations.
+ */
+DECL_HIDDEN_CONST(const RTVFSFILEOPS) g_rtZipTarWriterFileOps =
+{
+    { /* Stream */
+        { /* Obj */
+            RTVFSOBJOPS_VERSION,
+            RTVFSOBJTYPE_FILE,
+            "TAR push file",
+            rtZipTarWriterPush_Close,
+            rtZipTarWriterPush_QueryInfo,
+            NULL,
+            RTVFSOBJOPS_VERSION
+        },
+        RTVFSIOSTREAMOPS_VERSION,
+        RTVFSIOSTREAMOPS_FEAT_NO_SG,
+        rtZipTarWriterPush_Read,
+        rtZipTarWriterPush_Write,
+        rtZipTarWriterPush_Flush,
+        rtZipTarWriterPush_PollOne,
+        rtZipTarWriterPush_Tell,
+        rtZipTarWriterPush_Skip,
+        NULL /*ZeroFill*/,
+        RTVFSIOSTREAMOPS_VERSION,
+    },
+    RTVFSFILEOPS_VERSION,
+    0,
+    { /* ObjSet */
+        RTVFSOBJSETOPS_VERSION,
+        RT_UOFFSETOF(RTVFSFILEOPS, ObjSet) - RT_UOFFSETOF(RTVFSFILEOPS, Stream.Obj),
+        rtZipTarWriterPush_SetMode,
+        rtZipTarWriterPush_SetTimes,
+        rtZipTarWriterPush_SetOwner,
+        RTVFSOBJSETOPS_VERSION
+    },
+    rtZipTarWriterPush_Seek,
+    rtZipTarWriterPush_QuerySize,
+    NULL /*SetSize*/,
+    NULL /*QueryMaxSize*/,
+    RTVFSFILEOPS_VERSION
+};
+
+
+
+/**
+ * Checks rcFatal and completes any current push file.
+ *
+ * On return the output stream position will be at the next header location.
+ *
+ * After this call, the push object no longer can write anything.
+ *
+ * @returns IPRT status code.
+ * @param   pThis           The TAR writer instance.
+ */
+static int rtZipTarFssWriter_CompleteCurrentPushFile(PRTZIPTARFSSTREAMWRITER pThis)
+{
+    /*
+     * Check if there is a push file pending, remove it if there is.
+     * We also check for fatal errors at this point so the caller doesn't need to.
+     */
+    PRTZIPTARFSSTREAMWRITERPUSH pPush = pThis->pPush;
+    if (!pPush)
+    {
+        AssertRC(pThis->rcFatal);
+        return pThis->rcFatal;
+    }
+
+    pThis->pPush   = NULL;
+    pPush->pParent = NULL;
+
+    int rc = pThis->rcFatal;
+    AssertRCReturn(rc, rc);
+
+    /*
+     * Do we need to update the header.  pThis->aHdrs[0] will retain the current
+     * content at pPush->offHdr and we only need to update the size.
+     */
+    if (pPush->fOpenEnded)
+    {
+        rc = rtZipTarFssWriter_FormatOffset(pThis->aHdrs[0].Common.size, pPush->cbCurrent);
+        if (RT_SUCCESS(rc))
+            rc = rtZipTarFssWriter_ChecksumHdr(&pThis->aHdrs[0]);
+        if (RT_SUCCESS(rc))
+        {
+            rc = RTVfsFileWriteAt(pThis->hVfsFile, pPush->offHdr, &pThis->aHdrs[0], sizeof(pThis->aHdrs[0]), NULL);
+            if (RT_SUCCESS(rc))
+                rc = RTVfsFileSeek(pThis->hVfsFile, pPush->offData + pPush->cbCurrent, RTFILE_SEEK_BEGIN, NULL);
+        }
+    }
+    /*
+     * Check that we've received all the data we were promissed in the PushFile
+     * call, fail if we weren't.
+     */
+    else
+        AssertMsgStmt(pPush->cbCurrent == pPush->cbExpected,
+                      ("cbCurrent=%#RX64 cbExpected=%#RX64\n", pPush->cbCurrent, pPush->cbExpected),
+                      rc = VERR_BUFFER_UNDERFLOW);
+    if (RT_SUCCESS(rc))
+    {
+        /*
+         * Do zero padding if necessary.
+         */
+        if (pPush->cbCurrent & (RTZIPTAR_BLOCKSIZE - 1))
+        {
+            size_t cbToZero = RTZIPTAR_BLOCKSIZE - (pPush->cbCurrent & (RTZIPTAR_BLOCKSIZE - 1));
+            rc = RTVfsIoStrmWrite(pThis->hVfsIos, g_abRTZero4K, cbToZero, true /*fBlocking*/, NULL);
+            if (RT_SUCCESS(rc))
+                pThis->cbWritten += cbToZero;
+        }
+    }
+
+    if (RT_SUCCESS(rc))
+        return VINF_SUCCESS;
+    pThis->rcFatal = rc;
+    return rc;
+}
+
+
+/**
+ * Does the actual work for rtZipTarFssWriter_SwitchToWriteMode().
+ *
+ * @note    We won't be here if we've truncate the tar file.   Truncation
+ *          switches it into write mode.
+ */
+DECL_NO_INLINE(static, int) rtZipTarFssWriter_SwitchToWriteModeSlow(PRTZIPTARFSSTREAMWRITER pThis)
+{
+    /* Always go thru rtZipTarFssWriter_SwitchToWriteMode(). */
+    AssertRCReturn(pThis->rcFatal, pThis->rcFatal);
+    AssertReturn(!pThis->fWriting, VINF_SUCCESS);
+    AssertReturn(pThis->fFlags & RTZIPTAR_C_UPDATE, VERR_INTERNAL_ERROR_3);
+
+    /*
+     * If we're not at the end, locate the end of the tar file.
+     * Because I'm lazy, we do that using rtZipTarFss_Next.  This isn't entirely
+     * optimial as it involves VFS object instantations and such.
+     */
+    /** @todo Optimize skipping to end of tar file in update mode. */
+    while (!pThis->pRead->fEndOfStream)
+    {
+        int rc = rtZipTarFss_Next(pThis->pRead, NULL, NULL, NULL);
+        if (rc == VERR_EOF)
+            break;
+        AssertRCReturn(rc, rc);
+    }
+
+    /*
+     * Seek to the desired cut-off point and indicate that we've switched to writing.
+     */
+    Assert(pThis->pRead->offNextHdr == pThis->pRead->offCurHdr);
+    int rc = RTVfsFileSeek(pThis->hVfsFile, pThis->pRead->offNextHdr, RTFILE_SEEK_BEGIN, NULL /*poffActual*/);
+    if (RT_SUCCESS(rc))
+        pThis->fWriting = true;
+    else
+        pThis->rcFatal = rc;
+
+    return rc;
+}
+
+
+/**
+ * Switches the stream into writing mode if necessary.
+ *
+ * @returns VBox status code.
+ * @param   pThis           The TAR writer instance.
+ *
+ */
+DECLINLINE(int) rtZipTarFssWriter_SwitchToWriteMode(PRTZIPTARFSSTREAMWRITER pThis)
+{
+    if (pThis->fWriting)
+        return VINF_SUCCESS; /* ASSUMES caller already checked pThis->rcFatal. */
+    return rtZipTarFssWriter_SwitchToWriteModeSlow(pThis);
+}
+
+
+/**
+ * Allocates a buffer for transfering file data.
+ *
+ * @note    Will use the 3rd TAR header as fallback buffer if we're out of
+ *          memory!
+ *
+ * @returns Pointer to buffer (won't ever fail).
+ * @param   pThis           The TAR writer instance.
+ * @param   pcbBuf          Where to return the buffer size.  This will be a
+ *                          multiple of the TAR block size.
+ * @param   ppvFree         Where to return the pointer to pass to RTMemTmpFree
+ *                          when done with the buffer.
+ * @param   cbFile          The file size.  Used as a buffer size hint.
+ */
+static uint8_t *rtZipTarFssWriter_AllocBuf(PRTZIPTARFSSTREAMWRITER pThis, size_t *pcbBuf, void **ppvFree, uint64_t cbObject)
+{
+    uint8_t *pbBuf;
+
+    /*
+     * If this is a large file, try for a large buffer with 16KB alignment.
+     */
+    if (cbObject >= _64M)
+    {
+        pbBuf = (uint8_t *)RTMemTmpAlloc(_2M + _16K - 1);
+        if (pbBuf)
+        {
+            *pcbBuf  = _2M;
+            *ppvFree = pbBuf;
+            return RT_ALIGN_PT(pbBuf, _16K, uint8_t *);
+        }
+    }
+    /*
+     * 4KB aligned 512KB buffer if larger 512KB or larger.
+     */
+    else if (cbObject >= _512K)
+    {
+        pbBuf = (uint8_t *)RTMemTmpAlloc(_512K + _4K - 1);
+        if (pbBuf)
+        {
+            *pcbBuf  = _512K;
+            *ppvFree = pbBuf;
+            return RT_ALIGN_PT(pbBuf, _4K, uint8_t *);
+        }
+    }
+    /*
+     * Otherwise a 4KB aligned 128KB buffer.
+     */
+    else
+    {
+        pbBuf = (uint8_t *)RTMemTmpAlloc(_128K + _4K - 1);
+        if (pbBuf)
+        {
+            *pcbBuf  = _128K;
+            *ppvFree = pbBuf;
+            return RT_ALIGN_PT(pbBuf, _4K, uint8_t *);
+        }
+    }
+
+    /*
+     * If allocation failed, fallback on a 16KB buffer without any extra alignment.
+     */
+    pbBuf = (uint8_t *)RTMemTmpAlloc(_16K);
+    if (pbBuf)
+    {
+        *pcbBuf  = _16K;
+        *ppvFree = pbBuf;
+        return pbBuf;
+    }
+
+    /*
+     * Final fallback, 512KB buffer using the 3rd header.
+     */
+    AssertCompile(RT_ELEMENTS(pThis->aHdrs) >= 3);
+    *pcbBuf  = sizeof(pThis->aHdrs[2]);
+    *ppvFree = NULL;
+    return (uint8_t *)&pThis->aHdrs[2];
+}
+
+
+/**
+ * Frees the sparse info for a TAR file.
+ *
+ * @param   pSparse         The sparse info to free.
+ */
+static void rtZipTarFssWriter_SparseInfoDestroy(PRTZIPTARSPARSE pSparse)
+{
+    PRTZIPTARSPARSECHUNK pCur;
+    PRTZIPTARSPARSECHUNK pNext;
+    RTListForEachSafe(&pSparse->ChunkHead, pCur, pNext, RTZIPTARSPARSECHUNK, Entry)
+        RTMemTmpFree(pCur);
+    RTMemTmpFree(pSparse);
+}
+
+
+/**
+ * Adds a data span to the sparse info.
+ *
+ * @returns VINF_SUCCESS or VINF_NO_TMP_MEMORY.
+ * @param   pSparse         The sparse info to free.
+ * @param   offSpan         Offset of the span.
+ * @param   cbSpan          Number of bytes.
+ */
+static int rtZipTarFssWriter_SparseInfoAddSpan(PRTZIPTARSPARSE pSparse, uint64_t offSpan, uint64_t cbSpan)
+{
+    /*
+     * Get the chunk we're adding it to.
+     */
+    PRTZIPTARSPARSECHUNK pChunk;
+    if (pSparse->iNextSpan != 0)
+    {
+        pChunk = RTListGetLast(&pSparse->ChunkHead, RTZIPTARSPARSECHUNK, Entry);
+        Assert(pSparse->iNextSpan < RT_ELEMENTS(pChunk->aSpans));
+    }
+    else
+    {
+        pChunk = (PRTZIPTARSPARSECHUNK)RTMemTmpAllocZ(sizeof(*pChunk));
+        if (!pChunk)
+            return VERR_NO_TMP_MEMORY;
+        RTListAppend(&pSparse->ChunkHead, &pChunk->Entry);
+    }
+
+    /*
+     * Append it.
+     */
+    pSparse->cDataSpans  += 1;
+    pSparse->cbDataSpans += cbSpan;
+    pChunk->aSpans[pSparse->iNextSpan].cb  = cbSpan;
+    pChunk->aSpans[pSparse->iNextSpan].off = offSpan;
+    if (++pSparse->iNextSpan >= RT_ELEMENTS(pChunk->aSpans))
+        pSparse->iNextSpan = 0;
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * Scans the input stream recording non-zero blocks.
+ */
+static int rtZipTarFssWriter_ScanSparseFile(PRTZIPTARFSSTREAMWRITER pThis, RTVFSFILE hVfsFile, uint64_t cbFile,
+                                            size_t cbBuf, uint8_t *pbBuf, PRTZIPTARSPARSE *ppSparse)
+{
+    RT_NOREF(pThis);
+
+    /*
+     * Create an empty sparse info bundle.
+     */
+    PRTZIPTARSPARSE pSparse = (PRTZIPTARSPARSE)RTMemTmpAlloc(sizeof(*pSparse));
+    AssertReturn(pSparse, VERR_NO_MEMORY);
+    pSparse->cbDataSpans = 0;
+    pSparse->cDataSpans  = 0;
+    pSparse->iNextSpan   = 0;
+    RTListInit(&pSparse->ChunkHead);
+
+    /*
+     * Scan the file from the start.
+     */
+    int rc = RTVfsFileSeek(hVfsFile, 0, RTFILE_SEEK_BEGIN, NULL);
+    if (RT_SUCCESS(rc))
+    {
+        bool        fZeroSpan = false;
+        uint64_t    offSpan   = 0;
+        uint64_t    cbSpan    = 0;
+
+        for (uint64_t off = 0; off < cbFile;)
+        {
+            uint64_t cbLeft   = cbFile - off;
+            size_t   cbToRead = cbLeft >= cbBuf ? cbBuf : (size_t)cbLeft;
+            rc = RTVfsFileRead(hVfsFile, pbBuf, cbToRead, NULL);
+            if (RT_FAILURE(rc))
+                break;
+            size_t cBlocks = cbToRead / RTZIPTAR_BLOCKSIZE;
+
+            /* Zero pad the final buffer to a multiple of the blocksize. */
+            if (!(cbToRead & (RTZIPTAR_BLOCKSIZE - 1)))
+            { /* likely */ }
+            else
+            {
+                AssertBreakStmt(cbLeft == cbToRead, rc = VERR_INTERNAL_ERROR_3);
+                RT_BZERO(&pbBuf[cbToRead], RTZIPTAR_BLOCKSIZE - (cbToRead & (RTZIPTAR_BLOCKSIZE - 1)));
+                cBlocks++;
+            }
+
+            /*
+             * Process the blocks we've just read one by one.
+             */
+            uint8_t const *pbBlock = pbBuf;
+            for (size_t iBlock = 0; iBlock < cBlocks; iBlock++)
+            {
+                bool fZeroBlock = ASMMemIsZero(pbBlock, RTZIPTAR_BLOCKSIZE);
+                if (fZeroBlock == fZeroSpan)
+                    cbSpan += RTZIPTAR_BLOCKSIZE;
+                else
+                {
+                    if (!fZeroSpan && cbSpan)
+                    {
+                        rc = rtZipTarFssWriter_SparseInfoAddSpan(pSparse, offSpan, cbSpan);
+                        if (RT_FAILURE(rc))
+                            break;
+                    }
+                    fZeroSpan = fZeroBlock;
+                    offSpan   = off;
+                    cbSpan    = RTZIPTAR_BLOCKSIZE;
+                }
+
+                /* next block. */
+                pbBlock += RTZIPTAR_BLOCKSIZE;
+                off     += RTZIPTAR_BLOCKSIZE;
+            }
+        }
+
+        /*
+         * Deal with the final span.  If we've got zeros thowards the end, we
+         * must add a zero byte data span at the end.
+         */
+        if (RT_SUCCESS(rc))
+        {
+            if (!fZeroSpan && cbSpan)
+            {
+                if (cbFile & (RTZIPTAR_BLOCKSIZE - 1))
+                {
+                    Assert(!(cbSpan & (RTZIPTAR_BLOCKSIZE - 1)));
+                    cbSpan -= RTZIPTAR_BLOCKSIZE;
+                    cbSpan |= cbFile & (RTZIPTAR_BLOCKSIZE - 1);
+                }
+                rc = rtZipTarFssWriter_SparseInfoAddSpan(pSparse, offSpan, cbSpan);
+            }
+            if (RT_SUCCESS(rc))
+                rc = rtZipTarFssWriter_SparseInfoAddSpan(pSparse, cbFile, 0);
+        }
+    }
+
+    if (RT_SUCCESS(rc))
+    {
+        /*
+         * Return the file back to the start position before we return so that we
+         * can segue into the regular rtZipTarFssWriter_AddFile without further ado.
+         */
+        rc = RTVfsFileSeek(hVfsFile, 0, RTFILE_SEEK_BEGIN, NULL);
+        if (RT_SUCCESS(rc))
+        {
+            *ppSparse = pSparse;
+            return VINF_SUCCESS;
+        }
+    }
+
+    rtZipTarFssWriter_SparseInfoDestroy(pSparse);
+    *ppSparse = NULL;
+    return rc;
+}
+
+
+/**
+ * Writes GNU the sparse file headers.
+ *
+ * @returns IPRT status code.
+ * @param   pThis           The TAR writer instance.
+ * @param   pszPath         The path to the file.
+ * @param   pObjInfo        The object information.
+ * @param   pszOwnerNm      The owner name.
+ * @param   pszGroupNm      The group name.
+ * @param   pSparse         The sparse file info.
+ */
+static int rtZipTarFssWriter_WriteGnuSparseHeaders(PRTZIPTARFSSTREAMWRITER pThis, const char *pszPath,  PCRTFSOBJINFO pObjInfo,
+                                                   const char *pszOwnerNm, const char *pszGroupNm, PCRTZIPTARSPARSE pSparse)
+{
+    /*
+     * Format the first header.
+     */
+    int rc = rtZipTarFssWriter_ObjInfoToHdr(pThis, pszPath, pObjInfo, pszOwnerNm, pszGroupNm, RTZIPTAR_TF_GNU_SPARSE);
+    AssertRCReturn(rc, rc);
+    AssertReturn(pThis->cHdrs == 1, VERR_INTERNAL_ERROR_2);
+
+    /* data size. */
+    rc = rtZipTarFssWriter_FormatOffset(pThis->aHdrs[0].Common.size, pSparse->cbDataSpans);
+    AssertRCReturn(rc, rc);
+
+    /* realsize. */
+    rc = rtZipTarFssWriter_FormatOffset(pThis->aHdrs[0].Gnu.realsize, pObjInfo->cbObject);
+    AssertRCReturn(rc, rc);
+
+    Assert(pThis->aHdrs[0].Gnu.isextended == 0);
+
+    /*
+     * Walk the sparse spans, fill and write headers one by one.
+     */
+    PRTZIPTARGNUSPARSE  paSparse    = &pThis->aHdrs[0].Gnu.sparse[0];
+    uint32_t            cSparse     = RT_ELEMENTS(pThis->aHdrs[0].Gnu.sparse);
+    uint32_t            iSparse     = 0;
+
+    PRTZIPTARSPARSECHUNK const pLastChunk = RTListGetLast(&pSparse->ChunkHead, RTZIPTARSPARSECHUNK, Entry);
+    PRTZIPTARSPARSECHUNK pChunk;
+    RTListForEach(&pSparse->ChunkHead, pChunk, RTZIPTARSPARSECHUNK, Entry)
+    {
+        uint32_t cSpans = pChunk != pLastChunk || pSparse->iNextSpan == 0
+                        ? RT_ELEMENTS(pChunk->aSpans) : pSparse->iNextSpan;
+        for (uint32_t iSpan = 0; iSpan < cSpans; iSpan++)
+        {
+            /* Flush the header? */
+            if (iSparse >= cSparse)
+            {
+                if (cSparse != RT_ELEMENTS(pThis->aHdrs[0].Gnu.sparse))
+                    pThis->aHdrs[0].GnuSparse.isextended = 1; /* more headers to come */
+                else
+                {
+                    pThis->aHdrs[0].Gnu.isextended = 1; /* more headers to come */
+                    rc = rtZipTarFssWriter_ChecksumHdr(&pThis->aHdrs[0]);
+                }
+                if (RT_SUCCESS(rc))
+                    rc = RTVfsIoStrmWrite(pThis->hVfsIos, &pThis->aHdrs[0], sizeof(pThis->aHdrs[0]), true /*fBlocking*/, NULL);
+                if (RT_FAILURE(rc))
+                    return rc;
+                RT_ZERO(pThis->aHdrs[0]);
+                cSparse  = RT_ELEMENTS(pThis->aHdrs[0].GnuSparse.sp);
+                iSparse  = 0;
+                paSparse = &pThis->aHdrs[0].GnuSparse.sp[0];
+            }
+
+            /* Append sparse data segment. */
+            rc = rtZipTarFssWriter_FormatOffset(paSparse[iSparse].offset, pChunk->aSpans[iSpan].off);
+            AssertRCReturn(rc, rc);
+            rc = rtZipTarFssWriter_FormatOffset(paSparse[iSparse].numbytes, pChunk->aSpans[iSpan].cb);
+            AssertRCReturn(rc, rc);
+            iSparse++;
+        }
+    }
+
+    /*
+     * The final header.
+     */
+    if (iSparse != 0)
+    {
+        if (cSparse != RT_ELEMENTS(pThis->aHdrs[0].Gnu.sparse))
+            Assert(pThis->aHdrs[0].GnuSparse.isextended == 0);
+        else
+        {
+            Assert(pThis->aHdrs[0].Gnu.isextended == 0);
+            rc = rtZipTarFssWriter_ChecksumHdr(&pThis->aHdrs[0]);
+        }
+        if (RT_SUCCESS(rc))
+            rc = RTVfsIoStrmWrite(pThis->hVfsIos, &pThis->aHdrs[0], sizeof(pThis->aHdrs[0]), true /*fBlocking*/, NULL);
+    }
+    pThis->cHdrs = 0;
+    return rc;
+}
+
+
+/**
+ * Adds a potentially sparse file to the output.
+ *
+ * @returns IPRT status code.
+ * @param   pThis           The TAR writer instance.
+ * @param   pszPath         The path to the file.
+ * @param   hVfsFile        The potentially sparse file.
+ * @param   hVfsIos         The I/O stream of the file. Same as @a hVfsFile.
+ * @param   pObjInfo        The object information.
+ * @param   pszOwnerNm      The owner name.
+ * @param   pszGroupNm      The group name.
+ */
+static int rtZipTarFssWriter_AddFileSparse(PRTZIPTARFSSTREAMWRITER pThis, const char *pszPath, RTVFSFILE hVfsFile,
+                                           RTVFSIOSTREAM hVfsIos, PCRTFSOBJINFO pObjInfo,
+                                           const char *pszOwnerNm, const char *pszGroupNm)
+{
+    /*
+     * Scan the input file to locate all zero blocks.
+     */
+    void    *pvBufFree;
+    size_t   cbBuf;
+    uint8_t *pbBuf = rtZipTarFssWriter_AllocBuf(pThis, &cbBuf, &pvBufFree, pObjInfo->cbObject);
+
+    PRTZIPTARSPARSE pSparse;
+    int rc = rtZipTarFssWriter_ScanSparseFile(pThis, hVfsFile, pObjInfo->cbObject, cbBuf, pbBuf, &pSparse);
+    if (RT_SUCCESS(rc))
+    {
+        /*
+         * If there aren't at least 2 zero blocks in the file, don't bother
+         * doing the sparse stuff and store it as a normal file.
+         */
+        if (pSparse->cbDataSpans + RTZIPTAR_BLOCKSIZE > (uint64_t)pObjInfo->cbObject)
+        {
+            rtZipTarFssWriter_SparseInfoDestroy(pSparse);
+            RTMemTmpFree(pvBufFree);
+            return rtZipTarFssWriter_AddFile(pThis, pszPath, hVfsIos, pObjInfo, pszOwnerNm, pszGroupNm);
+        }
+
+        /*
+         * Produce and write the headers.
+         */
+        if (pThis->enmFormat == RTZIPTARFORMAT_GNU)
+            rc = rtZipTarFssWriter_WriteGnuSparseHeaders(pThis, pszPath, pObjInfo, pszOwnerNm, pszGroupNm, pSparse);
+        else
+            AssertStmt(pThis->enmFormat != RTZIPTARFORMAT_GNU, rc = VERR_NOT_IMPLEMENTED);
+        if (RT_SUCCESS(rc))
+        {
+            /*
+             * Write the file bytes.
+             */
+            PRTZIPTARSPARSECHUNK const pLastChunk = RTListGetLast(&pSparse->ChunkHead, RTZIPTARSPARSECHUNK, Entry);
+            PRTZIPTARSPARSECHUNK pChunk;
+            RTListForEach(&pSparse->ChunkHead, pChunk, RTZIPTARSPARSECHUNK, Entry)
+            {
+                uint32_t cSpans = pChunk != pLastChunk || pSparse->iNextSpan == 0
+                                ? RT_ELEMENTS(pChunk->aSpans) : pSparse->iNextSpan;
+                for (uint32_t iSpan = 0; iSpan < cSpans; iSpan++)
+                {
+                    rc = RTVfsFileSeek(hVfsFile, pChunk->aSpans[iSpan].off, RTFILE_SEEK_BEGIN, NULL);
+                    if (RT_FAILURE(rc))
+                        break;
+                    uint64_t cbLeft = pChunk->aSpans[iSpan].cb;
+                    Assert(   !(cbLeft & (RTZIPTAR_BLOCKSIZE - 1))
+                           || (iSpan + 1 == cSpans && pChunk == pLastChunk));
+                    while (cbLeft > 0)
+                    {
+                        size_t cbToRead = cbLeft >= cbBuf ? cbBuf : (size_t)cbLeft;
+                        rc = RTVfsFileRead(hVfsFile, pbBuf, cbToRead, NULL);
+                        if (RT_SUCCESS(rc))
+                        {
+                            rc = RTVfsIoStrmWrite(pThis->hVfsIos, pbBuf, cbToRead, true /*fBlocking*/, NULL);
+                            if (RT_SUCCESS(rc))
+                            {
+                                pThis->cbWritten += cbToRead;
+                                cbLeft           -= cbToRead;
+                                continue;
+                            }
+                        }
+                        break;
+                    }
+                    if (RT_FAILURE(rc))
+                        break;
+                }
+            }
+
+            /*
+             * Do the zero padding.
+             */
+            if (   RT_SUCCESS(rc)
+                && (pSparse->cbDataSpans & (RTZIPTAR_BLOCKSIZE - 1)))
+            {
+                size_t cbToZero = RTZIPTAR_BLOCKSIZE - (pSparse->cbDataSpans & (RTZIPTAR_BLOCKSIZE - 1));
+                rc = RTVfsIoStrmWrite(pThis->hVfsIos, g_abRTZero4K, cbToZero, true /*fBlocking*/, NULL);
+                if (RT_SUCCESS(rc))
+                    pThis->cbWritten += cbToZero;
+            }
+        }
+
+        if (RT_FAILURE(rc))
+            pThis->rcFatal = rc;
+        rtZipTarFssWriter_SparseInfoDestroy(pSparse);
+    }
+    RTMemTmpFree(pvBufFree);
+    return rc;
+}
+
+
+/**
+ * Adds an I/O stream of indeterminate length to the TAR file.
+ *
+ * This requires the output to be seekable, i.e. a file, because we need to go
+ * back and update @c size field of the TAR header after pumping all the data
+ * bytes thru and establishing the file length.
+ *
+ * @returns IPRT status code.
+ * @param   pThis           The TAR writer instance.
+ * @param   pszPath         The path to the file.
+ * @param   hVfsIos         The I/O stream of the file.
+ * @param   pObjInfo        The object information.
+ * @param   pszOwnerNm      The owner name.
+ * @param   pszGroupNm      The group name.
+ */
+static int rtZipTarFssWriter_AddFileStream(PRTZIPTARFSSTREAMWRITER pThis, const char *pszPath, RTVFSIOSTREAM hVfsIos,
+                                           PCRTFSOBJINFO pObjInfo, const char *pszOwnerNm, const char *pszGroupNm)
+{
+    AssertReturn(pThis->hVfsFile != NIL_RTVFSFILE, VERR_NOT_A_FILE);
+
+    /*
+     * Append the header.
+     */
+    int rc = rtZipTarFssWriter_ObjInfoToHdr(pThis, pszPath, pObjInfo, pszOwnerNm, pszGroupNm, UINT8_MAX);
+    if (RT_SUCCESS(rc))
+    {
+        RTFOFF const offHdr = RTVfsFileTell(pThis->hVfsFile);
+        if (offHdr >= 0)
+        {
+            rc = RTVfsIoStrmWrite(pThis->hVfsIos, pThis->aHdrs, pThis->cHdrs * sizeof(pThis->aHdrs[0]), true /*fBlocking*/, NULL);
+            if (RT_SUCCESS(rc))
+            {
+                pThis->cbWritten += pThis->cHdrs * sizeof(pThis->aHdrs[0]);
+
+                /*
+                 * Transfer the bytes.
+                 */
+                void    *pvBufFree;
+                size_t   cbBuf;
+                uint8_t *pbBuf = rtZipTarFssWriter_AllocBuf(pThis, &cbBuf, &pvBufFree,
+                                                            pObjInfo->cbObject > 0 && pObjInfo->cbObject != RTFOFF_MAX
+                                                            ? pObjInfo->cbObject : _1G);
+
+                uint64_t cbReadTotal = 0;
+                for (;;)
+                {
+                    size_t cbRead = 0;
+                    int rc2 = rc = RTVfsIoStrmRead(hVfsIos, pbBuf, cbBuf, true /*fBlocking*/, &cbRead);
+                    if (RT_SUCCESS(rc))
+                    {
+                        cbReadTotal += cbRead;
+                        rc = RTVfsIoStrmWrite(pThis->hVfsIos, pbBuf, cbRead, true /*fBlocking*/, NULL);
+                        if (RT_SUCCESS(rc))
+                        {
+                            pThis->cbWritten += cbRead;
+                            if (rc2 != VINF_EOF)
+                                continue;
+                        }
+                    }
+                    Assert(rc != VERR_EOF /* expecting VINF_EOF! */);
+                    break;
+                }
+
+                RTMemTmpFree(pvBufFree);
+
+                /*
+                 * Do the zero padding.
+                 */
+                if ((cbReadTotal & (RTZIPTAR_BLOCKSIZE - 1)) && RT_SUCCESS(rc))
+                {
+                    size_t cbToZero = RTZIPTAR_BLOCKSIZE - (cbReadTotal & (RTZIPTAR_BLOCKSIZE - 1));
+                    rc = RTVfsIoStrmWrite(pThis->hVfsIos, g_abRTZero4K, cbToZero, true /*fBlocking*/, NULL);
+                    if (RT_SUCCESS(rc))
+                        pThis->cbWritten += cbToZero;
+                }
+
+                /*
+                 * Update the header.  We ASSUME that aHdr[0] is unmodified
+                 * from before the data pumping above and just update the size.
+                 */
+                if ((RTFOFF)cbReadTotal != pObjInfo->cbObject && RT_SUCCESS(rc))
+                {
+                    RTFOFF const offRestore = RTVfsFileTell(pThis->hVfsFile);
+                    if (offRestore >= 0)
+                    {
+                        rc = rtZipTarFssWriter_FormatOffset(pThis->aHdrs[0].Common.size, cbReadTotal);
+                        if (RT_SUCCESS(rc))
+                            rc = rtZipTarFssWriter_ChecksumHdr(&pThis->aHdrs[0]);
+                        if (RT_SUCCESS(rc))
+                        {
+                            rc = RTVfsFileWriteAt(pThis->hVfsFile, offHdr, &pThis->aHdrs[0], sizeof(pThis->aHdrs[0]), NULL);
+                            if (RT_SUCCESS(rc))
+                                rc = RTVfsFileSeek(pThis->hVfsFile, offRestore, RTFILE_SEEK_BEGIN, NULL);
+                        }
+                    }
+                    else
+                        rc = (int)offRestore;
+                }
+
+                if (RT_SUCCESS(rc))
+                    return VINF_SUCCESS;
+            }
+        }
+        else
+            rc = (int)offHdr;
+        pThis->rcFatal = rc;
+    }
+    return rc;
+}
+
+
+/**
+ * Adds a file to the stream.
+ *
+ * @returns IPRT status code.
+ * @param   pThis           The TAR writer instance.
+ * @param   pszPath         The path to the file.
+ * @param   hVfsIos         The I/O stream of the file.
+ * @param   fFlags          The RTVFSFSSTREAMOPS::pfnAdd flags.
+ * @param   pObjInfo        The object information.
+ * @param   pszOwnerNm      The owner name.
+ * @param   pszGroupNm      The group name.
+ */
+static int rtZipTarFssWriter_AddFile(PRTZIPTARFSSTREAMWRITER pThis, const char *pszPath, RTVFSIOSTREAM hVfsIos,
+                                     PCRTFSOBJINFO pObjInfo, const char *pszOwnerNm, const char *pszGroupNm)
+{
+    /*
+     * Append the header.
+     */
+    int rc = rtZipTarFssWriter_ObjInfoToHdr(pThis, pszPath, pObjInfo, pszOwnerNm, pszGroupNm, UINT8_MAX);
+    if (RT_SUCCESS(rc))
+    {
+        rc = RTVfsIoStrmWrite(pThis->hVfsIos, pThis->aHdrs, pThis->cHdrs * sizeof(pThis->aHdrs[0]), true /*fBlocking*/, NULL);
+        if (RT_SUCCESS(rc))
+        {
+            pThis->cbWritten += pThis->cHdrs * sizeof(pThis->aHdrs[0]);
+
+            /*
+             * Copy the bytes.  Padding the last buffer to a multiple of 512.
+             */
+            void    *pvBufFree;
+            size_t   cbBuf;
+            uint8_t *pbBuf = rtZipTarFssWriter_AllocBuf(pThis, &cbBuf, &pvBufFree, pObjInfo->cbObject);
+
+            uint64_t cbLeft = pObjInfo->cbObject;
+            while (cbLeft > 0)
+            {
+                size_t cbRead = cbLeft > cbBuf ? cbBuf : (size_t)cbLeft;
+                rc = RTVfsIoStrmRead(hVfsIos, pbBuf, cbRead, true /*fBlocking*/, NULL);
+                if (RT_FAILURE(rc))
+                    break;
+
+                size_t cbToWrite = cbRead;
+                if (cbRead & (RTZIPTAR_BLOCKSIZE - 1))
+                {
+                    size_t cbToZero = RTZIPTAR_BLOCKSIZE - (cbRead & (RTZIPTAR_BLOCKSIZE - 1));
+                    memset(&pbBuf[cbRead], 0, cbToZero);
+                    cbToWrite += cbToZero;
+                }
+
+                rc = RTVfsIoStrmWrite(pThis->hVfsIos, pbBuf, cbToWrite, true /*fBlocking*/, NULL);
+                if (RT_FAILURE(rc))
+                    break;
+                pThis->cbWritten += cbToWrite;
+                cbLeft -= cbRead;
+            }
+
+            RTMemTmpFree(pvBufFree);
+
+            if (RT_SUCCESS(rc))
+                return VINF_SUCCESS;
+        }
+        pThis->rcFatal = rc;
+    }
+    return rc;
+}
+
+
+/**
+ * Adds a symbolic link to the stream.
+ *
+ * @returns IPRT status code.
+ * @param   pThis           The TAR writer instance.
+ * @param   pszPath         The path to the object.
+ * @param   hVfsSymlink     The symbolic link object to add.
+ * @param   pObjInfo        The object information.
+ * @param   pszOwnerNm      The owner name.
+ * @param   pszGroupNm      The group name.
+ */
+static int rtZipTarFssWriter_AddSymlink(PRTZIPTARFSSTREAMWRITER pThis, const char *pszPath, RTVFSSYMLINK hVfsSymlink,
+                                        PCRTFSOBJINFO pObjInfo,  const char *pszOwnerNm, const char *pszGroupNm)
+{
+    /*
+     * Read the symlink target first and check that it's not too long.
+     * Flip DOS slashes.
+     */
+    char szTarget[RTPATH_MAX];
+    int rc = RTVfsSymlinkRead(hVfsSymlink, szTarget,  sizeof(szTarget));
+    if (RT_SUCCESS(rc))
+    {
+#if RTPATH_STYLE != RTPATH_STR_F_STYLE_UNIX
+        char *pszDosSlash = strchr(szTarget, '\\');
+        while (pszDosSlash)
+        {
+            *pszDosSlash = '/';
+            pszDosSlash = strchr(pszDosSlash + 1, '\\');
+        }
+#endif
+        size_t cchTarget = strlen(szTarget);
+        if (cchTarget < sizeof(pThis->aHdrs[0].Common.linkname))
+        {
+            /*
+             * Create a header, add the link target and push it out.
+             */
+            rc = rtZipTarFssWriter_ObjInfoToHdr(pThis, pszPath, pObjInfo, pszOwnerNm, pszGroupNm, UINT8_MAX);
+            if (RT_SUCCESS(rc))
+            {
+                memcpy(pThis->aHdrs[0].Common.linkname, szTarget, cchTarget + 1);
+                rc = rtZipTarFssWriter_ChecksumHdr(&pThis->aHdrs[0]);
+                if (RT_SUCCESS(rc))
+                {
+                    rc = RTVfsIoStrmWrite(pThis->hVfsIos, pThis->aHdrs, pThis->cHdrs * sizeof(pThis->aHdrs[0]),
+                                          true /*fBlocking*/, NULL);
+                    if (RT_SUCCESS(rc))
+                    {
+                        pThis->cbWritten += pThis->cHdrs * sizeof(pThis->aHdrs[0]);
+                        return VINF_SUCCESS;
+                    }
+                    pThis->rcFatal = rc;
+                }
+            }
+        }
+        else
+        {
+            /** @todo implement gnu and pax long name extensions. */
+            rc = VERR_TAR_NAME_TOO_LONG;
+        }
+    }
+    return rc;
+}
+
+
+/**
+ * Adds a simple object to the stream.
+ *
+ * Simple objects only contains metadata, no actual data bits.  Directories,
+ * devices, fifos, sockets and such.
+ *
+ * @returns IPRT status code.
+ * @param   pThis           The TAR writer instance.
+ * @param   pszPath         The path to the object.
+ * @param   pObjInfo        The object information.
+ * @param   pszOwnerNm      The owner name.
+ * @param   pszGroupNm      The group name.
+ */
+static int rtZipTarFssWriter_AddSimpleObject(PRTZIPTARFSSTREAMWRITER pThis, const char *pszPath, PCRTFSOBJINFO pObjInfo,
+                                             const char *pszOwnerNm, const char *pszGroupNm)
+{
+    int rc = rtZipTarFssWriter_ObjInfoToHdr(pThis, pszPath, pObjInfo, pszOwnerNm, pszGroupNm, UINT8_MAX);
+    if (RT_SUCCESS(rc))
+    {
+        rc = RTVfsIoStrmWrite(pThis->hVfsIos, pThis->aHdrs, pThis->cHdrs * sizeof(pThis->aHdrs[0]), true /*fBlocking*/, NULL);
+        if (RT_SUCCESS(rc))
+        {
+            pThis->cbWritten += pThis->cHdrs * sizeof(pThis->aHdrs[0]);
+            return VINF_SUCCESS;
+        }
+        pThis->rcFatal = rc;
+    }
+    return rc;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSOBJOPS,pfnClose}
+ */
+static DECLCALLBACK(int) rtZipTarFssWriter_Close(void *pvThis)
+{
+    PRTZIPTARFSSTREAMWRITER pThis = (PRTZIPTARFSSTREAMWRITER)pvThis;
+
+    rtZipTarFssWriter_CompleteCurrentPushFile(pThis);
+
+    RTVfsIoStrmRelease(pThis->hVfsIos);
+    pThis->hVfsIos = NIL_RTVFSIOSTREAM;
+
+    if (pThis->hVfsFile != NIL_RTVFSFILE)
+    {
+        RTVfsFileRelease(pThis->hVfsFile);
+        pThis->hVfsFile = NIL_RTVFSFILE;
+    }
+
+    if (pThis->pszOwner)
+    {
+        RTStrFree(pThis->pszOwner);
+        pThis->pszOwner = NULL;
+    }
+    if (pThis->pszGroup)
+    {
+        RTStrFree(pThis->pszGroup);
+        pThis->pszGroup = NULL;
+    }
+    if (pThis->pszPrefix)
+    {
+        RTStrFree(pThis->pszPrefix);
+        pThis->pszPrefix = NULL;
+    }
+
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSOBJOPS,pfnQueryInfo}
+ */
+static DECLCALLBACK(int) rtZipTarFssWriter_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
+{
+    PRTZIPTARFSSTREAMWRITER pThis = (PRTZIPTARFSSTREAMWRITER)pvThis;
+    /* Take the lazy approach here, with the sideffect of providing some info
+       that is actually kind of useful. */
+    return RTVfsIoStrmQueryInfo(pThis->hVfsIos, pObjInfo, enmAddAttr);
+}
+
+
+/**
+ * @interface_method_impl{RTVFSFSSTREAMOPS,pfnNext}
+ */
+static DECLCALLBACK(int) rtZipTarFssWriter_Next(void *pvThis, char **ppszName, RTVFSOBJTYPE *penmType, PRTVFSOBJ phVfsObj)
+{
+    PRTZIPTARFSSTREAMWRITER pThis = (PRTZIPTARFSSTREAMWRITER)pvThis;
+
+    /*
+     * This only works in update mode and up to the point where
+     * modifications takes place (truncating the archive or appending files).
+     */
+    AssertReturn(pThis->pRead, VERR_ACCESS_DENIED);
+    AssertReturn(pThis->fFlags & RTZIPTAR_C_UPDATE, VERR_ACCESS_DENIED);
+
+    AssertReturn(!pThis->fWriting, VERR_WRONG_ORDER);
+
+    return rtZipTarFss_Next(pThis->pRead, ppszName, penmType, phVfsObj);
+}
+
+
+/**
+ * @interface_method_impl{RTVFSFSSTREAMOPS,pfnAdd}
+ */
+static DECLCALLBACK(int) rtZipTarFssWriter_Add(void *pvThis, const char *pszPath, RTVFSOBJ hVfsObj, uint32_t fFlags)
+{
+    PRTZIPTARFSSTREAMWRITER pThis = (PRTZIPTARFSSTREAMWRITER)pvThis;
+
+    /*
+     * Before we continue we must complete any current push file and check rcFatal.
+     */
+    int rc = rtZipTarFssWriter_CompleteCurrentPushFile(pThis);
+    AssertRCReturn(rc, rc);
+
+    /*
+     * Query information about the object.
+     */
+    RTFSOBJINFO ObjInfo;
+    rc = RTVfsObjQueryInfo(hVfsObj, &ObjInfo, RTFSOBJATTRADD_UNIX);
+    AssertRCReturn(rc, rc);
+
+    RTFSOBJINFO ObjOwnerName;
+    rc = RTVfsObjQueryInfo(hVfsObj, &ObjOwnerName, RTFSOBJATTRADD_UNIX_OWNER);
+    if (RT_FAILURE(rc) || ObjOwnerName.Attr.u.UnixOwner.szName[0] == '\0')
+        strcpy(ObjOwnerName.Attr.u.UnixOwner.szName, "someone");
+
+    RTFSOBJINFO ObjGrpName;
+    rc = RTVfsObjQueryInfo(hVfsObj, &ObjGrpName, RTFSOBJATTRADD_UNIX_GROUP);
+    if (RT_FAILURE(rc) || ObjGrpName.Attr.u.UnixGroup.szName[0] == '\0')
+        strcpy(ObjGrpName.Attr.u.UnixGroup.szName, "somegroup");
+
+    /*
+     * Switch the stream into write mode if necessary.
+     */
+    rc = rtZipTarFssWriter_SwitchToWriteMode(pThis);
+    AssertRCReturn(rc, rc);
+
+    /*
+     * Do type specific handling.  File have several options and variations to
+     * take into account, thus the mess.
+     */
+    if (RTFS_IS_FILE(ObjInfo.Attr.fMode))
+    {
+        RTVFSIOSTREAM hVfsIos = RTVfsObjToIoStream(hVfsObj);
+        AssertReturn(hVfsIos != NIL_RTVFSIOSTREAM, VERR_WRONG_TYPE);
+
+        if (fFlags & RTVFSFSSTRM_ADD_F_STREAM)
+            rc = rtZipTarFssWriter_AddFileStream(pThis, pszPath, hVfsIos, &ObjInfo,
+                                                 ObjOwnerName.Attr.u.UnixOwner.szName, ObjGrpName.Attr.u.UnixOwner.szName);
+        else if (   !(pThis->fFlags & RTZIPTAR_C_SPARSE)
+                 || ObjInfo.cbObject < RTZIPTAR_MIN_SPARSE)
+            rc = rtZipTarFssWriter_AddFile(pThis, pszPath, hVfsIos, &ObjInfo,
+                                           ObjOwnerName.Attr.u.UnixOwner.szName, ObjGrpName.Attr.u.UnixOwner.szName);
+        else
+        {
+            RTVFSFILE hVfsFile = RTVfsObjToFile(hVfsObj);
+            if (hVfsFile != NIL_RTVFSFILE)
+            {
+                rc = rtZipTarFssWriter_AddFileSparse(pThis, pszPath, hVfsFile, hVfsIos, &ObjInfo,
+                                                     ObjOwnerName.Attr.u.UnixOwner.szName, ObjGrpName.Attr.u.UnixOwner.szName);
+                RTVfsFileRelease(hVfsFile);
+            }
+            else
+                rc = rtZipTarFssWriter_AddFile(pThis, pszPath, hVfsIos, &ObjInfo,
+                                               ObjOwnerName.Attr.u.UnixOwner.szName, ObjGrpName.Attr.u.UnixOwner.szName);
+        }
+        RTVfsIoStrmRelease(hVfsIos);
+    }
+    else if (RTFS_IS_SYMLINK(ObjInfo.Attr.fMode))
+    {
+        RTVFSSYMLINK hVfsSymlink = RTVfsObjToSymlink(hVfsObj);
+        AssertReturn(hVfsSymlink != NIL_RTVFSSYMLINK, VERR_WRONG_TYPE);
+        rc = rtZipTarFssWriter_AddSymlink(pThis, pszPath, hVfsSymlink, &ObjInfo,
+                                          ObjOwnerName.Attr.u.UnixOwner.szName, ObjGrpName.Attr.u.UnixOwner.szName);
+        RTVfsSymlinkRelease(hVfsSymlink);
+    }
+    else
+        rc = rtZipTarFssWriter_AddSimpleObject(pThis, pszPath, &ObjInfo,
+                                               ObjOwnerName.Attr.u.UnixOwner.szName, ObjGrpName.Attr.u.UnixOwner.szName);
+
+    return rc;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSFSSTREAMOPS,pfnPushFile}
+ */
+static DECLCALLBACK(int) rtZipTarFssWriter_PushFile(void *pvThis, const char *pszPath, uint64_t cbFile, PCRTFSOBJINFO paObjInfo,
+                                                    uint32_t cObjInfo, uint32_t fFlags, PRTVFSIOSTREAM phVfsIos)
+{
+    PRTZIPTARFSSTREAMWRITER pThis = (PRTZIPTARFSSTREAMWRITER)pvThis;
+
+    /*
+     * We can only deal with output of indeterminate length if the output is
+     * seekable (see also rtZipTarFssWriter_AddFileStream).
+     */
+    AssertReturn(cbFile != UINT64_MAX || pThis->hVfsFile != NIL_RTVFSFILE, VERR_NOT_A_FILE);
+    AssertReturn(RT_BOOL(cbFile == UINT64_MAX) == RT_BOOL(fFlags & RTVFSFSSTRM_ADD_F_STREAM), VERR_INVALID_FLAGS);
+
+    /*
+     * Before we continue we must complete any current push file and check rcFatal.
+     */
+    int rc = rtZipTarFssWriter_CompleteCurrentPushFile(pThis);
+    AssertRCReturn(rc, rc);
+
+    /*
+     * If no object info was provideded, fake up some.
+     */
+    const char *pszOwnerNm = "someone";
+    const char *pszGroupNm = "somegroup";
+    RTFSOBJINFO ObjInfo;
+    if (cObjInfo == 0)
+    {
+        /* Fake up a info. */
+        RT_ZERO(ObjInfo);
+        ObjInfo.cbObject                    = cbFile != UINT64_MAX ? cbFile : 0;
+        ObjInfo.cbAllocated                 = cbFile != UINT64_MAX ? RT_ALIGN_64(cbFile, RTZIPTAR_BLOCKSIZE) : UINT64_MAX;
+        RTTimeNow(&ObjInfo.ModificationTime);
+        ObjInfo.BirthTime                   = ObjInfo.ModificationTime;
+        ObjInfo.ChangeTime                  = ObjInfo.ModificationTime;
+        ObjInfo.AccessTime                  = ObjInfo.ModificationTime;
+        ObjInfo.Attr.fMode                  = RTFS_TYPE_FILE | 0666;
+        ObjInfo.Attr.enmAdditional          = RTFSOBJATTRADD_UNIX;
+        ObjInfo.Attr.u.Unix.uid             = NIL_RTUID;
+        ObjInfo.Attr.u.Unix.gid             = NIL_RTGID;
+        ObjInfo.Attr.u.Unix.cHardlinks      = 1;
+        //ObjInfo.Attr.u.Unix.INodeIdDevice   = 0;
+        //ObjInfo.Attr.u.Unix.INodeId         = 0;
+        //ObjInfo.Attr.u.Unix.fFlags          = 0;
+        //ObjInfo.Attr.u.Unix.GenerationId    = 0;
+        //ObjInfo.Attr.u.Unix.Device          = 0;
+    }
+    else
+    {
+        /* Make a copy of the object info and adjust the size, if necessary. */
+        ObjInfo = paObjInfo[0];
+        Assert(ObjInfo.Attr.enmAdditional == RTFSOBJATTRADD_UNIX);
+        Assert(RTFS_IS_FILE(ObjInfo.Attr.fMode));
+        if ((uint64_t)ObjInfo.cbObject != cbFile)
+        {
+            ObjInfo.cbObject    = cbFile != UINT64_MAX ? cbFile : 0;
+            ObjInfo.cbAllocated = cbFile != UINT64_MAX ? RT_ALIGN_64(cbFile, RTZIPTAR_BLOCKSIZE) : UINT64_MAX;
+        }
+
+        /* Lookup the group and user names. */
+        for (uint32_t i = 0; i < cObjInfo; i++)
+            if (   paObjInfo[i].Attr.enmAdditional == RTFSOBJATTRADD_UNIX_OWNER
+                && paObjInfo[i].Attr.u.UnixOwner.szName[0] != '\0')
+                pszOwnerNm = paObjInfo[i].Attr.u.UnixOwner.szName;
+            else if (   paObjInfo[i].Attr.enmAdditional == RTFSOBJATTRADD_UNIX_GROUP
+                     && paObjInfo[i].Attr.u.UnixGroup.szName[0] != '\0')
+                pszGroupNm = paObjInfo[i].Attr.u.UnixGroup.szName;
+    }
+
+    /*
+     * Switch the stream into write mode if necessary.
+     */
+    rc = rtZipTarFssWriter_SwitchToWriteMode(pThis);
+    AssertRCReturn(rc, rc);
+
+    /*
+     * Create an I/O stream object for the caller to use.
+     */
+    RTFOFF const offHdr = RTVfsIoStrmTell(pThis->hVfsIos);
+    AssertReturn(offHdr >= 0, (int)offHdr);
+
+    PRTZIPTARFSSTREAMWRITERPUSH pPush;
+    RTVFSIOSTREAM hVfsIos;
+    if (pThis->hVfsFile == NIL_RTVFSFILE)
+    {
+        rc = RTVfsNewIoStream(&g_rtZipTarWriterIoStrmOps, sizeof(*pPush), RTFILE_O_WRITE, NIL_RTVFS, NIL_RTVFSLOCK,
+                              &hVfsIos, (void **)&pPush);
+        if (RT_FAILURE(rc))
+            return rc;
+    }
+    else
+    {
+        RTVFSFILE hVfsFile;
+        rc = RTVfsNewFile(&g_rtZipTarWriterFileOps, sizeof(*pPush), RTFILE_O_WRITE, NIL_RTVFS, NIL_RTVFSLOCK,
+                          &hVfsFile, (void **)&pPush);
+        if (RT_FAILURE(rc))
+            return rc;
+        hVfsIos = RTVfsFileToIoStream(hVfsFile);
+        RTVfsFileRelease(hVfsFile);
+    }
+    pPush->pParent      = NULL;
+    pPush->cbExpected   = cbFile;
+    pPush->offHdr       = (uint64_t)offHdr;
+    pPush->offData      = 0;
+    pPush->offCurrent   = 0;
+    pPush->cbCurrent    = 0;
+    pPush->ObjInfo      = ObjInfo;
+    pPush->fOpenEnded   = cbFile == UINT64_MAX;
+
+    /*
+     * Produce and write file headers.
+     */
+    rc = rtZipTarFssWriter_ObjInfoToHdr(pThis, pszPath, &ObjInfo, pszOwnerNm, pszGroupNm, RTZIPTAR_TF_NORMAL);
+    if (RT_SUCCESS(rc))
+    {
+        size_t cbHdrs = pThis->cHdrs * sizeof(pThis->aHdrs[0]);
+        rc = RTVfsIoStrmWrite(pThis->hVfsIos, pThis->aHdrs, cbHdrs, true /*fBlocking*/, NULL);
+        if (RT_SUCCESS(rc))
+        {
+            pThis->cbWritten += cbHdrs;
+
+            /*
+             * Complete the object and return.
+             */
+            pPush->offData = pPush->offHdr + cbHdrs;
+            if (cbFile == UINT64_MAX)
+                pPush->cbExpected = (uint64_t)(RTFOFF_MAX - _4K) - pPush->offData;
+            pPush->pParent = pThis;
+            pThis->pPush   = pPush;
+
+            *phVfsIos = hVfsIos;
+            return VINF_SUCCESS;
+        }
+        pThis->rcFatal = rc;
+    }
+
+    RTVfsIoStrmRelease(hVfsIos);
+    return rc;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSFSSTREAMOPS,pfnEnd}
+ */
+static DECLCALLBACK(int) rtZipTarFssWriter_End(void *pvThis)
+{
+    PRTZIPTARFSSTREAMWRITER pThis = (PRTZIPTARFSSTREAMWRITER)pvThis;
+
+    /*
+     * Make sure to complete any pending push file and that rcFatal is fine.
+     */
+    int rc = rtZipTarFssWriter_CompleteCurrentPushFile(pThis);
+    if (RT_SUCCESS(rc))
+    {
+        /*
+         * There are supposed to be two zero headers at the end of the archive.
+         * GNU tar may write more because of the way it does buffering,
+         * libarchive OTOH writes exactly two.
+         */
+        rc = RTVfsIoStrmWrite(pThis->hVfsIos, g_abRTZero4K, RTZIPTAR_BLOCKSIZE * 2, true /*fBlocking*/, NULL);
+        if (RT_SUCCESS(rc))
+        {
+            pThis->cbWritten += RTZIPTAR_BLOCKSIZE * 2;
+
+            /*
+             * Flush the output.
+             */
+            rc = RTVfsIoStrmFlush(pThis->hVfsIos);
+
+            /*
+             * If we're in update mode, set the end-of-file here to make sure
+             * unwanted bytes are really discarded.
+             */
+            if (RT_SUCCESS(rc) && (pThis->fFlags & RTZIPTAR_C_UPDATE))
+            {
+                RTFOFF cbTarFile = RTVfsFileTell(pThis->hVfsFile);
+                if (cbTarFile >= 0)
+                    rc =  RTVfsFileSetSize(pThis->hVfsFile, (uint64_t)cbTarFile, RTVFSFILE_SIZE_F_NORMAL);
+                else
+                    rc = (int)cbTarFile;
+            }
+
+            /*
+             * Success?
+             */
+            if (RT_SUCCESS(rc))
+                return rc;
+        }
+        pThis->rcFatal = rc;
+    }
+    return rc;
+}
+
+
+/**
+ * Tar filesystem stream operations.
+ */
+static const RTVFSFSSTREAMOPS g_rtZipTarFssOps =
+{
+    { /* Obj */
+        RTVFSOBJOPS_VERSION,
+        RTVFSOBJTYPE_FS_STREAM,
+        "TarFsStreamWriter",
+        rtZipTarFssWriter_Close,
+        rtZipTarFssWriter_QueryInfo,
+        NULL,
+        RTVFSOBJOPS_VERSION
+    },
+    RTVFSFSSTREAMOPS_VERSION,
+    0,
+    rtZipTarFssWriter_Next,
+    rtZipTarFssWriter_Add,
+    rtZipTarFssWriter_PushFile,
+    rtZipTarFssWriter_End,
+    RTVFSFSSTREAMOPS_VERSION
+};
+
+
+RTDECL(int) RTZipTarFsStreamToIoStream(RTVFSIOSTREAM hVfsIosOut, RTZIPTARFORMAT enmFormat,
+                                       uint32_t fFlags, PRTVFSFSSTREAM phVfsFss)
+{
+    /*
+     * Input validation.
+     */
+    AssertPtrReturn(phVfsFss, VERR_INVALID_HANDLE);
+    *phVfsFss = NIL_RTVFSFSSTREAM;
+    AssertPtrReturn(hVfsIosOut, VERR_INVALID_HANDLE);
+    AssertReturn(enmFormat > RTZIPTARFORMAT_INVALID && enmFormat < RTZIPTARFORMAT_END, VERR_INVALID_PARAMETER);
+    AssertReturn(!(fFlags & ~RTZIPTAR_C_VALID_MASK), VERR_INVALID_FLAGS);
+    AssertReturn(!(fFlags & RTZIPTAR_C_UPDATE), VERR_NOT_SUPPORTED); /* Must use RTZipTarFsStreamForFile! */
+
+    if (enmFormat == RTZIPTARFORMAT_DEFAULT)
+        enmFormat = RTZIPTARFORMAT_GNU;
+    AssertReturn(   enmFormat == RTZIPTARFORMAT_GNU
+                 || enmFormat == RTZIPTARFORMAT_USTAR
+                 , VERR_NOT_IMPLEMENTED); /* Only implementing GNU and USTAR output at the moment. */
+
+    uint32_t cRefs = RTVfsIoStrmRetain(hVfsIosOut);
+    AssertReturn(cRefs != UINT32_MAX, VERR_INVALID_HANDLE);
+
+    /*
+     * Retain the input stream and create a new filesystem stream handle.
+     */
+    PRTZIPTARFSSTREAMWRITER pThis;
+    RTVFSFSSTREAM           hVfsFss;
+    int rc = RTVfsNewFsStream(&g_rtZipTarFssOps, sizeof(*pThis), NIL_RTVFS, NIL_RTVFSLOCK, RTFILE_O_WRITE,
+                              &hVfsFss, (void **)&pThis);
+    if (RT_SUCCESS(rc))
+    {
+        pThis->hVfsIos          = hVfsIosOut;
+        pThis->hVfsFile         = RTVfsIoStrmToFile(hVfsIosOut);
+
+        pThis->enmFormat        = enmFormat;
+        pThis->fFlags           = fFlags;
+        pThis->rcFatal          = VINF_SUCCESS;
+
+        pThis->uidOwner         = NIL_RTUID;
+        pThis->pszOwner         = NULL;
+        pThis->gidGroup         = NIL_RTGID;
+        pThis->pszGroup         = NULL;
+        pThis->pszPrefix        = NULL;
+        pThis->pModTime         = NULL;
+        pThis->fFileModeAndMask = ~(RTFMODE)0;
+        pThis->fFileModeOrMask  = 0;
+        pThis->fDirModeAndMask  = ~(RTFMODE)0;
+        pThis->fDirModeOrMask   = 0;
+        pThis->fWriting         = true;
+
+        *phVfsFss = hVfsFss;
+        return VINF_SUCCESS;
+    }
+
+    RTVfsIoStrmRelease(hVfsIosOut);
+    return rc;
+}
+
+
+RTDECL(int) RTZipTarFsStreamForFile(RTVFSFILE hVfsFile, RTZIPTARFORMAT enmFormat, uint32_t fFlags, PRTVFSFSSTREAM phVfsFss)
+{
+    /*
+     * Input validation.
+     */
+    AssertPtrReturn(phVfsFss, VERR_INVALID_HANDLE);
+    *phVfsFss = NIL_RTVFSFSSTREAM;
+    AssertReturn(hVfsFile != NIL_RTVFSFILE, VERR_INVALID_HANDLE);
+    AssertReturn(enmFormat > RTZIPTARFORMAT_INVALID && enmFormat < RTZIPTARFORMAT_END, VERR_INVALID_PARAMETER);
+    AssertReturn(!(fFlags & ~RTZIPTAR_C_VALID_MASK), VERR_INVALID_FLAGS);
+
+    if (enmFormat == RTZIPTARFORMAT_DEFAULT)
+        enmFormat = RTZIPTARFORMAT_GNU;
+    AssertReturn(   enmFormat == RTZIPTARFORMAT_GNU
+                 || enmFormat == RTZIPTARFORMAT_USTAR
+                 , VERR_NOT_IMPLEMENTED); /* Only implementing GNU and USTAR output at the moment. */
+
+    RTFOFF const offStart = RTVfsFileTell(hVfsFile);
+    AssertReturn(offStart >= 0, (int)offStart);
+
+    uint32_t cRefs = RTVfsFileRetain(hVfsFile);
+    AssertReturn(cRefs != UINT32_MAX, VERR_INVALID_HANDLE);
+
+    RTVFSIOSTREAM hVfsIos = RTVfsFileToIoStream(hVfsFile);
+    AssertReturnStmt(hVfsIos != NIL_RTVFSIOSTREAM, RTVfsFileRelease(hVfsFile), VERR_INVALID_HANDLE);
+
+    /*
+     * Retain the input stream and create a new filesystem stream handle.
+     */
+    PRTZIPTARFSSTREAMWRITER pThis;
+    size_t const            cbThis = sizeof(*pThis) + (fFlags & RTZIPTAR_C_UPDATE ? sizeof(*pThis->pRead) : 0);
+    RTVFSFSSTREAM           hVfsFss;
+    int rc = RTVfsNewFsStream(&g_rtZipTarFssOps, cbThis, NIL_RTVFS, NIL_RTVFSLOCK,
+                              fFlags & RTZIPTAR_C_UPDATE ? RTFILE_O_READWRITE : RTFILE_O_WRITE,
+                              &hVfsFss, (void **)&pThis);
+    if (RT_SUCCESS(rc))
+    {
+        pThis->hVfsIos          = hVfsIos;
+        pThis->hVfsFile         = hVfsFile;
+
+        pThis->enmFormat        = enmFormat;
+        pThis->fFlags           = fFlags;
+        pThis->rcFatal          = VINF_SUCCESS;
+
+        pThis->uidOwner         = NIL_RTUID;
+        pThis->pszOwner         = NULL;
+        pThis->gidGroup         = NIL_RTGID;
+        pThis->pszGroup         = NULL;
+        pThis->pszPrefix        = NULL;
+        pThis->pModTime         = NULL;
+        pThis->fFileModeAndMask = ~(RTFMODE)0;
+        pThis->fFileModeOrMask  = 0;
+        pThis->fDirModeAndMask  = ~(RTFMODE)0;
+        pThis->fDirModeOrMask   = 0;
+        if (!(fFlags & RTZIPTAR_C_UPDATE))
+            pThis->fWriting     = true;
+        else
+        {
+            pThis->fWriting     = false;
+            pThis->pRead        = (PRTZIPTARFSSTREAM)(pThis + 1);
+            rtZipTarReaderInit(pThis->pRead, hVfsIos, (uint64_t)offStart);
+        }
+
+        *phVfsFss = hVfsFss;
+        return VINF_SUCCESS;
+    }
+
+    RTVfsIoStrmRelease(hVfsIos);
+    RTVfsFileRelease(hVfsFile);
+    return rc;
+}
+
+
+RTDECL(int) RTZipTarFsStreamSetOwner(RTVFSFSSTREAM hVfsFss, RTUID uid, const char *pszOwner)
+{
+    PRTZIPTARFSSTREAMWRITER pThis = (PRTZIPTARFSSTREAMWRITER)RTVfsFsStreamToPrivate(hVfsFss, &g_rtZipTarFssOps);
+    AssertReturn(pThis, VERR_WRONG_TYPE);
+
+    pThis->uidOwner = uid;
+    if (pThis->pszOwner)
+    {
+        RTStrFree(pThis->pszOwner);
+        pThis->pszOwner = NULL;
+    }
+    if (pszOwner)
+    {
+        pThis->pszOwner = RTStrDup(pszOwner);
+        AssertReturn(pThis->pszOwner, VERR_NO_STR_MEMORY);
+    }
+
+    return VINF_SUCCESS;
+}
+
+
+RTDECL(int) RTZipTarFsStreamSetGroup(RTVFSFSSTREAM hVfsFss, RTGID gid, const char *pszGroup)
+{
+    PRTZIPTARFSSTREAMWRITER pThis = (PRTZIPTARFSSTREAMWRITER)RTVfsFsStreamToPrivate(hVfsFss, &g_rtZipTarFssOps);
+    AssertReturn(pThis, VERR_WRONG_TYPE);
+
+    pThis->gidGroup = gid;
+    if (pThis->pszGroup)
+    {
+        RTStrFree(pThis->pszGroup);
+        pThis->pszGroup = NULL;
+    }
+    if (pszGroup)
+    {
+        pThis->pszGroup = RTStrDup(pszGroup);
+        AssertReturn(pThis->pszGroup, VERR_NO_STR_MEMORY);
+    }
+
+    return VINF_SUCCESS;
+}
+
+
+RTDECL(int) RTZipTarFsStreamSetPrefix(RTVFSFSSTREAM hVfsFss, const char *pszPrefix)
+{
+    PRTZIPTARFSSTREAMWRITER pThis = (PRTZIPTARFSSTREAMWRITER)RTVfsFsStreamToPrivate(hVfsFss, &g_rtZipTarFssOps);
+    AssertReturn(pThis, VERR_WRONG_TYPE);
+    AssertReturn(!pszPrefix || *pszPrefix, VERR_INVALID_NAME);
+
+    if (pThis->pszPrefix)
+    {
+        RTStrFree(pThis->pszPrefix);
+        pThis->pszPrefix = NULL;
+        pThis->cchPrefix = 0;
+    }
+    if (pszPrefix)
+    {
+        /*
+         * Make a copy of the prefix, make sure it ends with a slash,
+         * then flip DOS slashes.
+         */
+        size_t cchPrefix = strlen(pszPrefix);
+        char *pszCopy = RTStrAlloc(cchPrefix + 3);
+        AssertReturn(pszCopy, VERR_NO_STR_MEMORY);
+        memcpy(pszCopy, pszPrefix, cchPrefix + 1);
+
+        RTPathEnsureTrailingSeparator(pszCopy, cchPrefix + 3);
+
+#if RTPATH_STYLE != RTPATH_STR_F_STYLE_UNIX
+        char *pszDosSlash = strchr(pszCopy, '\\');
+        while (pszDosSlash)
+        {
+            *pszDosSlash = '/';
+            pszDosSlash = strchr(pszDosSlash + 1, '\\');
+        }
+#endif
+
+        pThis->cchPrefix = cchPrefix + strlen(&pszCopy[cchPrefix]);
+        pThis->pszPrefix = pszCopy;
+    }
+
+    return VINF_SUCCESS;
+}
+
+
+RTDECL(int) RTZipTarFsStreamSetModTime(RTVFSFSSTREAM hVfsFss, PCRTTIMESPEC pModificationTime)
+{
+    PRTZIPTARFSSTREAMWRITER pThis = (PRTZIPTARFSSTREAMWRITER)RTVfsFsStreamToPrivate(hVfsFss, &g_rtZipTarFssOps);
+    AssertReturn(pThis, VERR_WRONG_TYPE);
+
+    if (pModificationTime)
+    {
+        pThis->ModTime  = *pModificationTime;
+        pThis->pModTime = &pThis->ModTime;
+    }
+    else
+        pThis->pModTime = NULL;
+
+    return VINF_SUCCESS;
+}
+
+
+RTDECL(int) RTZipTarFsStreamSetFileMode(RTVFSFSSTREAM hVfsFss, RTFMODE fAndMode, RTFMODE fOrMode)
+{
+    PRTZIPTARFSSTREAMWRITER pThis = (PRTZIPTARFSSTREAMWRITER)RTVfsFsStreamToPrivate(hVfsFss, &g_rtZipTarFssOps);
+    AssertReturn(pThis, VERR_WRONG_TYPE);
+
+    pThis->fFileModeAndMask = fAndMode | ~RTFS_UNIX_ALL_PERMS;
+    pThis->fFileModeOrMask  = fOrMode  & RTFS_UNIX_ALL_PERMS;
+    return VINF_SUCCESS;
+}
+
+
+RTDECL(int) RTZipTarFsStreamSetDirMode(RTVFSFSSTREAM hVfsFss, RTFMODE fAndMode, RTFMODE fOrMode)
+{
+    PRTZIPTARFSSTREAMWRITER pThis = (PRTZIPTARFSSTREAMWRITER)RTVfsFsStreamToPrivate(hVfsFss, &g_rtZipTarFssOps);
+    AssertReturn(pThis, VERR_WRONG_TYPE);
+
+    pThis->fDirModeAndMask = fAndMode | ~RTFS_UNIX_ALL_PERMS;
+    pThis->fDirModeOrMask  = fOrMode  & RTFS_UNIX_ALL_PERMS;
+    return VINF_SUCCESS;
+}
+
+
+RTDECL(int) RTZipTarFsStreamTruncate(RTVFSFSSTREAM hVfsFss, RTVFSOBJ hVfsObj, bool fAfter)
+{
+    /*
+     * Translate and validate the input.
+     */
+    PRTZIPTARFSSTREAMWRITER pThis = (PRTZIPTARFSSTREAMWRITER)RTVfsFsStreamToPrivate(hVfsFss, &g_rtZipTarFssOps);
+    AssertReturn(pThis, VERR_WRONG_TYPE);
+
+    AssertReturn(hVfsObj != NIL_RTVFSOBJ, VERR_INVALID_HANDLE);
+    PRTZIPTARBASEOBJ pThisObj = rtZipTarFsStreamBaseObjToPrivate(pThis->pRead, hVfsObj);
+    AssertReturn(pThis, VERR_NOT_OWNER);
+
+    AssertReturn(pThis->pRead, VERR_ACCESS_DENIED);
+    AssertReturn(pThis->fFlags & RTZIPTAR_C_UPDATE, VERR_ACCESS_DENIED);
+    AssertReturn(!pThis->fWriting, VERR_WRONG_ORDER);
+
+    /*
+     * Seek to the desired cut-off point and indicate that we've switched to writing.
+     */
+    int rc = RTVfsFileSeek(pThis->hVfsFile, fAfter ? pThisObj->offNextHdr : pThisObj->offHdr,
+                           RTFILE_SEEK_BEGIN, NULL /*poffActual*/);
+    if (RT_SUCCESS(rc))
+        pThis->fWriting = true;
+    else
+        pThis->rcFatal = rc;
+    return rc;
+}
+
diff --git a/src/VBox/Runtime/common/zip/unzipcmd.cpp b/src/VBox/Runtime/common/zip/unzipcmd.cpp
new file mode 100644
index 00000000..58d70289
--- /dev/null
+++ b/src/VBox/Runtime/common/zip/unzipcmd.cpp
@@ -0,0 +1,480 @@
+/* $Id: unzipcmd.cpp $ */
+/** @file
+ * IPRT - A mini UNZIP Command.
+ */
+
+/*
+ * Copyright (C) 2014-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * The contents of this file may alternatively be used under the terms
+ * of the Common Development and Distribution License Version 1.0
+ * (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
+ * in the VirtualBox distribution, in which case the provisions of the
+ * CDDL are applicable instead of those of the GPL.
+ *
+ * You may elect to license modified versions of this file under the
+ * terms and conditions of either the GPL or the CDDL or both.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#include <iprt/zip.h>
+#include <iprt/asm.h>
+#include <iprt/getopt.h>
+#include <iprt/file.h>
+#include <iprt/err.h>
+#include <iprt/mem.h>
+#include <iprt/message.h>
+#include <iprt/path.h>
+#include <iprt/string.h>
+#include <iprt/vfs.h>
+#include <iprt/stream.h>
+
+
+/*********************************************************************************************************************************
+*   Structures and Typedefs                                                                                                      *
+*********************************************************************************************************************************/
+
+/**
+ * IPRT UNZIP option structure.
+ */
+typedef struct RTZIPUNZIPCMDOPS
+{
+    /** The operation. */
+    int            iOperation;
+    /** The long operation option name. */
+    const char     *pszOperation;
+    /** The directory to change into when upacking. */
+    const char     *pszDirectory;
+    /** The unzip file name. */
+    const char     *pszFile;
+    /** The number of files/directories to be extracted from archive specified. */
+    uint32_t       cFiles;
+    /** Wether we're verbose or quiet. */
+    bool           fVerbose;
+    /** Skip the restauration of the modification time for directories. */
+    bool           fNoModTimeDirectories;
+    /** Skip the restauration of the modification time for files. */
+    bool           fNoModTimeFiles;
+    /** Array of files/directories, terminated by a NULL entry. */
+    const char * const *papszFiles;
+} RTZIPUNZIPCMDOPS;
+/** Pointer to the UNZIP options. */
+typedef RTZIPUNZIPCMDOPS *PRTZIPUNZIPCMDOPS;
+
+/**
+ * Callback used by rtZipUnzipDoWithMembers
+ *
+ * @returns rcExit or RTEXITCODE_FAILURE.
+ * @param   pOpts               The Unzip options.
+ * @param   hVfsObj             The Unzip object to display
+ * @param   pszName             The name.
+ * @param   rcExit              The current exit code.
+ */
+typedef RTEXITCODE (*PFNDOWITHMEMBER)(PRTZIPUNZIPCMDOPS pOpts, RTVFSOBJ hVfsObj, const char *pszName, RTEXITCODE rcExit, PRTFOFF pcBytes);
+
+
+/**
+ *
+ */
+static RTEXITCODE rtZipUnzipCmdListCallback(PRTZIPUNZIPCMDOPS pOpts, RTVFSOBJ hVfsObj,
+                                            const char *pszName, RTEXITCODE rcExit, PRTFOFF pcBytes)
+{
+    RT_NOREF_PV(pOpts);
+
+    /*
+     * Query all the information.
+     */
+    RTFSOBJINFO UnixInfo;
+    int rc = RTVfsObjQueryInfo(hVfsObj, &UnixInfo, RTFSOBJATTRADD_UNIX);
+    if (RT_FAILURE(rc))
+        return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTVfsObjQueryInfo returned %Rrc on '%s'", rc, pszName);
+
+    RTTIME time;
+    if (!RTTimeExplode(&time, &UnixInfo.ModificationTime))
+        return RTMsgErrorExit(RTEXITCODE_FAILURE, "Cannot explode time on '%s'", pszName);
+
+    RTPrintf("%9RU64  %04d-%02d-%02d %02d:%02d   %s\n",
+             UnixInfo.cbObject,
+             time.i32Year, time.u8Month, time.u8MonthDay,
+             time.u8Hour, time.u8Minute,
+             pszName);
+
+    *pcBytes = UnixInfo.cbObject;
+    return rcExit;
+}
+
+
+/**
+ * Extracts a file.
+ */
+static RTEXITCODE rtZipUnzipCmdExtractFile(PRTZIPUNZIPCMDOPS pOpts, RTVFSOBJ hVfsObj, RTEXITCODE rcExit,
+                                           const char *pszDst, PCRTFSOBJINFO pUnixInfo)
+{
+    /*
+     * Open the destination file and create a stream object for it.
+     */
+    uint32_t fOpen = RTFILE_O_READWRITE | RTFILE_O_DENY_WRITE | RTFILE_O_CREATE_REPLACE | RTFILE_O_ACCESS_ATTR_DEFAULT
+                   | (pUnixInfo->Attr.fMode << RTFILE_O_CREATE_MODE_SHIFT);
+    RTFILE hFile;
+    int rc = RTFileOpen(&hFile, pszDst, fOpen);
+    if (RT_FAILURE(rc))
+        return RTMsgErrorExit(RTEXITCODE_FAILURE, "%s: Error creating file: %Rrc", pszDst, rc);
+
+    RTVFSIOSTREAM hVfsIosDst;
+    rc = RTVfsIoStrmFromRTFile(hFile, fOpen, true /*fLeaveOpen*/, &hVfsIosDst);
+    if (RT_SUCCESS(rc))
+    {
+        /*
+         * Pump the data thru.
+         */
+        RTVFSIOSTREAM hVfsIosSrc = RTVfsObjToIoStream(hVfsObj);
+        rc = RTVfsUtilPumpIoStreams(hVfsIosSrc, hVfsIosDst, (uint32_t)RT_MIN(pUnixInfo->cbObject, _1M));
+        if (RT_SUCCESS(rc))
+        {
+            /*
+             * Correct the file mode and other attributes.
+             */
+            if (!pOpts->fNoModTimeFiles)
+            {
+                rc = RTFileSetTimes(hFile, NULL, &pUnixInfo->ModificationTime, NULL, NULL);
+                if (RT_FAILURE(rc))
+                    rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "%s: Error setting times: %Rrc", pszDst, rc);
+            }
+        }
+        else
+            rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "%s: Error writing out file: %Rrc", pszDst, rc);
+        RTVfsIoStrmRelease(hVfsIosSrc);
+        RTVfsIoStrmRelease(hVfsIosDst);
+    }
+    else
+        rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "%s: Error creating I/O stream for file: %Rrc", pszDst, rc);
+
+    return rcExit;
+}
+
+
+/**
+ *
+ */
+static RTEXITCODE rtZipUnzipCmdExtractCallback(PRTZIPUNZIPCMDOPS pOpts, RTVFSOBJ hVfsObj,
+                                               const char *pszName, RTEXITCODE rcExit, PRTFOFF pcBytes)
+{
+    if (pOpts->fVerbose)
+        RTPrintf("%s\n", pszName);
+
+    /*
+     * Query all the information.
+     */
+    RTFSOBJINFO UnixInfo;
+    int rc = RTVfsObjQueryInfo(hVfsObj, &UnixInfo, RTFSOBJATTRADD_UNIX);
+    if (RT_FAILURE(rc))
+        return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTVfsObjQueryInfo returned %Rrc on '%s'", rc, pszName);
+
+    *pcBytes = UnixInfo.cbObject;
+
+    char szDst[RTPATH_MAX];
+    rc = RTPathJoin(szDst, sizeof(szDst), pOpts->pszDirectory ? pOpts->pszDirectory : ".", pszName);
+    if (RT_FAILURE(rc))
+        return RTMsgErrorExit(RTEXITCODE_FAILURE, "%s: Failed to construct destination path for: %Rrc", pszName, rc);
+
+    /*
+     * Extract according to the type.
+     */
+    switch (UnixInfo.Attr.fMode & RTFS_TYPE_MASK)
+    {
+        case RTFS_TYPE_FILE:
+            return rtZipUnzipCmdExtractFile(pOpts, hVfsObj, rcExit, szDst, &UnixInfo);
+
+        case RTFS_TYPE_DIRECTORY:
+            rc = RTDirCreateFullPath(szDst, UnixInfo.Attr.fMode & RTFS_UNIX_ALL_ACCESS_PERMS);
+            if (RT_FAILURE(rc))
+                return RTMsgErrorExit(RTEXITCODE_FAILURE, "%s: Error creating directory: %Rrc", szDst, rc);
+            break;
+
+        default:
+            return RTMsgErrorExit(RTEXITCODE_FAILURE, "%s: Unknown file type.", pszName);
+    }
+
+    if (!pOpts->fNoModTimeDirectories)
+    {
+        rc = RTPathSetTimesEx(szDst, NULL, &UnixInfo.ModificationTime, NULL, NULL, RTPATH_F_ON_LINK);
+        if (RT_FAILURE(rc) && rc != VERR_NOT_SUPPORTED && rc != VERR_NS_SYMLINK_SET_TIME)
+            rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "%s: Error changing modification time: %Rrc.", pszName, rc);
+    }
+
+    return rcExit;
+}
+
+
+/**
+ * Checks if @a pszName is a member of @a papszNames, optionally returning the
+ * index.
+ *
+ * @returns true if the name is in the list, otherwise false.
+ * @param   pszName             The name to find.
+ * @param   papszNames          The array of names.
+ * @param   piName              Where to optionally return the array index.
+ */
+static bool rtZipUnzipCmdIsNameInArray(const char *pszName, const char * const *papszNames, uint32_t *piName)
+{
+    for (uint32_t iName = 0; papszNames[iName]; ++iName)
+        if (!strcmp(papszNames[iName], pszName))
+        {
+            if (piName)
+                *piName = iName;
+            return true;
+        }
+    return false;
+}
+
+
+/**
+ * Opens the input archive specified by the options.
+ *
+ * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE + printed message.
+ * @param   pOpts           The options.
+ * @param   phVfsFss        Where to return the UNZIP filesystem stream handle.
+ */
+static RTEXITCODE rtZipUnzipCmdOpenInputArchive(PRTZIPUNZIPCMDOPS pOpts, PRTVFSFSSTREAM phVfsFss)
+{
+    /*
+     * Open the input file.
+     */
+    RTVFSIOSTREAM   hVfsIos;
+    uint32_t        offError = 0;
+    RTERRINFOSTATIC ErrInfo;
+    int rc = RTVfsChainOpenIoStream(pOpts->pszFile, RTFILE_O_READ | RTFILE_O_DENY_WRITE | RTFILE_O_OPEN,
+                                    &hVfsIos, &offError, RTErrInfoInitStatic(&ErrInfo));
+    if (RT_FAILURE(rc))
+        return RTVfsChainMsgErrorExitFailure("RTVfsChainOpenIoStream", pOpts->pszFile, rc, offError, &ErrInfo.Core);
+
+    rc = RTZipPkzipFsStreamFromIoStream(hVfsIos, 0 /*fFlags*/, phVfsFss);
+    RTVfsIoStrmRelease(hVfsIos);
+    if (RT_FAILURE(rc))
+        return RTMsgErrorExit(RTEXITCODE_FAILURE, "Failed to open pkzip filesystem stream: %Rrc", rc);
+
+    return RTEXITCODE_SUCCESS;
+}
+
+
+/**
+ * Worker for the --list and --extract commands.
+ *
+ * @returns The appropriate exit code.
+ * @param   pOpts               The Unzip options.
+ * @param   pfnCallback         The command specific callback.
+ */
+static RTEXITCODE rtZipUnzipDoWithMembers(PRTZIPUNZIPCMDOPS pOpts, PFNDOWITHMEMBER pfnCallback,
+                                          uint32_t *pcFiles, PRTFOFF pcBytes)
+{
+    /*
+     * Allocate a bitmap to go with the file list.  This will be used to
+     * indicate which files we've processed and which not.
+     */
+    uint32_t *pbmFound = NULL;
+    if (pOpts->cFiles)
+    {
+        pbmFound = (uint32_t *)RTMemAllocZ(((pOpts->cFiles + 31) / 32) * sizeof(uint32_t));
+        if (!pbmFound)
+            return RTMsgErrorExit(RTEXITCODE_FAILURE, "Failed to allocate the found-file-bitmap");
+    }
+
+    uint32_t cFiles = 0;
+    RTFOFF cBytesSum = 0;
+
+    /*
+     * Open the input archive.
+     */
+    RTVFSFSSTREAM hVfsFssIn;
+    RTEXITCODE rcExit = rtZipUnzipCmdOpenInputArchive(pOpts, &hVfsFssIn);
+    if (rcExit == RTEXITCODE_SUCCESS)
+    {
+        /*
+         * Process the stream.
+         */
+        for (;;)
+        {
+            /*
+             * Retrieve the next object.
+             */
+            char       *pszName;
+            RTVFSOBJ    hVfsObj;
+            int rc = RTVfsFsStrmNext(hVfsFssIn, &pszName, NULL, &hVfsObj);
+            if (RT_FAILURE(rc))
+            {
+                if (rc != VERR_EOF)
+                    rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "RTVfsFsStrmNext returned %Rrc", rc);
+                break;
+            }
+
+            /*
+             * Should we process this object?
+             */
+            uint32_t iFile = UINT32_MAX;
+            if (   !pOpts->cFiles
+                || rtZipUnzipCmdIsNameInArray(pszName, pOpts->papszFiles, &iFile))
+            {
+                if (pbmFound)
+                    ASMBitSet(pbmFound, iFile);
+
+                RTFOFF cBytes = 0;
+                rcExit = pfnCallback(pOpts, hVfsObj, pszName, rcExit, &cBytes);
+
+                cBytesSum += cBytes;
+                cFiles++;
+            }
+
+            /*
+             * Release the current object and string.
+             */
+            RTVfsObjRelease(hVfsObj);
+            RTStrFree(pszName);
+        }
+
+        /*
+         * Complain about any files we didn't find.
+         */
+        for (uint32_t iFile = 0; iFile <pOpts->cFiles; iFile++)
+            if (!ASMBitTest(pbmFound, iFile))
+            {
+                RTMsgError("%s: Was not found in the archive", pOpts->papszFiles[iFile]);
+                rcExit = RTEXITCODE_FAILURE;
+            }
+
+        RTVfsFsStrmRelease(hVfsFssIn);
+    }
+
+    RTMemFree(pbmFound);
+
+    *pcFiles = cFiles;
+    *pcBytes = cBytesSum;
+
+    return RTEXITCODE_SUCCESS;
+}
+
+
+RTDECL(RTEXITCODE) RTZipUnzipCmd(unsigned cArgs, char **papszArgs)
+{
+    /*
+     * Parse the command line.
+     */
+    static const RTGETOPTDEF s_aOptions[] =
+    {
+        /* options */
+        { NULL,            'c', RTGETOPT_REQ_NOTHING }, /* extract files to stdout/stderr */
+        { NULL,            'd', RTGETOPT_REQ_STRING  }, /* extract files to this directory */
+        { NULL,            'l', RTGETOPT_REQ_NOTHING }, /* list archive files (short format) */
+        { NULL,            'p', RTGETOPT_REQ_NOTHING }, /* extract files to stdout */
+        { NULL,            't', RTGETOPT_REQ_NOTHING }, /* test archive files */
+        { NULL,            'v', RTGETOPT_REQ_NOTHING }, /* verbose */
+
+        /* modifiers */
+        { NULL,            'a', RTGETOPT_REQ_NOTHING }, /* convert text files */
+        { NULL,            'b', RTGETOPT_REQ_NOTHING }, /* no conversion, treat as binary */
+        { NULL,            'D', RTGETOPT_REQ_NOTHING }, /* don't restore timestamps for directories
+                                                           (and files) */
+    };
+
+    RTGETOPTSTATE GetState;
+    int rc = RTGetOptInit(&GetState, cArgs, papszArgs, s_aOptions, RT_ELEMENTS(s_aOptions), 1,
+                          RTGETOPTINIT_FLAGS_OPTS_FIRST);
+    if (RT_FAILURE(rc))
+        return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTGetOpt failed: %Rrc", rc);
+
+    RTZIPUNZIPCMDOPS Opts;
+    RT_ZERO(Opts);
+
+    RTGETOPTUNION  ValueUnion;
+    while (   (rc = RTGetOpt(&GetState, &ValueUnion)) != 0
+           && rc != VINF_GETOPT_NOT_OPTION)
+    {
+        switch (rc)
+        {
+            case 'd':
+                if (Opts.pszDirectory)
+                    return RTMsgErrorExit(RTEXITCODE_SYNTAX, "You may only specify -d once");
+                Opts.pszDirectory = ValueUnion.psz;
+                break;
+
+            case 'D':
+                if (!Opts.fNoModTimeDirectories)
+                    Opts.fNoModTimeDirectories = true; /* -D */
+                else
+                    Opts.fNoModTimeFiles = true; /* -DD */
+                break;
+
+            case 'l':
+            case 't': /* treat 'test' like 'list' */
+                if (Opts.iOperation)
+                    return RTMsgErrorExit(RTEXITCODE_SYNTAX,
+                                          "Conflicting unzip operation (%s already set, now %s)",
+                                          Opts.pszOperation, ValueUnion.pDef->pszLong);
+                Opts.iOperation   = 'l';
+                Opts.pszOperation = ValueUnion.pDef->pszLong;
+                break;
+
+            case 'v':
+                Opts.fVerbose = true;
+                break;
+
+            default:
+                Opts.pszFile = ValueUnion.psz;
+                return RTGetOptPrintError(rc, &ValueUnion);
+        }
+    }
+
+    if (rc == VINF_GETOPT_NOT_OPTION)
+    {
+        Assert((unsigned)GetState.iNext - 1 <= cArgs);
+        Opts.pszFile = papszArgs[GetState.iNext - 1];
+        if ((unsigned)GetState.iNext <= cArgs)
+        {
+            Opts.papszFiles = (const char * const *)&papszArgs[GetState.iNext];
+            Opts.cFiles     = cArgs - GetState.iNext;
+        }
+    }
+
+    if (!Opts.pszFile)
+        return RTMsgErrorExit(RTEXITCODE_FAILURE, "No input archive specified");
+
+    RTFOFF cBytes = 0;
+    uint32_t cFiles = 0;
+    switch (Opts.iOperation)
+    {
+        case 'l':
+        {
+            RTPrintf("  Length      Date    Time    Name\n"
+                     "---------  ---------- -----   ----\n");
+            RTEXITCODE rcExit = rtZipUnzipDoWithMembers(&Opts, rtZipUnzipCmdListCallback, &cFiles, &cBytes);
+            RTPrintf("---------                     -------\n"
+                     "%9RU64                     %u file%s\n",
+                     cBytes, cFiles, cFiles != 1 ? "s" : "");
+
+            return rcExit;
+        }
+
+        default:
+            return rtZipUnzipDoWithMembers(&Opts, rtZipUnzipCmdExtractCallback, &cFiles, &cBytes);
+    }
+}
diff --git a/src/VBox/Runtime/common/zip/xarvfs.cpp b/src/VBox/Runtime/common/zip/xarvfs.cpp
new file mode 100644
index 00000000..571a51c7
--- /dev/null
+++ b/src/VBox/Runtime/common/zip/xarvfs.cpp
@@ -0,0 +1,2156 @@
+/* $Id: xarvfs.cpp $ */
+/** @file
+ * IPRT - XAR Virtual Filesystem.
+ */
+
+/*
+ * Copyright (C) 2010-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * The contents of this file may alternatively be used under the terms
+ * of the Common Development and Distribution License Version 1.0
+ * (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
+ * in the VirtualBox distribution, in which case the provisions of the
+ * CDDL are applicable instead of those of the GPL.
+ *
+ * You may elect to license modified versions of this file under the
+ * terms and conditions of either the GPL or the CDDL or both.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#include "internal/iprt.h"
+#include <iprt/zip.h>
+
+#include <iprt/asm.h>
+#include <iprt/assert.h>
+#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 <iprt/formats/xar.h>
+#include <iprt/cpp/xml.h>
+
+
+/*********************************************************************************************************************************
+*   Defined Constants And Macros                                                                                                 *
+*********************************************************************************************************************************/
+/** @name Hash state
+ * @{ */
+#define RTZIPXAR_HASH_PENDING           0
+#define RTZIPXAR_HASH_OK                1
+#define RTZIPXAR_HASH_FAILED_ARCHIVED   2
+#define RTZIPXAR_HASH_FAILED_EXTRACTED  3
+/** @} */
+
+
+/*********************************************************************************************************************************
+*   Structures and Typedefs                                                                                                      *
+*********************************************************************************************************************************/
+/**
+ * Hash digest value union for the supported XAR hash functions.
+ * @todo This could be generalized in iprt/checksum.h or somewhere.
+ */
+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;
+
+/**
+ * Hash context union.
+ */
+typedef union RTZIPXARHASHCTX
+{
+    RTMD5CONTEXT    Md5;
+    RTSHA1CONTEXT   Sha1;
+} RTZIPXARHASHCTX;
+/** Pointer to a hash context union. */
+typedef RTZIPXARHASHCTX *PRTZIPXARHASHCTX;
+
+/**
+ * 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. */
+    xml::ElementNode const *pCurFile;
+    /** The depth of the current file, with 0 being the root level. */
+    uint32_t                cCurDepth;
+} 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 file TOC element. */
+    xml::ElementNode const *pFileElem;
+    /** RTFS_TYPE_XXX value for the object. */
+    RTFMODE                 fModeType;
+} RTZIPXARBASEOBJ;
+/** Pointer to a XAR filesystem stream base object. */
+typedef RTZIPXARBASEOBJ *PRTZIPXARBASEOBJ;
+
+
+/**
+ * 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.
+     * @remarks The I/O stream and file constructor will adjust this so that it
+     *          relative to the start of the input stream, instead of the first byte
+     *          after the TOC. */
+    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.
+ */
+typedef struct RTZIPXARIOSTREAM
+{
+    /** The basic XAR object data. */
+    RTZIPXARBASEOBJ         BaseObj;
+    /** The attributes of the primary data stream. */
+    RTZIPXARDATASTREAM      DataAttr;
+    /** The current file position in the archived file. */
+    RTFOFF                  offCurPos;
+    /** The input I/O stream. */
+    RTVFSIOSTREAM           hVfsIos;
+    /** Set if we've reached the end of the file or if the next object in the
+     * file system stream has been requested. */
+    bool                    fEndOfStream;
+    /** Whether the stream is seekable. */
+    bool                    fSeekable;
+    /** Hash state. */
+    uint8_t                 uHashState;
+    /** 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. */
+    RTZIPXARHASHCTX         CtxArchived;
+    /** The digest of the extracted data. */
+    RTZIPXARHASHCTX         CtxExtracted;
+} 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 data. */
+    RTZIPXARIOSTREAM        Ios;
+    /** The input file. */
+    RTVFSFILE               hVfsFile;
+} RTZIPXARFILE;
+/** Pointer to the private data of a XAR file. */
+typedef RTZIPXARFILE *PRTZIPXARFILE;
+
+
+/**
+ * Decompressed I/O stream instance.
+ *
+ * This is just a front that checks digests and other sanity stuff.
+ */
+typedef struct RTZIPXARDECOMPIOS
+{
+    /** The decompressor I/O stream. */
+    RTVFSIOSTREAM           hVfsIosDecompressor;
+    /** The raw XAR I/O stream. */
+    RTVFSIOSTREAM           hVfsIosRaw;
+    /** Pointer to the raw XAR I/O stream instance data. */
+    PRTZIPXARIOSTREAM       pIosRaw;
+    /** The current file position in the archived file. */
+    RTFOFF                  offCurPos;
+    /** The hash function to use on the extracted data. */
+    uint8_t                 uHashFunExtracted;
+    /** Hash state on the extracted data. */
+    uint8_t                 uHashState;
+    /** The digest of the extracted data. */
+    RTZIPXARHASHCTX         CtxExtracted;
+    /** The expected digest of the extracted data. */
+    RTZIPXARHASHDIGEST      DigestExtracted;
+} RTZIPXARDECOMPIOS;
+/** Pointer to the private data of a XAR decompressed I/O stream. */
+typedef RTZIPXARDECOMPIOS *PRTZIPXARDECOMPIOS;
+
+
+/**
+ * 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 start offset in the input I/O stream. */
+    RTFOFF                  offStart;
+    /** 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. */
+    bool                    fEndOfStream;
+    /** Set if we've encountered a fatal error. */
+    int                     rcFatal;
+
+
+    /** 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.
+ *
+ * @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 message 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;
+    }
+}
+
+
+/**
+ * Initializes a hash context.
+ *
+ * @param   pCtx            Pointer to the context union.
+ * @param   uHashFunction   The hash function to use.
+ */
+static void rtZipXarHashInit(PRTZIPXARHASHCTX pCtx, uint32_t uHashFunction)
+{
+    switch (uHashFunction)
+    {
+        case XAR_HASH_SHA1:
+            RTSha1Init(&pCtx->Sha1);
+            break;
+        case XAR_HASH_MD5:
+            RTMd5Init(&pCtx->Md5);;
+            break;
+        default:
+            RT_ZERO(*pCtx);
+            break;
+    }
+}
+
+
+/**
+ * Adds a block to the hash calculation.
+ *
+ * @param   pCtx            Pointer to the context union.
+ * @param   uHashFunction   The hash function to use.
+ * @param   pvSrc           The data to add to the hash.
+ * @param   cbSrc           The size of the data.
+ */
+static void rtZipXarHashUpdate(PRTZIPXARHASHCTX pCtx, uint32_t uHashFunction, void const *pvSrc, size_t cbSrc)
+{
+    switch (uHashFunction)
+    {
+        case XAR_HASH_SHA1:
+            RTSha1Update(&pCtx->Sha1, pvSrc, cbSrc);
+            break;
+        case XAR_HASH_MD5:
+            RTMd5Update(&pCtx->Md5, pvSrc, cbSrc);
+            break;
+    }
+}
+
+
+/**
+ * Finalizes the hash, producing the message digest.
+ *
+ * @param   pCtx            Pointer to the context union.
+ * @param   uHashFunction   The hash function to use.
+ * @param   pHashDigest     Where to return the message digest.
+ */
+static void rtZipXarHashFinal(PRTZIPXARHASHCTX pCtx, uint32_t uHashFunction, PRTZIPXARHASHDIGEST pHashDigest)
+{
+    switch (uHashFunction)
+    {
+        case XAR_HASH_SHA1:
+            RTSha1Final(&pCtx->Sha1, pHashDigest->abSha1);
+            break;
+        case XAR_HASH_MD5:
+            RTMd5Final(pHashDigest->abMd5, &pCtx->Md5);
+            break;
+        default:
+            RT_ZERO(*pHashDigest);
+            break;
+    }
+}
+
+
+/**
+ * Compares two hash digests.
+ *
+ * @returns true if equal, false if not.
+ * @param   uHashFunction   The hash function to use.
+ * @param   pHashDigest1    The first hash digest.
+ * @param   pHashDigest2    The second hash digest.
+ */
+static bool rtZipXarHashIsEqual(uint32_t uHashFunction, PRTZIPXARHASHDIGEST pHashDigest1, PRTZIPXARHASHDIGEST pHashDigest2)
+{
+    switch (uHashFunction)
+    {
+        case XAR_HASH_SHA1:
+            return memcmp(pHashDigest1->abSha1, pHashDigest2->abSha1, sizeof(pHashDigest1->abSha1)) == 0;
+        case XAR_HASH_MD5:
+            return memcmp(pHashDigest1->abMd5, pHashDigest2->abMd5, sizeof(pHashDigest1->abMd5)) == 0;
+        default:
+            return true;
+    }
+}
+
+
+/**
+ * Gets the 'offset', 'size' and optionally 'length' sub elements.
+ *
+ * @returns IPRT status code.
+ * @param   pElement            The parent element.
+ * @param   poff                Where to return the offset value.
+ * @param   pcbSize             Where to return the size value.
+ * @param   pcbLength           Where to return the length value, optional.
+ */
+static int rtZipXarGetOffsetSizeLengthFromElem(xml::ElementNode const *pElement,
+                                               PRTFOFF poff, PRTFOFF pcbSize, PRTFOFF pcbLength)
+{
+    /*
+     * 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' stored in the archive.
+     */
+    pElem = pElement->findChildElement("size");
+    if (!pElem)
+        return VERR_XAR_MISSING_SIZE_ELEMENT;
+
+    pszValue = pElem->getValue();
+    if (!pszValue)
+        return VERR_XAR_BAD_SIZE_ELEMENT;
+
+    rc = RTStrToInt64Full(pszValue, 0, pcbSize);
+    if (   RT_FAILURE(rc)
+        || rc == VWRN_NUMBER_TOO_BIG
+        || *pcbSize >= RTFOFF_MAX - _1M
+        || *pcbSize < 0)
+        return VERR_XAR_BAD_SIZE_ELEMENT;
+    AssertCompile(RTFOFF_MAX == UINT64_MAX / 2);
+
+    /*
+     * The 'length' of the uncompressed data.  Not present for checksums, so
+     * the caller might not want it.
+     */
+    if (pcbLength)
+    {
+        pElem = pElement->findChildElement("length");
+        if (!pElem)
+            return VERR_XAR_MISSING_LENGTH_ELEMENT;
+
+        pszValue = pElem->getValue();
+        if (!pszValue)
+            return VERR_XAR_BAD_LENGTH_ELEMENT;
+
+        rc = RTStrToInt64Full(pszValue, 0, pcbLength);
+        if (   RT_FAILURE(rc)
+            || rc == VWRN_NUMBER_TOO_BIG
+            || *pcbLength >= RTFOFF_MAX - _1M
+            || *pcbLength < 0)
+            return VERR_XAR_BAD_LENGTH_ELEMENT;
+        AssertCompile(RTFOFF_MAX == UINT64_MAX / 2);
+    }
+
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * Convers a checksum style value into a XAR hash function number.
+ *
+ * @returns IPRT status code.
+ * @param   pszStyle        The XAR checksum style.
+ * @param   puHashFunction  Where to return the hash function number on success.
+ */
+static int rtZipXarParseChecksumStyle(const char *pszStyle, uint8_t *puHashFunction)
+{
+    size_t cchStyle = strlen(pszStyle);
+    if (   cchStyle == 4
+        && (pszStyle[0] == 's' || pszStyle[0] == 'S')
+        && (pszStyle[1] == 'h' || pszStyle[1] == 'H')
+        && (pszStyle[2] == 'a' || pszStyle[2] == 'A')
+        &&  pszStyle[3] == '1' )
+        *puHashFunction = XAR_HASH_SHA1;
+    else if (   cchStyle == 3
+             && (pszStyle[0] == 'm' || pszStyle[0] == 'M')
+             && (pszStyle[1] == 'd' || pszStyle[1] == 'D')
+             &&  pszStyle[2] == '5' )
+        *puHashFunction = XAR_HASH_MD5;
+    else if (   cchStyle == 4
+             && (pszStyle[0] == 'n' || pszStyle[0] == 'N')
+             && (pszStyle[1] == 'o' || pszStyle[1] == 'O')
+             && (pszStyle[2] == 'n' || pszStyle[2] == 'N')
+             && (pszStyle[3] == 'e' || pszStyle[3] == 'E') )
+        *puHashFunction = XAR_HASH_NONE;
+    else
+    {
+        *puHashFunction = UINT8_MAX;
+        return VERR_XAR_BAD_CHECKSUM_ELEMENT;
+    }
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * Parses a checksum element typically found under 'data'.
+ *
+ * @returns IPRT status code.
+ * @param   pParentElem     The parent element ('data').
+ * @param   pszName         The name of the element, like 'checksum-archived' or
+ *                          'checksum-extracted'.
+ * @param   puHashFunction  Where to return the XAR hash function number.
+ * @param   pDigest         Where to return the expected message digest.
+ */
+static int rtZipXarParseChecksumElem(xml::ElementNode const *pParentElem, const char *pszName,
+                                     uint8_t *puHashFunction, PRTZIPXARHASHDIGEST pDigest)
+{
+    /* Default is no checksum. */
+    *puHashFunction = XAR_HASH_NONE;
+    RT_ZERO(*pDigest);
+
+    xml::ElementNode const *pChecksumElem = pParentElem->findChildElement(pszName);
+    if (!pChecksumElem)
+        return VINF_SUCCESS;
+
+    /* The style. */
+    const char *pszStyle = pChecksumElem->findAttributeValue("style");
+    if (!pszStyle)
+        return VERR_XAR_BAD_CHECKSUM_ELEMENT;
+    int rc = rtZipXarParseChecksumStyle(pszStyle, puHashFunction);
+    if (RT_FAILURE(rc))
+        return rc;
+
+    if (*puHashFunction == XAR_HASH_NONE)
+        return VINF_SUCCESS;
+
+    /* The digest. */
+    const char *pszDigest = pChecksumElem->getValue();
+    if (!pszDigest)
+        return VERR_XAR_BAD_CHECKSUM_ELEMENT;
+
+    switch (*puHashFunction)
+    {
+        case XAR_HASH_SHA1:
+            rc = RTSha1FromString(pszDigest, pDigest->abSha1);
+            break;
+        case XAR_HASH_MD5:
+            rc = RTMd5FromString(pszDigest, pDigest->abMd5);
+            break;
+        default:
+            rc = VERR_INTERNAL_ERROR_2;
+    }
+    return rc;
+}
+
+
+/**
+ * Gets all the attributes of the primary data stream.
+ *
+ * @returns IPRT status code.
+ * @param   pFileElem           The file element, we'll be parsing the 'data'
+ *                              sub element of this.
+ * @param   pDataAttr           Where to return the attributes.
+ */
+static int rtZipXarGetDataStreamAttributes(xml::ElementNode const *pFileElem, PRTZIPXARDATASTREAM pDataAttr)
+{
+    /*
+     * Get the data element.
+     */
+    xml::ElementNode const *pDataElem = pFileElem->findChildElement("data");
+    if (!pDataElem)
+        return VERR_XAR_MISSING_DATA_ELEMENT;
+
+    /*
+     * Checksums.
+     */
+    int rc = rtZipXarParseChecksumElem(pDataElem, "extracted-checksum",
+                                       &pDataAttr->uHashFunExtracted, &pDataAttr->DigestExtracted);
+    if (RT_FAILURE(rc))
+        return rc;
+    rc = rtZipXarParseChecksumElem(pDataElem, "archived-checksum",
+                                   &pDataAttr->uHashFunArchived, &pDataAttr->DigestArchived);
+    if (RT_FAILURE(rc))
+        return rc;
+
+    /*
+     * The encoding.
+     */
+    const char *pszEncoding = pDataElem->findChildElementAttributeValueP("encoding", "style");
+    if (!pszEncoding)
+        return VERR_XAR_NO_ENCODING;
+    if (!strcmp(pszEncoding, "application/octet-stream"))
+        pDataAttr->enmEncoding = RTZIPXARENCODING_STORE;
+    else if (!strcmp(pszEncoding, "application/x-gzip"))
+        pDataAttr->enmEncoding = RTZIPXARENCODING_GZIP;
+    else
+        pDataAttr->enmEncoding = RTZIPXARENCODING_UNSUPPORTED;
+
+    /*
+     * The data offset and the compressed and uncompressed sizes.
+     */
+    rc = rtZipXarGetOffsetSizeLengthFromElem(pDataElem, &pDataAttr->offData,
+                                             &pDataAttr->cbDataExtracted, &pDataAttr->cbDataArchived);
+    if (RT_FAILURE(rc))
+        return rc;
+
+    /* No zero padding or other alignment crap, please. */
+    if (   pDataAttr->enmEncoding == RTZIPXARENCODING_STORE
+        && pDataAttr->cbDataExtracted != pDataAttr->cbDataArchived)
+        return VERR_XAR_ARCHIVED_AND_EXTRACTED_SIZES_MISMATCH;
+
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * Parses a timestamp.
+ *
+ * We consider all timestamps optional, and will only fail (return @c false) on
+ * parse errors.  If the specified element isn't found, we'll return epoc time.
+ *
+ * @returns boolean success indicator.
+ * @param   pParent             The parent element (typically 'file').
+ * @param   pszChild            The name of the child element.
+ * @param   pTimeSpec           Where to return the timespec on success.
+ */
+static bool rtZipXarParseTimestamp(const xml::ElementNode *pParent, const char *pszChild, PRTTIMESPEC pTimeSpec)
+{
+    const char *pszValue = pParent->findChildElementValueP(pszChild);
+    if (pszValue)
+    {
+        if (RTTimeSpecFromString(pTimeSpec, pszValue))
+            return true;
+        return false;
+    }
+    RTTimeSpecSetNano(pTimeSpec, 0);
+    return true;
+}
+
+
+/**
+ * Gets the next file element in the TOC.
+ *
+ * @returns Pointer to the next file, NULL if we've reached the end.
+ * @param   pCurFile            The current element.
+ * @param   pcCurDepth          Depth gauge we update when decending and
+ *                              acending thru the tree.
+ */
+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;
+    }
+
+    /*
+     * Siblings and ancestor siblings.
+     */
+    for (;;)
+    {
+        xml::ElementNode const *pSibling = pCurFile->findNextSibilingElement("file");
+        if (pSibling != NULL)
+            return pSibling;
+
+        if (*pcCurDepth == 0)
+            break;
+        *pcCurDepth -= 1;
+        pCurFile = static_cast<const xml::ElementNode *>(pCurFile->getParent());
+        AssertBreak(pCurFile);
+        Assert(pCurFile->nameEquals("file"));
+    }
+
+    return NULL;
+}
+
+
+
+/*
+ *
+ * T h e   V F S   F i l e s y s t e m   S t r e a m   B i t s.
+ * T h e   V F S   F i l e s y s t e m   S t r e a m   B i t s.
+ * T h e   V F S   F i l e s y s t e m   S t r e a m   B i t s.
+ *
+ */
+
+
+/**
+ * @interface_method_impl{RTVFSOBJOPS,pfnClose}
+ */
+static DECLCALLBACK(int) rtZipXarFssBaseObj_Close(void *pvThis)
+{
+    PRTZIPXARBASEOBJ pThis = (PRTZIPXARBASEOBJ)pvThis;
+
+    /* Currently there is nothing we really have to do here. */
+    NOREF(pThis);
+
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSOBJOPS,pfnQueryInfo}
+ */
+static DECLCALLBACK(int) rtZipXarFssBaseObj_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
+{
+    PRTZIPXARBASEOBJ pThis = (PRTZIPXARBASEOBJ)pvThis;
+
+    /*
+     * Get the common data.
+     */
+
+    /* Sizes. */
+    if (pThis->fModeType == RTFS_TYPE_FILE)
+    {
+        PRTZIPXARIOSTREAM pThisIos = RT_FROM_MEMBER(pThis, RTZIPXARIOSTREAM, BaseObj);
+        pObjInfo->cbObject    = pThisIos->DataAttr.cbDataArchived; /* Modified by decomp ios. */
+        pObjInfo->cbAllocated = pThisIos->DataAttr.cbDataArchived;
+    }
+    else
+    {
+        pObjInfo->cbObject    = 0;
+        pObjInfo->cbAllocated = 0;
+    }
+
+    /* The file mode. */
+    if (RT_UNLIKELY(!pThis->pFileElem->getChildElementValueDefP("mode", 0755, &pObjInfo->Attr.fMode)))
+        return VERR_XAR_BAD_FILE_MODE;
+    if (pObjInfo->Attr.fMode & RTFS_TYPE_MASK)
+        return VERR_XAR_BAD_FILE_MODE;
+    pObjInfo->Attr.fMode &= RTFS_UNIX_MASK & ~RTFS_TYPE_MASK;
+    pObjInfo->Attr.fMode |= pThis->fModeType;
+
+    /* File times. */
+    if (RT_UNLIKELY(!rtZipXarParseTimestamp(pThis->pFileElem, "atime", &pObjInfo->AccessTime)))
+        return VERR_XAR_BAD_FILE_TIMESTAMP;
+    if (RT_UNLIKELY(!rtZipXarParseTimestamp(pThis->pFileElem, "ctime", &pObjInfo->ChangeTime)))
+        return VERR_XAR_BAD_FILE_TIMESTAMP;
+    if (RT_UNLIKELY(!rtZipXarParseTimestamp(pThis->pFileElem, "mtime", &pObjInfo->ModificationTime)))
+        return VERR_XAR_BAD_FILE_TIMESTAMP;
+    pObjInfo->BirthTime = RTTimeSpecGetNano(&pObjInfo->AccessTime) <= RTTimeSpecGetNano(&pObjInfo->ChangeTime)
+                        ? pObjInfo->AccessTime : pObjInfo->ChangeTime;
+    if (RTTimeSpecGetNano(&pObjInfo->BirthTime) > RTTimeSpecGetNano(&pObjInfo->ModificationTime))
+        pObjInfo->BirthTime = pObjInfo->ModificationTime;
+
+    /*
+     * Copy the desired data.
+     */
+    switch (enmAddAttr)
+    {
+        case RTFSOBJATTRADD_NOTHING:
+        case RTFSOBJATTRADD_UNIX:
+            pObjInfo->Attr.enmAdditional = RTFSOBJATTRADD_UNIX;
+            if (RT_UNLIKELY(!pThis->pFileElem->getChildElementValueDefP("uid", 0, &pObjInfo->Attr.u.Unix.uid)))
+                return VERR_XAR_BAD_FILE_UID;
+            if (RT_UNLIKELY(!pThis->pFileElem->getChildElementValueDefP("gid", 0, &pObjInfo->Attr.u.Unix.gid)))
+                return VERR_XAR_BAD_FILE_GID;
+            if (RT_UNLIKELY(!pThis->pFileElem->getChildElementValueDefP("deviceno", 0, &pObjInfo->Attr.u.Unix.INodeIdDevice)))
+                return VERR_XAR_BAD_FILE_DEVICE_NO;
+            if (RT_UNLIKELY(!pThis->pFileElem->getChildElementValueDefP("inode", 0, &pObjInfo->Attr.u.Unix.INodeId)))
+                return VERR_XAR_BAD_FILE_INODE;
+            pObjInfo->Attr.u.Unix.cHardlinks    = 1;
+            pObjInfo->Attr.u.Unix.fFlags        = 0;
+            pObjInfo->Attr.u.Unix.GenerationId  = 0;
+            pObjInfo->Attr.u.Unix.Device        = 0;
+            break;
+
+        case RTFSOBJATTRADD_UNIX_OWNER:
+        {
+            pObjInfo->Attr.enmAdditional = RTFSOBJATTRADD_UNIX_OWNER;
+            if (RT_UNLIKELY(!pThis->pFileElem->getChildElementValueDefP("uid", 0, &pObjInfo->Attr.u.Unix.uid)))
+                return VERR_XAR_BAD_FILE_UID;
+            const char *pszUser = pThis->pFileElem->findChildElementValueP("user");
+            if (pszUser)
+                RTStrCopy(pObjInfo->Attr.u.UnixOwner.szName, sizeof(pObjInfo->Attr.u.UnixOwner.szName), pszUser);
+            else
+                pObjInfo->Attr.u.UnixOwner.szName[0] = '\0';
+            break;
+        }
+
+        case RTFSOBJATTRADD_UNIX_GROUP:
+        {
+            pObjInfo->Attr.enmAdditional = RTFSOBJATTRADD_UNIX_GROUP;
+            if (RT_UNLIKELY(!pThis->pFileElem->getChildElementValueDefP("gid", 0, &pObjInfo->Attr.u.Unix.gid)))
+                return VERR_XAR_BAD_FILE_GID;
+            const char *pszGroup = pThis->pFileElem->findChildElementValueP("group");
+            if (pszGroup)
+                RTStrCopy(pObjInfo->Attr.u.UnixGroup.szName, sizeof(pObjInfo->Attr.u.UnixGroup.szName), pszGroup);
+            else
+                pObjInfo->Attr.u.UnixGroup.szName[0] = '\0';
+            break;
+        }
+
+        case RTFSOBJATTRADD_EASIZE:
+            pObjInfo->Attr.enmAdditional = RTFSOBJATTRADD_EASIZE;
+            RT_ZERO(pObjInfo->Attr.u);
+            break;
+
+        default:
+            return VERR_NOT_SUPPORTED;
+    }
+
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * Xar filesystem base object operations.
+ */
+static const RTVFSOBJOPS g_rtZipXarFssBaseObjOps =
+{
+    RTVFSOBJOPS_VERSION,
+    RTVFSOBJTYPE_BASE,
+    "XarFsStream::Obj",
+    rtZipXarFssBaseObj_Close,
+    rtZipXarFssBaseObj_QueryInfo,
+    NULL,
+    RTVFSOBJOPS_VERSION
+};
+
+
+/**
+ * @interface_method_impl{RTVFSOBJOPS,pfnClose}
+ */
+static DECLCALLBACK(int) rtZipXarFssIos_Close(void *pvThis)
+{
+    PRTZIPXARIOSTREAM pThis = (PRTZIPXARIOSTREAM)pvThis;
+
+    RTVfsIoStrmRelease(pThis->hVfsIos);
+    pThis->hVfsIos = NIL_RTVFSIOSTREAM;
+
+    return rtZipXarFssBaseObj_Close(&pThis->BaseObj);
+}
+
+
+/**
+ * @interface_method_impl{RTVFSOBJOPS,pfnQueryInfo}
+ */
+static DECLCALLBACK(int) rtZipXarFssIos_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
+{
+    PRTZIPXARIOSTREAM pThis = (PRTZIPXARIOSTREAM)pvThis;
+    return rtZipXarFssBaseObj_QueryInfo(&pThis->BaseObj, pObjInfo, enmAddAttr);
+}
+
+
+/**
+ * @interface_method_impl{RTVFSIOSTREAMOPS,pfnRead}
+ */
+static DECLCALLBACK(int) rtZipXarFssIos_Read(void *pvThis, RTFOFF off, PCRTSGBUF pSgBuf, bool fBlocking, size_t *pcbRead)
+{
+    PRTZIPXARIOSTREAM pThis = (PRTZIPXARIOSTREAM)pvThis;
+    AssertReturn(off >= -1, VERR_INVALID_PARAMETER);
+    AssertReturn(pSgBuf->cSegs == 1, VERR_INVALID_PARAMETER);
+
+    /*
+     * Fend of reads beyond the end of the stream here.  If
+     */
+    if (off == -1)
+        off = pThis->offCurPos;
+    if (off < 0 || off > pThis->DataAttr.cbDataArchived)
+        return VERR_EOF;
+    if (pThis->fEndOfStream)
+    {
+        if (off >= pThis->DataAttr.cbDataArchived)
+            return pcbRead ? VINF_EOF : VERR_EOF;
+        if (!pThis->fSeekable)
+            return VERR_SEEK_ON_DEVICE;
+        pThis->fEndOfStream = false;
+    }
+
+    size_t cbToRead = pSgBuf->paSegs[0].cbSeg;
+    uint64_t cbLeft = pThis->DataAttr.cbDataArchived - off;
+    if (cbToRead > cbLeft)
+    {
+        if (!pcbRead)
+            return VERR_EOF;
+        cbToRead = (size_t)cbLeft;
+    }
+
+    /*
+     * Do the reading.
+     */
+    size_t cbReadStack = 0;
+    if (!pcbRead)
+        pcbRead = &cbReadStack;
+    int rc = RTVfsIoStrmReadAt(pThis->hVfsIos, off + pThis->DataAttr.offData, pSgBuf->paSegs[0].pvSeg,
+                               cbToRead, fBlocking, pcbRead);
+
+    /* Feed the hashes. */
+    size_t cbActuallyRead = *pcbRead;
+    if (pThis->uHashState == RTZIPXAR_HASH_PENDING)
+    {
+        if (pThis->offCurPos == pThis->cbDigested)
+        {
+            rtZipXarHashUpdate(&pThis->CtxArchived,  pThis->DataAttr.uHashFunArchived,  pSgBuf->paSegs[0].pvSeg, cbActuallyRead);
+            rtZipXarHashUpdate(&pThis->CtxExtracted, pThis->DataAttr.uHashFunExtracted, pSgBuf->paSegs[0].pvSeg, cbActuallyRead);
+            pThis->cbDigested += cbActuallyRead;
+        }
+        else if (   pThis->cbDigested > pThis->offCurPos
+                 && pThis->cbDigested < (RTFOFF)(pThis->offCurPos + cbActuallyRead))
+        {
+            size_t      offHash = pThis->cbDigested - pThis->offCurPos;
+            void const *pvHash  = (uint8_t const *)pSgBuf->paSegs[0].pvSeg + offHash;
+            size_t      cbHash  = cbActuallyRead - offHash;
+            rtZipXarHashUpdate(&pThis->CtxArchived,  pThis->DataAttr.uHashFunArchived,  pvHash, cbHash);
+            rtZipXarHashUpdate(&pThis->CtxExtracted, pThis->DataAttr.uHashFunExtracted, pvHash, cbHash);
+            pThis->cbDigested += cbHash;
+        }
+    }
+
+    /* Update the file position. */
+    pThis->offCurPos += cbActuallyRead;
+
+    /*
+     * Check for end of stream, also check the hash.
+     */
+    if (pThis->offCurPos >= pThis->DataAttr.cbDataArchived)
+    {
+        Assert(pThis->offCurPos == pThis->DataAttr.cbDataArchived);
+        pThis->fEndOfStream = true;
+
+        /* Check hash. */
+        if (   pThis->uHashState == RTZIPXAR_HASH_PENDING
+            && pThis->cbDigested == pThis->DataAttr.cbDataArchived)
+        {
+            RTZIPXARHASHDIGEST Digest;
+            rtZipXarHashFinal(&pThis->CtxArchived, pThis->DataAttr.uHashFunArchived, &Digest);
+            if (rtZipXarHashIsEqual(pThis->DataAttr.uHashFunArchived, &Digest, &pThis->DataAttr.DigestArchived))
+            {
+                rtZipXarHashFinal(&pThis->CtxExtracted, pThis->DataAttr.uHashFunExtracted, &Digest);
+                if (rtZipXarHashIsEqual(pThis->DataAttr.uHashFunExtracted, &Digest, &pThis->DataAttr.DigestExtracted))
+                    pThis->uHashState = RTZIPXAR_HASH_OK;
+                else
+                {
+                    pThis->uHashState = RTZIPXAR_HASH_FAILED_EXTRACTED;
+                    rc = VERR_XAR_EXTRACTED_HASH_MISMATCH;
+                }
+            }
+            else
+            {
+                pThis->uHashState = RTZIPXAR_HASH_FAILED_ARCHIVED;
+                rc = VERR_XAR_ARCHIVED_HASH_MISMATCH;
+            }
+        }
+        else if (pThis->uHashState == RTZIPXAR_HASH_FAILED_ARCHIVED)
+            rc = VERR_XAR_ARCHIVED_HASH_MISMATCH;
+        else if (pThis->uHashState == RTZIPXAR_HASH_FAILED_EXTRACTED)
+            rc = VERR_XAR_EXTRACTED_HASH_MISMATCH;
+    }
+
+    return rc;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSIOSTREAMOPS,pfnWrite}
+ */
+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. */
+    NOREF(pvThis); NOREF(off); NOREF(pSgBuf); NOREF(fBlocking); NOREF(pcbWritten);
+    return VERR_ACCESS_DENIED;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSIOSTREAMOPS,pfnFlush}
+ */
+static DECLCALLBACK(int) rtZipXarFssIos_Flush(void *pvThis)
+{
+    /* It's a read only stream, nothing dirty to flush. */
+    NOREF(pvThis);
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSIOSTREAMOPS,pfnPollOne}
+ */
+static DECLCALLBACK(int) rtZipXarFssIos_PollOne(void *pvThis, uint32_t fEvents, RTMSINTERVAL cMillies, bool fIntr,
+                                                uint32_t *pfRetEvents)
+{
+    PRTZIPXARIOSTREAM pThis = (PRTZIPXARIOSTREAM)pvThis;
+
+    /* When we've reached the end, read will be set to indicate it. */
+    if (   (fEvents & RTPOLL_EVT_READ)
+        && pThis->fEndOfStream)
+    {
+        int rc = RTVfsIoStrmPoll(pThis->hVfsIos, fEvents, 0, fIntr, pfRetEvents);
+        if (RT_SUCCESS(rc))
+            *pfRetEvents |= RTPOLL_EVT_READ;
+        else
+            *pfRetEvents = RTPOLL_EVT_READ;
+        return VINF_SUCCESS;
+    }
+
+    return RTVfsIoStrmPoll(pThis->hVfsIos, fEvents, cMillies, fIntr, pfRetEvents);
+}
+
+
+/**
+ * @interface_method_impl{RTVFSIOSTREAMOPS,pfnTell}
+ */
+static DECLCALLBACK(int) rtZipXarFssIos_Tell(void *pvThis, PRTFOFF poffActual)
+{
+    PRTZIPXARIOSTREAM pThis = (PRTZIPXARIOSTREAM)pvThis;
+    *poffActual = pThis->offCurPos;
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * Xar I/O stream operations.
+ */
+static const RTVFSIOSTREAMOPS g_rtZipXarFssIosOps =
+{
+    { /* Obj */
+        RTVFSOBJOPS_VERSION,
+        RTVFSOBJTYPE_IO_STREAM,
+        "XarFsStream::IoStream",
+        rtZipXarFssIos_Close,
+        rtZipXarFssIos_QueryInfo,
+        NULL,
+        RTVFSOBJOPS_VERSION
+    },
+    RTVFSIOSTREAMOPS_VERSION,
+    0,
+    rtZipXarFssIos_Read,
+    rtZipXarFssIos_Write,
+    rtZipXarFssIos_Flush,
+    rtZipXarFssIos_PollOne,
+    rtZipXarFssIos_Tell,
+    NULL /*Skip*/,
+    NULL /*ZeroFill*/,
+    RTVFSIOSTREAMOPS_VERSION
+};
+
+
+/**
+ * @interface_method_impl{RTVFSOBJOPS,pfnClose}
+ */
+static DECLCALLBACK(int) rtZipXarFssFile_Close(void *pvThis)
+{
+    PRTZIPXARFILE pThis = (PRTZIPXARFILE)pvThis;
+
+    RTVfsFileRelease(pThis->hVfsFile);
+    pThis->hVfsFile = NIL_RTVFSFILE;
+
+    return rtZipXarFssIos_Close(&pThis->Ios);
+}
+
+
+/**
+ * @interface_method_impl{RTVFSOBJSETOPS,pfnMode}
+ */
+static DECLCALLBACK(int) rtZipXarFssFile_SetMode(void *pvThis, RTFMODE fMode, RTFMODE fMask)
+{
+    NOREF(pvThis);
+    NOREF(fMode);
+    NOREF(fMask);
+    return VERR_NOT_SUPPORTED;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSOBJSETOPS,pfnSetTimes}
+ */
+static DECLCALLBACK(int) rtZipXarFssFile_SetTimes(void *pvThis, PCRTTIMESPEC pAccessTime, PCRTTIMESPEC pModificationTime,
+                                                  PCRTTIMESPEC pChangeTime, PCRTTIMESPEC pBirthTime)
+{
+    NOREF(pvThis);
+    NOREF(pAccessTime);
+    NOREF(pModificationTime);
+    NOREF(pChangeTime);
+    NOREF(pBirthTime);
+    return VERR_NOT_SUPPORTED;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSOBJSETOPS,pfnSetOwner}
+ */
+static DECLCALLBACK(int) rtZipXarFssFile_SetOwner(void *pvThis, RTUID uid, RTGID gid)
+{
+    NOREF(pvThis);
+    NOREF(uid);
+    NOREF(gid);
+    return VERR_NOT_SUPPORTED;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSFILEOPS,pfnSeek}
+ */
+static DECLCALLBACK(int) rtZipXarFssFile_Seek(void *pvThis, RTFOFF offSeek, unsigned uMethod, PRTFOFF poffActual)
+{
+    PRTZIPXARFILE pThis = (PRTZIPXARFILE)pvThis;
+
+    /* Recalculate the request to RTFILE_SEEK_BEGIN. */
+    switch (uMethod)
+    {
+        case RTFILE_SEEK_BEGIN:
+            break;
+        case RTFILE_SEEK_CURRENT:
+            offSeek += pThis->Ios.offCurPos;
+            break;
+        case RTFILE_SEEK_END:
+            offSeek = pThis->Ios.DataAttr.cbDataArchived + offSeek;
+            break;
+        default:
+            AssertFailedReturn(VERR_INVALID_PARAMETER);
+    }
+
+    /* Do limit checks. */
+    if (offSeek < 0)
+        offSeek = 0;
+    else if (offSeek > pThis->Ios.DataAttr.cbDataArchived)
+        offSeek = pThis->Ios.DataAttr.cbDataArchived;
+
+    /* Apply and return. */
+    pThis->Ios.fEndOfStream = (offSeek >= pThis->Ios.DataAttr.cbDataArchived);
+    pThis->Ios.offCurPos    = offSeek;
+    if (poffActual)
+        *poffActual = offSeek;
+
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSFILEOPS,pfnQuerySize}
+ */
+static DECLCALLBACK(int) rtZipXarFssFile_QuerySize(void *pvThis, uint64_t *pcbFile)
+{
+    PRTZIPXARFILE pThis = (PRTZIPXARFILE)pvThis;
+    *pcbFile = pThis->Ios.DataAttr.cbDataArchived;
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * Xar file operations.
+ */
+static const RTVFSFILEOPS g_rtZipXarFssFileOps =
+{
+    { /* I/O stream */
+        { /* Obj */
+            RTVFSOBJOPS_VERSION,
+            RTVFSOBJTYPE_FILE,
+            "XarFsStream::File",
+            rtZipXarFssFile_Close,
+            rtZipXarFssIos_QueryInfo,
+            NULL,
+            RTVFSOBJOPS_VERSION
+        },
+        RTVFSIOSTREAMOPS_VERSION,
+        RTVFSIOSTREAMOPS_FEAT_NO_SG,
+        rtZipXarFssIos_Read,
+        rtZipXarFssIos_Write,
+        rtZipXarFssIos_Flush,
+        rtZipXarFssIos_PollOne,
+        rtZipXarFssIos_Tell,
+        NULL /*Skip*/,
+        NULL /*ZeroFill*/,
+        RTVFSIOSTREAMOPS_VERSION
+    },
+    RTVFSFILEOPS_VERSION,
+    0,
+    { /* ObjSet */
+        RTVFSOBJSETOPS_VERSION,
+        RT_UOFFSETOF(RTVFSFILEOPS, ObjSet) - RT_UOFFSETOF(RTVFSFILEOPS, Stream.Obj),
+        rtZipXarFssFile_SetMode,
+        rtZipXarFssFile_SetTimes,
+        rtZipXarFssFile_SetOwner,
+        RTVFSOBJSETOPS_VERSION
+    },
+    rtZipXarFssFile_Seek,
+    rtZipXarFssFile_QuerySize,
+    NULL /*SetSize*/,
+    NULL /*QueryMaxSize*/,
+    RTVFSFILEOPS_VERSION,
+};
+
+
+
+
+/**
+ * @interface_method_impl{RTVFSOBJOPS,pfnClose}
+ */
+static DECLCALLBACK(int) rtZipXarFssDecompIos_Close(void *pvThis)
+{
+    PRTZIPXARDECOMPIOS pThis = (PRTZIPXARDECOMPIOS)pvThis;
+
+    RTVfsIoStrmRelease(pThis->hVfsIosDecompressor);
+    pThis->hVfsIosDecompressor = NIL_RTVFSIOSTREAM;
+
+    RTVfsIoStrmRelease(pThis->hVfsIosRaw);
+    pThis->hVfsIosRaw = NIL_RTVFSIOSTREAM;
+    pThis->pIosRaw = NULL;
+
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSOBJOPS,pfnQueryInfo}
+ */
+static DECLCALLBACK(int) rtZipXarFssDecompIos_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
+{
+    PRTZIPXARDECOMPIOS pThis = (PRTZIPXARDECOMPIOS)pvThis;
+
+    int rc = rtZipXarFssBaseObj_QueryInfo(&pThis->pIosRaw->BaseObj, pObjInfo, enmAddAttr);
+    pObjInfo->cbObject = pThis->pIosRaw->DataAttr.cbDataExtracted;
+    return rc;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSIOSTREAMOPS,pfnRead}
+ */
+static DECLCALLBACK(int) rtZipXarFssDecompIos_Read(void *pvThis, RTFOFF off, PCRTSGBUF pSgBuf, bool fBlocking, size_t *pcbRead)
+{
+    PRTZIPXARDECOMPIOS pThis = (PRTZIPXARDECOMPIOS)pvThis;
+    AssertReturn(pSgBuf->cSegs == 1, VERR_INVALID_PARAMETER);
+
+    /*
+     * Enforce the cbDataExtracted limit.
+     */
+    if (pThis->offCurPos > pThis->pIosRaw->DataAttr.cbDataExtracted)
+        return VERR_XAR_EXTRACTED_SIZE_EXCEEDED;
+
+    /*
+     * Read the data.
+     *
+     * ASSUMES the decompressor stream isn't seekable, so we don't have to
+     * validate off wrt data digest updating.
+     */
+    int rc = RTVfsIoStrmReadAt(pThis->hVfsIosDecompressor, off, pSgBuf->paSegs[0].pvSeg, pSgBuf->paSegs[0].cbSeg,
+                               fBlocking, pcbRead);
+    if (RT_FAILURE(rc))
+        return rc;
+
+    /*
+     * Hash the data.  When reaching the end match against the expected digest.
+     */
+    size_t cbActuallyRead = pcbRead ? *pcbRead : pSgBuf->paSegs[0].cbSeg;
+    pThis->offCurPos += cbActuallyRead;
+    rtZipXarHashUpdate(&pThis->CtxExtracted, pThis->uHashFunExtracted, pSgBuf->paSegs[0].pvSeg, cbActuallyRead);
+    if (rc == VINF_EOF)
+    {
+        if (pThis->offCurPos == pThis->pIosRaw->DataAttr.cbDataExtracted)
+        {
+            if (pThis->uHashState == RTZIPXAR_HASH_PENDING)
+            {
+                RTZIPXARHASHDIGEST Digest;
+                rtZipXarHashFinal(&pThis->CtxExtracted, pThis->uHashFunExtracted, &Digest);
+                if (rtZipXarHashIsEqual(pThis->uHashFunExtracted, &Digest, &pThis->DigestExtracted))
+                    pThis->uHashState = RTZIPXAR_HASH_OK;
+                else
+                {
+                    pThis->uHashState = RTZIPXAR_HASH_FAILED_EXTRACTED;
+                    rc = VERR_XAR_EXTRACTED_HASH_MISMATCH;
+                }
+            }
+            else if (pThis->uHashState != RTZIPXAR_HASH_OK)
+                rc = VERR_XAR_EXTRACTED_HASH_MISMATCH;
+        }
+        else
+            rc = VERR_XAR_EXTRACTED_SIZE_EXCEEDED;
+
+        /* Ensure that the raw stream is also at the end so that both
+           message digests are checked. */
+        if (RT_SUCCESS(rc))
+        {
+            if (   pThis->pIosRaw->offCurPos < pThis->pIosRaw->DataAttr.cbDataArchived
+                || pThis->pIosRaw->uHashState == RTZIPXAR_HASH_PENDING)
+                rc = VERR_XAR_UNUSED_ARCHIVED_DATA;
+            else if (pThis->pIosRaw->uHashState != RTZIPXAR_HASH_OK)
+                rc = VERR_XAR_ARCHIVED_HASH_MISMATCH;
+        }
+    }
+
+    return rc;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSIOSTREAMOPS,pfnWrite}
+ */
+static DECLCALLBACK(int) rtZipXarFssDecompIos_Write(void *pvThis, RTFOFF off, PCRTSGBUF pSgBuf, bool fBlocking, size_t *pcbWritten)
+{
+    /* Cannot write to a read-only I/O stream. */
+    NOREF(pvThis); NOREF(off); NOREF(pSgBuf); NOREF(fBlocking); NOREF(pcbWritten);
+    return VERR_ACCESS_DENIED;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSIOSTREAMOPS,pfnFlush}
+ */
+static DECLCALLBACK(int) rtZipXarFssDecompIos_Flush(void *pvThis)
+{
+    /* It's a read only stream, nothing dirty to flush. */
+    NOREF(pvThis);
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSIOSTREAMOPS,pfnPollOne}
+ */
+static DECLCALLBACK(int) rtZipXarFssDecompIos_PollOne(void *pvThis, uint32_t fEvents, RTMSINTERVAL cMillies, bool fIntr,
+                                                      uint32_t *pfRetEvents)
+{
+    PRTZIPXARDECOMPIOS pThis = (PRTZIPXARDECOMPIOS)pvThis;
+    return RTVfsIoStrmPoll(pThis->hVfsIosDecompressor, fEvents, cMillies, fIntr, pfRetEvents);
+}
+
+
+/**
+ * @interface_method_impl{RTVFSIOSTREAMOPS,pfnTell}
+ */
+static DECLCALLBACK(int) rtZipXarFssDecompIos_Tell(void *pvThis, PRTFOFF poffActual)
+{
+    PRTZIPXARDECOMPIOS pThis = (PRTZIPXARDECOMPIOS)pvThis;
+    *poffActual = pThis->offCurPos;
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * Xar I/O stream operations.
+ */
+static const RTVFSIOSTREAMOPS g_rtZipXarFssDecompIosOps =
+{
+    { /* Obj */
+        RTVFSOBJOPS_VERSION,
+        RTVFSOBJTYPE_IO_STREAM,
+        "XarFsStream::DecompIoStream",
+        rtZipXarFssDecompIos_Close,
+        rtZipXarFssDecompIos_QueryInfo,
+        NULL,
+        RTVFSOBJOPS_VERSION
+    },
+    RTVFSIOSTREAMOPS_VERSION,
+    0,
+    rtZipXarFssDecompIos_Read,
+    rtZipXarFssDecompIos_Write,
+    rtZipXarFssDecompIos_Flush,
+    rtZipXarFssDecompIos_PollOne,
+    rtZipXarFssDecompIos_Tell,
+    NULL /*Skip*/,
+    NULL /*ZeroFill*/,
+    RTVFSIOSTREAMOPS_VERSION
+};
+
+
+
+
+/**
+ * @interface_method_impl{RTVFSOBJOPS,pfnClose}
+ */
+static DECLCALLBACK(int) rtZipXarFssSym_Close(void *pvThis)
+{
+    PRTZIPXARBASEOBJ pThis = (PRTZIPXARBASEOBJ)pvThis;
+    return rtZipXarFssBaseObj_Close(pThis);
+}
+
+
+/**
+ * @interface_method_impl{RTVFSOBJOPS,pfnQueryInfo}
+ */
+static DECLCALLBACK(int) rtZipXarFssSym_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
+{
+    PRTZIPXARBASEOBJ pThis = (PRTZIPXARBASEOBJ)pvThis;
+    return rtZipXarFssBaseObj_QueryInfo(pThis, pObjInfo, enmAddAttr);
+}
+
+/**
+ * @interface_method_impl{RTVFSOBJSETOPS,pfnMode}
+ */
+static DECLCALLBACK(int) rtZipXarFssSym_SetMode(void *pvThis, RTFMODE fMode, RTFMODE fMask)
+{
+    NOREF(pvThis); NOREF(fMode); NOREF(fMask);
+    return VERR_ACCESS_DENIED;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSOBJSETOPS,pfnSetTimes}
+ */
+static DECLCALLBACK(int) rtZipXarFssSym_SetTimes(void *pvThis, PCRTTIMESPEC pAccessTime, PCRTTIMESPEC pModificationTime,
+                                                 PCRTTIMESPEC pChangeTime, PCRTTIMESPEC pBirthTime)
+{
+    NOREF(pvThis); NOREF(pAccessTime); NOREF(pModificationTime); NOREF(pChangeTime); NOREF(pBirthTime);
+    return VERR_ACCESS_DENIED;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSOBJSETOPS,pfnSetOwner}
+ */
+static DECLCALLBACK(int) rtZipXarFssSym_SetOwner(void *pvThis, RTUID uid, RTGID gid)
+{
+    NOREF(pvThis); NOREF(uid); NOREF(gid);
+    return VERR_ACCESS_DENIED;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSSYMLINKOPS,pfnRead}
+ */
+static DECLCALLBACK(int) rtZipXarFssSym_Read(void *pvThis, char *pszTarget, size_t cbTarget)
+{
+    PRTZIPXARBASEOBJ pThis = (PRTZIPXARBASEOBJ)pvThis;
+#if 0
+    return RTStrCopy(pszTarget, cbXarget, pThis->pXarReader->szTarget);
+#else
+    RT_NOREF_PV(pThis); RT_NOREF_PV(pszTarget); RT_NOREF_PV(cbTarget);
+    return VERR_NOT_IMPLEMENTED;
+#endif
+}
+
+
+/**
+ * Xar symbolic (and hardlink) operations.
+ */
+static const RTVFSSYMLINKOPS g_rtZipXarFssSymOps =
+{
+    { /* Obj */
+        RTVFSOBJOPS_VERSION,
+        RTVFSOBJTYPE_SYMLINK,
+        "XarFsStream::Symlink",
+        rtZipXarFssSym_Close,
+        rtZipXarFssSym_QueryInfo,
+        NULL,
+        RTVFSOBJOPS_VERSION
+    },
+    RTVFSSYMLINKOPS_VERSION,
+    0,
+    { /* ObjSet */
+        RTVFSOBJSETOPS_VERSION,
+        RT_UOFFSETOF(RTVFSSYMLINKOPS, ObjSet) - RT_UOFFSETOF(RTVFSSYMLINKOPS, Obj),
+        rtZipXarFssSym_SetMode,
+        rtZipXarFssSym_SetTimes,
+        rtZipXarFssSym_SetOwner,
+        RTVFSOBJSETOPS_VERSION
+    },
+    rtZipXarFssSym_Read,
+    RTVFSSYMLINKOPS_VERSION
+};
+
+
+/**
+ * @interface_method_impl{RTVFSOBJOPS,pfnClose}
+ */
+static DECLCALLBACK(int) rtZipXarFss_Close(void *pvThis)
+{
+    PRTZIPXARFSSTREAM pThis = (PRTZIPXARFSSTREAM)pvThis;
+
+    RTVfsIoStrmRelease(pThis->hVfsIos);
+    pThis->hVfsIos = NIL_RTVFSIOSTREAM;
+
+    RTVfsFileRelease(pThis->hVfsFile);
+    pThis->hVfsFile = NIL_RTVFSFILE;
+
+    if (pThis->XarReader.pDoc)
+        delete pThis->XarReader.pDoc;
+    pThis->XarReader.pDoc = NULL;
+    /* The other XarReader fields only point to elements within pDoc. */
+    pThis->XarReader.pToc = NULL;
+    pThis->XarReader.cCurDepth = 0;
+    pThis->XarReader.pCurFile = NULL;
+
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSOBJOPS,pfnQueryInfo}
+ */
+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. */
+    return RTVfsIoStrmQueryInfo(pThis->hVfsIos, pObjInfo, enmAddAttr);
+}
+
+
+/**
+ * @interface_method_impl{RTVFSFSSTREAMOPS,pfnNext}
+ */
+static DECLCALLBACK(int) rtZipXarFss_Next(void *pvThis, char **ppszName, RTVFSOBJTYPE *penmType, PRTVFSOBJ phVfsObj)
+{
+    PRTZIPXARFSSTREAM pThis = (PRTZIPXARFSSTREAM)pvThis;
+
+    /*
+     * Check if we've already reached the end in some way.
+     */
+    if (pThis->fEndOfStream)
+        return VERR_EOF;
+    if (pThis->rcFatal != VINF_SUCCESS)
+        return pThis->rcFatal;
+
+    /*
+     * Get the next file element.
+     */
+    xml::ElementNode const *pCurFile = pThis->XarReader.pCurFile;
+    if (pCurFile)
+        pThis->XarReader.pCurFile = pCurFile = rtZipXarGetNextFileElement(pCurFile, &pThis->XarReader.cCurDepth);
+    else if (!pThis->fEndOfStream)
+    {
+        pThis->XarReader.cCurDepth  = 0;
+        pThis->XarReader.pCurFile   = pCurFile = pThis->XarReader.pToc->findChildElement("file");
+    }
+    if (!pCurFile)
+    {
+        pThis->fEndOfStream = true;
+        return VERR_EOF;
+    }
+
+    /*
+     * Retrive the fundamental attributes (elements actually).
+     */
+    const char *pszName = pCurFile->findChildElementValueP("name");
+    const char *pszType = pCurFile->findChildElementValueP("type");
+    if (RT_UNLIKELY(!pszName || !pszType))
+        return pThis->rcFatal = VERR_XAR_BAD_FILE_ELEMENT;
+
+    /*
+     * Validate the filename.  Being a little too paranoid here, perhaps, wrt
+     * path separators and escapes...
+     */
+    if (   !*pszName
+        || strchr(pszName, '/')
+        || strchr(pszName, '\\')
+        || strchr(pszName, ':')
+        || !strcmp(pszName, "..") )
+        return pThis->rcFatal = VERR_XAR_INVALID_FILE_NAME;
+
+    /*
+     * 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"))
+    {
+        RTZIPXARDATASTREAM DataAttr;
+        rc = rtZipXarGetDataStreamAttributes(pCurFile, &DataAttr);
+        if (RT_FAILURE(rc))
+            return pThis->rcFatal = rc;
+        DataAttr.offData += pThis->offZero + pThis->offStart;
+
+        if (   pThis->hVfsFile != NIL_RTVFSFILE
+            && DataAttr.enmEncoding == RTZIPXARENCODING_STORE)
+        {
+            /*
+             * The input is seekable and the XAR file isn't compressed, so we
+             * can provide a seekable file to the user.
+             */
+            RTVFSFILE           hVfsFile;
+            PRTZIPXARFILE       pFileData;
+            rc = RTVfsNewFile(&g_rtZipXarFssFileOps,
+                              sizeof(*pFileData),
+                              RTFILE_O_READ | RTFILE_O_DENY_NONE | RTFILE_O_OPEN,
+                              NIL_RTVFS,
+                              NIL_RTVFSLOCK,
+                              &hVfsFile,
+                              (void **)&pFileData);
+            if (RT_FAILURE(rc))
+                return pThis->rcFatal = rc;
+
+            pFileData->Ios.BaseObj.pFileElem    = pCurFile;
+            pFileData->Ios.BaseObj.fModeType    = RTFS_TYPE_FILE;
+            pFileData->Ios.DataAttr             = DataAttr;
+            pFileData->Ios.offCurPos            = 0;
+            pFileData->Ios.fEndOfStream         = false;
+            pFileData->Ios.fSeekable            = true;
+            pFileData->Ios.uHashState           = RTZIPXAR_HASH_PENDING;
+            pFileData->Ios.cbDigested           = 0;
+            rtZipXarHashInit(&pFileData->Ios.CtxArchived,  pFileData->Ios.DataAttr.uHashFunArchived);
+            rtZipXarHashInit(&pFileData->Ios.CtxExtracted, pFileData->Ios.DataAttr.uHashFunExtracted);
+
+            pFileData->Ios.hVfsIos              = pThis->hVfsIos;
+            RTVfsIoStrmRetain(pFileData->Ios.hVfsIos);
+            pFileData->hVfsFile                 = pThis->hVfsFile;
+            RTVfsFileRetain(pFileData->hVfsFile);
+
+            /* Try avoid double content hashing. */
+            if (pFileData->Ios.DataAttr.uHashFunArchived == pFileData->Ios.DataAttr.uHashFunExtracted)
+                pFileData->Ios.DataAttr.uHashFunExtracted = XAR_HASH_NONE;
+
+            enmType = RTVFSOBJTYPE_FILE;
+            hVfsObj = RTVfsObjFromFile(hVfsFile);
+            RTVfsFileRelease(hVfsFile);
+        }
+        else
+        {
+            RTVFSIOSTREAM       hVfsIosRaw;
+            PRTZIPXARIOSTREAM   pIosData;
+            rc = RTVfsNewIoStream(&g_rtZipXarFssIosOps,
+                                  sizeof(*pIosData),
+                                  RTFILE_O_READ | RTFILE_O_DENY_NONE | RTFILE_O_OPEN,
+                                  NIL_RTVFS,
+                                  NIL_RTVFSLOCK,
+                                  &hVfsIosRaw,
+                                  (void **)&pIosData);
+            if (RT_FAILURE(rc))
+                return pThis->rcFatal = rc;
+
+            pIosData->BaseObj.pFileElem     = pCurFile;
+            pIosData->BaseObj.fModeType     = RTFS_TYPE_FILE;
+            pIosData->DataAttr              = DataAttr;
+            pIosData->offCurPos             = 0;
+            pIosData->fEndOfStream          = false;
+            pIosData->fSeekable             = pThis->hVfsFile != NIL_RTVFSFILE;
+            pIosData->uHashState            = RTZIPXAR_HASH_PENDING;
+            pIosData->cbDigested            = 0;
+            rtZipXarHashInit(&pIosData->CtxArchived,  pIosData->DataAttr.uHashFunArchived);
+            rtZipXarHashInit(&pIosData->CtxExtracted, pIosData->DataAttr.uHashFunExtracted);
+
+            pIosData->hVfsIos               = pThis->hVfsIos;
+            RTVfsIoStrmRetain(pThis->hVfsIos);
+
+            if (   pIosData->DataAttr.enmEncoding != RTZIPXARENCODING_STORE
+                && pIosData->DataAttr.enmEncoding != RTZIPXARENCODING_UNSUPPORTED)
+            {
+                /*
+                 * We need to set up a decompression chain.
+                 */
+                RTVFSIOSTREAM       hVfsIosDecomp;
+                PRTZIPXARDECOMPIOS  pIosDecompData;
+                rc = RTVfsNewIoStream(&g_rtZipXarFssDecompIosOps,
+                                      sizeof(*pIosDecompData),
+                                      RTFILE_O_READ | RTFILE_O_DENY_NONE | RTFILE_O_OPEN,
+                                      NIL_RTVFS,
+                                      NIL_RTVFSLOCK,
+                                      &hVfsIosDecomp,
+                                      (void **)&pIosDecompData);
+                if (RT_FAILURE(rc))
+                {
+                    RTVfsIoStrmRelease(hVfsIosRaw);
+                    return pThis->rcFatal = rc;
+                }
+
+                pIosDecompData->hVfsIosDecompressor = NIL_RTVFSIOSTREAM;
+                pIosDecompData->hVfsIosRaw          = hVfsIosRaw;
+                pIosDecompData->pIosRaw             = pIosData;
+                pIosDecompData->offCurPos           = 0;
+                pIosDecompData->uHashFunExtracted   = DataAttr.uHashFunExtracted;
+                pIosDecompData->uHashState = RTZIPXAR_HASH_PENDING;
+                rtZipXarHashInit(&pIosDecompData->CtxExtracted, pIosDecompData->uHashFunExtracted);
+                pIosDecompData->DigestExtracted     = DataAttr.DigestExtracted;
+
+                /* Tell the raw end to only hash the archived data. */
+                pIosData->DataAttr.uHashFunExtracted = XAR_HASH_NONE;
+
+                /*
+                 * Hook up the decompressor.
+                 */
+                switch (DataAttr.enmEncoding)
+                {
+                    case RTZIPXARENCODING_GZIP:
+                        /* Must allow zlib header, all examples I've got seems
+                           to be using it rather than the gzip one.  Makes
+                           sense as there is no need to repeat the file name
+                           and the attributes. */
+                        rc = RTZipGzipDecompressIoStream(hVfsIosRaw, RTZIPGZIPDECOMP_F_ALLOW_ZLIB_HDR,
+                                                         &pIosDecompData->hVfsIosDecompressor);
+                        break;
+                    default:
+                        rc = VERR_INTERNAL_ERROR_5;
+                        break;
+                }
+                if (RT_FAILURE(rc))
+                {
+                    RTVfsIoStrmRelease(hVfsIosDecomp);
+                    return pThis->rcFatal = rc;
+                }
+
+                /* What to return. */
+                hVfsObj = RTVfsObjFromIoStream(hVfsIosDecomp);
+                RTVfsIoStrmRelease(hVfsIosDecomp);
+            }
+            else
+            {
+                /* Try avoid double content hashing. */
+                if (pIosData->DataAttr.uHashFunArchived == pIosData->DataAttr.uHashFunExtracted)
+                    pIosData->DataAttr.uHashFunExtracted = XAR_HASH_NONE;
+
+                /* What to return. */
+                hVfsObj = RTVfsObjFromIoStream(hVfsIosRaw);
+                RTVfsIoStrmRelease(hVfsIosRaw);
+            }
+            enmType = RTVFSOBJTYPE_IO_STREAM;
+        }
+    }
+    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->pFileElem  = pCurFile;
+        pBaseObjData->fModeType  = RTFS_TYPE_DIRECTORY;
+
+        enmType = RTVFSOBJTYPE_BASE;
+    }
+    else if (!strcmp(pszType, "symlink"))
+    {
+        RTVFSSYMLINK        hVfsSym;
+        PRTZIPXARBASEOBJ    pBaseObjData;
+        rc = RTVfsNewSymlink(&g_rtZipXarFssSymOps,
+                             sizeof(*pBaseObjData),
+                             NIL_RTVFS,
+                             NIL_RTVFSLOCK,
+                             &hVfsSym,
+                             (void **)&pBaseObjData);
+        if (RT_FAILURE(rc))
+            return pThis->rcFatal = rc;
+
+        pBaseObjData->pFileElem  = pCurFile;
+        pBaseObjData->fModeType  = RTFS_TYPE_SYMLINK;
+
+        enmType = RTVFSOBJTYPE_SYMLINK;
+        hVfsObj = RTVfsObjFromSymlink(hVfsSym);
+        RTVfsSymlinkRelease(hVfsSym);
+    }
+    else
+        return pThis->rcFatal = VERR_XAR_UNKNOWN_FILE_TYPE;
+
+    /*
+     * Set the return data and we're done.
+     */
+    if (ppszName)
+    {
+        /* Figure the length. */
+        size_t const            cbCurName  = strlen(pszName) + 1;
+        size_t                  cbFullName = cbCurName;
+        const xml::ElementNode *pAncestor  = pCurFile;
+        uint32_t                cLeft      = pThis->XarReader.cCurDepth;
+        while (cLeft-- > 0)
+        {
+            pAncestor = (const xml::ElementNode *)pAncestor->getParent();               Assert(pAncestor);
+            const char *pszAncestorName = pAncestor->findChildElementValueP("name");    Assert(pszAncestorName);
+            cbFullName += strlen(pszAncestorName) + 1;
+        }
+
+        /* Allocate a buffer. */
+        char *psz = *ppszName = RTStrAlloc(cbFullName);
+        if (!psz)
+        {
+            RTVfsObjRelease(hVfsObj);
+            return VERR_NO_STR_MEMORY;
+        }
+
+        /* Construct it, from the end. */
+        psz += cbFullName;
+        psz -= cbCurName;
+        memcpy(psz, pszName, cbCurName);
+
+        pAncestor = pCurFile;
+        cLeft = pThis->XarReader.cCurDepth;
+        while (cLeft-- > 0)
+        {
+            pAncestor = (const xml::ElementNode *)pAncestor->getParent();             Assert(pAncestor);
+            const char *pszAncestorName = pAncestor->findChildElementValueP("name");  Assert(pszAncestorName);
+            *--psz = '/';
+            size_t cchAncestorName = strlen(pszAncestorName);
+            psz -= cchAncestorName;
+            memcpy(psz, pszAncestorName, cchAncestorName);
+        }
+        Assert(*ppszName == psz);
+    }
+
+    if (phVfsObj)
+        *phVfsObj = hVfsObj;
+    else
+        RTVfsObjRelease(hVfsObj);
+
+    if (penmType)
+        *penmType = enmType;
+
+    return VINF_SUCCESS;
+}
+
+
+
+/**
+ * Xar filesystem stream operations.
+ */
+static const RTVFSFSSTREAMOPS rtZipXarFssOps =
+{
+    { /* Obj */
+        RTVFSOBJOPS_VERSION,
+        RTVFSOBJTYPE_FS_STREAM,
+        "XarFsStream",
+        rtZipXarFss_Close,
+        rtZipXarFss_QueryInfo,
+        NULL,
+        RTVFSOBJOPS_VERSION
+    },
+    RTVFSFSSTREAMOPS_VERSION,
+    0,
+    rtZipXarFss_Next,
+    NULL,
+    NULL,
+    NULL,
+    RTVFSFSSTREAMOPS_VERSION
+};
+
+
+
+/**
+ * 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;
+    RT_NOREF_PV(pXarHdr);
+
+    /*
+     * 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;
+        rc = rtZipXarParseChecksumStyle(pszStyle, &uHashFunction);
+        if (RT_FAILURE(rc))
+            return rc;
+        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;
+            RTFOFF   cbChecksum;
+            rc = rtZipXarGetOffsetSizeLengthFromElem(pChecksumElem, &offChecksum, &cbChecksum, NULL);
+            if (RT_FAILURE(rc))
+                return rc;
+            if (cbChecksum != (RTFOFF)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, pThis->cbHashDigest,
+                                   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 &)
+                {
+                    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("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)
+{
+    /*
+     * Input validation.
+     */
+    AssertPtrReturn(phVfsFss, VERR_INVALID_HANDLE);
+    *phVfsFss = NIL_RTVFSFSSTREAM;
+    AssertPtrReturn(hVfsIosIn, VERR_INVALID_HANDLE);
+    AssertReturn(!fFlags, VERR_INVALID_PARAMETER);
+
+    RTFOFF const offStart = RTVfsIoStrmTell(hVfsIosIn);
+    AssertReturn(offStart >= 0, (int)offStart);
+
+    uint32_t cRefs = RTVfsIoStrmRetain(hVfsIosIn);
+    AssertReturn(cRefs != UINT32_MAX, VERR_INVALID_HANDLE);
+
+    /*
+     * Read and validate the header, then uncompress the TOC.
+     */
+    XARHEADER XarHdr;
+    int rc = rtZipXarReadAndValidateHeader(hVfsIosIn, &XarHdr);
+    if (RT_SUCCESS(rc))
+    {
+        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, RTFILE_O_READ,
+                                          &hVfsFss, (void **)&pThis);
+                    if (RT_SUCCESS(rc))
+                    {
+                        pThis->hVfsIos              = hVfsIosIn;
+                        pThis->hVfsFile             = RTVfsIoStrmToFile(hVfsIosIn);
+                        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.pCurFile   = 0;
+                        pThis->XarReader.cCurDepth  = 0;
+
+                        /*
+                         * 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;
+    }
+
+    RTVfsIoStrmRelease(hVfsIosIn);
+    return rc;
+}
+
diff --git a/src/VBox/Runtime/common/zip/zip.cpp b/src/VBox/Runtime/common/zip/zip.cpp
new file mode 100644
index 00000000..68c2a9c6
--- /dev/null
+++ b/src/VBox/Runtime/common/zip/zip.cpp
@@ -0,0 +1,2016 @@
+/* $Id: zip.cpp $ */
+/** @file
+ * IPRT - Compression.
+ */
+
+/*
+ * Copyright (C) 2006-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * The contents of this file may alternatively be used under the terms
+ * of the Common Development and Distribution License Version 1.0
+ * (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
+ * in the VirtualBox distribution, in which case the provisions of the
+ * CDDL are applicable instead of those of the GPL.
+ *
+ * You may elect to license modified versions of this file under the
+ * terms and conditions of either the GPL or the CDDL or both.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
+ */
+
+
+/*********************************************************************************************************************************
+*   Defined Constants And Macros                                                                                                 *
+*********************************************************************************************************************************/
+#define RTZIP_USE_STORE 1
+#define RTZIP_USE_ZLIB 1
+//#define RTZIP_USE_BZLIB 1
+#if !defined(IN_GUEST) && !defined(IPRT_NO_CRT)
+# define RTZIP_USE_LZF 1
+#endif
+#define RTZIP_LZF_BLOCK_BY_BLOCK
+//#define RTZIP_USE_LZJB 1
+//#define RTZIP_USE_LZO 1
+
+/** @todo FastLZ? QuickLZ? Others? */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#include <iprt/cdefs.h>
+#ifdef RTZIP_USE_BZLIB
+# include <bzlib.h>
+#endif
+#ifdef RTZIP_USE_ZLIB
+# include <zlib.h>
+#endif
+#ifdef RTZIP_USE_LZF
+ RT_C_DECLS_BEGIN
+#  include <lzf.h>
+ RT_C_DECLS_END
+# include <iprt/crc.h>
+#endif
+#ifdef RTZIP_USE_LZJB
+# include "lzjb.h"
+#endif
+#ifdef RTZIP_USE_LZO
+# include <lzo/lzo1x.h>
+#endif
+
+#include <iprt/zip.h>
+#include "internal/iprt.h"
+
+/*#include <iprt/asm.h>*/
+#include <iprt/alloc.h>
+#include <iprt/assert.h>
+#include <iprt/err.h>
+#include <iprt/log.h>
+#include <iprt/string.h>
+
+#ifndef IPRT_NO_CRT
+# include <errno.h>
+#endif
+
+
+/*********************************************************************************************************************************
+*   Structures and Typedefs                                                                                                      *
+*********************************************************************************************************************************/
+
+#ifdef RTZIP_USE_LZF
+
+/**
+ * LZF block header.
+ */
+#pragma pack(1)                         /* paranoia */
+typedef struct RTZIPLZFHDR
+{
+    /** Magic word (RTZIPLZFHDR_MAGIC). */
+    uint16_t    u16Magic;
+    /** The number of bytes of data following this header. */
+    uint16_t    cbData;
+    /** The CRC32 of the block. */
+    uint32_t    u32CRC;
+    /** The size of the uncompressed data in bytes. */
+    uint16_t    cbUncompressed;
+} RTZIPLZFHDR;
+#pragma pack()
+/** Pointer to a LZF block header. */
+typedef RTZIPLZFHDR *PRTZIPLZFHDR;
+/** Pointer to a const LZF block header. */
+typedef const RTZIPLZFHDR *PCRTZIPLZFHDR;
+
+/** The magic of a LZF block header. */
+#define RTZIPLZFHDR_MAGIC                       ('Z' | ('V' << 8))
+
+/** The max compressed data size.
+ * The maximum size of a block is currently 16KB.
+ * This is very important so we don't have to move input buffers around. */
+#define RTZIPLZF_MAX_DATA_SIZE                  (16384 - sizeof(RTZIPLZFHDR))
+
+/** The max uncompressed data size.
+ * This is important so we don't overflow the spill buffer in the decompressor. */
+#define RTZIPLZF_MAX_UNCOMPRESSED_DATA_SIZE     (32*_1K)
+
+#endif /* RTZIP_USE_LZF */
+
+
+/**
+ * Compressor/Decompressor instance data.
+ */
+typedef struct RTZIPCOMP
+{
+    /** Output buffer. */
+    uint8_t             abBuffer[_128K];
+    /** Compression output consumer. */
+    PFNRTZIPOUT         pfnOut;
+    /** User argument for the callback. */
+    void               *pvUser;
+
+    /**
+     * @copydoc RTZipCompress
+     */
+    DECLCALLBACKMEMBER(int, pfnCompress,(PRTZIPCOMP pZip, const void *pvBuf, size_t cbBuf));
+
+    /**
+     * @copydoc RTZipCompFinish
+     */
+    DECLCALLBACKMEMBER(int, pfnFinish,(PRTZIPCOMP pZip));
+
+    /**
+     * @copydoc RTZipCompDestroy
+     */
+    DECLCALLBACKMEMBER(int, pfnDestroy,(PRTZIPCOMP pZip));
+
+    /** Compression type. */
+    RTZIPTYPE           enmType;
+    /** Type specific data. */
+    union
+    {
+#ifdef RTZIP_USE_STORE
+        /** Simple storing. */
+        struct
+        {
+            /** Current buffer position. (where to start write) */
+            uint8_t    *pb;
+        } Store;
+#endif
+#ifdef RTZIP_USE_ZLIB
+        /** Zlib stream. */
+        z_stream        Zlib;
+#endif
+#ifdef RTZIP_USE_BZLIB
+        /** BZlib stream. */
+        bz_stream       BZlib;
+#endif
+#ifdef RTZIP_USE_LZF
+        /** LZF stream. */
+        struct
+        {
+            /** Current output buffer position. */
+            uint8_t    *pbOutput;
+            /** The input buffer position. */
+            uint8_t    *pbInput;
+            /** The number of free bytes in the input buffer. */
+            size_t      cbInputFree;
+            /** The input buffer. */
+            uint8_t     abInput[RTZIPLZF_MAX_UNCOMPRESSED_DATA_SIZE];
+        } LZF;
+#endif
+
+    } u;
+} RTZIPCOMP;
+
+
+
+/**
+ * Decompressor instance data.
+ */
+typedef struct RTZIPDECOMP
+{
+    /** Input buffer. */
+    uint8_t             abBuffer[_128K];
+    /** Decompression input producer. */
+    PFNRTZIPIN          pfnIn;
+    /** User argument for the callback. */
+    void               *pvUser;
+
+    /**
+     * @copydoc RTZipDecompress
+     */
+    DECLCALLBACKMEMBER(int, pfnDecompress,(PRTZIPDECOMP pZip, void *pvBuf, size_t cbBuf, size_t *pcbWritten));
+
+    /**
+     * @copydoc RTZipDecompDestroy
+     */
+    DECLCALLBACKMEMBER(int, pfnDestroy,(PRTZIPDECOMP pZip));
+
+    /** Compression type. */
+    RTZIPTYPE           enmType;
+    /** Type specific data. */
+    union
+    {
+#ifdef RTZIP_USE_STORE
+        /** Simple storing. */
+        struct
+        {
+            /** Current buffer position. (where to start read) */
+            uint8_t    *pb;
+            /** Number of bytes left in the buffer. */
+            size_t      cbBuffer;
+        } Store;
+#endif
+#ifdef RTZIP_USE_ZLIB
+        /** Zlib stream. */
+        z_stream        Zlib;
+#endif
+#ifdef RTZIP_USE_BZLIB
+        /** BZlib stream. */
+        bz_stream       BZlib;
+#endif
+#ifdef RTZIP_USE_LZF
+        /** LZF 'stream'. */
+        struct
+        {
+# ifndef RTZIP_LZF_BLOCK_BY_BLOCK
+            /** Current input buffer position. */
+            uint8_t    *pbInput;
+            /** The number of bytes left in the input buffer. */
+            size_t      cbInput;
+# endif
+            /** The spill buffer.
+             * LZF is a block based compressor and not a stream compressor. So,
+             * we have to decompress full blocks if we want to get any of the data.
+             * This buffer is to store the spill after decompressing a block. */
+            uint8_t     abSpill[RTZIPLZF_MAX_UNCOMPRESSED_DATA_SIZE];
+            /** The number of bytes left spill buffer. */
+            unsigned    cbSpill;
+            /** The current spill buffer position. */
+            uint8_t    *pbSpill;
+        } LZF;
+#endif
+
+    } u;
+} RTZIPDECOM;
+
+
+
+#ifdef RTZIP_USE_STORE
+
+/**
+ * @copydoc RTZipCompress
+ */
+static DECLCALLBACK(int) rtZipStoreCompress(PRTZIPCOMP pZip, const void *pvBuf, size_t cbBuf)
+{
+    uint8_t *pbDst = pZip->u.Store.pb;
+    while (cbBuf)
+    {
+        /*
+         * Flush.
+         */
+        size_t cb = sizeof(pZip->abBuffer) - (size_t)(pbDst - &pZip->abBuffer[0]); /* careful here, g++ 4.1.2 screws up easily */
+        if (cb == 0)
+        {
+            int rc = pZip->pfnOut(pZip->pvUser, &pZip->abBuffer[0], sizeof(pZip->abBuffer));
+            if (RT_FAILURE(rc))
+                return rc;
+
+            cb = sizeof(pZip->abBuffer);
+            pbDst = &pZip->abBuffer[0];
+        }
+
+        /*
+         * Add to the buffer and advance.
+         */
+        if (cbBuf < cb)
+            cb = cbBuf;
+        memcpy(pbDst, pvBuf, cb);
+
+        pbDst += cb;
+        cbBuf -= cb;
+        pvBuf = (uint8_t *)pvBuf + cb;
+    }
+    pZip->u.Store.pb = pbDst;
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * @copydoc RTZipCompFinish
+ */
+static DECLCALLBACK(int) rtZipStoreCompFinish(PRTZIPCOMP pZip)
+{
+    size_t cb = (uintptr_t)pZip->u.Store.pb - (uintptr_t)&pZip->abBuffer[0];
+    if (cb > 0)
+    {
+        int rc = pZip->pfnOut(pZip->pvUser, &pZip->abBuffer[0], cb);
+        if (RT_FAILURE(rc))
+            return rc;
+    }
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * @copydoc RTZipCompDestroy
+ */
+static DECLCALLBACK(int) rtZipStoreCompDestroy(PRTZIPCOMP pZip)
+{
+    NOREF(pZip);
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * Initializes the compressor instance.
+ * @returns iprt status code.
+ * @param   pZip        The compressor instance.
+ * @param   enmLevel    The desired compression level.
+ */
+static DECLCALLBACK(int) rtZipStoreCompInit(PRTZIPCOMP pZip, RTZIPLEVEL enmLevel)
+{
+    NOREF(enmLevel);
+    pZip->pfnCompress = rtZipStoreCompress;
+    pZip->pfnFinish   = rtZipStoreCompFinish;
+    pZip->pfnDestroy  = rtZipStoreCompDestroy;
+
+    pZip->u.Store.pb = &pZip->abBuffer[1];
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * @copydoc RTZipDecompress
+ */
+static DECLCALLBACK(int) rtZipStoreDecompress(PRTZIPDECOMP pZip, void *pvBuf, size_t cbBuf, size_t *pcbWritten)
+{
+    size_t cbWritten = 0;
+    while (cbBuf)
+    {
+        /*
+         * Fill buffer.
+         */
+        size_t cb = pZip->u.Store.cbBuffer;
+        if (cb <= 0)
+        {
+            int rc = pZip->pfnIn(pZip->pvUser, &pZip->abBuffer[0], sizeof(pZip->abBuffer), &cb);
+            if (RT_FAILURE(rc))
+                return rc;
+            pZip->u.Store.cbBuffer = cb;
+            pZip->u.Store.pb = &pZip->abBuffer[0];
+        }
+
+        /*
+         * No more data?
+         */
+        if (cb == 0)
+        {
+            if (pcbWritten)
+            {
+                *pcbWritten = cbWritten;
+                return VINF_SUCCESS;
+            }
+            return VERR_NO_DATA;
+        }
+
+        /*
+         * Add to the buffer and advance.
+         */
+        if (cbBuf < cb)
+            cb = cbBuf;
+        memcpy(pvBuf, pZip->u.Store.pb, cb);
+        pZip->u.Store.pb += cb;
+        pZip->u.Store.cbBuffer -= cb;
+        cbBuf -= cb;
+        pvBuf = (char *)pvBuf + cb;
+        cbWritten += cb;
+    }
+    if (pcbWritten)
+        *pcbWritten = cbWritten;
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * @copydoc RTZipDecompDestroy
+ */
+static DECLCALLBACK(int) rtZipStoreDecompDestroy(PRTZIPDECOMP pZip)
+{
+    NOREF(pZip);
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * Initialize the decompressor instance.
+ * @returns iprt status code.
+ * @param   pZip        The decompressor instance.
+ */
+static DECLCALLBACK(int) rtZipStoreDecompInit(PRTZIPDECOMP pZip)
+{
+    pZip->pfnDecompress = rtZipStoreDecompress;
+    pZip->pfnDestroy = rtZipStoreDecompDestroy;
+
+    pZip->u.Store.pb = &pZip->abBuffer[0];
+    pZip->u.Store.cbBuffer = 0;
+    return VINF_SUCCESS;
+}
+
+#endif /* RTZIP_USE_STORE */
+
+
+#ifdef RTZIP_USE_ZLIB
+
+/*
+ * Missing definitions from zutil.h. We need these constants for calling
+ * inflateInit2() / deflateInit2().
+ */
+# ifndef Z_DEF_WBITS
+#  define Z_DEF_WBITS        MAX_WBITS
+# endif
+# ifndef Z_DEF_MEM_LEVEL
+#  define Z_DEF_MEM_LEVEL    8
+# endif
+
+/**
+ * Convert from zlib errno to iprt status code.
+ * @returns iprt status code.
+ * @param   rc              Zlib error code.
+ * @param   fCompressing    Set if we're compressing, clear if decompressing.
+ */
+static int zipErrConvertFromZlib(int rc, bool fCompressing)
+{
+    switch (rc)
+    {
+        case Z_OK:
+            return VINF_SUCCESS;
+
+        case Z_STREAM_ERROR:
+            return VERR_ZIP_CORRUPTED;
+
+        case Z_DATA_ERROR:
+            return fCompressing ? VERR_ZIP_ERROR : VERR_ZIP_CORRUPTED;
+
+        case Z_MEM_ERROR:
+            return VERR_ZIP_NO_MEMORY;
+
+        case Z_BUF_ERROR:
+            return VERR_ZIP_ERROR;
+
+        case Z_VERSION_ERROR:
+            return VERR_ZIP_UNSUPPORTED_VERSION;
+
+        case Z_ERRNO: /* We shouldn't see this status! */
+        default:
+            AssertMsgFailed(("%d\n", rc));
+            if (rc >= 0)
+                return VINF_SUCCESS;
+            return VERR_ZIP_ERROR;
+    }
+}
+
+
+/**
+ * @copydoc RTZipCompress
+ */
+static DECLCALLBACK(int) rtZipZlibCompress(PRTZIPCOMP pZip, const void *pvBuf, size_t cbBuf)
+{
+    pZip->u.Zlib.next_in  = (Bytef *)pvBuf;
+    pZip->u.Zlib.avail_in = (uInt)cbBuf;                    Assert(pZip->u.Zlib.avail_in == cbBuf);
+    while (pZip->u.Zlib.avail_in > 0)
+    {
+        /*
+         * Flush output buffer?
+         */
+        if (pZip->u.Zlib.avail_out <= 0)
+        {
+            int rc = pZip->pfnOut(pZip->pvUser, &pZip->abBuffer[0], sizeof(pZip->abBuffer) - pZip->u.Zlib.avail_out);
+            if (RT_FAILURE(rc))
+                return rc;
+            pZip->u.Zlib.avail_out = sizeof(pZip->abBuffer);
+            pZip->u.Zlib.next_out = &pZip->abBuffer[0];
+        }
+
+        /*
+         * Pass it on to zlib.
+         */
+        int rc = deflate(&pZip->u.Zlib, Z_NO_FLUSH);
+        if (rc != Z_OK)
+            return zipErrConvertFromZlib(rc, true /*fCompressing*/);
+    }
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * @copydoc RTZipCompFinish
+ */
+static DECLCALLBACK(int) rtZipZlibCompFinish(PRTZIPCOMP pZip)
+{
+    int rc = Z_OK;
+    for (;;)
+    {
+        /*
+         * Flush outstanding stuff. writes.
+         */
+        if (rc == Z_STREAM_END || pZip->u.Zlib.avail_out <= 0)
+        {
+            int rc2 = pZip->pfnOut(pZip->pvUser, &pZip->abBuffer[0], sizeof(pZip->abBuffer) - pZip->u.Zlib.avail_out);
+            if (RT_FAILURE(rc2))
+                return rc2;
+            pZip->u.Zlib.avail_out = sizeof(pZip->abBuffer);
+            pZip->u.Zlib.next_out = &pZip->abBuffer[0];
+            if (rc == Z_STREAM_END)
+                return VINF_SUCCESS;
+        }
+
+        /*
+         * Tell zlib to flush.
+         */
+        rc = deflate(&pZip->u.Zlib, Z_FINISH);
+        if (rc != Z_OK && rc != Z_STREAM_END)
+            return zipErrConvertFromZlib(rc, true /*fCompressing*/);
+    }
+}
+
+
+/**
+ * @copydoc RTZipCompDestroy
+ */
+static DECLCALLBACK(int) rtZipZlibCompDestroy(PRTZIPCOMP pZip)
+{
+    /*
+     * Terminate the deflate instance.
+     */
+    int rc = deflateEnd(&pZip->u.Zlib);
+    if (rc != Z_OK)
+        rc = zipErrConvertFromZlib(rc, true /*fCompressing*/);
+    return rc;
+}
+
+
+/**
+ * Initializes the compressor instance.
+ * @returns iprt status code.
+ * @param   pZip        The compressor instance.
+ * @param   enmLevel    The desired compression level.
+ * @param   fZlibHeader If true, write the Zlib header.
+ */
+static DECLCALLBACK(int) rtZipZlibCompInit(PRTZIPCOMP pZip, RTZIPLEVEL enmLevel, bool fZlibHeader)
+{
+    pZip->pfnCompress = rtZipZlibCompress;
+    pZip->pfnFinish   = rtZipZlibCompFinish;
+    pZip->pfnDestroy  = rtZipZlibCompDestroy;
+
+    int iLevel = Z_DEFAULT_COMPRESSION;
+    switch (enmLevel)
+    {
+        case RTZIPLEVEL_STORE:      iLevel = 0; break;
+        case RTZIPLEVEL_FAST:       iLevel = 2; break;
+        case RTZIPLEVEL_DEFAULT:    iLevel = Z_DEFAULT_COMPRESSION; break;
+        case RTZIPLEVEL_MAX:        iLevel = 9; break;
+    }
+
+    memset(&pZip->u.Zlib, 0, sizeof(pZip->u.Zlib));
+    pZip->u.Zlib.next_out  = &pZip->abBuffer[1];
+    pZip->u.Zlib.avail_out = sizeof(pZip->abBuffer) - 1;
+    pZip->u.Zlib.opaque    = pZip;
+
+    int rc = deflateInit2(&pZip->u.Zlib, iLevel, Z_DEFLATED, fZlibHeader ? Z_DEF_WBITS : -Z_DEF_WBITS,
+                          Z_DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY);
+    return rc >= 0 ? rc = VINF_SUCCESS : zipErrConvertFromZlib(rc, true /*fCompressing*/);
+}
+
+
+/**
+ * @copydoc RTZipDecompress
+ */
+static DECLCALLBACK(int) rtZipZlibDecompress(PRTZIPDECOMP pZip, void *pvBuf, size_t cbBuf, size_t *pcbWritten)
+{
+    pZip->u.Zlib.next_out = (Bytef *)pvBuf;
+    pZip->u.Zlib.avail_out = (uInt)cbBuf;
+    Assert(pZip->u.Zlib.avail_out == cbBuf);
+
+    /*
+     * Be greedy reading input, even if no output buffer is left. It's possible
+     * that it's just the end of stream marker which needs to be read. Happens
+     * for incompressible blocks just larger than the input buffer size.
+     */
+    while (pZip->u.Zlib.avail_out > 0 || pZip->u.Zlib.avail_in <= 0)
+    {
+        /*
+         * Read more input?
+         */
+        if (pZip->u.Zlib.avail_in <= 0)
+        {
+            size_t cb = sizeof(pZip->abBuffer);
+            int rc = pZip->pfnIn(pZip->pvUser, &pZip->abBuffer[0], sizeof(pZip->abBuffer), &cb);
+            if (RT_FAILURE(rc))
+                return rc;
+            pZip->u.Zlib.avail_in = (uInt)cb;               Assert(pZip->u.Zlib.avail_in == cb);
+            pZip->u.Zlib.next_in = &pZip->abBuffer[0];
+        }
+
+        /*
+         * Pass it on to zlib.
+         */
+        int rc = inflate(&pZip->u.Zlib, Z_NO_FLUSH);
+        if (rc == Z_STREAM_END)
+        {
+            if (pcbWritten)
+                *pcbWritten = cbBuf - pZip->u.Zlib.avail_out;
+            else if (pZip->u.Zlib.avail_out > 0)
+                return VERR_NO_DATA;
+            break;
+        }
+        if (rc != Z_OK)
+            return zipErrConvertFromZlib(rc, false /*fCompressing*/);
+    }
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * @copydoc RTZipDecompDestroy
+ */
+static DECLCALLBACK(int) rtZipZlibDecompDestroy(PRTZIPDECOMP pZip)
+{
+    /*
+     * Terminate the deflate instance.
+     */
+    int rc = inflateEnd(&pZip->u.Zlib);
+    if (rc != Z_OK)
+        rc = zipErrConvertFromZlib(rc, false /*fCompressing*/);
+    return rc;
+}
+
+
+/**
+ * Initialize the decompressor instance.
+ * @returns iprt status code.
+ * @param   pZip        The decompressor instance.
+ * @param   fZlibHeader If true, expect the Zlib header.
+ */
+static DECLCALLBACK(int) rtZipZlibDecompInit(PRTZIPDECOMP pZip, bool fZlibHeader)
+{
+    pZip->pfnDecompress = rtZipZlibDecompress;
+    pZip->pfnDestroy = rtZipZlibDecompDestroy;
+
+    memset(&pZip->u.Zlib, 0, sizeof(pZip->u.Zlib));
+    pZip->u.Zlib.opaque    = pZip;
+
+    int rc = inflateInit2(&pZip->u.Zlib, fZlibHeader ? Z_DEF_WBITS : -Z_DEF_WBITS);
+    return rc >= 0 ? VINF_SUCCESS : zipErrConvertFromZlib(rc, false /*fCompressing*/);
+}
+
+#endif /* RTZIP_USE_ZLIB */
+
+
+#ifdef RTZIP_USE_BZLIB
+/**
+ * Convert from BZlib errno to iprt status code.
+ * @returns iprt status code.
+ * @param   rc      BZlib error code.
+ */
+static int zipErrConvertFromBZlib(int rc)
+{
+    /** @todo proper bzlib error conversion. */
+    switch (rc)
+    {
+        case BZ_SEQUENCE_ERROR:
+            AssertMsgFailed(("BZ_SEQUENCE_ERROR shall not happen!\n"));
+            return VERR_GENERAL_FAILURE;
+        case BZ_PARAM_ERROR:
+            return VERR_INVALID_PARAMETER;
+        case BZ_MEM_ERROR:
+            return VERR_NO_MEMORY;
+        case BZ_DATA_ERROR:
+        case BZ_DATA_ERROR_MAGIC:
+        case BZ_IO_ERROR:
+        case BZ_UNEXPECTED_EOF:
+        case BZ_CONFIG_ERROR:
+            return VERR_GENERAL_FAILURE;
+        case BZ_OUTBUFF_FULL:
+            AssertMsgFailed(("BZ_OUTBUFF_FULL shall not happen!\n"));
+            return VERR_GENERAL_FAILURE;
+        default:
+            if (rc >= 0)
+                return VINF_SUCCESS;
+            return VERR_GENERAL_FAILURE;
+    }
+}
+
+
+/**
+ * @copydoc RTZipCompress
+ */
+static DECLCALLBACK(int) rtZipBZlibCompress(PRTZIPCOMP pZip, const void *pvBuf, size_t cbBuf)
+{
+    pZip->u.BZlib.next_in  = (char *)pvBuf;
+    pZip->u.BZlib.avail_in = cbBuf;
+    while (pZip->u.BZlib.avail_in > 0)
+    {
+        /*
+         * Flush output buffer?
+         */
+        if (pZip->u.BZlib.avail_out <= 0)
+        {
+            int rc = pZip->pfnOut(pZip->pvUser, &pZip->abBuffer[0], sizeof(pZip->abBuffer) - pZip->u.BZlib.avail_out);
+            if (RT_FAILURE(rc))
+                return rc;
+            pZip->u.BZlib.avail_out = sizeof(pZip->abBuffer);
+            pZip->u.BZlib.next_out = (char *)&pZip->abBuffer[0];
+        }
+
+        /*
+         * Pass it on to zlib.
+         */
+        int rc = BZ2_bzCompress(&pZip->u.BZlib, BZ_RUN);
+        if (rc < 0 && rc != BZ_OUTBUFF_FULL)
+            return zipErrConvertFromBZlib(rc);
+    }
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * @copydoc RTZipCompFinish
+ */
+static DECLCALLBACK(int) rtZipBZlibCompFinish(PRTZIPCOMP pZip)
+{
+    int rc = BZ_FINISH_OK;
+    for (;;)
+    {
+        /*
+         * Flush output buffer?
+         */
+        if (rc == BZ_STREAM_END || pZip->u.BZlib.avail_out <= 0)
+        {
+            int rc2 = pZip->pfnOut(pZip->pvUser, &pZip->abBuffer[0], sizeof(pZip->abBuffer) - pZip->u.BZlib.avail_out);
+            if (RT_FAILURE(rc2))
+                return rc2;
+            pZip->u.BZlib.avail_out = sizeof(pZip->abBuffer);
+            pZip->u.BZlib.next_out = (char *)&pZip->abBuffer[0];
+            if (rc == BZ_STREAM_END)
+                return VINF_SUCCESS;
+        }
+
+        /*
+         * Tell BZlib to finish it.
+         */
+        rc = BZ2_bzCompress(&pZip->u.BZlib, BZ_FINISH);
+        if (rc < 0 && rc != BZ_OUTBUFF_FULL)
+            return zipErrConvertFromBZlib(rc);
+    }
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * @copydoc RTZipCompDestroy
+ */
+static DECLCALLBACK(int) rtZipBZlibCompDestroy(PRTZIPCOMP pZip)
+{
+    /*
+     * Terminate the deflate instance.
+     */
+    int rc = BZ2_bzCompressEnd(&pZip->u.BZlib);
+    if (rc != BZ_OK)
+        rc = zipErrConvertFromBZlib(rc);
+    return rc;
+}
+
+
+/**
+ * Initializes the compressor instance.
+ * @returns iprt status code.
+ * @param   pZip        The compressor instance.
+ * @param   enmLevel    The desired compression level.
+ */
+static DECLCALLBACK(int) rtZipBZlibCompInit(PRTZIPCOMP pZip, RTZIPLEVEL enmLevel)
+{
+    pZip->pfnCompress = rtZipBZlibCompress;
+    pZip->pfnFinish   = rtZipBZlibCompFinish;
+    pZip->pfnDestroy  = rtZipBZlibCompDestroy;
+
+    int iSize = 6;
+    int iWork = 0;
+    switch (enmLevel)
+    {
+        case RTZIPLEVEL_STORE:      iSize = 1; iWork = 2; break;
+        case RTZIPLEVEL_FAST:       iSize = 2; iWork = 0; break;
+        case RTZIPLEVEL_DEFAULT:    iSize = 5; iWork = 0; break;
+        case RTZIPLEVEL_MAX:        iSize = 9; iWork = 0; break;
+    }
+
+    memset(&pZip->u.BZlib, 0, sizeof(pZip->u.BZlib));
+    pZip->u.BZlib.next_out  = (char *)&pZip->abBuffer[1];
+    pZip->u.BZlib.avail_out = sizeof(pZip->abBuffer) - 1;
+    pZip->u.BZlib.opaque    = pZip;
+
+    int rc = BZ2_bzCompressInit(&pZip->u.BZlib, iSize, 0, iWork);
+    return rc >= 0 ? VINF_SUCCESS : zipErrConvertFromBZlib(rc);;
+}
+
+
+/**
+ * @copydoc RTZipDecompress
+ */
+static DECLCALLBACK(int) rtZipBZlibDecompress(PRTZIPDECOMP pZip, void *pvBuf, size_t cbBuf, size_t *pcbWritten)
+{
+    pZip->u.BZlib.next_out  = (char *)pvBuf;
+    pZip->u.BZlib.avail_out = cbBuf;
+    while (pZip->u.BZlib.avail_out > 0)
+    {
+        /*
+         * Read more output buffer?
+         */
+        if (pZip->u.BZlib.avail_in <= 0)
+        {
+            size_t cb;
+            int rc = pZip->pfnIn(pZip->pvUser, &pZip->abBuffer[0], sizeof(pZip->abBuffer), &cb);
+            if (RT_FAILURE(rc))
+                return rc;
+            pZip->u.BZlib.avail_in = cb;
+            pZip->u.BZlib.next_in = (char *)&pZip->abBuffer[0];
+        }
+
+        /*
+         * Pass it on to zlib.
+         */
+        int rc = BZ2_bzDecompress(&pZip->u.BZlib);
+        if (rc == BZ_STREAM_END || rc == BZ_OUTBUFF_FULL)
+        {
+            if (pcbWritten)
+                *pcbWritten = cbBuf - pZip->u.BZlib.avail_out;
+            else if (pZip->u.BZlib.avail_out > 0)
+                return VERR_NO_DATA;
+            break;
+        }
+        if (rc < 0)
+            return zipErrConvertFromBZlib(rc);
+    }
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * @copydoc RTZipDecompDestroy
+ */
+static DECLCALLBACK(int) rtZipBZlibDecompDestroy(PRTZIPDECOMP pZip)
+{
+    /*
+     * Terminate the deflate instance.
+     */
+    int rc = BZ2_bzDecompressEnd(&pZip->u.BZlib);
+    if (rc != BZ_OK)
+        rc = zipErrConvertFromBZlib(rc);
+    return rc;
+}
+
+
+/**
+ * Initialize the decompressor instance.
+ * @returns iprt status code.
+ * @param   pZip        The decompressor instance.
+ */
+static DECLCALLBACK(int) rtZipBZlibDecompInit(PRTZIPDECOMP pZip)
+{
+    pZip->pfnDecompress = rtZipBZlibDecompress;
+    pZip->pfnDestroy = rtZipBZlibDecompDestroy;
+
+    memset(&pZip->u.BZlib, 0, sizeof(pZip->u.BZlib));
+    pZip->u.BZlib.opaque    = pZip;
+
+    int rc = BZ2_bzDecompressInit(&pZip->u.BZlib, 0, 0);
+    return rc >= 0 ? VINF_SUCCESS : zipErrConvertFromBZlib(rc);
+}
+
+#endif /* RTZIP_USE_BZLIB */
+
+
+#ifdef RTZIP_USE_LZF
+
+/**
+ * Flushes the output buffer.
+ * @returns iprt status code.
+ * @param   pZip        The compressor instance.
+ */
+static int rtZipLZFCompFlushOutput(PRTZIPCOMP pZip)
+{
+    size_t      cb = pZip->u.LZF.pbOutput - &pZip->abBuffer[0];
+    pZip->u.LZF.pbOutput = &pZip->abBuffer[0];
+    return pZip->pfnOut(pZip->pvUser, &pZip->abBuffer[0], cb);
+}
+
+
+/**
+ * Compresses a buffer using LZF.
+ *
+ * @returns VBox status code.
+ * @param   pZip        The compressor instance.
+ * @param   pbBuf       What to compress.
+ * @param   cbBuf       How much to compress.
+ */
+static int rtZipLZFCompressBuffer(PRTZIPCOMP pZip, const uint8_t *pbBuf, size_t cbBuf)
+{
+    bool fForceFlush = false;
+    while (cbBuf > 0)
+    {
+        /*
+         * Flush output buffer?
+         */
+        unsigned cbFree = (unsigned)(sizeof(pZip->abBuffer) - (pZip->u.LZF.pbOutput - &pZip->abBuffer[0]));
+        if (    fForceFlush
+            ||  cbFree < RTZIPLZF_MAX_DATA_SIZE + sizeof(RTZIPLZFHDR))
+        {
+            int rc = rtZipLZFCompFlushOutput(pZip);
+            if (RT_FAILURE(rc))
+                return rc;
+            fForceFlush = false;
+            cbFree = sizeof(pZip->abBuffer);
+        }
+
+        /*
+         * Setup the block header.
+         */
+        PRTZIPLZFHDR pHdr = (PRTZIPLZFHDR)pZip->u.LZF.pbOutput; /* warning: This might be unaligned! */
+        pHdr->u16Magic = RTZIPLZFHDR_MAGIC;
+        pHdr->cbData = 0;
+        pHdr->u32CRC = 0;
+        pHdr->cbUncompressed = 0;
+        cbFree -= sizeof(*pHdr);
+        pZip->u.LZF.pbOutput += sizeof(*pHdr);
+
+        /*
+         * Compress data for the block.
+         *
+         * We try compress as much as we have freespace for at first,
+         * but if it turns out the compression is inefficient, we'll
+         * reduce the size of data we try compress till it fits the
+         * output space.
+         */
+        cbFree = RT_MIN(cbFree, RTZIPLZF_MAX_DATA_SIZE);
+        unsigned cbInput = (unsigned)RT_MIN(RTZIPLZF_MAX_UNCOMPRESSED_DATA_SIZE, cbBuf);
+        unsigned cbOutput = lzf_compress(pbBuf, cbInput, pZip->u.LZF.pbOutput, cbFree);
+        if (!cbOutput)
+        {
+            /** @todo add an alternative method which stores the raw data if bad compression. */
+            do
+            {
+                cbInput /= 2;
+                if (!cbInput)
+                {
+                    AssertMsgFailed(("lzf_compress bug! cbFree=%zu\n", cbFree));
+                    return VERR_INTERNAL_ERROR;
+                }
+                cbOutput = lzf_compress(pbBuf, cbInput, pZip->u.LZF.pbOutput, cbFree);
+            } while (!cbOutput);
+            fForceFlush = true;
+        }
+
+        /*
+         * Update the header and advance the input buffer.
+         */
+        pHdr->cbData = cbOutput;
+        //pHdr->u32CRC = RTCrc32(pbBuf, cbInput); - too slow
+        pHdr->cbUncompressed = cbInput;
+
+        pZip->u.LZF.pbOutput += cbOutput;
+        cbBuf -= cbInput;
+        pbBuf += cbInput;
+    }
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * Flushes the input buffer.
+ * @returns iprt status code.
+ * @param   pZip        The compressor instance.
+ */
+static int rtZipLZFCompFlushInput(PRTZIPCOMP pZip)
+{
+    size_t cb = pZip->u.LZF.pbInput - &pZip->u.LZF.abInput[0];
+    pZip->u.LZF.pbInput = &pZip->u.LZF.abInput[0];
+    pZip->u.LZF.cbInputFree = sizeof(pZip->u.LZF.abInput);
+    if (cb)
+        return rtZipLZFCompressBuffer(pZip, pZip->u.LZF.abInput, cb);
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * @copydoc RTZipCompress
+ */
+static DECLCALLBACK(int) rtZipLZFCompress(PRTZIPCOMP pZip, const void *pvBuf, size_t cbBuf)
+{
+#define RTZIPLZF_SMALL_CHUNK (128)
+
+    /*
+     * Flush the input buffer if necessary.
+     */
+    if (    (   cbBuf <= RTZIPLZF_SMALL_CHUNK
+             && cbBuf > pZip->u.LZF.cbInputFree)
+        ||  (   cbBuf > RTZIPLZF_SMALL_CHUNK
+             && pZip->u.LZF.cbInputFree != sizeof(pZip->u.LZF.abInput))
+       )
+    {
+        int rc = rtZipLZFCompFlushInput(pZip);
+        if (RT_FAILURE(rc))
+            return rc;
+    }
+
+    /*
+     * If it's a relativly small block put it in the input buffer, elsewise
+     * compress directly it.
+     */
+    if (cbBuf <= RTZIPLZF_SMALL_CHUNK)
+    {
+        Assert(pZip->u.LZF.cbInputFree >= cbBuf);
+        memcpy(pZip->u.LZF.pbInput, pvBuf, cbBuf);
+        pZip->u.LZF.pbInput += cbBuf;
+        pZip->u.LZF.cbInputFree -= cbBuf;
+    }
+    else
+    {
+        Assert(pZip->u.LZF.cbInputFree == sizeof(pZip->u.LZF.abInput));
+        int rc = rtZipLZFCompressBuffer(pZip, (const uint8_t *)pvBuf, cbBuf);
+        if (RT_FAILURE(rc))
+            return rc;
+    }
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * @copydoc RTZipCompFinish
+ */
+static DECLCALLBACK(int) rtZipLZFCompFinish(PRTZIPCOMP pZip)
+{
+    int rc = rtZipLZFCompFlushInput(pZip);
+    if (RT_SUCCESS(rc))
+        rc = rtZipLZFCompFlushOutput(pZip);
+    return rc;
+}
+
+
+/**
+ * @copydoc RTZipCompDestroy
+ */
+static DECLCALLBACK(int) rtZipLZFCompDestroy(PRTZIPCOMP pZip)
+{
+    NOREF(pZip);
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * Initializes the compressor instance.
+ * @returns iprt status code.
+ * @param   pZip        The compressor instance.
+ * @param   enmLevel    The desired compression level.
+ */
+static DECLCALLBACK(int) rtZipLZFCompInit(PRTZIPCOMP pZip, RTZIPLEVEL enmLevel)
+{
+    NOREF(enmLevel);
+    pZip->pfnCompress = rtZipLZFCompress;
+    pZip->pfnFinish   = rtZipLZFCompFinish;
+    pZip->pfnDestroy  = rtZipLZFCompDestroy;
+
+    pZip->u.LZF.pbOutput = &pZip->abBuffer[1];
+    pZip->u.LZF.pbInput  = &pZip->u.LZF.abInput[0];
+    pZip->u.LZF.cbInputFree = sizeof(pZip->u.LZF.abInput);
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * This will validate a header and to all the necessary bitching if it's invalid.
+ * @returns true if valid.
+ * @returns false if invalid.
+ * @param   pHdr        Pointer to the header.\
+ */
+static bool rtZipLZFValidHeader(PCRTZIPLZFHDR pHdr)
+{
+    if (    pHdr->u16Magic != RTZIPLZFHDR_MAGIC
+        ||  !pHdr->cbData
+        ||  pHdr->cbData > RTZIPLZF_MAX_DATA_SIZE
+        ||  !pHdr->cbUncompressed
+        ||  pHdr->cbUncompressed > RTZIPLZF_MAX_UNCOMPRESSED_DATA_SIZE
+       )
+    {
+        AssertMsgFailed(("Invalid LZF header! %.*Rhxs\n", sizeof(*pHdr), pHdr));
+        return false;
+    }
+    return true;
+}
+
+
+/**
+ * @copydoc RTZipDecompress
+ */
+static DECLCALLBACK(int) rtZipLZFDecompress(PRTZIPDECOMP pZip, void *pvBuf, size_t cbBuf, size_t *pcbWritten)
+{
+    /*
+     * Decompression loop.
+     *
+     * This a bit ugly because we have to deal with reading block...
+     * To simplify matters we've put a max block size and will never
+     * fill the input buffer with more than allows us to complete
+     * any partially read blocks.
+     *
+     * When possible we decompress directly to the user buffer, when
+     * not possible we'll use the spill buffer.
+     */
+# ifdef RTZIP_LZF_BLOCK_BY_BLOCK
+    size_t cbWritten = 0;
+    while (cbBuf > 0)
+    {
+        /*
+         * Anything in the spill buffer?
+         */
+        if (pZip->u.LZF.cbSpill > 0)
+        {
+            unsigned cb = (unsigned)RT_MIN(pZip->u.LZF.cbSpill, cbBuf);
+            memcpy(pvBuf, pZip->u.LZF.pbSpill, cb);
+            pZip->u.LZF.pbSpill += cb;
+            pZip->u.LZF.cbSpill -= cb;
+            cbWritten += cb;
+            cbBuf -= cb;
+            if (!cbBuf)
+                break;
+            pvBuf = (uint8_t *)pvBuf + cb;
+        }
+
+        /*
+         * We always read and work one block at a time.
+         */
+        RTZIPLZFHDR Hdr;
+        int rc = pZip->pfnIn(pZip->pvUser, &Hdr, sizeof(Hdr), NULL);
+        if (RT_FAILURE(rc))
+            return rc;
+        if (!rtZipLZFValidHeader(&Hdr))
+            return VERR_GENERAL_FAILURE; /** @todo Get better error codes for RTZip! */
+        if (Hdr.cbData > 0)
+        {
+            rc = pZip->pfnIn(pZip->pvUser, &pZip->abBuffer[0], Hdr.cbData, NULL);
+            if (RT_FAILURE(rc))
+                return rc;
+        }
+
+        /*
+         * Does the uncompressed data fit into the supplied buffer?
+         * If so we uncompress it directly into the user buffer, else we'll have to use the spill buffer.
+         */
+        unsigned cbUncompressed = Hdr.cbUncompressed;
+        if (cbUncompressed <= cbBuf)
+        {
+            unsigned cbOutput = lzf_decompress(&pZip->abBuffer[0], Hdr.cbData, pvBuf, cbUncompressed);
+            if (cbOutput != cbUncompressed)
+            {
+# ifndef IPRT_NO_CRT /* no errno */
+                AssertMsgFailed(("Decompression error, errno=%d. cbOutput=%#x cbUncompressed=%#x\n",
+                                 errno, cbOutput, cbUncompressed));
+# endif
+                return VERR_GENERAL_FAILURE; /** @todo Get better error codes for RTZip! */
+            }
+            cbBuf -= cbUncompressed;
+            pvBuf = (uint8_t *)pvBuf + cbUncompressed;
+            cbWritten += cbUncompressed;
+        }
+        else
+        {
+            unsigned cbOutput = lzf_decompress(&pZip->abBuffer[0], Hdr.cbData, pZip->u.LZF.abSpill, cbUncompressed);
+            if (cbOutput != cbUncompressed)
+            {
+# ifndef IPRT_NO_CRT /* no errno */
+                AssertMsgFailed(("Decompression error, errno=%d. cbOutput=%#x cbUncompressed=%#x\n",
+                                 errno, cbOutput, cbUncompressed));
+# endif
+                return VERR_GENERAL_FAILURE; /** @todo Get better error codes for RTZip! */
+            }
+            pZip->u.LZF.pbSpill = &pZip->u.LZF.abSpill[0];
+            pZip->u.LZF.cbSpill = cbUncompressed;
+        }
+    }
+
+    if (pcbWritten)
+        *pcbWritten = cbWritten;
+# else  /* !RTZIP_LZF_BLOCK_BY_BLOCK */
+    while (cbBuf > 0)
+    {
+        /*
+         * Anything in the spill buffer?
+         */
+        if (pZip->u.LZF.cbSpill > 0)
+        {
+            unsigned cb = (unsigned)RT_MIN(pZip->u.LZF.cbSpill, cbBuf);
+            memcpy(pvBuf, pZip->u.LZF.pbSpill, cb);
+            pZip->u.LZF.pbSpill += cb;
+            pZip->u.LZF.cbSpill -= cb;
+            cbBuf -= cb;
+            if (pcbWritten)
+                *pcbWritten = cb;
+            if (!cbBuf)
+                break;
+            pvBuf = (uint8_t *)pvBuf + cb;
+        }
+
+        /*
+         * Incomplete header or nothing at all.
+         */
+        PCRTZIPLZFHDR pHdr;
+        if (pZip->u.LZF.cbInput < sizeof(RTZIPLZFHDR))
+        {
+            if (pZip->u.LZF.cbInput <= 0)
+            {
+                /* empty, fill the buffer. */
+                size_t cb = 0;
+                int rc = pZip->pfnIn(pZip->pvUser, &pZip->abBuffer[0],
+                                     sizeof(pZip->abBuffer) - RTZIPLZF_MAX_DATA_SIZE, &cb);
+                if (RT_FAILURE(rc))
+                    return rc;
+                pZip->u.LZF.pbInput = &pZip->abBuffer[0];
+                pZip->u.LZF.cbInput = cb;
+                pHdr = (PCRTZIPLZFHDR)pZip->u.LZF.pbInput;
+            }
+            else
+            {
+                /* move the header up and fill the buffer. */
+                size_t cbCur = pZip->u.LZF.cbInput;
+                memmove(&pZip->abBuffer[0], pZip->u.LZF.pbInput, cbCur);
+                pZip->u.LZF.pbInput = &pZip->abBuffer[0];
+
+                size_t cb = 0;
+                int rc = pZip->pfnIn(pZip->pvUser, &pZip->abBuffer[cbCur],
+                                     sizeof(pZip->abBuffer) - RTZIPLZF_MAX_DATA_SIZE - cbCur, &cb);
+                if (RT_FAILURE(rc))
+                    return rc;
+                pHdr = (PCRTZIPLZFHDR)pZip->u.LZF.pbInput;
+                pZip->u.LZF.cbInput += cb;
+            }
+
+            /*
+             * Validate the header.
+             */
+            if (!rtZipLZFValidHeader(pHdr))
+                return VERR_GENERAL_FAILURE; /** @todo Get better error codes for RTZip! */
+        }
+        else
+        {
+            /*
+             * Validate the header and check if it's an incomplete block.
+             */
+            pHdr = (PCRTZIPLZFHDR)pZip->u.LZF.pbInput;
+            if (!rtZipLZFValidHeader(pHdr))
+                return VERR_GENERAL_FAILURE; /** @todo Get better error codes for RTZip! */
+
+            if (pHdr->cbData > pZip->u.LZF.cbInput - sizeof(*pHdr))
+            {
+                /* read the remainder of the block. */
+                size_t cbToRead = pHdr->cbData - (pZip->u.LZF.cbInput - sizeof(*pHdr));
+                Assert(&pZip->u.LZF.pbInput[pZip->u.LZF.cbInput + cbToRead] <= &pZip->u.LZF.pbInput[sizeof(pZip->abBuffer)]);
+                int rc = pZip->pfnIn(pZip->pvUser, &pZip->u.LZF.pbInput[pZip->u.LZF.cbInput],
+                                     cbToRead, NULL);
+                if (RT_FAILURE(rc))
+                    return rc;
+                pZip->u.LZF.cbInput += cbToRead;
+            }
+        }
+        AssertMsgReturn(sizeof(*pHdr) + pHdr->cbData <= pZip->u.LZF.cbInput,
+                        ("cbData=%#x cbInput=%#x\n", pHdr->cbData, pZip->u.LZF.cbInput),
+                        VERR_GENERAL_FAILURE); /** @todo Get better error codes for RTZip! */
+
+        /*
+         * Does the uncompressed data fit into the supplied buffer?
+         * If so we uncompress it directly into the user buffer, else we'll have to use the spill buffer.
+         */
+        unsigned cbUncompressed = pHdr->cbUncompressed;
+        if (cbUncompressed <= cbBuf)
+        {
+            unsigned cbOutput = lzf_decompress(pHdr + 1, pHdr->cbData, pvBuf, cbUncompressed);
+            if (cbOutput != cbUncompressed)
+            {
+                AssertMsgFailed(("Decompression error, errno=%d. cbOutput=%#x cbUncompressed=%#x\n",
+                                 errno, cbOutput, cbUncompressed));
+                return VERR_GENERAL_FAILURE; /** @todo Get better error codes for RTZip! */
+            }
+            cbBuf -= cbUncompressed;
+            pvBuf = (uint8_t *)pvBuf + cbUncompressed;
+        }
+        else
+        {
+            unsigned cbOutput = lzf_decompress(pHdr + 1, pHdr->cbData, pZip->u.LZF.abSpill, cbUncompressed);
+            if (cbOutput != cbUncompressed)
+            {
+                AssertMsgFailed(("Decompression error, errno=%d. cbOutput=%#x cbUncompressed=%#x\n",
+                                 errno, cbOutput, cbUncompressed));
+                return VERR_GENERAL_FAILURE; /** @todo Get better error codes for RTZip! */
+            }
+            pZip->u.LZF.pbSpill = &pZip->u.LZF.abSpill[0];
+            pZip->u.LZF.cbSpill = cbUncompressed;
+        }
+
+        /* advance the input buffer */
+        pZip->u.LZF.cbInput -= pHdr->cbData + sizeof(*pHdr);
+        pZip->u.LZF.pbInput += pHdr->cbData + sizeof(*pHdr);
+        if (pcbWritten)
+            *pcbWritten += cbUncompressed;
+    }
+# endif /* !RTZIP_LZF_BLOCK_BY_BLOCK */
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * @copydoc RTZipDecompDestroy
+ */
+static DECLCALLBACK(int) rtZipLZFDecompDestroy(PRTZIPDECOMP pZip)
+{
+    NOREF(pZip);
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * Initialize the decompressor instance.
+ * @returns iprt status code.
+ * @param   pZip        The decompressor instance.
+ */
+static DECLCALLBACK(int) rtZipLZFDecompInit(PRTZIPDECOMP pZip)
+{
+    pZip->pfnDecompress = rtZipLZFDecompress;
+    pZip->pfnDestroy = rtZipLZFDecompDestroy;
+
+# ifndef RTZIP_LZF_BLOCK_BY_BLOCK
+    pZip->u.LZF.pbInput    = NULL;
+    pZip->u.LZF.cbInput    = 0;
+# endif
+    pZip->u.LZF.cbSpill    = 0;
+    pZip->u.LZF.pbSpill    = NULL;
+
+    return VINF_SUCCESS;
+}
+
+#endif /* RTZIP_USE_LZF */
+
+
+/**
+ * Create a compressor instance.
+ *
+ * @returns iprt status code.
+ * @param   ppZip       Where to store the instance handle.
+ * @param   pvUser      User argument which will be passed on to pfnOut and pfnIn.
+ * @param   pfnOut      Callback for consuming output of compression.
+ * @param   enmType     Type of compressor to create.
+ * @param   enmLevel    Compression level.
+ */
+RTDECL(int)     RTZipCompCreate(PRTZIPCOMP *ppZip, void *pvUser, PFNRTZIPOUT pfnOut, RTZIPTYPE enmType, RTZIPLEVEL enmLevel)
+{
+    /*
+     * Validate input.
+     */
+    AssertReturn(enmType >= RTZIPTYPE_INVALID && enmType < RTZIPTYPE_END, VERR_INVALID_PARAMETER);
+    AssertReturn(enmLevel >= RTZIPLEVEL_STORE && enmLevel <= RTZIPLEVEL_MAX, VERR_INVALID_PARAMETER);
+    AssertPtrReturn(pfnOut, VERR_INVALID_POINTER);
+    AssertPtrReturn(ppZip, VERR_INVALID_POINTER);
+
+    /*
+     * Allocate memory for the instance data.
+     */
+    PRTZIPCOMP pZip = (PRTZIPCOMP)RTMemAlloc(sizeof(RTZIPCOMP));
+    if (!pZip)
+        return VERR_NO_MEMORY;
+
+    /*
+     * Determine auto type.
+     */
+    if (enmType == RTZIPTYPE_AUTO)
+    {
+        if (enmLevel == RTZIPLEVEL_STORE)
+            enmType = RTZIPTYPE_STORE;
+        else
+        {
+#if defined(RTZIP_USE_ZLIB) && defined(RTZIP_USE_BZLIB)
+            if (enmLevel == RTZIPLEVEL_MAX)
+                enmType = RTZIPTYPE_BZLIB;
+            else
+                enmType = RTZIPTYPE_ZLIB;
+#elif defined(RTZIP_USE_ZLIB)
+            enmType = RTZIPTYPE_ZLIB;
+#elif defined(RTZIP_USE_BZLIB)
+            enmType = RTZIPTYPE_BZLIB;
+#else
+            enmType = RTZIPTYPE_STORE;
+#endif
+        }
+    }
+
+    /*
+     * Init instance.
+     */
+    pZip->pfnOut  = pfnOut;
+    pZip->enmType = enmType;
+    pZip->pvUser  = pvUser;
+    pZip->abBuffer[0] = enmType;       /* first byte is the compression type. */
+    int rc = VERR_NOT_IMPLEMENTED;
+    switch (enmType)
+    {
+        case RTZIPTYPE_STORE:
+#ifdef RTZIP_USE_STORE
+            rc = rtZipStoreCompInit(pZip, enmLevel);
+#endif
+            break;
+
+        case RTZIPTYPE_ZLIB:
+        case RTZIPTYPE_ZLIB_NO_HEADER:
+#ifdef RTZIP_USE_ZLIB
+            rc = rtZipZlibCompInit(pZip, enmLevel, enmType == RTZIPTYPE_ZLIB /*fZlibHeader*/);
+#endif
+            break;
+
+        case RTZIPTYPE_BZLIB:
+#ifdef RTZIP_USE_BZLIB
+            rc = rtZipBZlibCompInit(pZip, enmLevel);
+#endif
+            break;
+
+        case RTZIPTYPE_LZF:
+#ifdef RTZIP_USE_LZF
+            rc = rtZipLZFCompInit(pZip, enmLevel);
+#endif
+            break;
+
+        case RTZIPTYPE_LZJB:
+        case RTZIPTYPE_LZO:
+            break;
+
+        default:
+            AssertFailedBreak();
+    }
+
+    if (RT_SUCCESS(rc))
+        *ppZip = pZip;
+    else
+        RTMemFree(pZip);
+    return rc;
+}
+RT_EXPORT_SYMBOL(RTZipCompCreate);
+
+
+/**
+ * Compresses a chunk of memory.
+ *
+ * @returns iprt status code.
+ * @param   pZip        The compressor instance.
+ * @param   pvBuf       Pointer to buffer containing the bits to compress.
+ * @param   cbBuf       Number of bytes to compress.
+ */
+RTDECL(int)     RTZipCompress(PRTZIPCOMP pZip, const void *pvBuf, size_t cbBuf)
+{
+    if (!cbBuf)
+        return VINF_SUCCESS;
+    return pZip->pfnCompress(pZip, pvBuf, cbBuf);
+}
+RT_EXPORT_SYMBOL(RTZipCompress);
+
+
+/**
+ * Finishes the compression.
+ * This will flush all data and terminate the compression data stream.
+ *
+ * @returns iprt status code.
+ * @param   pZip        The compressor instance.
+ */
+RTDECL(int)     RTZipCompFinish(PRTZIPCOMP pZip)
+{
+    return pZip->pfnFinish(pZip);
+}
+RT_EXPORT_SYMBOL(RTZipCompFinish);
+
+
+/**
+ * Destroys the compressor instance.
+ *
+ * @returns iprt status code.
+ * @param   pZip        The compressor instance.
+ */
+RTDECL(int)     RTZipCompDestroy(PRTZIPCOMP pZip)
+{
+    /*
+     * Compressor specific destruction attempt first.
+     */
+    int rc = pZip->pfnDestroy(pZip);
+    AssertRCReturn(rc, rc);
+
+    /*
+     * Free the instance memory.
+     */
+    pZip->enmType = RTZIPTYPE_INVALID;
+    RTMemFree(pZip);
+    return VINF_SUCCESS;
+}
+RT_EXPORT_SYMBOL(RTZipCompDestroy);
+
+
+/**
+ * @copydoc RTZipDecompress
+ */
+static DECLCALLBACK(int) rtZipStubDecompress(PRTZIPDECOMP pZip, void *pvBuf, size_t cbBuf, size_t *pcbWritten)
+{
+    NOREF(pZip); NOREF(pvBuf); NOREF(cbBuf); NOREF(pcbWritten);
+    return VERR_NOT_SUPPORTED;
+}
+
+
+/**
+ * @copydoc RTZipDecompDestroy
+ */
+static DECLCALLBACK(int) rtZipStubDecompDestroy(PRTZIPDECOMP pZip)
+{
+    NOREF(pZip);
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * Create a decompressor instance.
+ *
+ * @returns iprt status code.
+ * @param   ppZip       Where to store the instance handle.
+ * @param   pvUser      User argument which will be passed on to pfnOut and pfnIn.
+ * @param   pfnIn       Callback for producing input for decompression.
+ */
+RTDECL(int)     RTZipDecompCreate(PRTZIPDECOMP *ppZip, void *pvUser, PFNRTZIPIN pfnIn)
+{
+    /*
+     * Validate input.
+     */
+    AssertPtrReturn(pfnIn, VERR_INVALID_POINTER);
+    AssertPtrReturn(ppZip, VERR_INVALID_POINTER);
+
+    /*
+     * Allocate memory for the instance data.
+     */
+    PRTZIPDECOMP pZip = (PRTZIPDECOMP)RTMemAlloc(sizeof(RTZIPDECOMP));
+    if (!pZip)
+        return VERR_NO_MEMORY;
+
+    /*
+     * Init instance.
+     */
+    pZip->pfnIn   = pfnIn;
+    pZip->enmType = RTZIPTYPE_INVALID;
+    pZip->pvUser  = pvUser;
+    pZip->pfnDecompress = NULL;
+    pZip->pfnDestroy = rtZipStubDecompDestroy;
+
+    *ppZip = pZip;
+    return VINF_SUCCESS;
+}
+RT_EXPORT_SYMBOL(RTZipDecompCreate);
+
+
+/**
+ * Lazy init of the decompressor.
+ * @returns iprt status code.
+ * @param   pZip        The decompressor instance.
+ */
+static int rtzipDecompInit(PRTZIPDECOMP pZip)
+{
+    /*
+     * Read the first byte from the stream so we can determine the type.
+     */
+    uint8_t u8Type;
+    int rc = pZip->pfnIn(pZip->pvUser, &u8Type, sizeof(u8Type), NULL);
+    if (RT_FAILURE(rc))
+        return rc;
+
+    /*
+     * Determine type and do type specific init.
+     */
+    pZip->enmType = (RTZIPTYPE)u8Type;
+    rc = VERR_NOT_SUPPORTED;
+    switch (pZip->enmType)
+    {
+        case RTZIPTYPE_STORE:
+#ifdef RTZIP_USE_STORE
+            rc = rtZipStoreDecompInit(pZip);
+#else
+            AssertMsgFailed(("Store is not include in this build!\n"));
+#endif
+            break;
+
+        case RTZIPTYPE_ZLIB:
+        case RTZIPTYPE_ZLIB_NO_HEADER:
+#ifdef RTZIP_USE_ZLIB
+            rc = rtZipZlibDecompInit(pZip, pZip->enmType == RTZIPTYPE_ZLIB /*fHeader*/);
+#else
+            AssertMsgFailed(("Zlib is not include in this build!\n"));
+#endif
+            break;
+
+        case RTZIPTYPE_BZLIB:
+#ifdef RTZIP_USE_BZLIB
+            rc = rtZipBZlibDecompInit(pZip);
+#else
+            AssertMsgFailed(("BZlib is not include in this build!\n"));
+#endif
+            break;
+
+        case RTZIPTYPE_LZF:
+#ifdef RTZIP_USE_LZF
+            rc = rtZipLZFDecompInit(pZip);
+#else
+            AssertMsgFailed(("LZF is not include in this build!\n"));
+#endif
+            break;
+
+        case RTZIPTYPE_LZJB:
+#ifdef RTZIP_USE_LZJB
+            AssertMsgFailed(("LZJB streaming support is not implemented yet!\n"));
+#else
+            AssertMsgFailed(("LZJB is not include in this build!\n"));
+#endif
+            break;
+
+        case RTZIPTYPE_LZO:
+#ifdef RTZIP_USE_LZJB
+            AssertMsgFailed(("LZO streaming support is not implemented yet!\n"));
+#else
+            AssertMsgFailed(("LZO is not include in this build!\n"));
+#endif
+            break;
+
+        default:
+            AssertMsgFailed(("Invalid compression type %d (%#x)!\n", pZip->enmType, pZip->enmType));
+            rc = VERR_INVALID_MAGIC;
+            break;
+    }
+    if (RT_FAILURE(rc))
+    {
+        pZip->pfnDecompress = rtZipStubDecompress;
+        pZip->pfnDestroy = rtZipStubDecompDestroy;
+    }
+
+    return rc;
+}
+
+
+/**
+ * Decompresses a chunk of memory.
+ *
+ * @returns iprt status code.
+ * @param   pZip        The decompressor instance.
+ * @param   pvBuf       Where to store the decompressed data.
+ * @param   cbBuf       Number of bytes to produce. If pcbWritten is set
+ *                      any number of bytes up to cbBuf might be returned.
+ * @param   pcbWritten  Number of bytes actually written to the buffer. If NULL
+ *                      cbBuf number of bytes must be written.
+ */
+RTDECL(int)     RTZipDecompress(PRTZIPDECOMP pZip, void *pvBuf, size_t cbBuf, size_t *pcbWritten)
+{
+    /*
+     * Skip empty requests.
+     */
+    if (!cbBuf)
+        return VINF_SUCCESS;
+
+    /*
+     * Lazy init.
+     */
+    if (!pZip->pfnDecompress)
+    {
+        int rc = rtzipDecompInit(pZip);
+        if (RT_FAILURE(rc))
+            return rc;
+    }
+
+    /*
+     * 'Read' the decompressed stream.
+     */
+    return pZip->pfnDecompress(pZip, pvBuf, cbBuf, pcbWritten);
+}
+RT_EXPORT_SYMBOL(RTZipDecompress);
+
+
+/**
+ * Destroys the decompressor instance.
+ *
+ * @returns iprt status code.
+ * @param   pZip        The decompressor instance.
+ */
+RTDECL(int)     RTZipDecompDestroy(PRTZIPDECOMP pZip)
+{
+    /*
+     * Destroy compressor instance and flush the output buffer.
+     */
+    int rc = pZip->pfnDestroy(pZip);
+    AssertRCReturn(rc, rc);
+
+    /*
+     * Free the instance memory.
+     */
+    pZip->enmType = RTZIPTYPE_INVALID;
+    RTMemFree(pZip);
+    return rc;
+}
+RT_EXPORT_SYMBOL(RTZipDecompDestroy);
+
+
+RTDECL(int) RTZipBlockCompress(RTZIPTYPE enmType, RTZIPLEVEL enmLevel, uint32_t fFlags,
+                               void const *pvSrc, size_t cbSrc,
+                               void *pvDst, size_t cbDst, size_t *pcbDstActual) RT_NO_THROW_DEF
+{
+    /* input validation - the crash and burn approach as speed is essential here. */
+    Assert(enmLevel <= RTZIPLEVEL_MAX && enmLevel >= RTZIPLEVEL_STORE); RT_NOREF_PV(enmLevel);
+    Assert(!fFlags);                                                    RT_NOREF_PV(fFlags);
+
+    /*
+     * Deal with flags involving prefixes.
+     */
+    /** @todo later: type and/or compressed length prefix. */
+
+    /*
+     * The type specific part.
+     */
+    switch (enmType)
+    {
+        case RTZIPTYPE_LZF:
+        {
+#ifdef RTZIP_USE_LZF
+# if 0
+            static const uint8_t s_abZero4K[] =
+            {
+                0x01, 0x00, 0x00, 0xe0, 0xff, 0x00, 0xe0, 0xff,
+                0x00, 0xe0, 0xff, 0x00, 0xe0, 0xff, 0x00, 0xe0,
+                0xff, 0x00, 0xe0, 0xff, 0x00, 0xe0, 0xff, 0x00,
+                0xe0, 0xff, 0x00, 0xe0, 0xff, 0x00, 0xe0, 0xff,
+                0x00, 0xe0, 0xff, 0x00, 0xe0, 0xff, 0x00, 0xe0,
+                0xff, 0x00, 0xe0, 0xff, 0x00, 0xe0, 0xff, 0x00,
+                0xe0, 0x7d, 0x00
+            };
+            if (    cbSrc == _4K
+                &&  !((uintptr_t)pvSrc & 15)
+                &&  ASMMemIsZeroPage(pvSrc))
+            {
+                if (RT_UNLIKELY(cbDst < sizeof(s_abZero4K)))
+                    return VERR_BUFFER_OVERFLOW;
+                memcpy(pvDst, s_abZero4K, sizeof(s_abZero4K));
+                *pcbDstActual = sizeof(s_abZero4K);
+                break;
+            }
+# endif
+
+            unsigned cbDstActual = lzf_compress(pvSrc, (unsigned)cbSrc, pvDst, (unsigned)cbDst);    /** @todo deal with size type overflows */
+            if (RT_UNLIKELY(cbDstActual < 1))
+                return VERR_BUFFER_OVERFLOW;
+            *pcbDstActual = cbDstActual;
+            break;
+#else
+            return VERR_NOT_SUPPORTED;
+#endif
+        }
+
+        case RTZIPTYPE_STORE:
+        {
+            if (cbDst < cbSrc)
+                return VERR_BUFFER_OVERFLOW;
+            memcpy(pvDst, pvSrc, cbSrc);
+            *pcbDstActual = cbSrc;
+            break;
+        }
+
+        case RTZIPTYPE_LZJB:
+        {
+#ifdef RTZIP_USE_LZJB
+            AssertReturn(cbDst > cbSrc, VERR_BUFFER_OVERFLOW);
+            size_t cbDstActual = lzjb_compress((void *)pvSrc, (uint8_t *)pvDst + 1, cbSrc, cbSrc, 0 /*??*/);
+            if (cbDstActual == cbSrc)
+                *(uint8_t *)pvDst = 0;
+            else
+                *(uint8_t *)pvDst = 1;
+            *pcbDstActual = cbDstActual + 1;
+            break;
+#else
+            return VERR_NOT_SUPPORTED;
+#endif
+        }
+
+        case RTZIPTYPE_LZO:
+        {
+#ifdef RTZIP_USE_LZO
+            uint64_t Scratch[RT_ALIGN(LZO1X_1_MEM_COMPRESS, sizeof(uint64_t)) / sizeof(uint64_t)];
+            int rc = lzo_init();
+            if (RT_UNLIKELY(rc != LZO_E_OK))
+                return VERR_INTERNAL_ERROR;
+
+            lzo_uint cbDstInOut = cbDst;
+            rc = lzo1x_1_compress((const lzo_bytep)pvSrc, cbSrc, (lzo_bytep )pvDst, &cbDstInOut, &Scratch[0]);
+            if (RT_UNLIKELY(rc != LZO_E_OK))
+                switch (rc)
+                {
+                    case LZO_E_OUTPUT_OVERRUN:  return VERR_BUFFER_OVERFLOW;
+                    default:                    return VERR_GENERAL_FAILURE;
+                }
+            *pcbDstActual = cbDstInOut;
+            break;
+#else
+            return VERR_NOT_SUPPORTED;
+#endif
+        }
+
+        case RTZIPTYPE_ZLIB:
+        case RTZIPTYPE_BZLIB:
+            return VERR_NOT_SUPPORTED;
+
+        default:
+            AssertMsgFailed(("%d\n", enmType));
+            return VERR_INVALID_PARAMETER;
+    }
+
+    return VINF_SUCCESS;
+}
+RT_EXPORT_SYMBOL(RTZipBlockCompress);
+
+
+RTDECL(int) RTZipBlockDecompress(RTZIPTYPE enmType, uint32_t fFlags,
+                                 void const *pvSrc, size_t cbSrc, size_t *pcbSrcActual,
+                                 void *pvDst, size_t cbDst, size_t *pcbDstActual) RT_NO_THROW_DEF
+{
+    /* input validation - the crash and burn approach as speed is essential here. */
+    Assert(!fFlags); RT_NOREF_PV(fFlags);
+
+    /*
+     * Deal with flags involving prefixes.
+     */
+    /** @todo later: type and/or compressed length prefix. */
+
+    /*
+     * The type specific part.
+     */
+    switch (enmType)
+    {
+        case RTZIPTYPE_LZF:
+        {
+#ifdef RTZIP_USE_LZF
+            unsigned cbDstActual = lzf_decompress(pvSrc, (unsigned)cbSrc, pvDst, (unsigned)cbDst);  /** @todo deal with size type overflows */
+            if (RT_UNLIKELY(cbDstActual < 1))
+            {
+# ifndef IPRT_NO_CRT /* no errno */
+                if (errno == E2BIG)
+                    return VERR_BUFFER_OVERFLOW;
+                Assert(errno == EINVAL);
+# endif
+                return VERR_GENERAL_FAILURE;
+            }
+            if (pcbDstActual)
+                *pcbDstActual = cbDstActual;
+            if (pcbSrcActual)
+                *pcbSrcActual = cbSrc;
+            break;
+#else
+            return VERR_NOT_SUPPORTED;
+#endif
+        }
+
+        case RTZIPTYPE_STORE:
+        {
+            if (cbDst < cbSrc)
+                return VERR_BUFFER_OVERFLOW;
+            memcpy(pvDst, pvSrc, cbSrc);
+            if (pcbDstActual)
+                *pcbDstActual = cbSrc;
+            if (pcbSrcActual)
+                *pcbSrcActual = cbSrc;
+            break;
+        }
+
+        case RTZIPTYPE_LZJB:
+        {
+#ifdef RTZIP_USE_LZJB
+            if (*(uint8_t *)pvSrc == 1)
+            {
+                int rc = lzjb_decompress((uint8_t *)pvSrc + 1, pvDst, cbSrc - 1, cbDst, 0 /*??*/);
+                if (RT_UNLIKELY(rc != 0))
+                    return VERR_GENERAL_FAILURE;
+                if (pcbDstActual)
+                    *pcbDstActual = cbDst;
+            }
+            else
+            {
+                AssertReturn(cbDst >= cbSrc - 1, VERR_BUFFER_OVERFLOW);
+                memcpy(pvDst, (uint8_t *)pvSrc + 1, cbSrc - 1);
+                if (pcbDstActual)
+                    *pcbDstActual = cbSrc - 1;
+            }
+            if (pcbSrcActual)
+                *pcbSrcActual = cbSrc;
+            break;
+#else
+            return VERR_NOT_SUPPORTED;
+#endif
+        }
+
+        case RTZIPTYPE_LZO:
+        {
+#ifdef RTZIP_USE_LZO
+            int rc = lzo_init();
+            if (RT_UNLIKELY(rc != LZO_E_OK))
+                return VERR_INTERNAL_ERROR;
+            lzo_uint cbDstInOut = cbDst;
+            rc = lzo1x_decompress((const lzo_bytep)pvSrc, cbSrc, (lzo_bytep)pvDst, &cbDstInOut, NULL);
+            if (RT_UNLIKELY(rc != LZO_E_OK))
+                switch (rc)
+                {
+                    case LZO_E_OUTPUT_OVERRUN:  return VERR_BUFFER_OVERFLOW;
+                    default:
+                    case LZO_E_INPUT_OVERRUN:   return VERR_GENERAL_FAILURE;
+                }
+            if (pcbSrcActual)
+                *pcbSrcActual = cbSrc;
+            if (pcbDstActual)
+                *pcbDstActual = cbDstInOut;
+            break;
+#else
+            return VERR_NOT_SUPPORTED;
+#endif
+        }
+
+        case RTZIPTYPE_ZLIB:
+        case RTZIPTYPE_ZLIB_NO_HEADER:
+        {
+#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;
+            if (enmType == RTZIPTYPE_ZLIB)
+                rc = inflateInit(&ZStrm);
+            else if (enmType == RTZIPTYPE_ZLIB_NO_HEADER)
+                rc = inflateInit2(&ZStrm, -Z_DEF_WBITS);
+            else
+                AssertFailedReturn(VERR_INTERNAL_ERROR);
+
+            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 = cbSrc - ZStrm.avail_in;
+            if (pcbDstActual)
+                *pcbDstActual = ZStrm.total_out;
+            break;
+#else
+            return VERR_NOT_SUPPORTED;
+#endif
+        }
+
+        case RTZIPTYPE_BZLIB:
+            return VERR_NOT_SUPPORTED;
+
+        default:
+            AssertMsgFailed(("%d\n", enmType));
+            return VERR_INVALID_PARAMETER;
+    }
+    return VINF_SUCCESS;
+}
+RT_EXPORT_SYMBOL(RTZipBlockDecompress);
+