Merge pull request #2511 from pgavlin/SNWebSocketsClient

Initial commit of System.Net.WebSockets.Client.

Author: pgavlin

src/Common/src/Interop/Windows/mincore/Interop.FreeLibrary.cs

@@ -0,0 +1,16 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Runtime.InteropServices;
+
+using Microsoft.Win32.SafeHandles;
+
+internal partial class Interop
+{
+    internal partial class mincore
+    {
+        [DllImport(Libraries.LibraryLoader, ExactSpelling = true, SetLastError = true)]
+        public static extern unsafe bool FreeLibrary([In] IntPtr hModule);
+    }
+}

src/Common/src/Interop/Windows/mincore/Interop.GetProcAddress.cs

@@ -0,0 +1,16 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Runtime.InteropServices;
+
+using Microsoft.Win32.SafeHandles;
+
+internal partial class Interop
+{
+    internal partial class mincore
+    {
+        [DllImport(Libraries.LibraryLoader, CharSet = CharSet.Ansi, BestFitMapping = false)]
+        public static extern IntPtr GetProcAddress(SafeLibraryHandle hModule, string lpProcName);
+    }
+}

src/Common/src/Interop/Windows/mincore/Interop.HRESULT_FROM_WIN32.cs

@@ -0,0 +1,22 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System.Runtime.CompilerServices;
+
+internal partial class Interop
+{
+    internal partial class mincore
+    {
+        // Implementation of HRESULT_FROM_WIN32 macro
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static int HRESULT_FROM_WIN32(int errorCode)
+        {
+            if ((errorCode & 0x80000000) == 0x80000000)
+            {
+                return errorCode;
+            }
+
+            return (errorCode & 0x0000FFFF) | unchecked((int)0x80070000);
+        } 
+    }
+}

src/Common/src/Interop/Windows/mincore/Interop.LoadLibraryEx.cs

@@ -0,0 +1,16 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Runtime.InteropServices;
+
+using Microsoft.Win32.SafeHandles;
+
+internal partial class Interop
+{
+    internal partial class mincore
+    {
+        [DllImport(Libraries.LibraryLoader, ExactSpelling = true, CharSet = CharSet.Unicode, SetLastError = true)]
+        public static extern SafeLibraryHandle LoadLibraryExW([In] string lpwLibFileName, [In] IntPtr hFile, [In] uint dwFlags);
+    }
+}

src/Common/src/Interop/Windows/winhttp/Interop.SafeWinHttpHandle.cs

@@ -4,43 +4,81 @@
 using System;
 using System.Runtime.InteropServices;
 
+using Microsoft.Win32.SafeHandles;
+
 internal partial class Interop
 {
     internal partial class WinHttp
     {
-        // TODO: Move SafeHandleZeroOrMinusOneIsInvalid class to Common
-        internal abstract class SafeHandleZeroOrMinusOneIsInvalid : SafeHandle
+        // Issue 2501: Fold SafeWinHttpHandleWithCallback and SafeWinHttpHandle into a single type.
+        //
+        // SafeWinHttpHandleWithCallback is a better pattern; SafeWinHttpHandle is probably a better
+        // name. The implementation for the former should probably be folded into the latter.
+
+        internal class SafeWinHttpHandle : SafeHandleZeroOrMinusOneIsInvalid
         {
-            protected SafeHandleZeroOrMinusOneIsInvalid(bool ownsHandle)
-                : base(IntPtr.Zero, ownsHandle)
+            public SafeWinHttpHandle() : base(true)
             {
             }
 
-            public override bool IsInvalid
+            public static void DisposeAndClearHandle(ref SafeWinHttpHandle winHttpHandler)
             {
-                get { return this.handle == IntPtr.Zero || this.handle == (IntPtr)(-1); }
+                if (winHttpHandler != null)
+                {
+                    winHttpHandler.Dispose();
+                    winHttpHandler = null;
+                }
+            }
+
+            // Important: WinHttp API calls should not happen while another WinHttp call for the same handle did not 
+            // return. During finalization that was not initiated by the Dispose pattern we don't expect any other WinHttp
+            // calls in progress.
+            protected override bool ReleaseHandle()
+            {
+                // TODO(Issue 2500): Add logging so we know when the handle gets closed.
+                return Interop.WinHttp.WinHttpCloseHandle(handle);
             }
         }
 
-        internal class SafeWinHttpHandle : SafeHandleZeroOrMinusOneIsInvalid
+        internal sealed class SafeWinHttpHandleWithCallback : SafeWinHttpHandle
         {
-            public SafeWinHttpHandle() : base(true)
+            // Add a reference to this object so that the AppDomain doesn't get unloaded before the last WinHttp callback.
+            public void AttachCallback()
+            {
+                bool success = false;
+                DangerousAddRef(ref success);
+                if (!success)
+                {
+                    throw new InvalidOperationException("Could not increase SafeHandle reference.");
+                }
+            }
+
+            public void DetachCallback()
             {
+                DangerousRelease();
             }
 
-            public static void DisposeAndClearHandle(ref SafeWinHttpHandle handle)
+            protected override void Dispose(bool disposing)
             {
-                if (handle != null)
+                if (disposing)
                 {
-                    handle.Dispose();
-                    handle = null;
+                    // We need to initiate the asynchronous process of closing the WinHttp handle:
+                    // 1. Ensure that all other WinHttp function calls for this handle have returned.
+                    // 2. Call WinHttpCloseHandle.
+                    // 3. Wait for WINHTTP_CALLBACK_STATUS_HANDLE_CLOSING in the callback.
+                    //    On this event, call DetachCallback.
+                    //
+                    // WinHttp guarantees that no other calls to the callback are made for this handle after 
+                    // WINHTTP_CALLBACK_STATUS_HANDLE_CLOSING has been received.
+                    // Holding the reference to the SafeHandle object ensures that the appdomain where the SafeHandle 
+                    // lives until it is guaranteed that no further callback calls are made from the native (WinHttp) side.
+                    Interop.WinHttp.WinHttpCloseHandle(handle);
                 }
             }
 
             protected override bool ReleaseHandle()
             {
-                // TODO: Add logging so we know when the handle gets closed.
-                return Interop.WinHttp.WinHttpCloseHandle(this.handle);
+                return base.ReleaseHandle();
             }
         }
     }

src/Common/src/Interop/Windows/winhttp/Interop.winhttp.cs

@@ -28,6 +28,14 @@ public static extern SafeWinHttpHandle WinHttpConnect(
             ushort serverPort,
             uint reserved);
 
+        // NOTE: except for the return type, this refers to the same function as WinHttpConnect.
+        [DllImport(Interop.Libraries.WinHttp, EntryPoint = "WinHttpConnect", CharSet = CharSet.Unicode, SetLastError = true)]
+        public static extern SafeWinHttpHandleWithCallback WinHttpConnectWithCallback(
+            SafeWinHttpHandle sessionHandle,
+            string serverName,
+            ushort serverPort,
+            uint reserved);
+
         [DllImport(Interop.Libraries.WinHttp, CharSet = CharSet.Unicode, SetLastError = true)]
         public static extern SafeWinHttpHandle WinHttpOpenRequest(
             SafeWinHttpHandle connectHandle,
@@ -38,6 +46,17 @@ public static extern SafeWinHttpHandle WinHttpOpenRequest(
             string acceptTypes,
             uint flags);
 
+        // NOTE: except for the return type, this refers to the same function as WinOpenRequest.
+        [DllImport(Interop.Libraries.WinHttp, EntryPoint = "WinHttpOpenRequest", CharSet = CharSet.Unicode, SetLastError = true)]
+        public static extern SafeWinHttpHandleWithCallback WinHttpOpenRequestWithCallback(
+            SafeWinHttpHandle connectHandle,
+            string verb,
+            string objectName,
+            string version,
+            string referrer,
+            string acceptTypes,
+            uint flags);
+
         [DllImport(Interop.Libraries.WinHttp, CharSet = CharSet.Unicode, SetLastError = true)]
         [return: MarshalAs(UnmanagedType.Bool)]
         public static extern bool WinHttpAddRequestHeaders(
@@ -206,5 +225,61 @@ public static extern IntPtr WinHttpSetStatusCallback(
             WINHTTP_STATUS_CALLBACK callback,
             uint notificationFlags,
             IntPtr reserved);
+
+        [DllImport(Interop.Libraries.WinHttp, CharSet = CharSet.Unicode, SetLastError = true)]
+        public static extern SafeWinHttpHandleWithCallback WinHttpWebSocketCompleteUpgrade(
+            SafeWinHttpHandle requestHandle,
+            IntPtr context);
+
+        [DllImport(Interop.Libraries.WinHttp, CharSet = CharSet.Unicode, SetLastError = false)]
+        public static extern uint WinHttpWebSocketSend(
+            SafeWinHttpHandle webSocketHandle,
+            WINHTTP_WEB_SOCKET_BUFFER_TYPE bufferType,
+            IntPtr buffer,
+            uint bufferLength);
+
+        [DllImport(Interop.Libraries.WinHttp, CharSet = CharSet.Unicode, SetLastError = false)]
+        public static extern uint WinHttpWebSocketReceive(
+            SafeWinHttpHandle webSocketHandle,
+            IntPtr buffer,
+            uint bufferLength,
+            out uint bytesRead,
+            out WINHTTP_WEB_SOCKET_BUFFER_TYPE bufferType);
+
+        [DllImport(Interop.Libraries.WinHttp, CharSet = CharSet.Unicode, SetLastError = false)]
+        public static extern uint WinHttpWebSocketShutdown(
+            SafeWinHttpHandle webSocketHandle,
+            ushort status,
+            byte[] reason,
+            uint reasonLength);
+
+        [DllImport(Interop.Libraries.WinHttp, CharSet = CharSet.Unicode, SetLastError = false)]
+        public static extern uint WinHttpWebSocketShutdown(
+            SafeWinHttpHandle webSocketHandle,
+            ushort status,
+            IntPtr reason,
+            uint reasonLength);
+
+        [DllImport(Interop.Libraries.WinHttp, CharSet = CharSet.Unicode, SetLastError = false)]
+        public static extern uint WinHttpWebSocketClose(
+            SafeWinHttpHandle webSocketHandle,
+            ushort status,
+            byte[] reason,
+            uint reasonLength);
+
+        [DllImport(Interop.Libraries.WinHttp, CharSet = CharSet.Unicode, SetLastError = false)]
+        public static extern uint WinHttpWebSocketClose(
+            SafeWinHttpHandle webSocketHandle,
+            ushort status,
+            IntPtr reason,
+            uint reasonLength);
+
+        [DllImport(Interop.Libraries.WinHttp, CharSet = CharSet.Unicode, SetLastError = false)]
+        public static extern uint WinHttpWebSocketQueryCloseStatus(
+            SafeWinHttpHandle webSocketHandle,
+            out ushort status,
+            byte[] reason,
+            uint reasonLength,
+            out uint reasonLengthConsumed);
     }
 }

src/Common/src/Interop/Windows/winhttp/Interop.winhttp_types.cs

@@ -3,18 +3,21 @@
 
 using System;
 using System.Runtime.InteropServices;
+using System.Text;
 
 internal partial class Interop
 {
     internal partial class WinHttp
     {
+        public const uint ERROR_SUCCESS = 0;
         public const uint ERROR_FILE_NOT_FOUND = 2;
         public const uint ERROR_INVALID_HANDLE = 6;
         public const uint ERROR_INVALID_PARAMETER = 87;
         public const uint ERROR_INSUFFICIENT_BUFFER = 122;
         public const uint ERROR_NOT_FOUND = 1168;
         public const uint ERROR_WINHTTP_INVALID_OPTION = 12009;
         public const uint ERROR_WINHTTP_LOGIN_FAILURE = 12015;
+        public const uint ERROR_WINHTTP_OPERATION_CANCELLED = 12017;
         public const uint ERROR_WINHTTP_INCORRECT_HANDLE_STATE = 12019;
         public const uint ERROR_WINHTTP_CONNECTION_ERROR = 12030;
         public const uint ERROR_WINHTTP_RESEND_REQUEST = 12032;
@@ -58,7 +61,7 @@ internal partial class WinHttp
 
         public const uint WINHTTP_FLAG_SECURE = 0x00800000;
 
-        public const string WINHTTP_NO_ADDITIONAL_HEADERS = null;
+        public const StringBuilder WINHTTP_NO_ADDITIONAL_HEADERS = null;
 
         public const uint WINHTTP_QUERY_FLAG_NUMBER = 0x20000000;
         public const uint WINHTTP_QUERY_VERSION = 18;
@@ -141,6 +144,28 @@ internal partial class WinHttp
         public const uint WINHTTP_OPTION_MAX_RESPONSE_DRAIN_SIZE = 92;
         public const uint WINHTTP_OPTION_CONNECTION_INFO = 93;
 
+        public const uint WINHTTP_OPTION_ASSURED_NON_BLOCKING_CALLBACKS = 111;
+
+        public const uint WINHTTP_OPTION_UPGRADE_TO_WEB_SOCKET = 114;
+        public const uint WINHTTP_OPTION_WEB_SOCKET_CLOSE_TIMEOUT = 115;
+        public const uint WINHTTP_OPTION_WEB_SOCKET_KEEPALIVE_INTERVAL = 116;
+
+        public const uint WINHTTP_OPTION_WEB_SOCKET_RECEIVE_BUFFER_SIZE = 122;
+        public const uint WINHTTP_OPTION_WEB_SOCKET_SEND_BUFFER_SIZE = 123;
+
+        public enum WINHTTP_WEB_SOCKET_BUFFER_TYPE
+        {
+            WINHTTP_WEB_SOCKET_BINARY_MESSAGE_BUFFER_TYPE = 0,
+            WINHTTP_WEB_SOCKET_BINARY_FRAGMENT_BUFFER_TYPE = 1,
+            WINHTTP_WEB_SOCKET_UTF8_MESSAGE_BUFFER_TYPE = 2,
+            WINHTTP_WEB_SOCKET_UTF8_FRAGMENT_BUFFER_TYPE = 3,
+            WINHTTP_WEB_SOCKET_CLOSE_BUFFER_TYPE = 4
+        }
+
+        public const uint WINHTTP_OPTION_CONTEXT_VALUE = 45;
+
+        public const uint WINHTTP_FLAG_ASYNC = 0x10000000;
+
         public const uint WINHTTP_CALLBACK_STATUS_RESOLVING_NAME = 0x00000001;
         public const uint WINHTTP_CALLBACK_STATUS_NAME_RESOLVED = 0x00000002;
         public const uint WINHTTP_CALLBACK_STATUS_CONNECTING_TO_SERVER = 0x00000004;
@@ -219,5 +244,40 @@ public struct WINHTTP_CONNECTION_INFO
             [MarshalAs(UnmanagedType.ByValArray, SizeConst = 128)]
             public byte[] RemoteAddress; // SOCKADDR_STORAGE
         }
+
+        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
+        public struct WINHTTP_ASYNC_RESULT
+        {
+            public IntPtr dwResult;
+            public uint dwError;
+        }
+
+        public const uint API_RECEIVE_RESPONSE = 1;
+        public const uint API_QUERY_DATA_AVAILABLE = 2;
+        public const uint API_READ_DATA = 3;
+        public const uint API_WRITE_DATA = 4;
+        public const uint API_SEND_REQUEST = 5;
+
+        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
+        public struct WINHTTP_WEB_SOCKET_ASYNC_RESULT
+        {
+            public WINHTTP_ASYNC_RESULT AsyncResult;
+            public WINHTTP_WEB_SOCKET_OPERATION Operation;
+        }
+
+        public enum WINHTTP_WEB_SOCKET_OPERATION
+        {
+            WINHTTP_WEB_SOCKET_SEND_OPERATION = 0,
+            WINHTTP_WEB_SOCKET_RECEIVE_OPERATION = 1,
+            WINHTTP_WEB_SOCKET_CLOSE_OPERATION = 2,
+            WINHTTP_WEB_SOCKET_SHUTDOWN_OPERATION = 3
+        }
+
+        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
+        public struct WINHTTP_WEB_SOCKET_STATUS
+        {
+            public uint dwBytesTransferred;
+            public WINHTTP_WEB_SOCKET_BUFFER_TYPE eBufferType;
+        }
     }
 }

src/Common/src/Microsoft/Win32/SafeHandles/SafeHandleZeroOrMinusOneIsInvalid.cs

@@ -0,0 +1,24 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Runtime.InteropServices;
+
+namespace Microsoft.Win32.SafeHandles
+{
+    // Issue 2499: Replace ad-hoc definitions of SafeHandleZeroOrMinusOneIsInvalid with a single definition
+    //
+    // Other definitions of this type should be removed in favor of this definition.
+    internal abstract class SafeHandleZeroOrMinusOneIsInvalid : SafeHandle
+    {
+        protected SafeHandleZeroOrMinusOneIsInvalid(bool ownsHandle)
+            : base(IntPtr.Zero, ownsHandle)
+        {
+        }
+
+        public override bool IsInvalid
+        {
+            get { return handle == IntPtr.Zero || handle == (IntPtr)(-1); }
+        }
+    }
+}