Changeset 34049 in vbox

Timestamp:

Nov 13, 2010 1:31:07 AM (15 years ago)

Author:

vboxsync

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

67731

Message:

iprt/tarvfs: Working on validating and parsing the tar headers.

Location:

trunk

Files:

• include/iprt/err.h (modified) (1 diff)
• include/iprt/types.h (modified) (1 diff)
• src/VBox/Runtime/common/zip/gzipvfs.cpp (modified) (2 diffs)
• src/VBox/Runtime/common/zip/tar.h (modified) (1 diff)
• src/VBox/Runtime/common/zip/tarvfs.cpp (modified) (5 diffs)

trunk/include/iprt/err.h

@@ -1299 +1299 @@
   * the input stream. */
 #define VERR_TAR_EOS_MORE_INPUT                 (-928)
+/** A number tar header field was malformed.  */
+#define VERR_TAR_BAD_NUM_FIELD                  (-929)
+/** A numeric tar header field was not terminated correctly. */
+#define VERR_TAR_BAD_NUM_FIELD_TERM             (-930)
+/** A number tar header field was encoded using base-256 which this
+ * tar implementation currently does not support.  */
+#define VERR_TAR_BASE_256_NOT_SUPPORTED         (-931)
+/** A number tar header field yielded a value too large for the internal
+ * variable of the tar interpreter. */
+#define VERR_TAR_NUM_VALUE_TOO_LARGE            (-932)
+/** The combined minor and major device number type is too small to hold the
+ * value stored in the tar header.  */
+#define VERR_TAR_DEV_VALUE_TOO_LARGE            (-933)
+/** The mode field in a tar header is bad. */
+#define VERR_TAR_BAD_MODE_FIELD                 (-934)
+/** The mode field should not include the type. */
+#define VERR_TAR_MODE_WITH_TYPE                 (-935)
+/** The size field should be zero for links and symlinks. */
+#define VERR_TAR_SIZE_NOT_ZERO                  (-936)
+/** Encountered an unknown type flag. */
+#define VERR_TAR_UNKNOWN_TYPE_FLAG              (-937)
+/** The tar header is all zeros. */
+#define VERR_TAR_ZERO_HEADER                    (-938)
+/** Not a uniform standard tape archive header. */
+#define VERR_TAR_NOT_USTAR                      (-939)
+/** The name is empty. */
+#define VERR_TAR_EMPTY_NAME                     (-940)
+/** A non-directory entry has a name ending with a slash. */
+#define VERR_TAR_NON_DIR_ENDS_WITH_SLASH        (-941)
+/** Encountered an unsupported portable archive exchange (pax) header. */
+#define VERR_TAR_UNSUPPORTED_PAX_TYPE           (-942)
+/** Encountered an unsupported Solaris Tar extension. */
+#define VERR_TAR_UNSUPPORTED_SOLARIS_HDR_TYPE   (-943)
+/** Encountered an unsupported GNU Tar extension. */
+#define VERR_TAR_UNSUPPORTED_GNU_HDR_TYPE       (-944)
+/** Malformed checksum field in the tar header. */
+#define VERR_TAR_BAD_CHKSUM_FIELD               (-945)
 /** @} */
 

trunk/include/iprt/types.h

@@ -547 +547 @@
 typedef RTDEV          *PRTDEV;
 
+/** @name RTDEV Macros
+ * @{  */
+/**
+ * Our makedev macro.
+ * @returns RTDEV
+ * @param   uMajor          The major device number.
+ * @param   uMinor          The minor device number.
+ */
+#define RTDEV_MAKE(uMajor, uMinor)      ((RTDEV)( ((RTDEV)(uMajor) << 24) | (uMinor & UINT32_C(0x00ffffff)) ))
+/**
+ * Get the major device node number from an RTDEV type.
+ * @returns The major device number of @a uDev
+ * @param   uDev            The device number.
+ */
+#define RTDEV_MAJOR(uDev)               ((uDev) >> 24)
+/**
+ * Get the minor device node number from an RTDEV type.
+ * @returns The minor device number of @a uDev
+ * @param   uDev            The device number.
+ */
+#define RTDEV_MINOR(uDev)               ((uDev) & UINT32_C(0x00ffffff))
+/** @}  */
+
 /** i-node number. */
 typedef uint64_t        RTINODE;

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

@@ -442 +442 @@
 {
     PRTZIPGZIPSTREAM pThis = (PRTZIPGZIPSTREAM)pvThis;
-    return pThis->offStream;
+    *poffActual = pThis->offStream;
+    return VINF_SUCCESS;
 }
 
@@ -486 +487 @@
     RTVFSIOSTREAM    hVfsIos;
     PRTZIPGZIPSTREAM pThis;
-    int rc = RTVfsNewIoStream(&g_rtZipGzipOps, sizeof(RTZIPGZIPSTREAM), RTFILE_O_READ, NIL_RTVFS, NIL_RTSEMRW,
+    int rc = RTVfsNewIoStream(&g_rtZipGzipOps, sizeof(RTZIPGZIPSTREAM), RTFILE_O_READ, NIL_RTVFS, NIL_RTVFSLOCK,
                               &hVfsIos, (void **)&pThis);
     if (RT_SUCCESS(rc))

trunk/src/VBox/Runtime/common/zip/tar.h

@@ -32 +32 @@
 /** @name RTZIPTARHDRPOSIX::typeflag
  * @{  */
-#define RTZIPTAR_TF_OLDNORMAL '\0' /**< Normal disk file, Unix compatible */
-#define RTZIPTAR_TF_NORMAL    '0'  /**< Normal disk file */
-#define RTZIPTAR_TF_LINK      '1'  /**< Link to previously dumped file */
-#define RTZIPTAR_TF_SYMLINK   '2'  /**< Symbolic link */
-#define RTZIPTAR_TF_CHR       '3'  /**< Character special file */
-#define RTZIPTAR_TF_BLK       '4'  /**< Block special file */
-#define RTZIPTAR_TF_DIR       '5'  /**< Directory */
-#define RTZIPTAR_TF_FIFO      '6'  /**< FIFO special file */
-#define RTZIPTAR_TF_CONTIG    '7'  /**< Contiguous file */
+#define RTZIPTAR_TF_OLDNORMAL   '\0' /**< Normal disk file, Unix compatible */
+#define RTZIPTAR_TF_NORMAL      '0'  /**< Normal disk file */
+#define RTZIPTAR_TF_LINK        '1'  /**< Link to previously dumped file */
+#define RTZIPTAR_TF_SYMLINK     '2'  /**< Symbolic link */
+#define RTZIPTAR_TF_CHR         '3'  /**< Character special file */
+#define RTZIPTAR_TF_BLK         '4'  /**< Block special file */
+#define RTZIPTAR_TF_DIR         '5'  /**< Directory */
+#define RTZIPTAR_TF_FIFO        '6'  /**< FIFO special file */
+#define RTZIPTAR_TF_CONTIG      '7'  /**< Contiguous file */
+
+#define RTZIPTAR_TF_X_HDR       'x'  /**< Extended header. */
+#define RTZIPTAR_TF_X_GLOBAL    'g'  /**< Global extended header. */
+
+#define RTZIPTAR_TF_SOLARIS_XHDR    'X'
+
+#define RTZIPTAR_TF_GNU_DUMPDIR     'D'
+#define RTZIPTAR_TF_GNU_LONGLINK    'K'
+#define RTZIPTAR_TF_GNU_LONGNAME    'L'
+#define RTZIPTAR_TF_GNU_MULTIVOL    'M'
+#define RTZIPTAR_TF_GNU_SPARSE      'S'
+#define RTZIPTAR_TF_GNU_VOLDHR      'V'
 /** @} */
+
+/** The uniform standard tape archive format magic value. */
+#define RTZIPTAR_USTAR_MAGIC    "ustar"
+/** The ustar version string.
+ * @remarks The terminator character is not part of the field.  */
+#define RTZIPTAR_USTAR_VERSION  "00"
+
 
 /**

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

@@ -112 +112 @@
 
 
-
-/**
- * Checks if the TAR header includes a posix user name field.
+/**
+ * Checks if the TAR header is in the ustar format.
  *
  * @returns true / false.
  * @param   pTar                The TAR header.
  */
-DECLINLINE(bool) rtZipTarHdrHasPosixUserName(PCRTZIPTARHDR pTar)
-{
-    return true;
-}
-
-
-/**
- * Checks if the TAR header includes a posix group name field.
+DECLINLINE(bool) rtZipTarHdrIsUstar(PCRTZIPTARHDR pTar)
+{
+    return pTar->Posix.magic[0] == 'u'
+        && pTar->Posix.magic[1] == 's'
+        && pTar->Posix.magic[2] == 't'
+        && pTar->Posix.magic[3] == 'a'
+        && pTar->Posix.magic[4] == 'r'
+        && pTar->Posix.magic[5] == '\0'
+        && pTar->Posix.version[0] == '0'
+        && pTar->Posix.version[1] == '0';
+}
+
+
+/**
+ * Checks if the TAR header is in the ustar format and has a regular file type.
  *
  * @returns true / false.
  * @param   pTar                The TAR header.
  */
-DECLINLINE(bool) rtZipTarHdrHasPosixGroupName(PCRTZIPTARHDR pTar)
-{
-    return true;
-}
-
-
-/**
- * Checks if the TAR header includes a posix compatible path prefix field.
+DECLINLINE(bool) rtZipTarHdrIsRegularUstar(PCRTZIPTARHDR pTar)
+{
+    return rtZipTarHdrIsUstar(pTar)
+        && (    (   pTar->Posix.typeflag >= RTZIPTAR_TF_NORMAL
+                 && pTar->Posix.typeflag <= RTZIPTAR_TF_CONTIG)
+            ||  pTar->Posix.typeflag == RTZIPTAR_TF_OLDNORMAL);
+}
+
+
+/**
+ * Checks if the TAR header includes a posix user name field.
  *
  * @returns true / false.
  * @param   pTar                The TAR header.
  */
+DECLINLINE(bool) rtZipTarHdrHasPosixUserName(PCRTZIPTARHDR pTar)
+{
+    return pTar->Posix.uname[0] != '\0'
+        && rtZipTarHdrIsUstar(pTar);
+}
+
+
+/**
+ * Checks if the TAR header includes a posix group name field.
+ *
+ * @returns true / false.
+ * @param   pTar                The TAR header.
+ */
+DECLINLINE(bool) rtZipTarHdrHasPosixGroupName(PCRTZIPTARHDR pTar)
+{
+    return pTar->Posix.gname[0] != '\0'
+        && rtZipTarHdrIsUstar(pTar);
+}
+
+
+/**
+ * Checks if the TAR header includes a posix compatible path prefix field.
+ *
+ * @returns true / false.
+ * @param   pTar                The TAR header.
+ */
 DECLINLINE(bool) rtZipTarHdrHasPrefix(PCRTZIPTARHDR pTar)
 {
-    return pTar->Posix.prefix[0] != '\0';
-}
-
-
-/**
- * Validates the TAR header.
- *
- * @returns VINF_SUCCESS if valid, appropriate VERR_TAR_XXX if not.
- * @param   pTar                The TAR header.
- */
-static int rtZipTarHdrValidate(PCRTZIPTARHDR pTar)
-{
-    return VINF_SUCCESS;
+    return pTar->Posix.prefix[0] != '\0'
+        && rtZipTarHdrIsUstar(pTar);
 }
 
@@ -173 +197 @@
 static int rtZipTarHdrFieldToNum(const char *pszField, size_t cchField, bool fOctalOnly, int64_t *pi64)
 {
-    /** @todo check for base256 and more  */
-    return RTStrToInt64Full(pszField, 8, pi64);
+    size_t const cchFieldOrg = cchField;
+    if (   fOctalOnly
+        || !(*(unsigned char *)pszField & 0x80))
+    {
+        /*
+         * Skip leading zeros, saving a few slower loops below.
+         */
+        while (cchField > 0 && *pszField == '0')
+            cchField--, pszField++;
+
+        /*
+         * Convert octal digits.
+         */
+        int64_t i64 = 0;
+        while (cchField > 0)
+        {
+            unsigned char uDigit = *pszField - '0';
+            if (uDigit >= 8)
+                break;
+            i64 <<= 3;
+            i64 |= uDigit;
+
+            pszField++;
+            cchField--;
+        }
+        *pi64 = i64;
+
+        /*
+         * Was it terminated correctly?
+         */
+        while (cchField > 0)
+        {
+            char ch = *pszField++;
+            if (ch != 0 && ch != ' ')
+                return cchField < cchFieldOrg
+                     ? VERR_TAR_BAD_NUM_FIELD_TERM
+                     : VERR_TAR_BAD_NUM_FIELD;
+            cchField--;
+        }
+    }
+    else
+    {
+        /** @todo implement base-256 encoded fields. */
+        return VERR_TAR_BASE_256_NOT_SUPPORTED;
+    }
+
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * Calculates the tar header checksums and detects if it's all zeros.
+ *
+ * @returns true if all zeros, false if not.
+ * @param   pHdr                The header to checksum.
+ * @param   pi32Unsigned        Where to store the checksum calculated using
+ *                              unsigned chars.   This is the one POSIX
+ *                              specifies.
+ * @param   pi32Signed          Where to store the checksum calculated using
+ *                              signed chars.
+ *
+ * @remarks The reason why we calculate the checksum as both signed and unsigned
+ *          has to do with various the char C type being signed on some hosts
+ *          and unsigned on others.
+ */
+static bool rtZipTarCalcChkSum(PCRTZIPTARHDR pHdr, int32_t *pi32Unsigned, int32_t *pi32Signed)
+{
+    int32_t i32Unsigned = 0;
+    int32_t i32Signed   = 0;
+
+    /*
+     * Sum up the entire header.
+     */
+    const char *pch    = (const char *)pHdr;
+    const char *pchEnd = pch + sizeof(*pHdr);
+    do
+    {
+        i32Unsigned += *(unsigned char *)pch;
+        i32Signed   += *(signed   char *)pch;
+    } while (++pch != pchEnd);
+
+    /*
+     * Check if it's all zeros and replace the chksum field with spaces.
+     */
+    bool const fZeroHdr = i32Unsigned == 0;
+
+    pch    = pHdr->Posix.chksum;
+    pchEnd = pch + sizeof(pHdr->Posix.chksum);
+    do
+    {
+        i32Unsigned -= *(unsigned char *)pch;
+        i32Signed   -= *(signed   char *)pch;
+        pch++;
+    } while (++pch != pchEnd);
+
+    i32Unsigned += (unsigned char)' ' * sizeof(pHdr->Posix.chksum);
+    i32Signed   += (signed   char)' ' * sizeof(pHdr->Posix.chksum);
+
+    *pi32Unsigned = i32Unsigned;
+    if (pi32Signed)
+        *pi32Signed = i32Signed;
+    return fZeroHdr;
+}
+
+
+/**
+ * Validates the TAR header.
+ *
+ * @returns VINF_SUCCESS if valid, appropriate VERR_TAR_XXX if not.
+ * @param   pTar                The TAR header.
+ */
+static int rtZipTarHdrValidate(PCRTZIPTARHDR pTar)
+{
+    /*
+     * 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->Posix.chksum, sizeof(pTar->Posix.chksum), true /*fOctalOnly*/, &i64HdrChkSum);
+    if (RT_FAILURE(rc))
+        return VERR_TAR_BAD_CHKSUM_FIELD;
+//    if (   i32ChkSum          != i64HdrChkSum
+//        && i32ChkSumSignedAlt != i64HdrChkSum) /** @todo check this */
+//        return VERR_TAR_CHKSUM_MISMATCH;
+
+    /*
+     * Perform some basic checks.
+     */
+    if (!rtZipTarHdrIsUstar(pTar))
+        return VERR_TAR_NOT_USTAR;
+
+    switch (pTar->Posix.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:
+        {
+            if (!pTar->Posix.name[0])
+                return VERR_TAR_EMPTY_NAME;
+
+            const char *pchEnd = RTStrEnd(&pTar->Posix.name[0], sizeof(pTar->Posix.name));
+            pchEnd = pchEnd ? pchEnd - 1 : &pTar->Posix.name[sizeof(pTar->Posix.name) - 1];
+            if (*pchEnd == '/')
+                return VERR_TAR_NON_DIR_ENDS_WITH_SLASH;
+            break;
+        }
+
+        case RTZIPTAR_TF_DIR:
+            if (!pTar->Posix.name[0])
+                return VERR_TAR_EMPTY_NAME;
+            break;
+
+        case RTZIPTAR_TF_X_HDR:
+        case RTZIPTAR_TF_X_GLOBAL:
+            return VERR_TAR_UNSUPPORTED_PAX_TYPE;
+
+        case RTZIPTAR_TF_SOLARIS_XHDR:
+            return VERR_TAR_UNSUPPORTED_SOLARIS_HDR_TYPE;
+
+        case RTZIPTAR_TF_GNU_DUMPDIR:
+        case RTZIPTAR_TF_GNU_LONGLINK:
+        case RTZIPTAR_TF_GNU_LONGNAME:
+        case RTZIPTAR_TF_GNU_MULTIVOL:
+        case RTZIPTAR_TF_GNU_SPARSE:
+        case RTZIPTAR_TF_GNU_VOLDHR:
+            return VERR_TAR_UNSUPPORTED_GNU_HDR_TYPE;
+    }
+
+    return VINF_SUCCESS;
 }
 
@@ -181 +384 @@
  * 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.
@@ -188 +393 @@
 static int rtZipTarHdrToFsObjInfo(PCRTZIPTARHDR pTar, PRTFSOBJINFO pObjInfo)
 {
+    /*
+     * Zap the whole structure, this takes care of unused space in the union.
+     */
     RT_ZERO(*pObjInfo);
-    int rc;
-
-    int64_t i64;
-    rc = rtZipTarHdrFieldToNum(pTar->Posix.size, sizeof(pTar->Posix.size), false, &i64);
-    AssertRCSuccessReturn(rc, rc);
-    pObjInfo->cbObject = i64;
-
+
+    /*
+     * 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,        pTar->Posix.size);
+    pObjInfo->cbAllocated = RT_ALIGN_64(pObjInfo->cbObject, 512);
+    int64_t c64SecModTime;
+    GET_TAR_NUMERIC_FIELD_RET(c64SecModTime,             pTar->Posix.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,      pTar->Posix.mode);
     pObjInfo->Attr.enmAdditional = RTFSOBJATTRADD_UNIX;
+    GET_TAR_NUMERIC_FIELD_RET(pObjInfo->Attr.u.Unix.uid, pTar->Posix.uid);
+    GET_TAR_NUMERIC_FIELD_RET(pObjInfo->Attr.u.Unix.gid, pTar->Posix.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;
+    if (   pTar->Posix.typeflag == RTZIPTAR_TF_CHR
+        || pTar->Posix.typeflag == RTZIPTAR_TF_BLK)
+    {
+        uint32_t uMajor, uMinor;
+        GET_TAR_NUMERIC_FIELD_RET(uMajor,               pTar->Posix.devmajor);
+        GET_TAR_NUMERIC_FIELD_RET(uMinor,               pTar->Posix.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;
+    }
+
+#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)
+        return VERR_TAR_BAD_MODE_FIELD;
+
+    RTFMODE fModeType;
+    switch (pTar->Posix.typeflag)
+    {
+        case RTZIPTAR_TF_OLDNORMAL:
+        case RTZIPTAR_TF_NORMAL:
+        case RTZIPTAR_TF_CONTIG:
+            fModeType |= RTFS_TYPE_FILE;
+            break;
+
+        case RTZIPTAR_TF_LINK:
+            if (pObjInfo->cbObject != 0)
+                return VERR_TAR_SIZE_NOT_ZERO;
+            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;
+
+        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 |= fModeType;
+
+    switch (pTar->Posix.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;
@@ -672 +982 @@
     if (RT_FAILURE_NP(rc))
     {
-        if (ASMMemIsAllU32(&Hdr, sizeof(Hdr), 0) == NULL)
+        if (rc == VERR_TAR_ZERO_HEADER)
         {
             int rc2 = RTVfsIoStrmRead(pThis->hVfsIos, &Hdr, sizeof(Hdr), true /*fBlocking*/, &cbRead);