Merge pull request #25 from ntherning/bump-corert

Bump to latest upstream

1 files changed, 53 insertions, 0 deletions

diff --git a/src/System.Private.CoreLib/shared/System/IO/FileStream.WinRT.cs b/src/System.Private.CoreLib/shared/System/IO/FileStream.WinRT.cs
index 304088eea..b326525a7 100644
--- a/src/System.Private.CoreLib/shared/System/IO/FileStream.WinRT.cs
+++ b/src/System.Private.CoreLib/shared/System/IO/FileStream.WinRT.cs
@@ -40,5 +40,58 @@ namespace System.IO
                     pCreateExParams: ref parameters));
             }
         }
+
+        private static bool GetDefaultIsAsync(SafeFileHandle handle) => handle.IsAsync ?? DefaultIsAsync;
+
+        private static unsafe bool? IsHandleSynchronous(SafeFileHandle handle, FileAccess access)
+        {
+            // Do NOT use this method on any type other than DISK. Reading or writing to a pipe may
+            // cause an app to block incorrectly, introducing a deadlock (depending on whether a write
+            // will wake up an already-blocked thread or this Win32FileStream's thread).
+
+            byte* bytes = stackalloc byte[1];
+            int numBytesReadWritten;
+            int r = -1;
+
+            // If the handle is a pipe, ReadFile will block until there
+            // has been a write on the other end.  We'll just have to deal with it,
+            // For the read end of a pipe, you can mess up and 
+            // accidentally read synchronously from an async pipe.
+            if ((access & FileAccess.Read) != 0)
+            {
+                r = Interop.Kernel32.ReadFile(handle, bytes, 0, out numBytesReadWritten, IntPtr.Zero);
+            }
+            else if ((access & FileAccess.Write) != 0)
+            {
+                r = Interop.Kernel32.WriteFile(handle, bytes, 0, out numBytesReadWritten, IntPtr.Zero);
+            }
+
+            if (r == 0)
+            {
+                int errorCode = Marshal.GetLastWin32Error();
+                switch (errorCode)
+                {
+                    case Interop.Errors.ERROR_INVALID_PARAMETER:
+                        return false;
+                    case Interop.Errors.ERROR_INVALID_HANDLE:
+                        throw Win32Marshal.GetExceptionForWin32Error(errorCode);
+                }
+            }
+
+            return true;
+        }
+
+        private static void VerifyHandleIsSync(SafeFileHandle handle, int fileType, FileAccess access)
+        {
+            // The technique here only really works for FILE_TYPE_DISK. FileMode is the right thing to check, but it currently
+            // isn't available in WinRT.
+
+            if (fileType == Interop.Kernel32.FileTypes.FILE_TYPE_DISK)
+            {
+                // If we can't check the handle, just assume it is ok.
+                if (!(IsHandleSynchronous(handle, access) ?? true))
+                    throw new ArgumentException(SR.Arg_HandleNotSync, nameof(handle));
+            }
+        }
     }
 }