Changeset 33973 in vbox

Timestamp:

Nov 11, 2010 11:10:10 AM (14 years ago)

Author:

vboxsync

Message:

vfs: the gunzip stream works, except for some double frees somewhere.

Location:

trunk

Files:

• include/iprt/handle.h (modified) (1 diff)
• include/iprt/pipe.h (modified) (1 diff)
• include/iprt/types.h (modified) (2 diffs)
• include/iprt/vfs.h (modified) (8 diffs)
• include/iprt/vfslowlevel.h (modified) (1 diff)
• include/iprt/zip.h (modified) (1 diff)
• src/VBox/Runtime/Makefile.kmk (modified) (7 diffs)
• src/VBox/Runtime/common/vfs/vfsbase.cpp (modified) (21 diffs)
• src/VBox/Runtime/common/vfs/vfschain.cpp (modified) (4 diffs)
• src/VBox/Runtime/common/vfs/vfsmisc.cpp (added)
• src/VBox/Runtime/common/vfs/vfsstdfile.cpp (modified) (1 diff)
• src/VBox/Runtime/common/zip/zipgzip.cpp (modified) (5 diffs)
• src/VBox/Runtime/r3/posix/RTHandleGetStandard-posix.cpp (added)
• src/VBox/Runtime/r3/win/RTHandleGetStandard-win.cpp (added)
• src/VBox/Runtime/testcase/Makefile.kmk (modified) (1 diff)
• src/VBox/Runtime/testcase/RTGzip.cpp (modified) (8 diffs)

trunk/include/iprt/handle.h

@@ -47 +47 @@
 RTDECL(int) RTHandleClose(PRTHANDLE ph);
 
+/**
+ * Gets one of the standard handles.
+ *
+ * @returns IPRT status code.
+ * @param   enmStdHandle    The standard handle.
+ * @param   ph              Pointer to the generic handle.  This will contain
+ *                          the most appropriate IPRT handle on success.
+ */
+RTDECL(int) RTHandleGetStandard(RTHANDLESTD enmStdHandle, PRTHANDLE ph);
+
 /** @} */
 

trunk/include/iprt/pipe.h

@@ -88 +88 @@
 #define RTPIPE_N_INHERIT            RT_BIT(2)
 /** Mask of valid flags. */
-#define RTPIPE_N_VALID_MASK         UINT32_C(0x00000003)
+#define RTPIPE_N_VALID_MASK         UINT32_C(0x00000007)
 /** @} */
 

trunk/include/iprt/types.h

@@ -1482 +1482 @@
 #define RTSTRCACHE_DEFAULT                          ((RTSTRCACHE)-2)
 
+
+/** Virtual Filesystem handle. */
+typedef struct RTVFSINTERNAL                       *RTVFS;
+/** Pointer to a VFS handle. */
+typedef RTVFS                                      *PRTVFS;
+/** A NIL VFS handle. */
+#define NIL_RTVFS                                   ((RTVFS)~(uintptr_t)0)
+
+/** Virtual Filesystem base object handle. */
+typedef struct RTVFSOBJINTERNAL                    *RTVFSOBJ;
+/** Pointer to a VFS base object handle. */
+typedef RTVFSOBJ                                   *PRTVFSOBJ;
+/** A NIL VFS base object handle. */
+#define NIL_RTVFSOBJ                                ((RTVFSOBJ)~(uintptr_t)0)
+
+/** Virtual Filesystem directory handle. */
+typedef struct RTVFSDIRINTERNAL                    *RTVFSDIR;
+/** Pointer to a VFS directory handle. */
+typedef RTVFSDIR                                   *PRTVFSDIR;
+/** A NIL VFS directory handle. */
+#define NIL_RTVFSDIR                                ((RTVFSDIR)~(uintptr_t)0)
+
+/** Virtual Filesystem filesystem stream handle. */
+typedef struct RTVFSFSSTREAMINTERNAL               *RTVFSFSSTREAM;
+/** Pointer to a VFS filesystem stream handle. */
+typedef RTVFSFSSTREAM                              *PRTVFSFSSTREAM;
+/** A NIL VFS filesystem stream handle. */
+#define NIL_RTVFSFSSTREAM                           ((RTVFSFSSTREAM)~(uintptr_t)0)
+
+/** Virtual Filesystem I/O stream handle. */
+typedef struct RTVFSIOSTREAMINTERNAL               *RTVFSIOSTREAM;
+/** Pointer to a VFS I/O stream handle. */
+typedef RTVFSIOSTREAM                              *PRTVFSIOSTREAM;
+/** A NIL VFS I/O stream handle. */
+#define NIL_RTVFSIOSTREAM                           ((RTVFSIOSTREAM)~(uintptr_t)0)
+
+/** Virtual Filesystem file handle. */
+typedef struct RTVFSFILEINTERNAL                   *RTVFSFILE;
+/** Pointer to a VFS file handle. */
+typedef RTVFSFILE                                  *PRTVFSFILE;
+/** A NIL VFS file handle. */
+#define NIL_RTVFSFILE                               ((RTVFSFILE)~(uintptr_t)0)
+
+/** Virtual Filesystem symbolic link handle. */
+typedef struct RTVFSSYMLINKINTERNAL                *RTVFSSYMLINK;
+/** Pointer to a VFS symbolic link handle. */
+typedef RTVFSSYMLINK                               *PRTVFSSYMLINK;
+/** A NIL VFS symbolic link handle. */
+#define NIL_RTVFSSYMLINK                            ((RTVFSSYMLINK)~(uintptr_t)0)
+
+
 /**
  * Handle type.
@@ -1542 +1593 @@
 /** Pointer to a const generic handle. */
 typedef RTHANDLE const *PCRTHANDLE;
+
+
+/**
+ * Standard handles.
+ *
+ * @remarks These have the correct file descriptor values for unixy systems and
+ *          can be used directly in code specific to those platforms.
+ */
+typedef enum RTHANDLESTD
+{
+    /** Invalid standard handle. */
+    RTHANDLESTD_INVALID = -1,
+    /** The standard input handle. */
+    RTHANDLESTD_INPUT = 0,
+    /** The standard output handle. */
+    RTHANDLESTD_OUTPUT,
+    /** The standard error handle. */
+    RTHANDLESTD_ERROR,
+    /** The typical 32-bit type hack. */
+    RTHANDLESTD_32BIT_HACK = 0x7fffffff
+} RTHANDLESTD;
 
 

trunk/include/iprt/vfs.h

@@ -31 +31 @@
 #include <iprt/dir.h>
 #include <iprt/fs.h>
+#include <iprt/handle.h>
 #include <iprt/symlink.h>
 #include <iprt/sg.h>
@@ -56 +57 @@
  * @{
  */
-
-/** Virtual Filesystem handle. */
-typedef struct RTVFSINTERNAL           *RTVFS;
-/** Pointer to a VFS handle. */
-typedef RTVFS                          *PRTVFS;
-/** A NIL VFS handle. */
-#define NIL_RTVFS                       ((RTVFS)~(uintptr_t)0)
-
-/** Virtual Filesystem base object handle. */
-typedef struct RTVFSOBJINTERNAL        *RTVFSOBJ;
-/** Pointer to a VFS base object handle. */
-typedef RTVFSOBJ                       *PRTVFSOBJ;
-/** A NIL VFS base object handle. */
-#define NIL_RTVFSOBJ                    ((RTVFSOBJ)~(uintptr_t)0)
-
-/** Virtual Filesystem directory handle. */
-typedef struct RTVFSDIRINTERNAL        *RTVFSDIR;
-/** Pointer to a VFS directory handle. */
-typedef RTVFSDIR                       *PRTVFSDIR;
-/** A NIL VFS directory handle. */
-#define NIL_RTVFSDIR                    ((RTVFSDIR)~(uintptr_t)0)
-
-/** Virtual Filesystem filesystem stream handle. */
-typedef struct RTVFSFSSTREAMINTERNAL   *RTVFSFSSTREAM;
-/** Pointer to a VFS filesystem stream handle. */
-typedef RTVFSFSSTREAM                  *PRTVFSFSSTREAM;
-/** A NIL VFS filesystem stream handle. */
-#define NIL_RTVFSFSSTREAM               ((RTVFSFSSTREAM)~(uintptr_t)0)
-
-/** Virtual Filesystem I/O stream handle. */
-typedef struct RTVFSIOSTREAMINTERNAL   *RTVFSIOSTREAM;
-/** Pointer to a VFS I/O stream handle. */
-typedef RTVFSIOSTREAM                  *PRTVFSIOSTREAM;
-/** A NIL VFS I/O stream handle. */
-#define NIL_RTVFSIOSTREAM               ((RTVFSIOSTREAM)~(uintptr_t)0)
-
-/** Virtual Filesystem file handle. */
-typedef struct RTVFSFILEINTERNAL       *RTVFSFILE;
-/** Pointer to a VFS file handle. */
-typedef RTVFSFILE                      *PRTVFSFILE;
-/** A NIL VFS file handle. */
-#define NIL_RTVFSFILE                   ((RTVFSFILE)~(uintptr_t)0)
-
-/** Virtual Filesystem symbolic link handle. */
-typedef struct RTVFSSYMLINKINTERNAL    *RTVFSSYMLINK;
-/** Pointer to a VFS symbolic link handle. */
-typedef RTVFSSYMLINK                   *PRTVFSSYMLINK;
-/** A NIL VFS symbolic link handle. */
-#define NIL_RTVFSSYMLINK                ((RTVFSSYMLINK)~(uintptr_t)0)
 
 /**
@@ -139 +91 @@
 
 
-
 /** @name RTVfsCreate flags
  * @{ */
@@ -293 +244 @@
 
 /**
+ * Create a VFS I/O stream handle from a standard IPRT file handle (RTFILE).
+ *
+ * @returns IPRT status code.
+ * @param   hFile           The standard IPRT file handle.
+ * @param   fOpen           The flags the handle was opened with.  Pass 0 to
+ *                          have these detected.
+ * @param   fLeaveOpen      Whether to leave the handle open when the VFS file
+ *                          is released, or to close it (@c false).
+ * @param   phVfsIos        Where to return the VFS I/O stream handle.
+ */
+RTDECL(int)         RTVfsIoStrmFromRTFile(RTFILE hFile, uint32_t fOpen, bool fLeaveOpen, PRTVFSIOSTREAM phVfsIos);
+
+/**
+ * Create a VFS I/O stream handle from one of the standard handles.
+ *
+ * @returns IPRT status code.
+ * @param   enmStdHandle    The standard IPRT file handle.
+ * @param   fOpen           The flags the handle was opened with.  Pass 0 to
+ *                          have these detected.
+ * @param   fLeaveOpen      Whether to leave the handle open when the VFS file
+ *                          is released, or to close it (@c false).
+ * @param   phVfsIos        Where to return the VFS I/O stream handle.
+ */
+RTDECL(int)         RTVfsIoStrmFromStdHandle(RTHANDLESTD enmStdHandle, uint32_t fOpen, bool fLeaveOpen,
+                                             PRTVFSIOSTREAM phVfsIos);
+
+/**
  * Retains a reference to the VFS I/O stream handle.
  *
@@ -316 +294 @@
  * @sa      RTVfsFileToIoStream
  */
-RTDECL(RTVFSFILE)   RTVfsIoStrmToFile(RTVFSIOSTREAM hVfsIos);
+RTDECL(RTVFSFILE) RTVfsIoStrmToFile(RTVFSIOSTREAM hVfsIos);
 
 /**
@@ -327 +305 @@
  * @sa      RTFileQueryInfo
  */
-RTDECL(int)         RTVfsIoStrmQueryInfo(RTVFSIOSTREAM hVfsIos, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr);
+RTDECL(int) RTVfsIoStrmQueryInfo(RTVFSIOSTREAM hVfsIos, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr);
 
 /**
  * Read bytes from the I/O stream.
- *
- * @returns IPRT status code.
- * @param   hVfsIos         The VFS I/O stream handle.
- * @param   pvBuf           Where to store the read bytes.
- * @param   cbToRead        The number of bytes to read.
- * @param   pcbRead         Where to always store the number of bytes actually
- *                          read.  If this is NULL, the call will block until
- *                          @a cbToRead bytes are available.  If this is
- *                          non-NULL, the call will not block and return what
- *                          is currently avaiable.
- * @sa      RTFileRead, RTPipeRead, RTPipeReadBlocking, RTSocketRead
- */
-RTDECL(int)         RTVfsIoStrmRead(RTVFSIOSTREAM hVfsIos, void *pvBuf, size_t cbToRead, size_t *pcbRead);
-
-/**
- * Write bytes to the I/O stream.
- *
- * @returns IPRT status code.
- * @param   hVfsIos         The VFS I/O stream handle.
- * @param   pvBuf           The bytes to write.
- * @param   cbToWrite       The number of bytes to write.
- * @param   pcbWritten      Where to always store the number of bytes actually
- *                          written.  If this is NULL, the call will block
- *                          until
- *                          @a cbToWrite bytes are available.  If this is
- *                          non-NULL, the call will not block and return after
- *                          writing what is possible.
- * @sa      RTFileWrite, RTPipeWrite, RTPipeWriteBlocking, RTSocketWrite
- */
-RTDECL(int)         RTVfsIoStrmWrite(RTVFSIOSTREAM hVfsIos, const void *pvBuf, size_t cbToWrite, size_t *pcbWritten);
-
-/**
- * Reads bytes from the I/O stream into a scatter buffer.
  *
  * @returns IPRT status code.
@@ -380 +325 @@
  *
  * @param   hVfsIos         The VFS I/O stream handle.
+ * @param   pvBuf           Where to store the read bytes.
+ * @param   cbToRead        The number of bytes to read.
+ * @param   fBlocking       Whether the call is blocking (@c true) or not.  If
+ *                          not, the @a pcbRead parameter must not be NULL.
+ * @param   pcbRead         Where to always store the number of bytes actually
+ *                          read.  This can be NULL if @a fBlocking is true.
+ * @sa      RTFileRead, RTPipeRead, RTPipeReadBlocking, RTSocketRead
+ */
+RTDECL(int) RTVfsIoStrmRead(RTVFSIOSTREAM hVfsIos, void *pvBuf, size_t cbToRead, bool fBlocking, size_t *pcbRead);
+
+/**
+ * Write bytes to the I/O stream.
+ *
+ * @returns IPRT status code.
+ * @param   hVfsIos         The VFS I/O stream handle.
+ * @param   pvBuf           The bytes to write.
+ * @param   cbToWrite       The number of bytes to write.
+ * @param   fBlocking       Whether the call is blocking (@c true) or not.  If
+ *                          not, the @a pcbWritten parameter must not be NULL.
+ * @param   pcbRead         Where to always store the number of bytes actually
+ *                          written.  This can be NULL if @a fBlocking is true.
+ * @sa      RTFileWrite, RTPipeWrite, RTPipeWriteBlocking, RTSocketWrite
+ */
+RTDECL(int) RTVfsIoStrmWrite(RTVFSIOSTREAM hVfsIos, const void *pvBuf, size_t cbToWrite, bool fBlocking, size_t *pcbWritten);
+
+/**
+ * Reads bytes from the I/O stream into a scatter buffer.
+ *
+ * @returns IPRT status code.
+ * @retval  VINF_SUCCESS and the number of bytes read written to @a pcbRead.
+ * @retval  VINF_TRY_AGAIN if @a fBlocking is @c false, @a pcbRead is not NULL,
+ *          and no data was available. @a *pcbRead will be set to 0.
+ * @retval  VINF_EOF when trying to read __beyond__ the end of the stream and
+ *          @a pcbRead is not NULL (it will be set to the number of bytes read,
+ *          or 0 if the end of the stream was reached before this call).
+ *          When the last byte of the read request is the last byte in the
+ *          stream, this status code will not be used.  However, VINF_EOF is
+ *          returned when attempting to read 0 bytes while standing at the end
+ *          of the stream.
+ * @retval  VERR_EOF when trying to read __beyond__ the end of the stream and
+ *          @a pcbRead is NULL.
+ *
+ * @param   hVfsIos         The VFS I/O stream handle.
  * @param   pSgBuf          Pointer to a scatter buffer descriptor.  The number
  *                          of bytes described by the segments is what will be
@@ -550 +538 @@
 RTDECL(int) RTVfsChainOpenIoStream( const char *pszSpec, uint32_t fOpen, PRTVFSIOSTREAM  phVfsIos,  const char **ppszError);
 
+/**
+ * Tests if the given string is a chain specification or not.
+ *
+ * @returns true if it is, false if it isn't.
+ * @param   pszSpec         The alleged chain spec.
+ */
+RTDECL(bool)    RTVfsChainIsSpec(const char *pszSpec);
+
 /** @}  */
 

trunk/include/iprt/vfslowlevel.h

@@ -735 +735 @@
 {
     /** Invalid action. */
-    RTVFSCHAINACTION_INVALID,
+    RTVFSCHAINACTION_INVALID = 0,
     /** No action (start of the chain). */
     RTVFSCHAINACTION_NONE,

trunk/include/iprt/zip.h

@@ -217 +217 @@
 
 
+/**
+ * Opens a gzip decompression I/O stream.
+ *
+ * @returns IPRT status code.
+ *
+ * @param   hVfsIosIn           The compressed input stream.  The reference is
+ *                              not consumed, instead another one is retained.
+ * @param   fFlags              Flags, MBZ.
+ * @param   phVfsIosOut         Where to return the handle to the gzip I/O
+ *                              stream.
+ */
+RTDECL(int) RTZipGzipDecompressIoStream(RTVFSIOSTREAM hVfsIosIn, uint32_t fFlags, PRTVFSIOSTREAM phVfsIosOut);
+
 /** @} */
 

trunk/src/VBox/Runtime/Makefile.kmk

@@ -371 +371 @@
         common/vfs/vfsbase.cpp \
         common/vfs/vfschain.cpp \
+        common/vfs/vfsmisc.cpp \
         common/vfs/vfsstdfile.cpp \
         common/zip/zipgzip.cpp \
@@ -479 +480 @@
         nt/RTErrConvertFromNtStatus.cpp \
         r3/posix/env-posix.cpp \
+        r3/win/RTHandleGetStandard-win.cpp \
         r3/win/RTSystemQueryOSInfo-win.cpp \
         r3/win/RTSystemQueryDmiString-win.cpp \
@@ -537 +539 @@
         r3/linux/RTSystemQueryDmiString-linux.cpp \
         r3/posix/RTFileQueryFsSizes-posix.cpp \
+        r3/posix/RTHandleGetStandard-posix.cpp \
         r3/posix/RTMemProtect-posix.cpp \
         r3/posix/RTPathUserHome-posix.cpp \
@@ -622 +625 @@
         r3/os2/time-os2.cpp \
         r3/posix/RTFileQueryFsSizes-posix.cpp \
+        r3/posix/RTHandleGetStandard-posix.cpp \
         r3/posix/RTMemProtect-posix.cpp \
         r3/posix/RTPathUserHome-posix.cpp \
@@ -671 +675 @@
         r3/darwin/time-darwin.cpp \
         r3/posix/RTFileQueryFsSizes-posix.cpp \
+        r3/posix/RTHandleGetStandard-posix.cpp \
         r3/posix/RTMemProtect-posix.cpp \
         r3/posix/RTPathUserHome-posix.cpp \
@@ -720 +725 @@
         r3/freebsd/rtProcInitExePath-freebsd.cpp \
         r3/posix/RTFileQueryFsSizes-posix.cpp \
+        r3/posix/RTHandleGetStandard-posix.cpp \
         r3/posix/RTMemProtect-posix.cpp \
         r3/posix/RTPathUserHome-posix.cpp \
@@ -769 +775 @@
         generic/RTThreadGetNativeState-generic.cpp \
         r3/posix/RTFileQueryFsSizes-posix.cpp \
+        r3/posix/RTHandleGetStandard-posix.cpp \
         r3/posix/RTMemProtect-posix.cpp \
         r3/posix/RTPathUserHome-posix.cpp \

trunk/src/VBox/Runtime/common/vfs/vfsbase.cpp

@@ -1084 +1084 @@
 
 
-RTDECL(int) RTVfsNewIoStream(PCRTVFSFSSTREAMOPS pFsStreamOps, size_t cbInstance, RTVFS hVfs, RTSEMRW hSemRW,
+RTDECL(int) RTVfsNewFsStream(PCRTVFSFSSTREAMOPS pFsStreamOps, size_t cbInstance, RTVFS hVfs, RTSEMRW hSemRW,
                              PRTVFSFSSTREAM phVfsFss, void **ppvInstance)
 {
@@ -1231 +1231 @@
 
     RTVFSINTERNAL *pVfs = NULL;
-    if (hVfs == NIL_RTVFS)
+    if (hVfs != NIL_RTVFS)
     {
         pVfs = hVfs;
@@ -1252 +1252 @@
     pThis->Base.uMagic  = RTVFSOBJ_MAGIC;
     pThis->Base.pvThis  = (char *)pThis + RT_ALIGN_Z(sizeof(*pThis), RTVFS_INST_ALIGNMENT);
+    pThis->Base.pOps    = &pIoStreamOps->Obj;
     pThis->Base.hSemRW  = hSemRW != NIL_RTSEMRW ? hSemRW : pVfs ? pVfs->Base.hSemRW : NIL_RTSEMRW;
     pThis->Base.hVfs    = hVfs;
@@ -1299 +1300 @@
 
 
-RTDECL(int)         RTVfsIoStrmQueryInfo(RTVFSIOSTREAM hVfsIos, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
+RTDECL(int) RTVfsIoStrmQueryInfo(RTVFSIOSTREAM hVfsIos, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
 {
     RTVFSIOSTREAMINTERNAL *pThis = hVfsIos;
@@ -1308 +1309 @@
 
 
-RTDECL(int)         RTVfsIoStrmRead(RTVFSIOSTREAM hVfsIos, void *pvBuf, size_t cbToRead, size_t *pcbRead)
+RTDECL(int) RTVfsIoStrmRead(RTVFSIOSTREAM hVfsIos, void *pvBuf, size_t cbToRead, bool fBlocking, size_t *pcbRead)
 {
     AssertPtrNullReturn(pcbRead, VERR_INVALID_POINTER);
@@ -1316 +1317 @@
     AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
     AssertReturn(pThis->uMagic == RTVFSIOSTREAM_MAGIC, VERR_INVALID_HANDLE);
+    AssertReturn(fBlocking || pcbRead, VERR_INVALID_PARAMETER);
 
     RTSGSEG Seg = { pvBuf, cbToRead };
@@ -1322 +1324 @@
 
     rtVfsObjWriteLock(&pThis->Base);
-    int rc = pThis->pOps->pfnRead(pThis->Base.pvThis, -1 /*off*/, &SgBuf, pcbRead == NULL /*fBlocking*/, pcbRead);
+    int rc = pThis->pOps->pfnRead(pThis->Base.pvThis, -1 /*off*/, &SgBuf, fBlocking, pcbRead);
     rtVfsObjWriteUnlock(&pThis->Base);
     return rc;
@@ -1328 +1330 @@
 
 
-RTDECL(int)         RTVfsIoStrmWrite(RTVFSIOSTREAM hVfsIos, const void *pvBuf, size_t cbToWrite, size_t *pcbWritten)
+RTDECL(int) RTVfsIoStrmWrite(RTVFSIOSTREAM hVfsIos, const void *pvBuf, size_t cbToWrite, bool fBlocking, size_t *pcbWritten)
 {
     AssertPtrNullReturn(pcbWritten, VERR_INVALID_POINTER);
@@ -1336 +1338 @@
     AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
     AssertReturn(pThis->uMagic == RTVFSIOSTREAM_MAGIC, VERR_INVALID_HANDLE);
+    AssertReturn(fBlocking || pcbWritten, VERR_INVALID_PARAMETER);
 
     RTSGSEG Seg = { (void *)pvBuf, cbToWrite };
@@ -1342 +1345 @@
 
     rtVfsObjWriteLock(&pThis->Base);
-    int rc = pThis->pOps->pfnWrite(pThis->Base.pvThis, -1 /*off*/, &SgBuf, pcbWritten == NULL /*fBlocking*/, pcbWritten);
+    int rc = pThis->pOps->pfnWrite(pThis->Base.pvThis, -1 /*off*/, &SgBuf, fBlocking, pcbWritten);
     rtVfsObjWriteUnlock(&pThis->Base);
     return rc;
@@ -1348 +1351 @@
 
 
-RTDECL(int)         RTVfsIoStrmSgRead(RTVFSIOSTREAM hVfsIos, PCRTSGBUF pSgBuf, bool fBlocking, size_t *pcbRead)
+RTDECL(int) RTVfsIoStrmSgRead(RTVFSIOSTREAM hVfsIos, PCRTSGBUF pSgBuf, bool fBlocking, size_t *pcbRead)
 {
     AssertPtrNullReturn(pcbRead, VERR_INVALID_POINTER);
@@ -1366 +1369 @@
 
 
-RTDECL(int)         RTVfsIoStrmSgWrite(RTVFSIOSTREAM hVfsIos, PCRTSGBUF pSgBuf, bool fBlocking, size_t *pcbWritten)
+RTDECL(int) RTVfsIoStrmSgWrite(RTVFSIOSTREAM hVfsIos, PCRTSGBUF pSgBuf, bool fBlocking, size_t *pcbWritten)
 {
     AssertPtrNullReturn(pcbWritten, VERR_INVALID_POINTER);
@@ -1384 +1387 @@
 
 
-RTDECL(int)         RTVfsIoStrmFlush(RTVFSIOSTREAM hVfsIos)
+RTDECL(int) RTVfsIoStrmFlush(RTVFSIOSTREAM hVfsIos)
 {
     RTVFSIOSTREAMINTERNAL *pThis = hVfsIos;
@@ -1397 +1400 @@
 
 
-RTDECL(RTFOFF)      RTVfsIoStrmPoll(RTVFSIOSTREAM hVfsIos, uint32_t fEvents, RTMSINTERVAL cMillies, bool fIntr,
-                                    uint32_t *pfRetEvents)
+RTDECL(RTFOFF) RTVfsIoStrmPoll(RTVFSIOSTREAM hVfsIos, uint32_t fEvents, RTMSINTERVAL cMillies, bool fIntr,
+                               uint32_t *pfRetEvents)
 {
     RTVFSIOSTREAMINTERNAL *pThis = hVfsIos;
@@ -1411 +1414 @@
 
 
-RTDECL(RTFOFF)      RTVfsIoStrmTell(RTVFSIOSTREAM hVfsIos)
+RTDECL(RTFOFF) RTVfsIoStrmTell(RTVFSIOSTREAM hVfsIos)
 {
     RTVFSIOSTREAMINTERNAL *pThis = hVfsIos;
@@ -1427 +1430 @@
 
 
-RTDECL(int)         RTVfsIoStrmSkip(RTVFSIOSTREAM hVfsIos, RTFOFF cb)
+RTDECL(int) RTVfsIoStrmSkip(RTVFSIOSTREAM hVfsIos, RTFOFF cb)
 {
     RTVFSIOSTREAMINTERNAL *pThis = hVfsIos;
@@ -1451 +1454 @@
                 size_t cbToRead = RT_MIN(cb, _64K);
                 rtVfsObjWriteLock(&pThis->Base);
-                rc = RTVfsIoStrmRead(hVfsIos, pvBuf, cbToRead, NULL);
+                rc = RTVfsIoStrmRead(hVfsIos, pvBuf, cbToRead, true /*fBlocking*/, NULL);
                 rtVfsObjWriteUnlock(&pThis->Base);
                 if (RT_FAILURE(rc))
@@ -1467 +1470 @@
 
 
-RTDECL(int)         RTVfsIoStrmZeroFill(RTVFSIOSTREAM hVfsIos, RTFOFF cb)
+RTDECL(int) RTVfsIoStrmZeroFill(RTVFSIOSTREAM hVfsIos, RTFOFF cb)
 {
     RTVFSIOSTREAMINTERNAL *pThis = hVfsIos;
@@ -1490 +1493 @@
                 size_t cbToWrite = RT_MIN(cb, _64K);
                 rtVfsObjWriteLock(&pThis->Base);
-                rc = RTVfsIoStrmWrite(hVfsIos, pvBuf, cbToWrite, NULL);
+                rc = RTVfsIoStrmWrite(hVfsIos, pvBuf, cbToWrite, true /*fBlocking*/, NULL);
                 rtVfsObjWriteUnlock(&pThis->Base);
                 if (RT_FAILURE(rc))
@@ -1534 +1537 @@
 
     RTVFSINTERNAL *pVfs = NULL;
-    if (hVfs == NIL_RTVFS)
+    if (hVfs != NIL_RTVFS)
     {
         pVfs = hVfs;
@@ -1557 +1560 @@
     pThis->Stream.pOps          = &pFileOps->Stream;
     pThis->Stream.Base.pvThis   = (char *)pThis + RT_ALIGN_Z(sizeof(*pThis), RTVFS_INST_ALIGNMENT);
+    pThis->Stream.Base.pOps     = &pFileOps->Stream.Obj;
     pThis->Stream.Base.hSemRW   = pVfs ? pVfs->Base.hSemRW : NIL_RTSEMRW;
     pThis->Stream.Base.hVfs     = hVfs;

trunk/src/VBox/Runtime/common/vfs/vfschain.cpp

@@ -431 +431 @@
         }
 
-
         /*
          * Ok, there should be an element here so add one to the return struct.
@@ -440 +439 @@
         pElement->enmAction = enmAction;
 
-        /* First comes a type which is followed by a '('. */
+        /*
+         * First up is the VFS object type followed by a parentheses.
+         */
         if (strncmp(pszSrc, "base", cch = 4) == 0)
             pElement->enmTypeOut = RTVFSOBJTYPE_BASE;
@@ -495 +496 @@
         }
 
-        /* Must end with a right parantheses. */
+        /* Must end with a right parentheses. */
         if (*pszSrc != ')')
         {
@@ -657 +658 @@
 
 
+RTDECL(bool) RTVfsChainIsSpec(const char *pszSpec)
+{
+    return pszSpec
+        && strcmp(pszSpec, RTVFSCHAIN_SPEC_PREFIX) == 0;
+}
+

trunk/src/VBox/Runtime/common/vfs/vfsstdfile.cpp

@@ -446 +446 @@
 }
 
+
+RTDECL(int)         RTVfsIoStrmFromRTFile(RTFILE hFile, uint32_t fOpen, bool fLeaveOpen, PRTVFSIOSTREAM phVfsIos)
+{
+    RTVFSFILE hVfsFile;
+    int rc = RTVfsFileFromRTFile(hFile, fOpen, fLeaveOpen, &hVfsFile);
+    if (RT_SUCCESS(rc))
+        *phVfsIos = RTVfsFileToIoStream(hVfsFile);
+    return rc;
+}
+
+
+

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

@@ -30 +30 @@
 *******************************************************************************/
 #include "internal/iprt.h"
-#include <iprt/vfslowlevel.h>
+#include <iprt/zip.h>
 
 #include <iprt/assert.h>
@@ -37 +37 @@
 #include <iprt/poll.h>
 #include <iprt/string.h>
+#include <iprt/vfslowlevel.h>
+
 #include <zlib.h>
 
@@ -477 +479 @@
     AssertPtrReturn(phVfsIosOut, VERR_INVALID_POINTER);
 
+    uint32_t cRefs = RTVfsIoStrmRetain(hVfsIosIn);
+    AssertReturn(cRefs != UINT32_MAX, VERR_INVALID_HANDLE);
+
     /*
      * Create the decompression I/O stream.
@@ -507 +512 @@
              */
             size_t cbRead = 0;
-            rc = RTVfsIoStrmRead(pThis->hVfsIos, pThis->abBuffer, sizeof(RTZIPGZIPHDR), NULL /*pcbRead*/);
+            rc = RTVfsIoStrmRead(pThis->hVfsIos, pThis->abBuffer, sizeof(RTZIPGZIPHDR), true /*fBlocking*/, NULL /*pcbRead*/);
             if (RT_SUCCESS(rc))
             {
@@ -539 +544 @@
         }
         else
-            rc = rtZipGzipConvertErrFromZlib(pThis, rc);
+            rc = rtZipGzipConvertErrFromZlib(pThis, rc); /** @todo cleaning up in this situation is going to go wrong. */
+        RTVfsIoStrmRelease(hVfsIos);
     }
+    else
+        RTVfsIoStrmRelease(hVfsIosIn);
     return rc;
 }

trunk/src/VBox/Runtime/testcase/Makefile.kmk

@@ -572 +572 @@
 RTLdrFlt_SOURCES = RTLdrFlt.cpp
 
+# RTGzip - our gzip clone (for testing the gzip/gunzip streaming code)
+PROGRAMS += RTGzip
+RTGzip_TEMPLATE = VBOXR3TSTEXE
+RTGzip_SOURCES = RTGzip.cpp
+
 
 

trunk/src/VBox/Runtime/testcase/RTGzip.cpp

@@ -31 +31 @@
 #include <iprt/zip.h>
 
+#include <iprt/buildconfig.h>
+#include <iprt/file.h>
 #include <iprt/getopt.h>
-#include <iprt/init.h>
+#include <iprt/initterm.h>
 #include <iprt/message.h>
+#include <iprt/param.h>
+#include <iprt/stream.h>
 #include <iprt/string.h>
 #include <iprt/vfs.h>
+#include <iprt/zip.h>
 
 
@@ -43 +48 @@
     return false;
 }
+
+
+/**
+ * Pushes data from the input to the output I/O streams.
+ *
+ * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE.
+ * @param   hVfsIn              The input I/O stream.
+ * @param   hVfsOut             The input I/O stream.
+ */
+static RTEXITCODE gzipPush(RTVFSIOSTREAM hVfsIn, RTVFSIOSTREAM hVfsOut)
+{
+    for (;;)
+    {
+        uint8_t abBuf[_64K];
+        size_t  cbRead;
+        int rc = RTVfsIoStrmRead(hVfsIn, 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(hVfsOut, abBuf, cbRead, true /*fBlocking*/, NULL /*cbWritten*/);
+        if (RT_FAILURE(rc))
+            return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTVfsIoStrmWrite failed: %Rrc", rc);
+    }
+}
+
+static RTEXITCODE gzipCompress(RTVFSIOSTREAM hVfsIn, RTVFSIOSTREAM hVfsOut)
+{
+    return RTMsgErrorExit(RTEXITCODE_FAILURE, "Compression is not yet implemented, sorry.");
+}
+
+
+static RTEXITCODE gzipCompressFile(const char *pszFile, bool fStdOut, bool fForce, PRTVFSIOSTREAM phVfsStdOut)
+{
+    return RTMsgErrorExit(RTEXITCODE_FAILURE, "Compression is not yet implemented, sorry.");
+}
+
+
+static RTEXITCODE gzipDecompress(RTVFSIOSTREAM hVfsIn, RTVFSIOSTREAM hVfsOut)
+{
+    RTEXITCODE      rcExit;
+    RTVFSIOSTREAM   hVfsGunzip;
+    int rc = RTZipGzipDecompressIoStream(hVfsIn, 0 /*fFlags*/, &hVfsGunzip);
+    if (RT_SUCCESS(rc))
+    {
+        rcExit = gzipPush(hVfsGunzip, hVfsOut);
+        RTVfsIoStrmRelease(hVfsGunzip);
+    }
+    else
+        rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "RTZipGzipDecompressIoStream failed: %Rrc", rc);
+    return rcExit;
+}
+
+
+/**
+ * Handles a file on the command line.
+ *
+ * @returns exit code.
+ * @param   pszFile             The file to handle.
+ * @param   fStdOut             Whether to output to standard output or not.
+ * @param   fForce              Whether to output to or input from terminals.
+ * @param   phVfsStdOut         Pointer to the standard out handle.
+ *                              (input/output)
+ */
+static RTEXITCODE gzipDecompressFile(const char *pszFile, bool fStdOut, bool fForce, PRTVFSIOSTREAM phVfsStdOut)
+{
+    /*
+     * Open the specified input file.
+     */
+    const char *pszError;
+    RTVFSIOSTREAM hVfsIn;
+    int rc = RTVfsChainOpenIoStream(pszFile, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_WRITE, &hVfsIn, &pszError);
+    if (RT_FAILURE(rc))
+    {
+        if (pszError && *pszError)
+            return RTMsgErrorExit(RTEXITCODE_FAILURE,
+                                  "RTVfsChainOpenIoStream failed with rc=%Rrc:\n"
+                                  "    '%s'\n",
+                                  "     %*s^\n",
+                                  rc, pszFile, pszError - pszFile, "");
+        return RTMsgErrorExit(RTEXITCODE_FAILURE,
+                              "RTVfsChainOpenIoStream failed with rc=%Rrc: '%s'",
+                              rc, pszFile);
+    }
+
+    /*
+     * Output the output file.
+     */
+    RTVFSIOSTREAM hVfsOut;
+    char szFinal[RTPATH_MAX];
+    if (fStdOut)
+    {
+        if (*phVfsStdOut == NIL_RTVFSIOSTREAM)
+        {
+            rc = RTVfsIoStrmFromStdHandle(RTHANDLESTD_OUTPUT, 0 /*fOpen*/, true /*fLeaveOpen*/, phVfsStdOut);
+            if (RT_FAILURE(rc))
+                return RTMsgErrorExit(RTEXITCODE_FAILURE, "Failed to set up standard out: %Rrc", rc);
+        }
+        hVfsOut = *phVfsStdOut;
+        szFinal[0] = '\0';
+    }
+    else
+    {
+        rc = RTStrCopy(szFinal, sizeof(szFinal), pszFile);
+        /** @todo remove the extension?  Or are we supposed
+         *        to get the org name from the gzip stream? */
+        return RTMsgErrorExit(RTEXITCODE_FAILURE, "Decompressing to file is not implemented");
+    }
+
+    /*
+     * Do the decompressing, then flush and close the output stream (unless
+     * it is stdout).
+     */
+    RTEXITCODE rcExit = gzipDecompress(hVfsIn, hVfsOut);
+    RTVfsIoStrmRelease(hVfsIn);
+    rc = RTVfsIoStrmFlush(hVfsOut);
+    if (RT_FAILURE(rc))
+        rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "Failed to flush the output file: %Rrc", rc);
+    RTVfsIoStrmRelease(hVfsOut);
+
+    /*
+     * Remove the input file, if that's the desire of the caller, or
+     * remove the output file on decompression failure.
+     */
+    if (!fStdOut)
+    {
+        if (rcExit == RTEXITCODE_SUCCESS)
+        {
+            rc = RTFileDelete(pszFile);
+            if (RT_FAILURE(rc))
+                rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "RTFileDelete failed with %rc: '%s'", rc, pszFile);
+        }
+        else
+        {
+            /* should we do this? */
+            rc = RTFileDelete(szFinal);
+            if (RT_FAILURE(rc))
+                RTMsgError("RTFileDelete failed with %rc: '%s'", rc, pszFile);
+        }
+    }
+
+    return rcExit;
+}
+
+
+static RTEXITCODE gzipTestFile(const char *pszFile, bool fForce)
+{
+    return RTMsgErrorExit(RTEXITCODE_FAILURE, "Testiong has not been implemented");
+}
+
+
+static RTEXITCODE gzipListFile(const char *pszFile, bool fForce)
+{
+    return RTMsgErrorExit(RTEXITCODE_FAILURE, "Listing has not been implemented");
+}
+
 
 int main(int argc, char **argv)
@@ -53 +215 @@
      * Parse the command line.
      */
-    static const RTGETOPTDEF s_aOptions[]
+    static const RTGETOPTDEF s_aOptions[] =
     {
         { "--ascii",        'a', RTGETOPT_REQ_NOTHING },
@@ -96 +258 @@
     RTEXITCODE  rcExit      = RTEXITCODE_SUCCESS;
     unsigned    cProcessed  = 0;
-
-    RTGETOPTSTAT GetState;
-    int rc = RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1,
-                          RTGETOPTINIT_FLAGS_OPTS_FIRST);
+    RTVFSIOSTREAM hVfsStdOut= NIL_RTVFSIOSTREAM;
+
+    RTGETOPTSTATE GetState;
+    rc = RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1,
+                      RTGETOPTINIT_FLAGS_OPTS_FIRST);
     for (;;)
     {
@@ -112 +275 @@
                  * input from stdin and write the output to stdout.
                  */
-                if (cProcessed)
+                if (cProcessed > 0)
                     return rcExit;
-
-                RTVFSIOSTREAM hVfsIn;
-                RTVFSIOSTREAM hVfsOut;
+#if 0
+                rc = RTVfsFileFromRTFile(1,
+                                         RTFILE_O_WRITE | RTFILE_O_OPEN | RTFILE_O_DENY_NONE,
+                                         true /*fLeaveOpen*/,
+                                         &hVfsOut);
+
 
                 if (!fForce && isStdHandleATty(fDecompress ? 0 : 1))
@@ -123 +289 @@
                                           fDecompress ? "reading" : "writing",
                                           fDecompress ? "from"    : "to");
+#else
+                rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "reading from standard input has not yet been implemented");
+#endif
                 return rcExit;
             }
@@ -128 +297 @@
             case VINF_GETOPT_NOT_OPTION:
             {
-                RTVFSIOSTREAM hVfsSrc;
-                rc = RTVfsOpenIoStreamFromSpec(ValueUnion.psz, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_WRITE, &hVfsSrc);
+                if (!*pszSuff && !fStdOut)
+                    return RTMsgErrorExit(RTEXITCODE_SYNTAX, "The --suffix option specified an empty string");
+                if (!fStdOut && RTVfsChainIsSpec(ValueUnion.psz))
+                    return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Must use standard out with VFS chain specifications");
+
+                RTEXITCODE rcExit2;
+                if (fList)
+                    rcExit2 = gzipListFile(ValueUnion.psz, fForce);
+                else if (fTest)
+                    rcExit2 = gzipTestFile(ValueUnion.psz, fForce);
+                else if (fDecompress)
+                    rcExit2 = gzipDecompressFile(ValueUnion.psz, fStdOut, fForce, &hVfsStdOut);
+                else
+                    rcExit2 = gzipCompressFile(ValueUnion.psz, fStdOut, fForce, &hVfsStdOut);
+                if (rcExit2 != RTEXITCODE_SUCCESS)
+                    rcExit = rcExit2;
 
                 cProcessed++;
-                if (fDecompress)
-                {
-                }
-                else
-                {
-                    if (!*pszSuff && !fStdOut)
-                        return
-                    {
-                    }
-                }
                 break;
             }
@@ -167 +340 @@
             case '9':   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(ch, &ValueUnion);
+                return RTGetOptPrintError(rc, &ValueUnion);
         }
     }