Imported Upstream version 4.0.0~alpha1

Former-commit-id: 806294f5ded97629b74c85c09952f2a74fe182d9

external/referencesource/mscorlib/microsoft/win32/safehandles/safefilehandle.cs

@@ -0,0 +1,47 @@
+// ==++==
+// 
+//   Copyright (c) Microsoft Corporation.  All rights reserved.
+// 
+// ==--==
+/*============================================================
+**
+** Class:  SafeFileHandle 
+**
+**
+** A wrapper for file handles
+**
+** 
+===========================================================*/
+
+using System;
+using System.Security;
+using System.Security.Permissions;
+using System.Runtime.InteropServices;
+using System.Runtime.CompilerServices;
+using System.Runtime.ConstrainedExecution;
+using System.Runtime.Versioning;
+using Microsoft.Win32;
+
+namespace Microsoft.Win32.SafeHandles {
+
+    [System.Security.SecurityCritical]  // auto-generated_required
+    public sealed class SafeFileHandle: SafeHandleZeroOrMinusOneIsInvalid {
+
+        private SafeFileHandle() : base(true) 
+        {
+        }
+
+        public SafeFileHandle(IntPtr preexistingHandle, bool ownsHandle) : base(ownsHandle) {
+            SetHandle(preexistingHandle);
+        }
+
+        [System.Security.SecurityCritical]
+        [ResourceExposure(ResourceScope.Machine)]
+        [ResourceConsumption(ResourceScope.Machine)]
+        override protected bool ReleaseHandle()
+        {
+            return Win32Native.CloseHandle(handle);
+        }
+    }
+}
+

external/referencesource/mscorlib/microsoft/win32/safehandles/safefilemappinghandle.cs

@@ -0,0 +1,47 @@
+// ==++==
+// 
+//   Copyright (c) Microsoft Corporation.  All rights reserved.
+// 
+// ==--==
+/*============================================================
+**
+** Class:  SafeFileMappingHandle
+**
+**
+** A wrapper for file handles
+**
+** 
+===========================================================*/
+using System;
+using System.Security;
+using System.Security.Permissions;
+using System.Runtime.InteropServices;
+using System.Runtime.CompilerServices;
+using System.Runtime.ConstrainedExecution;
+using System.Runtime.Versioning;
+
+namespace Microsoft.Win32.SafeHandles
+{
+    [System.Security.SecurityCritical]  // auto-generated
+    internal sealed class SafeFileMappingHandle : SafeHandleZeroOrMinusOneIsInvalid
+    {
+        [System.Security.SecurityCritical]  // auto-generated_required
+        internal SafeFileMappingHandle() : base(true) {}
+
+        // 0 is an Invalid Handle
+        [System.Security.SecurityCritical]  // auto-generated_required
+        internal SafeFileMappingHandle(IntPtr handle, bool ownsHandle) : base (ownsHandle)
+        {
+            SetHandle(handle);
+        }
+
+        [System.Security.SecurityCritical]
+        [ResourceExposure(ResourceScope.Machine)]
+        [ResourceConsumption(ResourceScope.Machine)]
+        override protected bool ReleaseHandle()
+        {
+            return Win32Native.CloseHandle(handle);
+        }
+    }
+}
+

external/referencesource/mscorlib/microsoft/win32/safehandles/safefindhandle.cs

@@ -0,0 +1,37 @@
+// ==++==
+// 
+//   Copyright (c) Microsoft Corporation.  All rights reserved.
+// 
+// ==--==
+/*============================================================
+**
+** Class:  SafeFindHandle 
+**
+**
+** A wrapper for find handles
+**
+** 
+===========================================================*/
+
+using System;
+using System.Security;
+using System.Security.Permissions;
+using System.Runtime.InteropServices;
+using System.Runtime.CompilerServices;
+using System.Runtime.ConstrainedExecution;
+using Microsoft.Win32;
+
+namespace Microsoft.Win32.SafeHandles {
+    [System.Security.SecurityCritical]  // auto-generated
+    internal sealed class SafeFindHandle : SafeHandleZeroOrMinusOneIsInvalid
+    {
+        [System.Security.SecurityCritical]  // auto-generated_required
+        internal SafeFindHandle() : base(true) {}
+
+        [System.Security.SecurityCritical]
+        override protected bool ReleaseHandle()
+        {
+            return Win32Native.FindClose(handle);
+        }
+    }
+}

external/referencesource/mscorlib/microsoft/win32/safehandles/safelibraryhandle.cs

@@ -0,0 +1,35 @@
+// ==++==
+// 
+//   Copyright (c) Microsoft Corporation.  All rights reserved.
+// 
+// ==--==
+/*============================================================
+**
+** Class: SafeLibraryHandle
+**
+============================================================*/
+namespace Microsoft.Win32 {
+    using Microsoft.Win32;
+    using Microsoft.Win32.SafeHandles;
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.ConstrainedExecution;
+    using System.Runtime.InteropServices;
+    using System.Runtime.Serialization;
+    using System.Runtime.Versioning;
+    using System.Security;
+    using System.Security.Permissions;
+    using System.Text;
+
+    [System.Security.SecurityCritical]  // auto-generated
+    [HostProtectionAttribute(MayLeakOnAbort = true)]
+    sealed internal class SafeLibraryHandle : SafeHandleZeroOrMinusOneIsInvalid {
+        internal SafeLibraryHandle() : base(true) {}
+
+        [System.Security.SecurityCritical]
+        override protected bool ReleaseHandle()
+        {
+            return UnsafeNativeMethods.FreeLibrary(handle);
+        }
+    }
+}

external/referencesource/mscorlib/microsoft/win32/safehandles/safelocalallochandle.cs

@@ -0,0 +1,29 @@
+// <OWNER>clrbclc</OWNER>
+namespace Microsoft.Win32.SafeHandles {
+#if !FEATURE_PAL
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+    using System.Runtime.ConstrainedExecution;
+
+    [System.Security.SecurityCritical]  // auto-generated
+    internal sealed class SafeLocalAllocHandle : SafeBuffer {
+        private SafeLocalAllocHandle () : base(true) {}
+
+        // 0 is an Invalid Handle
+        internal SafeLocalAllocHandle (IntPtr handle) : base (true) {
+            SetHandle(handle);
+        }
+
+        internal static SafeLocalAllocHandle InvalidHandle {
+            get { return new SafeLocalAllocHandle(IntPtr.Zero); }
+        }
+
+        [System.Security.SecurityCritical]
+        override protected bool ReleaseHandle()
+        {
+            return Win32Native.LocalFree(handle) == IntPtr.Zero;
+        }
+    }
+#endif
+}

external/referencesource/mscorlib/microsoft/win32/safehandles/safepefilehandle.cs

@@ -0,0 +1,38 @@
+// ==++==
+// 
+//   Copyright (c) Microsoft Corporation.  All rights reserved.
+// 
+// ==--==
+
+using System;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.ConstrainedExecution;
+using System.Runtime.InteropServices;
+using System.Security;
+
+namespace Microsoft.Win32.SafeHandles
+{
+    /// <summary>
+    ///     Handle to a VM PEFile *
+    /// </summary>
+    [SecurityCritical] 
+    internal sealed class SafePEFileHandle : SafeHandleZeroOrMinusOneIsInvalid
+    {
+        private SafePEFileHandle() : base(true)
+        {
+        }
+
+        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
+        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
+        [SuppressUnmanagedCodeSecurity]
+        private static extern void ReleaseSafePEFileHandle(IntPtr peFile);
+
+        [SecurityCritical]
+        protected override bool ReleaseHandle()
+        {
+            ReleaseSafePEFileHandle(handle);
+            return true;
+        }
+    }
+}

external/referencesource/mscorlib/microsoft/win32/safehandles/saferegistryhandle.cs

@@ -0,0 +1,46 @@
+// ==++==
+//
+//   Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// ==--==
+//
+// File: SafeRegistryHandle.cs
+//
+// <OWNER>[....]</OWNER>
+//
+// Implements Microsoft.Win32.SafeHandles.SafeRegistryHandle
+//
+// ======================================================================================
+#if !FEATURE_PAL
+namespace Microsoft.Win32.SafeHandles {
+    using System;
+    using System.Security;
+    using System.Security.Permissions;
+    using System.Runtime.InteropServices;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.ConstrainedExecution;
+    using System.Runtime.Versioning;
+
+    [System.Security.SecurityCritical]
+    public sealed class SafeRegistryHandle : SafeHandleZeroOrMinusOneIsInvalid {
+        [System.Security.SecurityCritical]
+        internal SafeRegistryHandle() : base(true) {}
+
+        [System.Security.SecurityCritical]
+        public SafeRegistryHandle(IntPtr preexistingHandle, bool ownsHandle) : base(ownsHandle) {
+            SetHandle(preexistingHandle);
+        }
+
+        [System.Security.SecurityCritical]
+        override protected bool ReleaseHandle() {
+            return (RegCloseKey(handle) == Win32Native.ERROR_SUCCESS);
+        }
+
+        [DllImport(Win32Native.ADVAPI32),
+         SuppressUnmanagedCodeSecurity,
+         ResourceExposure(ResourceScope.None),
+         ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
+        internal static extern int RegCloseKey(IntPtr hKey);
+    }
+}
+#endif // !FEATURE_PAL

external/referencesource/mscorlib/microsoft/win32/safehandles/safeviewoffilehandle.cs

@@ -0,0 +1,54 @@
+// ==++==
+// 
+//   Copyright (c) Microsoft Corporation.  All rights reserved.
+// 
+// ==--==
+/*============================================================
+**
+** Class:  SafeViewOfFileHandle 
+**
+**
+** A wrapper for file handles
+**
+** 
+===========================================================*/
+using System;
+using System.Security;
+using System.Security.Permissions;
+using System.Runtime.InteropServices;
+using System.Runtime.CompilerServices;
+using System.Runtime.ConstrainedExecution;
+using System.Runtime.Versioning;
+using Microsoft.Win32;
+using Microsoft.Win32.SafeHandles;
+
+namespace Microsoft.Win32.SafeHandles
+{
+    [System.Security.SecurityCritical]  // auto-generated
+    internal sealed class SafeViewOfFileHandle : SafeHandleZeroOrMinusOneIsInvalid
+    {
+        [System.Security.SecurityCritical]  // auto-generated_required
+        internal SafeViewOfFileHandle() : base(true) {}
+
+        // 0 is an Invalid Handle
+        [System.Security.SecurityCritical]  // auto-generated_required
+        internal SafeViewOfFileHandle(IntPtr handle, bool ownsHandle) : base (ownsHandle) {
+            SetHandle(handle);
+        }
+
+        [System.Security.SecurityCritical]
+        [ResourceExposure(ResourceScope.Machine)]
+        [ResourceConsumption(ResourceScope.Machine)]
+        override protected bool ReleaseHandle()
+        {
+            if (Win32Native.UnmapViewOfFile(handle))
+            {
+                handle = IntPtr.Zero;
+                return true;
+            }
+            
+            return false;
+        }
+    }
+}
+

external/referencesource/mscorlib/microsoft/win32/safehandles/safewaithandle.cs

@@ -0,0 +1,99 @@
+// ==++==
+// 
+//   Copyright (c) Microsoft Corporation.  All rights reserved.
+// 
+// ==--==
+/*============================================================
+**
+** Class:  SafeWaitHandle
+**
+**
+** A wrapper for Win32 events (mutexes, auto reset events, and
+** manual reset events).  Used by WaitHandle.
+**
+** 
+===========================================================*/
+
+using System;
+using System.Security;
+using System.Security.Permissions;
+using System.Runtime.InteropServices;
+using System.Runtime.CompilerServices;
+using System.Runtime.ConstrainedExecution;
+using System.Runtime.Versioning;
+using Microsoft.Win32;
+using System.Threading;
+
+namespace Microsoft.Win32.SafeHandles {
+ 
+    [System.Security.SecurityCritical]  // auto-generated_required
+    public sealed class SafeWaitHandle : SafeHandleZeroOrMinusOneIsInvalid
+    {
+
+
+    // Special case flags for Mutexes enables workaround for known OS bug at 
+        // http://support.microsoft.com/default.aspx?scid=kb;en-us;889318        
+        // One machine-wide mutex serializes all OpenMutex and CloseHandle operations.
+
+        // bIsMutex: if true, we need to grab machine-wide mutex before doing any Close ops.
+        // Initialized to false by the runtime.
+        private bool bIsMutex;
+
+        // bIsMutex: if true, we need to avoid grabbing the machine-wide mutex before Close ops, 
+        // since that mutex is, of course, this very handle.
+        // Initialized to false by the runtime.
+        private bool bIsReservedMutex;
+
+        // Called by P/Invoke marshaler
+        private SafeWaitHandle() : base(true)
+        {
+        }
+
+        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
+        public SafeWaitHandle(IntPtr existingHandle, bool ownsHandle) : base(ownsHandle)
+        {
+            SetHandle(existingHandle);
+        }
+
+        [System.Security.SecurityCritical]
+        [ResourceExposure(ResourceScope.Machine)]
+        [ResourceConsumption(ResourceScope.Machine)]
+        override protected bool ReleaseHandle()
+        {
+#if !FEATURE_CORECLR
+            if (!bIsMutex || Environment.HasShutdownStarted)
+                return Win32Native.CloseHandle(handle);                
+            
+            bool bReturn = false;                
+            bool bMutexObtained = false;                
+            try
+            {
+               if (!bIsReservedMutex)
+               {
+                   Mutex.AcquireReservedMutex(ref bMutexObtained);    
+               }
+               bReturn = Win32Native.CloseHandle(handle);
+            }
+            finally
+            {
+                if (bMutexObtained)
+                    Mutex.ReleaseReservedMutex();
+            }
+            return bReturn;
+#else
+            return Win32Native.CloseHandle(handle);
+#endif
+        }
+
+        internal void SetAsMutex()
+        {
+            bIsMutex = true;
+        }
+
+        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]        
+        internal void SetAsReservedMutex()
+        {
+            bIsReservedMutex = true;
+        }    
+    }
+}

external/referencesource/mscorlib/microsoft/win32/safehandles/win32safehandles.cs

@@ -0,0 +1,113 @@
+// ==++==
+// 
+//   Copyright (c) Microsoft Corporation.  All rights reserved.
+// 
+// ==--==
+//
+// Abstract derivations of SafeHandle designed to provide the common
+// functionality supporting Win32 handles. More specifically, they describe how
+// an invalid handle looks (for instance, some handles use -1 as an invalid
+// handle value, others use 0).
+//
+// Further derivations of these classes can specialise this even further (e.g.
+// file or registry handles).
+// 
+//
+
+namespace Microsoft.Win32.SafeHandles
+{
+    using System;
+    using System.Runtime.InteropServices;
+    using System.Runtime.CompilerServices;
+    using System.Security.Permissions;
+    using System.Runtime.ConstrainedExecution;
+
+    // Class of safe handle which uses 0 or -1 as an invalid handle.
+    [System.Security.SecurityCritical]  // auto-generated_required
+#if !FEATURE_CORECLR
+    [SecurityPermission(SecurityAction.InheritanceDemand, UnmanagedCode=true)]
+#endif
+    public abstract class SafeHandleZeroOrMinusOneIsInvalid : SafeHandle
+    {
+        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
+        protected SafeHandleZeroOrMinusOneIsInvalid(bool ownsHandle) : base(IntPtr.Zero, ownsHandle) 
+        {
+        }
+
+#if FEATURE_CORECLR
+        // A default constructor is needed to satisfy CoreCLR inheritence rules. It should not be called at runtime
+        protected SafeHandleZeroOrMinusOneIsInvalid()
+        {
+            throw new NotImplementedException();
+        }
+#endif // FEATURE_CORECLR
+
+        public override bool IsInvalid {
+            [System.Security.SecurityCritical]
+            get { return handle.IsNull() || handle == new IntPtr(-1); }
+        }
+    }
+
+    // Class of safe handle which uses only -1 as an invalid handle.
+    [System.Security.SecurityCritical]  // auto-generated_required
+#if !FEATURE_CORECLR
+    [SecurityPermission(SecurityAction.InheritanceDemand, UnmanagedCode=true)]
+#endif
+    public abstract class SafeHandleMinusOneIsInvalid : SafeHandle
+    {
+        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
+        protected SafeHandleMinusOneIsInvalid(bool ownsHandle) : base(new IntPtr(-1), ownsHandle) 
+        {
+        }
+
+#if FEATURE_CORECLR
+        // A default constructor is needed to satisfy CoreCLR inheritence rules. It should not be called at runtime
+        protected SafeHandleMinusOneIsInvalid()
+        {
+            throw new NotImplementedException();
+        }
+#endif // FEATURE_CORECLR
+
+        public override bool IsInvalid {
+            [System.Security.SecurityCritical]
+            get { return handle == new IntPtr(-1); }
+        }
+    }
+
+    // Class of critical handle which uses 0 or -1 as an invalid handle.
+    [System.Security.SecurityCritical]  // auto-generated_required
+#if !FEATURE_CORECLR
+    [SecurityPermission(SecurityAction.InheritanceDemand, UnmanagedCode=true)]
+#endif
+    public abstract class CriticalHandleZeroOrMinusOneIsInvalid : CriticalHandle
+    {
+        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
+        protected CriticalHandleZeroOrMinusOneIsInvalid() : base(IntPtr.Zero) 
+        {
+        }
+
+        public override bool IsInvalid {
+            [System.Security.SecurityCritical]
+            get { return handle.IsNull() || handle == new IntPtr(-1); }
+        }
+    }
+
+    // Class of critical handle which uses only -1 as an invalid handle.
+    [System.Security.SecurityCritical]  // auto-generated_required
+#if !FEATURE_CORECLR
+    [SecurityPermission(SecurityAction.InheritanceDemand, UnmanagedCode=true)]
+#endif
+    public abstract class CriticalHandleMinusOneIsInvalid : CriticalHandle
+    {
+        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
+        protected CriticalHandleMinusOneIsInvalid() : base(new IntPtr(-1)) 
+        {
+        }
+
+        public override bool IsInvalid {
+            [System.Security.SecurityCritical]
+            get { return handle == new IntPtr(-1); }
+        }
+    }
+
+}