Changeset 57643 in vbox

Timestamp:

Sep 7, 2015 1:47:08 PM (9 years ago)

Author:

vboxsync

Message:

IPRT: Added RTVfsIoStrmFromRTPipe (and RTPipeQueryInfo) for the purpose of making RTVfsIoStrmFromStdHandle be able to work with pipes. Mostly untested.

Location:

trunk

Files:

• include/iprt/mangling.h (modified) (2 diffs)
• include/iprt/pipe.h (modified) (2 diffs)
• include/iprt/vfs.h (modified) (2 diffs)
• src/VBox/Runtime/Makefile.kmk (modified) (1 diff)
• src/VBox/Runtime/common/vfs/vfsmisc.cpp (modified) (1 diff)
• src/VBox/Runtime/common/vfs/vfsstdpipe.cpp (copied) (copied from trunk/src/VBox/Runtime/common/vfs/vfsstdfile.cpp ) (13 diffs)
• src/VBox/Runtime/include/internal/pipe.h (modified) (1 diff)
• src/VBox/Runtime/r3/os2/pipe-os2.cpp (modified) (1 diff)
• src/VBox/Runtime/r3/posix/pipe-posix.cpp (modified) (1 diff)
• src/VBox/Runtime/r3/win/pipe-win.cpp (modified) (9 diffs)

trunk/include/iprt/mangling.h

@@ -1105 +1105 @@
 # define RTPipeFlush                                    RT_MANGLER(RTPipeFlush)
 # define RTPipeFromNative                               RT_MANGLER(RTPipeFromNative)
+# define RTPipeQueryInfo                                RT_MANGLER(RTPipeQueryInfo)
 # define RTPipeQueryReadable                            RT_MANGLER(RTPipeQueryReadable)
 # define RTPipeRead                                     RT_MANGLER(RTPipeRead)
@@ -1935 +1936 @@
 # define RTVfsIoStrmFlush                               RT_MANGLER(RTVfsIoStrmFlush)
 # define RTVfsIoStrmFromRTFile                          RT_MANGLER(RTVfsIoStrmFromRTFile)
+# define RTVfsIoStrmFromRTPipe                          RT_MANGLER(RTVfsIoStrmFromRTPipe)
 # define RTVfsIoStrmFromStdHandle                       RT_MANGLER(RTVfsIoStrmFromStdHandle)
 # define RTVfsIoStrmIsAtEnd                             RT_MANGLER(RTVfsIoStrmIsAtEnd)

trunk/include/iprt/pipe.h

@@ -29 +29 @@
 #include <iprt/cdefs.h>
 #include <iprt/types.h>
+#include <iprt/fs.h>
 
 RT_C_DECLS_BEGIN
@@ -219 +220 @@
 RTDECL(int) RTPipeQueryReadable(RTPIPE hPipe, size_t *pcbReadable);
 
+/**
+ * Query information about a pipe (mainly a VFS I/O stream formality).
+ *
+ * The only thing we guarentee to be returned is RTFSOBJINFO::Attr.fMode being
+ * set to FIFO and will reflect the read/write end in the RTFS_DOS_READONLY,
+ * RTFS_UNIX_IRUSR and RTFS_UNIX_IWUSR bits.
+ *
+ * Some implementations sometimes provide the pipe buffer size via
+ * RTFSOBJINFO::cbAllocated.
+ *
+ * Some implementations sometimes provide the available read data or available
+ * write space via RTFSOBJINFO::cbObject.
+ *
+ * Some implementations sometimes provide valid device and/or inode numbers.
+ *
+ * @returns iprt status code.
+ *
+ * @param   hPipe       The IPRT read pipe handle.
+ * @param   pObjInfo    Object information structure to be filled on successful
+ *                      return.
+ * @param   enmAddAttr  Which set of additional attributes to request.  Use
+ *                      RTFSOBJATTRADD_NOTHING if this doesn't matter.
+ */
+RTDECL(int) RTPipeQueryInfo(RTPIPE hPipe, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr);
+
 /** @} */
 

trunk/include/iprt/vfs.h

@@ -440 +440 @@
 
 /**
- * Create a VFS I/O stream handle from a standard IPRT file handle (RTFILE).
+ * Creates a VFS I/O stream handle from a standard IPRT file handle (RTFILE).
  *
  * @returns IPRT status code.
@@ -451 +451 @@
  */
 RTDECL(int)         RTVfsIoStrmFromRTFile(RTFILE hFile, uint64_t fOpen, bool fLeaveOpen, PRTVFSIOSTREAM phVfsIos);
+
+/**
+ * Creates a VFS I/O stream handle from a standard IPRT pipe handle (RTPIPE).
+ *
+ * @returns IPRT status code.
+ * @param   hPipe           The standard IPRT pipe handle.
+ * @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)         RTVfsIoStrmFromRTPipe(RTPIPE hPipe, bool fLeaveOpen, PRTVFSIOSTREAM phVfsIos);
 
 /**

trunk/src/VBox/Runtime/Makefile.kmk

@@ -572 +572 @@
         common/vfs/vfsmisc.cpp \
         common/vfs/vfsstdfile.cpp \
+        common/vfs/vfsstdpipe.cpp \
         common/zip/tar.cpp \
         common/zip/tarcmd.cpp \

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

@@ -71 +71 @@
 
             case RTHANDLETYPE_PIPE:
-                /** @todo  */
-                rc = VERR_NOT_IMPLEMENTED;
+                rc = RTVfsIoStrmFromRTPipe(h.u.hPipe, fLeaveOpen, phVfsIos);
                 break;
 

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

@@ -1 +1 @@
 /* $Id$ */
 /** @file
- * IPRT - Virtual File System, Standard File Implementation.
+ * IPRT - Virtual File System, Standard Pipe I/O stream Implementation.
  */
 
@@ -32 +32 @@
 #include <iprt/vfslowlevel.h>
 
+#include <iprt/assert.h>
 #include <iprt/err.h>
 #include <iprt/file.h>
+#include <iprt/pipe.h>
 #include <iprt/poll.h>
-#include <iprt/thread.h>
 
 
@@ -42 +43 @@
 *********************************************************************************************************************************/
 /**
- * Private data of a standard file.
- */
-typedef struct RTVFSSTDFILE
-{
-    /** The file handle. */
-    RTFILE          hFile;
+ * Private data of a standard pipe.
+ */
+typedef struct RTVFSSTDPIPE
+{
+    /** The pipe handle. */
+    RTPIPE          hPipe;
     /** Whether to leave the handle open when the VFS handle is closed. */
     bool            fLeaveOpen;
-} RTVFSSTDFILE;
-/** Pointer to the private data of a standard file. */
-typedef RTVFSSTDFILE *PRTVFSSTDFILE;
+    /** Set if primarily read, clear if write. */
+    bool            fReadPipe;
+    /** Fake stream position. */
+    uint64_t        offFakePos;
+} RTVFSSTDPIPE;
+/** Pointer to the private data of a standard pipe. */
+typedef RTVFSSTDPIPE *PRTVFSSTDPIPE;
 
 
@@ -58 +63 @@
  * @interface_method_impl{RTVFSOBJOPS,pfnClose}
  */
-static DECLCALLBACK(int) rtVfsStdFile_Close(void *pvThis)
-{
-    PRTVFSSTDFILE pThis = (PRTVFSSTDFILE)pvThis;
+static DECLCALLBACK(int) rtVfsStdPipe_Close(void *pvThis)
+{
+    PRTVFSSTDPIPE pThis = (PRTVFSSTDPIPE)pvThis;
 
     int rc;
     if (!pThis->fLeaveOpen)
-        rc = RTFileClose(pThis->hFile);
+        rc = RTPipeClose(pThis->hPipe);
     else
         rc = VINF_SUCCESS;
-    pThis->hFile = NIL_RTFILE;
+    pThis->hPipe = NIL_RTPIPE;
 
     return rc;
@@ -76 +81 @@
  * @interface_method_impl{RTVFSOBJOPS,pfnQueryInfo}
  */
-static DECLCALLBACK(int) rtVfsStdFile_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
-{
-    PRTVFSSTDFILE pThis = (PRTVFSSTDFILE)pvThis;
-    return RTFileQueryInfo(pThis->hFile, pObjInfo, enmAddAttr);
-}
-
-
-/**
- * RTFileRead and RTFileReadAt does not return VINF_EOF or VINF_TRY_AGAIN, this
- * function tries to fix this as best as it can.
- *
- * This fixing can be subject to races if some other thread or process is
- * modifying the file size between the read and our size query here.
- *
- * @returns VINF_SUCCESS, VINF_EOF or VINF_TRY_AGAIN.
- * @param   pThis               The instance data.
- * @param   off                 The offset parameter.
- * @param   cbToRead            The number of bytes attempted read .
- * @param   cbActuallyRead      The number of bytes actually read.
- */
-DECLINLINE(int) rtVfsStdFile_ReadFixRC(PRTVFSSTDFILE pThis, RTFOFF off, size_t cbToRead, size_t cbActuallyRead)
-{
-    /* If the read returned less bytes than requested, it means the end of the
-       file has been reached. */
-    if (cbToRead > cbActuallyRead)
-        return VINF_EOF;
-
-    /* The other case here is the very special zero byte read at the end of the
-       file, where we're supposed to indicate EOF. */
-    if (cbToRead > 0)
-        return VINF_SUCCESS;
-
-    uint64_t cbFile;
-    int rc = RTFileGetSize(pThis->hFile, &cbFile);
-    if (RT_FAILURE(rc))
-        return rc;
-
-    uint64_t off2;
-    if (off >= 0)
-        off2 = off;
-    else
-    {
-        rc = RTFileSeek(pThis->hFile, 0, RTFILE_SEEK_CURRENT, &off2);
-        if (RT_FAILURE(rc))
-            return rc;
-    }
-
-    return off2 >= cbFile ? VINF_EOF : VINF_SUCCESS;
+static DECLCALLBACK(int) rtVfsStdPipe_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
+{
+    PRTVFSSTDPIPE pThis = (PRTVFSSTDPIPE)pvThis;
+    return RTPipeQueryInfo(pThis->hPipe, pObjInfo, enmAddAttr);
 }
 
@@ -130 +91 @@
  * @interface_method_impl{RTVFSIOSTREAMOPS,pfnRead}
  */
-static DECLCALLBACK(int) rtVfsStdFile_Read(void *pvThis, RTFOFF off, PCRTSGBUF pSgBuf, bool fBlocking, size_t *pcbRead)
-{
-    PRTVFSSTDFILE pThis = (PRTVFSSTDFILE)pvThis;
+static DECLCALLBACK(int) rtVfsStdPipe_Read(void *pvThis, RTFOFF off, PCRTSGBUF pSgBuf, bool fBlocking, size_t *pcbRead)
+{
+    PRTVFSSTDPIPE pThis = (PRTVFSSTDPIPE)pvThis;
     int           rc;
+    AssertReturn(off < 0 || pThis->offFakePos == off, VERR_SEEK_ON_DEVICE);
 
     NOREF(fBlocking);
     if (pSgBuf->cSegs == 1)
     {
-        if (off < 0)
-            rc = RTFileRead(  pThis->hFile,      pSgBuf->paSegs[0].pvSeg, pSgBuf->paSegs[0].cbSeg, pcbRead);
+        if (fBlocking)
+            rc = RTPipeReadBlocking(pThis->hPipe, pSgBuf->paSegs[0].pvSeg, pSgBuf->paSegs[0].cbSeg, pcbRead);
         else
-            rc = RTFileReadAt(pThis->hFile, off, pSgBuf->paSegs[0].pvSeg, pSgBuf->paSegs[0].cbSeg, pcbRead);
-        if (rc == VINF_SUCCESS && pcbRead)
-            rc = rtVfsStdFile_ReadFixRC(pThis, off, pSgBuf->paSegs[0].cbSeg, *pcbRead);
+            rc = RTPipeRead(        pThis->hPipe, pSgBuf->paSegs[0].pvSeg, pSgBuf->paSegs[0].cbSeg, pcbRead);
+        if (RT_SUCCESS(rc))
+            pThis->offFakePos += pcbRead ? *pcbRead : pSgBuf->paSegs[0].cbSeg;
     }
     else
@@ -150 +112 @@
         size_t  cbRead     = 0;
         size_t  cbReadSeg  = 0;
+        size_t *pcbReadSeg = pcbRead ? &cbReadSeg : NULL;
         rc = VINF_SUCCESS;
 
@@ -158 +121 @@
 
             cbReadSeg = cbSeg;
-            if (off < 0)
-                rc = RTFileRead(  pThis->hFile,      pvSeg, cbSeg, pcbRead ? &cbReadSeg : NULL);
+            if (fBlocking)
+                rc = RTPipeReadBlocking(pThis->hPipe, pvSeg, cbSeg, pcbReadSeg);
             else
-                rc = RTFileReadAt(pThis->hFile, off, pvSeg, cbSeg, pcbRead ? &cbReadSeg : NULL);
+                rc = RTPipeRead(        pThis->hPipe, pvSeg, cbSeg, pcbReadSeg);
             if (RT_FAILURE(rc))
                 break;
-            if (off >= 0)
-                off += cbReadSeg;
-            cbRead  += cbReadSeg;
-            if ((pcbRead && cbReadSeg != cbSeg) || rc != VINF_SUCCESS)
+            pThis->offFakePos += pcbRead ? cbReadSeg : cbSeg;
+            cbRead += cbReadSeg;
+            if (rc != VINF_SUCCESS)
                 break;
+            AssertBreakStmt(!pcbRead || cbReadSeg == cbSeg, rc = VINF_TRY_AGAIN);
         }
 
         if (pcbRead)
-        {
             *pcbRead = cbRead;
-            if (rc == VINF_SUCCESS)
-                rc = rtVfsStdFile_ReadFixRC(pThis, off, cbSeg, cbReadSeg);
-        }
     }
 
@@ -186 +145 @@
  * @interface_method_impl{RTVFSIOSTREAMOPS,pfnWrite}
  */
-static DECLCALLBACK(int) rtVfsStdFile_Write(void *pvThis, RTFOFF off, PCRTSGBUF pSgBuf, bool fBlocking, size_t *pcbWritten)
-{
-    PRTVFSSTDFILE pThis = (PRTVFSSTDFILE)pvThis;
+static DECLCALLBACK(int) rtVfsStdPipe_Write(void *pvThis, RTFOFF off, PCRTSGBUF pSgBuf, bool fBlocking, size_t *pcbWritten)
+{
+    PRTVFSSTDPIPE pThis = (PRTVFSSTDPIPE)pvThis;
     int           rc;
-
-    NOREF(fBlocking);
+    AssertReturn(off < 0 || pThis->offFakePos == off, VERR_SEEK_ON_DEVICE);
+
     if (pSgBuf->cSegs == 1)
     {
-        if (off < 0)
-            rc = RTFileWrite(pThis->hFile, pSgBuf->paSegs[0].pvSeg, pSgBuf->paSegs[0].cbSeg, pcbWritten);
+        if (fBlocking)
+            rc = RTPipeWriteBlocking(pThis->hPipe, pSgBuf->paSegs[0].pvSeg, pSgBuf->paSegs[0].cbSeg, pcbWritten);
         else
-            rc = RTFileWriteAt(pThis->hFile, off, pSgBuf->paSegs[0].pvSeg, pSgBuf->paSegs[0].cbSeg, pcbWritten);
+            rc = RTPipeWrite(        pThis->hPipe, pSgBuf->paSegs[0].pvSeg, pSgBuf->paSegs[0].cbSeg, pcbWritten);
+        if (RT_SUCCESS(rc))
+            pThis->offFakePos += pcbWritten ? *pcbWritten : pSgBuf->paSegs[0].cbSeg;
     }
     else
@@ -212 +173 @@
 
             cbWrittenSeg = 0;
-            if (off < 0)
-                rc = RTFileWrite(pThis->hFile, pvSeg, cbSeg, pcbWrittenSeg);
+            if (fBlocking)
+                rc = RTPipeWriteBlocking(pThis->hPipe, pvSeg, cbSeg, pcbWrittenSeg);
             else
-            {
-                rc = RTFileWriteAt(pThis->hFile, off, pvSeg, cbSeg, pcbWrittenSeg);
-                off += cbSeg;
-            }
+                rc = RTPipeWrite(        pThis->hPipe, pvSeg, cbSeg, pcbWrittenSeg);
             if (RT_FAILURE(rc))
                 break;
+            pThis->offFakePos += pcbWritten ? cbWrittenSeg : cbSeg;
             if (pcbWritten)
             {
                 cbWritten += cbWrittenSeg;
-                if (cbWrittenSeg != cbSeg)
+                if (rc != VINF_SUCCESS)
                     break;
+                AssertStmt(cbWrittenSeg == cbSeg, rc = VINF_TRY_AGAIN);
             }
+            else
+                AssertBreak(rc == VINF_SUCCESS);
         }
 
@@ -240 +202 @@
  * @interface_method_impl{RTVFSIOSTREAMOPS,pfnFlush}
  */
-static DECLCALLBACK(int) rtVfsStdFile_Flush(void *pvThis)
-{
-    PRTVFSSTDFILE pThis = (PRTVFSSTDFILE)pvThis;
-    return RTFileFlush(pThis->hFile);
+static DECLCALLBACK(int) rtVfsStdPipe_Flush(void *pvThis)
+{
+    PRTVFSSTDPIPE pThis = (PRTVFSSTDPIPE)pvThis;
+    return RTPipeFlush(pThis->hPipe);
 }
 
@@ -250 +212 @@
  * @interface_method_impl{RTVFSIOSTREAMOPS,pfnPollOne}
  */
-static DECLCALLBACK(int) rtVfsStdFile_PollOne(void *pvThis, uint32_t fEvents, RTMSINTERVAL cMillies, bool fIntr,
+static DECLCALLBACK(int) rtVfsStdPipe_PollOne(void *pvThis, uint32_t fEvents, RTMSINTERVAL cMillies, bool fIntr,
                                               uint32_t *pfRetEvents)
 {
-    NOREF(pvThis);
-    int rc;
-    if (fEvents != RTPOLL_EVT_ERROR)
-    {
-        *pfRetEvents = fEvents & ~RTPOLL_EVT_ERROR;
+    PRTVFSSTDPIPE pThis = (PRTVFSSTDPIPE)pvThis;
+    uint32_t const fPossibleEvt = pThis->fReadPipe ? RTPOLL_EVT_READ : RTPOLL_EVT_WRITE;
+
+    int rc = RTPipeSelectOne(pThis->hPipe, cMillies);
+    if (RT_SUCCESS(rc))
+    {
+        if (fEvents & fPossibleEvt)
+            *pfRetEvents = fPossibleEvt;
+        else
+            rc = RTVfsUtilDummyPollOne(fEvents, cMillies, fIntr, pfRetEvents);
+    }
+    else if (   rc != VERR_TIMEOUT
+             && rc != VERR_INTERRUPTED
+             && rc != VERR_TRY_AGAIN /* paranoia */)
+    {
+        *pfRetEvents = RTPOLL_EVT_ERROR;
         rc = VINF_SUCCESS;
     }
-    else if (fIntr)
-        rc = RTThreadSleep(cMillies);
-    else
-    {
-        uint64_t uMsStart = RTTimeMilliTS();
-        do
-            rc = RTThreadSleep(cMillies);
-        while (   rc == VERR_INTERRUPTED
-               && !fIntr
-               && RTTimeMilliTS() - uMsStart < cMillies);
-        if (rc == VERR_INTERRUPTED)
-            rc = VERR_TIMEOUT;
-    }
+
     return rc;
 }
@@ -280 +241 @@
  * @interface_method_impl{RTVFSIOSTREAMOPS,pfnTell}
  */
-static DECLCALLBACK(int) rtVfsStdFile_Tell(void *pvThis, PRTFOFF poffActual)
-{
-    PRTVFSSTDFILE pThis = (PRTVFSSTDFILE)pvThis;
-    uint64_t offActual;
-    int rc = RTFileSeek(pThis->hFile, 0, RTFILE_SEEK_CURRENT, &offActual);
-    if (RT_SUCCESS(rc))
-        *poffActual = (RTFOFF)offActual;
-    return rc;
-}
-
-
-/**
- * @interface_method_impl{RTVFSIOSTREAMOPS,pfnSkip}
- */
-static DECLCALLBACK(int) rtVfsStdFile_Skip(void *pvThis, RTFOFF cb)
-{
-    PRTVFSSTDFILE pThis = (PRTVFSSTDFILE)pvThis;
-    uint64_t offIgnore;
-    return RTFileSeek(pThis->hFile, cb, RTFILE_SEEK_CURRENT, &offIgnore);
-}
-
-
-/**
- * @interface_method_impl{RTVFSOBJSETOPS,pfnMode}
- */
-static DECLCALLBACK(int) rtVfsStdFile_SetMode(void *pvThis, RTFMODE fMode, RTFMODE fMask)
-{
-    PRTVFSSTDFILE pThis = (PRTVFSSTDFILE)pvThis;
-    if (fMask != ~RTFS_TYPE_MASK)
-    {
-#if 0
-        RTFMODE fCurMode;
-        int rc = RTFileGetMode(pThis->hFile, &fCurMode);
-        if (RT_FAILURE(rc))
-            return rc;
-        fMode |= ~fMask & fCurMode;
-#else
-        RTFSOBJINFO ObjInfo;
-        int rc = RTFileQueryInfo(pThis->hFile, &ObjInfo, RTFSOBJATTRADD_NOTHING);
-        if (RT_FAILURE(rc))
-            return rc;
-        fMode |= ~fMask & ObjInfo.Attr.fMode;
-#endif
-    }
-    return RTFileSetMode(pThis->hFile, fMode);
-}
-
-
-/**
- * @interface_method_impl{RTVFSOBJSETOPS,pfnSetTimes}
- */
-static DECLCALLBACK(int) rtVfsStdFile_SetTimes(void *pvThis, PCRTTIMESPEC pAccessTime, PCRTTIMESPEC pModificationTime,
-                                               PCRTTIMESPEC pChangeTime, PCRTTIMESPEC pBirthTime)
-{
-    PRTVFSSTDFILE pThis = (PRTVFSSTDFILE)pvThis;
-    return RTFileSetTimes(pThis->hFile, pAccessTime, pModificationTime, pChangeTime, pBirthTime);
-}
-
-
-/**
- * @interface_method_impl{RTVFSOBJSETOPS,pfnSetOwner}
- */
-static DECLCALLBACK(int) rtVfsStdFile_SetOwner(void *pvThis, RTUID uid, RTGID gid)
-{
-#if 0
-    PRTVFSSTDFILE pThis = (PRTVFSSTDFILE)pvThis;
-    return RTFileSetOwner(pThis->hFile, uid, gid);
-#else
-    NOREF(pvThis); NOREF(uid); NOREF(gid);
-    return VERR_NOT_IMPLEMENTED;
-#endif
-}
-
-
-/**
- * @interface_method_impl{RTVFSFILEOPS,pfnSeek}
- */
-static DECLCALLBACK(int) rtVfsStdFile_Seek(void *pvThis, RTFOFF offSeek, unsigned uMethod, PRTFOFF poffActual)
-{
-    PRTVFSSTDFILE pThis     = (PRTVFSSTDFILE)pvThis;
-    uint64_t      offActual = 0;
-    int rc = RTFileSeek(pThis->hFile, offSeek, uMethod, &offActual);
-    if (RT_SUCCESS(rc))
-        *poffActual = offActual;
-    return rc;
-}
-
-
-/**
- * @interface_method_impl{RTVFSFILEOPS,pfnQuerySize}
- */
-static DECLCALLBACK(int) rtVfsStdFile_QuerySize(void *pvThis, uint64_t *pcbFile)
-{
-    PRTVFSSTDFILE pThis = (PRTVFSSTDFILE)pvThis;
-    return RTFileGetSize(pThis->hFile, pcbFile);
-}
-
-
-/**
- * Standard file operations.
- */
-DECL_HIDDEN_CONST(const RTVFSFILEOPS) g_rtVfsStdFileOps =
-{
-    { /* Stream */
-        { /* Obj */
-            RTVFSOBJOPS_VERSION,
-            RTVFSOBJTYPE_FILE,
-            "StdFile",
-            rtVfsStdFile_Close,
-            rtVfsStdFile_QueryInfo,
-            RTVFSOBJOPS_VERSION
-        },
-        RTVFSIOSTREAMOPS_VERSION,
-        0,
-        rtVfsStdFile_Read,
-        rtVfsStdFile_Write,
-        rtVfsStdFile_Flush,
-        rtVfsStdFile_PollOne,
-        rtVfsStdFile_Tell,
-        rtVfsStdFile_Skip,
-        NULL /*ZeroFill*/,
-        RTVFSIOSTREAMOPS_VERSION,
+static DECLCALLBACK(int) rtVfsStdPipe_Tell(void *pvThis, PRTFOFF poffActual)
+{
+    PRTVFSSTDPIPE pThis = (PRTVFSSTDPIPE)pvThis;
+    *poffActual = pThis->offFakePos;
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * Standard pipe operations.
+ */
+DECL_HIDDEN_CONST(const RTVFSIOSTREAMOPS) g_rtVfsStdPipeOps =
+{
+    { /* Obj */
+        RTVFSOBJOPS_VERSION,
+        RTVFSOBJTYPE_IO_STREAM,
+        "StdFile",
+        rtVfsStdPipe_Close,
+        rtVfsStdPipe_QueryInfo,
+        RTVFSOBJOPS_VERSION
     },
-    RTVFSFILEOPS_VERSION,
+    RTVFSIOSTREAMOPS_VERSION,
     0,
-    { /* ObjSet */
-        RTVFSOBJSETOPS_VERSION,
-        RT_OFFSETOF(RTVFSFILEOPS, Stream.Obj) - RT_OFFSETOF(RTVFSFILEOPS, ObjSet),
-        rtVfsStdFile_SetMode,
-        rtVfsStdFile_SetTimes,
-        rtVfsStdFile_SetOwner,
-        RTVFSOBJSETOPS_VERSION
-    },
-    rtVfsStdFile_Seek,
-    rtVfsStdFile_QuerySize,
-    RTVFSFILEOPS_VERSION
+    rtVfsStdPipe_Read,
+    rtVfsStdPipe_Write,
+    rtVfsStdPipe_Flush,
+    rtVfsStdPipe_PollOne,
+    rtVfsStdPipe_Tell,
+    NULL /*rtVfsStdPipe_Skip*/,
+    NULL /*ZeroFill*/,
+    RTVFSIOSTREAMOPS_VERSION,
 };
 
 
 /**
- * Internal worker for RTVfsFileFromRTFile and RTVfsFileOpenNormal.
+ * Internal worker for RTVfsIosFromRTPipe and later some create API.
  *
  * @returns IRPT status code.
- * @param   hFile               The IPRT file handle.
+ * @param   hPipe               The IPRT file handle.
  * @param   fOpen               The RTFILE_O_XXX flags.
  * @param   fLeaveOpen          Whether to leave it open or close it.
  * @param   phVfsFile           Where to return the handle.
  */
-static int rtVfsFileFromRTFile(RTFILE hFile, uint64_t fOpen, bool fLeaveOpen, PRTVFSFILE phVfsFile)
-{
-    PRTVFSSTDFILE   pThis;
-    RTVFSFILE       hVfsFile;
-    int rc = RTVfsNewFile(&g_rtVfsStdFileOps, sizeof(RTVFSSTDFILE), fOpen, NIL_RTVFS, NIL_RTVFSLOCK,
-                          &hVfsFile, (void **)&pThis);
+static int rtVfsFileFromRTPipe(RTPIPE hPipe, uint64_t fOpen, bool fLeaveOpen, PRTVFSIOSTREAM phVfsIos)
+{
+    PRTVFSSTDPIPE   pThis;
+    RTVFSIOSTREAM   hVfsIos;
+    int rc = RTVfsNewIoStream(&g_rtVfsStdPipeOps, sizeof(RTVFSSTDPIPE), fOpen, NIL_RTVFS, NIL_RTVFSLOCK,
+                              &hVfsIos, (void **)&pThis);
     if (RT_FAILURE(rc))
         return rc;
 
-    pThis->hFile        = hFile;
+    pThis->hPipe        = hPipe;
     pThis->fLeaveOpen   = fLeaveOpen;
-    *phVfsFile = hVfsFile;
+    *phVfsIos = hVfsIos;
     return VINF_SUCCESS;
 }
 
 
-RTDECL(int) RTVfsFileFromRTFile(RTFILE hFile, uint64_t fOpen, bool fLeaveOpen, PRTVFSFILE phVfsFile)
+RTDECL(int) RTVfsIoStrmFromRTPipe(RTPIPE hPipe, bool fLeaveOpen, PRTVFSIOSTREAM phVfsIos)
 {
     /*
-     * Check the handle validity.
+     * Check the handle validity and read/write mode, then create a stream for it.
      */
     RTFSOBJINFO ObjInfo;
-    int rc = RTFileQueryInfo(hFile, &ObjInfo, RTFSOBJATTRADD_NOTHING);
-    if (RT_FAILURE(rc))
-        return rc;
-
-    /*
-     * Set up some fake fOpen flags if necessary and create a VFS file handle.
-     */
-    if (!fOpen)
-        fOpen = RTFILE_O_READWRITE | RTFILE_O_DENY_NONE | RTFILE_O_OPEN_CREATE;
-
-    return rtVfsFileFromRTFile(hFile, fOpen, fLeaveOpen, phVfsFile);
-}
-
-
-RTDECL(int) RTVfsFileOpenNormal(const char *pszFilename, uint64_t fOpen, PRTVFSFILE phVfsFile)
-{
-    /*
-     * Open the file the normal way and pass it to RTVfsFileFromRTFile.
-     */
-    RTFILE hFile;
-    int rc = RTFileOpen(&hFile, pszFilename, fOpen);
+    int rc = RTPipeQueryInfo(hPipe, &ObjInfo, RTFSOBJATTRADD_NOTHING);
     if (RT_SUCCESS(rc))
-    {
-        /*
-         * Create a VFS file handle.
-         */
-        rc = rtVfsFileFromRTFile(hFile, fOpen, false /*fLeaveOpen*/, phVfsFile);
-        if (RT_FAILURE(rc))
-            RTFileClose(hFile);
-    }
-    return rc;
-}
-
-
-RTDECL(int) RTVfsIoStrmFromRTFile(RTFILE hFile, uint64_t fOpen, bool fLeaveOpen, PRTVFSIOSTREAM phVfsIos)
-{
-    RTVFSFILE hVfsFile;
-    int rc = RTVfsFileFromRTFile(hFile, fOpen, fLeaveOpen, &hVfsFile);
-    if (RT_SUCCESS(rc))
-    {
-        *phVfsIos = RTVfsFileToIoStream(hVfsFile);
-        RTVfsFileRelease(hVfsFile);
-    }
-    return rc;
-}
-
-
-RTDECL(int) RTVfsIoStrmOpenNormal(const char *pszFilename, uint64_t fOpen, PRTVFSIOSTREAM phVfsIos)
-{
-    RTVFSFILE hVfsFile;
-    int rc = RTVfsFileOpenNormal(pszFilename, fOpen, &hVfsFile);
-    if (RT_SUCCESS(rc))
-        *phVfsIos = RTVfsFileToIoStream(hVfsFile);
-    return rc;
-}
-
+        rc = rtVfsFileFromRTPipe(hPipe,
+                                 ObjInfo.Attr.fMode & RTFS_DOS_READONLY ? RTFILE_O_READ : RTFILE_O_WRITE,
+                                 fLeaveOpen, phVfsIos);
+    return rc;
+}
+
+/** @todo Create pipe API? */
+

trunk/src/VBox/Runtime/include/internal/pipe.h

@@ -82 +82 @@
 uint32_t    rtPipePollDone(RTPIPE hPipe, uint32_t fEvents, bool fFinalEntry, bool fHarvestEvents);
 
+
+/**
+ * Fakes basic query info data for RTPipeQueryInfo.
+ *
+ * @param   pObjInfo            The output structure.
+ * @param   enmAddAttr          The extra attribute.
+ * @param   fReadPipe           Set if read pipe, clear if write pipe.
+ */
+DECLINLINE(void) rtPipeFakeQueryInfo(PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr, bool fReadPipe)
+{
+    RT_ZERO(*pObjInfo);
+    if (fReadPipe)
+        pObjInfo->Attr.fMode     = RTFS_TYPE_FIFO | RTFS_UNIX_IRUSR | RTFS_DOS_READONLY;
+    else
+        pObjInfo->Attr.fMode     = RTFS_TYPE_FIFO | RTFS_UNIX_IWUSR;
+    pObjInfo->Attr.enmAdditional = enmAddAttr;
+    switch (enmAddAttr)
+    {
+        case RTFSOBJATTRADD_UNIX:
+            pObjInfo->Attr.u.Unix.cHardlinks = 1;
+            break;
+        case RTFSOBJATTRADD_UNIX_OWNER:
+            pObjInfo->Attr.u.UnixOwner.uid = NIL_RTUID;
+            break;
+        case RTFSOBJATTRADD_UNIX_GROUP:
+            pObjInfo->Attr.u.UnixGroup.gid = NIL_RTGID;
+            break;
+        case RTFSOBJATTRADD_EASIZE:
+            break;
+        case RTFSOBJATTRADD_32BIT_SIZE_HACK:
+            /* shut up gcc. */
+            break;
+        /* no default, want warnings. */
+    }
+}
+
+
 RT_C_DECLS_END
 

trunk/src/VBox/Runtime/r3/os2/pipe-os2.cpp

@@ -879 +879 @@
 
 
+RTDECL(int) RTPipeQueryInfo(RTPIPE hPipe, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
+{
+    RTPIPEINTERNAL *pThis = hPipe;
+    AssertPtrReturn(pThis, 0);
+    AssertReturn(pThis->u32Magic == RTPIPE_MAGIC, 0);
+
+    int rc = RTCritSectEnter(&pThis->CritSect);
+    AssertRCReturn(rc, 0);
+
+    rtPipeFakeQueryInfo(pObjInfo, enmAddAttr, pThis->fRead);
+
+    if (pThis->fRead)
+    {
+        ULONG       cbActual = 0;
+        ULONG       ulState  = 0;
+        AVAILDATA   Avail    = { 0, 0 };
+        APIRET orc = DosPeekNPipe(pThis->hPipe, NULL, 0, &cbActual, &Avail, &ulState);
+        if (orc == NO_ERROR && (Avail.cbpipe > 0 || ulState == NP_STATE_CONNECTED))
+            pObjInfo->cbObject = Avail.cbpipe;
+    }
+    else
+        pObjInfo->cbObject = rtPipeOs2GetSpace(pThis)
+    pObjInfo->cbAllocated = RTPIPE_OS2_SIZE; /** @todo this isn't necessarily true if we didn't create it... but, whatever */
+
+    RTCritSectLeave(&pThis->CritSect);
+    return VINF_SUCCESS;
+}
+
+
 int rtPipePollGetHandle(RTPIPE hPipe, uint32_t fEvents, PRTHCINTPTR phNative)
 {

trunk/src/VBox/Runtime/r3/posix/pipe-posix.cpp

@@ -672 +672 @@
 
 
+RTDECL(int) RTPipeQueryInfo(RTPIPE hPipe, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
+{
+    RTPIPEINTERNAL *pThis = hPipe;
+    AssertPtrReturn(pThis, 0);
+    AssertReturn(pThis->u32Magic == RTPIPE_MAGIC, 0);
+
+    rtPipeFakeQueryInfo(pObjInfo, enmAddAttr, pThis->fRead);
+
+    if (pThis->fRead)
+    {
+        int cb = 0;
+        int rc = ioctl(pThis->fd, FIONREAD, &cb);
+        if (rc >= 0)
+            pObjInfo->cbObject = cb;
+    }
+#ifdef FIONSPACE
+    else
+    {
+        int cb = 0;
+        int rc = ioctl(pThis->fd, FIONSPACE, &cb);
+        if (rc >= 0)
+            pObjInfo->cbObject = cb;
+    }
+#endif
+
+    /** @todo Check this out on linux, solaris and darwin... (Currently going by a
+     *        FreeBSD manpage.) */
+    struct stat St;
+    if (fstat(pThis->fd, &St))
+    {
+        pObjInfo->cbAllocated = St.st_blksize;
+        if (   enmAddAttr == RTFSOBJATTRADD_NOTHING
+            || enmAddAttr == RTFSOBJATTRADD_UNIX)
+        {
+            pObjInfo->Attr.enmAdditional = RTFSOBJATTRADD_UNIX;
+            pObjInfo->Attr.u.Unix.INodeId       = St.st_ino;
+            pObjInfo->Attr.u.Unix.INodeIdDevice = St.st_dev;
+        }
+    }
+    /** @todo error handling?  */
+
+    return VINF_SUCCESS;
+}
+
+
 int rtPipePollGetHandle(RTPIPE hPipe, uint32_t fEvents, PRTHCINTPTR phNative)
 {

trunk/src/VBox/Runtime/r3/win/pipe-win.cpp

@@ -149 +149 @@
  * @param   pInfo               The info structure.
  */
-static bool rtPipeQueryInfo(RTPIPEINTERNAL *pThis, FILE_PIPE_LOCAL_INFORMATION *pInfo)
+static bool rtPipeQueryNtInfo(RTPIPEINTERNAL *pThis, FILE_PIPE_LOCAL_INFORMATION *pInfo)
 {
     IO_STATUS_BLOCK Ios;
@@ -459 +459 @@
 
     /*
-     * Looks kind of OK, create a handle so we can try rtPipeQueryInfo on it
+     * Looks kind of OK, create a handle so we can try rtPipeQueryNtInfo on it
      * and see if we need to duplicate it to make that call work.
      */
@@ -487 +487 @@
             HANDLE  hNative2 = INVALID_HANDLE_VALUE;
             FILE_PIPE_LOCAL_INFORMATION Info;
-            if (rtPipeQueryInfo(pThis, &Info))
+            if (rtPipeQueryNtInfo(pThis, &Info))
                 rc = VINF_SUCCESS;
             else
@@ -498 +498 @@
                 {
                     pThis->hPipe = hNative2;
-                    if (rtPipeQueryInfo(pThis, &Info))
+                    if (rtPipeQueryNtInfo(pThis, &Info))
                         rc = VINF_SUCCESS;
                     else
@@ -538 +538 @@
                      * Ok, we're good!
                      */
+/** @todo This is bogus for standard handles! */
                     if (hNative2 != INVALID_HANDLE_VALUE)
                         CloseHandle(hNative);
@@ -746 +747 @@
                 if (   !pThis->fPromisedWritable
                     && cbToWrite > 0
-                    && rtPipeQueryInfo(pThis, &Info))
+                    && rtPipeQueryNtInfo(pThis, &Info))
                 {
                     if (Info.NamedPipeState == FILE_PIPE_CLOSING_STATE)
@@ -1051 +1052 @@
             {
                 FILE_PIPE_LOCAL_INFORMATION Info;
-                if (rtPipeQueryInfo(pThis, &Info))
+                if (rtPipeQueryNtInfo(pThis, &Info))
                 {
                     /* Check for broken pipe. */
@@ -1172 +1173 @@
 
 
+RTDECL(int) RTPipeQueryInfo(RTPIPE hPipe, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
+{
+    RTPIPEINTERNAL *pThis = hPipe;
+    AssertPtrReturn(pThis, 0);
+    AssertReturn(pThis->u32Magic == RTPIPE_MAGIC, 0);
+
+    int rc = RTCritSectEnter(&pThis->CritSect);
+    AssertRCReturn(rc, 0);
+
+    rtPipeFakeQueryInfo(pObjInfo, enmAddAttr, pThis->fRead);
+
+    FILE_PIPE_LOCAL_INFORMATION Info;
+    if (rtPipeQueryNtInfo(pThis, &Info))
+    {
+        pObjInfo->cbAllocated = pThis->fRead ? Info.InboundQuota : Info.OutboundQuota;
+        pObjInfo->cbObject    = pThis->fRead ? Info.ReadDataAvailable : Info.WriteQuotaAvailable;
+    }
+
+    RTCritSectLeave(&pThis->CritSect);
+    return VINF_SUCCESS;
+}
+
+
 int rtPipePollGetHandle(RTPIPE hPipe, uint32_t fEvents, PRTHCINTPTR phNative)
 {
@@ -1232 +1256 @@
         {
             FILE_PIPE_LOCAL_INFORMATION Info;
-            if (rtPipeQueryInfo(pThis, &Info))
+            if (rtPipeQueryNtInfo(pThis, &Info))
             {
                 /* Check for broken pipe. */