public abstract bool GetDescriptor(SafeHandle interfaceHandle, byte descriptorType, byte index, ushort languageID, IntPtr buffer, int bufferLength, out int lengthTransferred);
internal static extern bool AdjustTokenPrivileges(SafeHandle TokenHandle, [MarshalAs(UnmanagedType.Bool)]bool DisableAllPrivileges, ref TOKEN_PRIVILEGES NewState, Int32 BufferLength, //ref TOKEN_PRIVILEGES PreviousState, !! for some reason this won't accept null IntPtr PreviousState, IntPtr ReturnLength);
public void SetOperationCompleted() { if (this._overlapped != null) { this._cancellationRegistration.Dispose(); this._handle = null; this._overlapped = null; } }
public static extern bool SetWaitableTimer( SafeHandle hTimer, ref long dueTime, int period, TimerAPCProc completionRoutine, IntPtr completionArg, bool fResume);
private static Exception _HandleErrorCode(int errorCode, string name, SafeHandle handle, object context) { Exception exception = null; switch (errorCode) { case 2: if (((context == null) || !(context is bool)) || !((bool) context)) { if ((name != null) && (name.Length != 0)) { return new FileNotFoundException(name); } return new FileNotFoundException(); } if ((name != null) && (name.Length != 0)) { return new DirectoryNotFoundException(name); } return new DirectoryNotFoundException(); case 6: return new ArgumentException(Environment.GetResourceString("AccessControl_InvalidHandle")); case 0x7b: exception = new ArgumentException(Environment.GetResourceString("Argument_InvalidName"), "name"); break; } return exception; }
public static extern int DrawState(SafeHandle hdc, IntPtr hBrush, DrawStateProc qfnCallBack, IntPtr lData, IntPtr wData, int x, int y, int width, int height, uint uFlags);
protected NativeObjectSecurity (bool isContainer, ResourceType resourceType, SafeHandle handle, AccessControlSections includeSections) : this (isContainer, resourceType, handle, includeSections, null, null) { }
internal static void CloseInvalidOutSafeHandle(SafeHandle handle) { if (handle != null) { handle.SetHandleAsInvalid(); } }
internal static bool UsbIOSync(SafeHandle dev, int code, Object inBuffer, int inSize, IntPtr outBuffer, int outSize, out int ret) { SafeOverlapped deviceIoOverlapped = new SafeOverlapped(); ManualResetEvent hEvent = new ManualResetEvent(false); deviceIoOverlapped.ClearAndSetEvent(hEvent.SafeWaitHandle.DangerousGetHandle()); ret = 0; if (!Kernel32.DeviceIoControlAsObject(dev, code, inBuffer, inSize, outBuffer, outSize, ref ret, deviceIoOverlapped.GlobalOverlapped)) { int iError = Marshal.GetLastWin32Error(); if (iError != ERROR_IO_PENDING) { // Don't log errors for these control codes. do { if (code == LibUsbIoCtl.GET_REG_PROPERTY) break; if (code == LibUsbIoCtl.GET_CUSTOM_REG_PROPERTY) break; UsbError.Error(ErrorCode.Win32Error, iError, String.Format("DeviceIoControl code {0:X8} failed:{1}", code, Kernel32.FormatSystemMessage(iError)), typeof(LibUsbDriverIO)); } while (false); hEvent.Close(); return false; } } if (Kernel32.GetOverlappedResult(dev, deviceIoOverlapped.GlobalOverlapped, out ret, true)) { hEvent.Close(); return true; } UsbError.Error(ErrorCode.Win32Error, Marshal.GetLastWin32Error(), "GetOverlappedResult failed.\nIoCtlCode:" + code, typeof(LibUsbDriverIO)); hEvent.Close(); return false; }
public static extern SECURITY_STATUS NCryptGetProperty( SafeHandle hObject, string pszProperty, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 4)] byte[] pbOutput, int cbOutput, out int pcbResult, NCryptGetPropertyFlags dwFlags);
private static bool Write(SafeHandle fileHandle, string dumpType) { if (dumpType.ToLower() == MiniDumpType.Tiny.ToString().ToLower()) { return Write(fileHandle, DumpTypeFlag.WithIndirectlyReferencedMemory | DumpTypeFlag.ScanMemory); } else if (dumpType.ToLower() == MiniDumpType.Normal.ToString().ToLower()) { // If the debugger is attached, it is not possible to access private read-write memory if (Debugger.IsAttached) { return Write(fileHandle, DumpTypeFlag.WithDataSegs | DumpTypeFlag.WithHandleData | DumpTypeFlag.WithUnloadedModules); } else { // Bug: Combination of WithPrivateReadWriteMemory + WithDataSegs hangs Visual Studio 2010 SP1 on some cases while loading the minidump for debugging in mixed mode which was created in by a release build application return Write(fileHandle, DumpTypeFlag.WithPrivateReadWriteMemory | DumpTypeFlag.WithDataSegs | DumpTypeFlag.WithHandleData | DumpTypeFlag.WithUnloadedModules); } } else if (dumpType.ToLower() == MiniDumpType.Full.ToString().ToLower()) { return Write(fileHandle, DumpTypeFlag.WithFullMemory); } else { throw NBugConfigurationException.Create(() => Settings.MiniDumpType, "Parameter supplied for settings property is invalid."); } }
public static IntPtr FPDF_LoadMemDocument(SafeHandle data_buf, int size, string password) { lock (LockString) { return Imports.FPDF_LoadMemDocument(data_buf, size, password); } }
/* This is to support SSL with no client cert. Important: safeHandle should not be Disposed during construction of this object. _SecPkgInfoW in sspi.h */ internal SecurityPackageInfoClass(SafeHandle safeHandle, int index) { if (safeHandle.IsInvalid) { GlobalLog.Print("SecurityPackageInfoClass::.ctor() the pointer is invalid: " + (safeHandle.DangerousGetHandle()).ToString("x")); return; } IntPtr unmanagedAddress = IntPtrHelper.Add(safeHandle.DangerousGetHandle(), SecurityPackageInfo.Size * index); GlobalLog.Print("SecurityPackageInfoClass::.ctor() unmanagedPointer: " + ((long)unmanagedAddress).ToString("x")); // TODO (Issue #3114): replace with Marshal.PtrToStructure. Capabilities = Marshal.ReadInt32(unmanagedAddress, (int)Marshal.OffsetOf<SecurityPackageInfo>("Capabilities")); Version = Marshal.ReadInt16(unmanagedAddress, (int)Marshal.OffsetOf<SecurityPackageInfo>("Version")); RPCID = Marshal.ReadInt16(unmanagedAddress, (int)Marshal.OffsetOf<SecurityPackageInfo>("RPCID")); MaxToken = Marshal.ReadInt32(unmanagedAddress, (int)Marshal.OffsetOf<SecurityPackageInfo>("MaxToken")); IntPtr unmanagedString; unmanagedString = Marshal.ReadIntPtr(unmanagedAddress, (int)Marshal.OffsetOf<SecurityPackageInfo>("Name")); if (unmanagedString != IntPtr.Zero) { Name = Marshal.PtrToStringUni(unmanagedString); GlobalLog.Print("Name: " + Name); } unmanagedString = Marshal.ReadIntPtr(unmanagedAddress, (int)Marshal.OffsetOf<SecurityPackageInfo>("Comment")); if (unmanagedString != IntPtr.Zero) { Comment = Marshal.PtrToStringUni(unmanagedString); GlobalLog.Print("Comment: " + Comment); } GlobalLog.Print("SecurityPackageInfoClass::.ctor(): " + ToString()); }
internal bool DisconnectEx(SafeCloseSocket socketHandle, SafeHandle overlapped, int flags, int reserved) { EnsureDynamicWinsockMethods(); DisconnectExDelegate disconnectEx = _dynamicWinsockMethods.GetDelegate<DisconnectExDelegate>(socketHandle); return disconnectEx(socketHandle, overlapped, flags, reserved); }
internal NegotiationInfoClass(SafeHandle safeHandle, int negotiationState) { if (!safeHandle.IsInvalid) { IntPtr handle = safeHandle.DangerousGetHandle(); if ((negotiationState == 0) || (negotiationState == 1)) { IntPtr ptr = Marshal.ReadIntPtr(handle, SecurityPackageInfo.NameOffest); string strA = null; if (ptr != IntPtr.Zero) { strA = ComNetOS.IsWin9x ? Marshal.PtrToStringAnsi(ptr) : Marshal.PtrToStringUni(ptr); } if (string.Compare(strA, "Kerberos", StringComparison.OrdinalIgnoreCase) == 0) { this.AuthenticationPackage = "Kerberos"; } else if (string.Compare(strA, "NTLM", StringComparison.OrdinalIgnoreCase) == 0) { this.AuthenticationPackage = "NTLM"; } else if (string.Compare(strA, "WDigest", StringComparison.OrdinalIgnoreCase) == 0) { this.AuthenticationPackage = "WDigest"; } else { this.AuthenticationPackage = strA; } } } }
public static bool Write(SafeHandle fileHandle, Option options, ExceptionInfo exceptionInfo = ExceptionInfo.None) { Process currentProcess = Process.GetCurrentProcess(); IntPtr currentProcessHandle = currentProcess.Handle; var currentProcessId = (uint)currentProcess.Id; MiniDumpExceptionInformation exp; exp.ThreadId = GetCurrentThreadId(); exp.ClientPointers = false; exp.ExceptionPointers = IntPtr.Zero; if (exceptionInfo == ExceptionInfo.Present) { exp.ExceptionPointers = Marshal.GetExceptionPointers(); } var result = false; if (exp.ExceptionPointers == IntPtr.Zero) { result = MiniDumpWriteDump(currentProcessHandle, currentProcessId, fileHandle, (uint)options, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero); } else { result = MiniDumpWriteDump(currentProcessHandle, currentProcessId, fileHandle, (uint)options, ref exp, IntPtr.Zero, IntPtr.Zero); } return result; }
internal SecurityPackageInfoClass(SafeHandle safeHandle, int index) { if (!safeHandle.IsInvalid) { IntPtr ptr = IntPtrHelper.Add(safeHandle.DangerousGetHandle(), SecurityPackageInfo.Size * index); this.Capabilities = Marshal.ReadInt32(ptr, (int) Marshal.OffsetOf(typeof(SecurityPackageInfo), "Capabilities")); this.Version = Marshal.ReadInt16(ptr, (int) Marshal.OffsetOf(typeof(SecurityPackageInfo), "Version")); this.RPCID = Marshal.ReadInt16(ptr, (int) Marshal.OffsetOf(typeof(SecurityPackageInfo), "RPCID")); this.MaxToken = Marshal.ReadInt32(ptr, (int) Marshal.OffsetOf(typeof(SecurityPackageInfo), "MaxToken")); IntPtr ptr2 = Marshal.ReadIntPtr(ptr, (int) Marshal.OffsetOf(typeof(SecurityPackageInfo), "Name")); if (ptr2 != IntPtr.Zero) { if (ComNetOS.IsWin9x) { this.Name = Marshal.PtrToStringAnsi(ptr2); } else { this.Name = Marshal.PtrToStringUni(ptr2); } } ptr2 = Marshal.ReadIntPtr(ptr, (int) Marshal.OffsetOf(typeof(SecurityPackageInfo), "Comment")); if (ptr2 != IntPtr.Zero) { if (ComNetOS.IsWin9x) { this.Comment = Marshal.PtrToStringAnsi(ptr2); } else { this.Comment = Marshal.PtrToStringUni(ptr2); } } } }
/// <summary> /// Obtains the private key for a certificate. This function is used to obtain access to a user's private key when the user's certificate is available, but the handle of the user's key container is not available. This function can only be used by the owner of a private key and not by any other user. /// If a CSP handle and the key container containing a user's private key are available, the CryptGetUserKey function should be used instead. /// </summary> /// <param name="pCert">The address of a CERT_CONTEXT structure that contains the certificate context for which a private key will be obtained.</param> /// <param name="dwFlags">A set of flags that modify the behavior of this function. This can be zero or a combination of one or more of <see cref="CryptAcquireCertificatePrivateKeyFlags"/> values.</param> /// <param name="pvParameters"> /// If the <see cref="CryptAcquireCertificatePrivateKeyFlags.CRYPT_ACQUIRE_WINDOW_HANDLE_FLAG"/> is set, then this is the address of an HWND. If the <see cref="CryptAcquireCertificatePrivateKeyFlags.CRYPT_ACQUIRE_WINDOW_HANDLE_FLAG"/> is not set, then this parameter must be NULL. /// Windows Server 2008 R2, Windows 7, Windows Server 2008, Windows Vista, Windows Server 2003 and Windows XP: This parameter was named pvReserved and reserved for future use and must be NULL. /// </param> /// <param name="cryptHandle"> /// Receives a safe handle to either CNG key handle of type NCRYPT_KEY_HANDLE or CryptoAPI provider handle of type HCRYPTPROV. /// </param> /// <returns> /// If the function succeeds, the return value is nonzero. /// If the function fails, the return value is zero. /// </returns> public static unsafe bool CryptAcquireCertificatePrivateKey( IntPtr pCert, CryptAcquireCertificatePrivateKeyFlags dwFlags, IntPtr pvParameters, out SafeHandle cryptHandle) { IntPtr cryptProvOrNCryptKey; uint keySpec; bool callerFreeProvOrNCryptKey; if (!CryptAcquireCertificatePrivateKey( pCert, dwFlags, (void*)pvParameters, out cryptProvOrNCryptKey, out keySpec, out callerFreeProvOrNCryptKey)) { cryptHandle = AdvApi32.SafeCryptographicProviderHandle.Null; return false; } if (keySpec == CERT_NCRYPT_KEY_SPEC) { cryptHandle = new NCrypt.SafeKeyHandle(cryptProvOrNCryptKey, callerFreeProvOrNCryptKey); } else { cryptHandle = new AdvApi32.SafeCryptographicProviderHandle(cryptProvOrNCryptKey, callerFreeProvOrNCryptKey); } return true; }
/* This is to support SSL with no client cert. Important: safeHandle should not be Disposed during construction of this object. _SecPkgInfoW in sspi.h */ internal SecurityPackageInfoClass(SafeHandle safeHandle, int index) { if (safeHandle.IsInvalid) { if (NetEventSource.IsEnabled) NetEventSource.Info(this, $"Invalid handle: {safeHandle}"); return; } IntPtr unmanagedAddress = IntPtrHelper.Add(safeHandle.DangerousGetHandle(), SecurityPackageInfo.Size * index); if (NetEventSource.IsEnabled) NetEventSource.Info(this, $"unmanagedAddress: {unmanagedAddress}"); // TODO (Issue #3114): replace with Marshal.PtrToStructure. Capabilities = Marshal.ReadInt32(unmanagedAddress, (int)Marshal.OffsetOf<SecurityPackageInfo>("Capabilities")); Version = Marshal.ReadInt16(unmanagedAddress, (int)Marshal.OffsetOf<SecurityPackageInfo>("Version")); RPCID = Marshal.ReadInt16(unmanagedAddress, (int)Marshal.OffsetOf<SecurityPackageInfo>("RPCID")); MaxToken = Marshal.ReadInt32(unmanagedAddress, (int)Marshal.OffsetOf<SecurityPackageInfo>("MaxToken")); IntPtr unmanagedString; unmanagedString = Marshal.ReadIntPtr(unmanagedAddress, (int)Marshal.OffsetOf<SecurityPackageInfo>("Name")); if (unmanagedString != IntPtr.Zero) { Name = Marshal.PtrToStringUni(unmanagedString); if (NetEventSource.IsEnabled) NetEventSource.Info(this, $"Name: {Name}"); } unmanagedString = Marshal.ReadIntPtr(unmanagedAddress, (int)Marshal.OffsetOf<SecurityPackageInfo>("Comment")); if (unmanagedString != IntPtr.Zero) { Comment = Marshal.PtrToStringUni(unmanagedString); if (NetEventSource.IsEnabled) NetEventSource.Info(this, $"Comment: {Comment}"); } if (NetEventSource.IsEnabled) NetEventSource.Info(this, this.ToString()); }
/// <summary> /// Initializes a new instance of the <see cref="ReflogEntry"/> class. /// </summary> /// <param name="entryHandle">a <see cref="SafeHandle"/> to the reflog entry</param> public ReflogEntry(SafeHandle entryHandle) { _from = Proxy.git_reflog_entry_id_old(entryHandle); _to = Proxy.git_reflog_entry_id_new(entryHandle); _commiter = Proxy.git_reflog_entry_committer(entryHandle); message = Proxy.git_reflog_entry_message(entryHandle); }
private static extern int _RegNotifyChangeKeyValue( SafeHandle hKey, bool bWatchSubtree, RegNotifyChange dwNotifyFilter, SafeHandle hEvent, bool fAsynchronous );
public static void AssertSafeHandleIsValid(SafeHandle safeHandle) { if (safeHandle == null || safeHandle.IsInvalid) { throw new CryptographicException(Res.SafeHandleNotValid); } }
public static void CryptUnprotectMemory(SafeHandle pBuffer, uint byteCount) { if (!UnsafeNativeMethods.CryptUnprotectMemory(pBuffer, byteCount, CRYPTPROTECTMEMORY_SAME_PROCESS)) { UnsafeNativeMethods.ThrowExceptionForLastCrypt32Error(); } }
public static bool BindHandle (SafeHandle osHandle) { if (osHandle == null) throw new ArgumentNullException ("osHandle"); return true; }
public static ThreadPoolBoundHandle BindHandle(SafeHandle handle) { if (handle == null) throw new ArgumentNullException("handle"); if (handle.IsClosed || handle.IsInvalid) throw new ArgumentException(SR.Argument_InvalidHandle, "handle"); // Make sure we use a statically-rooted completion callback, // so it doesn't get collected while the I/O is in progress. Interop.NativeIoCompletionCallback callback = s_nativeIoCompletionCallback; if (callback == null) s_nativeIoCompletionCallback = callback = new Interop.NativeIoCompletionCallback(OnNativeIOCompleted); SafeThreadPoolIOHandle threadPoolHandle = Interop.mincore.CreateThreadpoolIo(handle, s_nativeIoCompletionCallback, IntPtr.Zero, IntPtr.Zero); if (threadPoolHandle.IsInvalid) { int hr = Marshal.GetHRForLastWin32Error(); if (hr == System.HResults.E_HANDLE) // Bad handle throw new ArgumentException(SR.Argument_InvalidHandle, "handle"); if (hr == System.HResults.E_INVALIDARG) // Handle already bound or sync handle throw new ArgumentException(SR.Argument_AlreadyBoundOrSyncHandle, "handle"); throw Marshal.GetExceptionForHR(hr); } return new ThreadPoolBoundHandle(handle, threadPoolHandle); }
/// <summary> /// Returns a <see cref="ThreadPoolBoundHandle"/> for the specific handle, /// which is bound to the system thread pool. /// </summary> /// <param name="handle"> /// A <see cref="SafeHandle"/> object that holds the operating system handle. The /// handle must have been opened for overlapped I/O on the unmanaged side. /// </param> /// <returns> /// <see cref="ThreadPoolBoundHandle"/> for <paramref name="handle"/>, which /// is bound to the system thread pool. /// </returns> /// <exception cref="ArgumentNullException"> /// <paramref name="handle"/> is <see langword="null"/>. /// </exception> /// <exception cref="ArgumentException"> /// <paramref name="handle"/> has been disposed. /// <para> /// -or- /// </para> /// <paramref name="handle"/> does not refer to a valid I/O handle. /// <para> /// -or- /// </para> /// <paramref name="handle"/> refers to a handle that has not been opened /// for overlapped I/O. /// <para> /// -or- /// </para> /// <paramref name="handle"/> refers to a handle that has already been bound. /// </exception> /// <remarks> /// This method should be called once per handle. /// <para> /// -or- /// </para> /// <see cref="ThreadPoolBoundHandle"/> does not take ownership of <paramref name="handle"/>, /// it remains the responsibility of the caller to call <see cref="SafeHandle.Dispose"/>. /// </remarks> public static ThreadPoolBoundHandle BindHandle(SafeHandle handle) { if (handle == null) throw new ArgumentNullException("handle"); if (handle.IsClosed || handle.IsInvalid) throw new ArgumentException(SR.Argument_InvalidHandle, "handle"); try { // ThreadPool.BindHandle will always return true, otherwise, it throws. See the underlying FCall // implementation in ThreadPoolNative::CorBindIoCompletionCallback to see the implementation. bool succeeded = ThreadPool.BindHandle(handle); Debug.Assert(succeeded); } catch (Exception ex) { // BindHandle throws ApplicationException on full CLR and Exception on CoreCLR. // We do not let either of these leak and convert them to ArgumentException to // indicate that the specified handles are invalid. if (ex.HResult == System.__HResults.E_HANDLE) // Bad handle throw new ArgumentException(SR.Argument_InvalidHandle, "handle"); if (ex.HResult == System.__HResults.E_INVALIDARG) // Handle already bound or sync handle throw new ArgumentException(SR.Argument_AlreadyBoundOrSyncHandle, "handle"); throw; } return new ThreadPoolBoundHandle(handle); }
private static extern bool ExternDuplicateHandle( ProcessHandle hSourceProcessHandle, SafeHandle hSourceHandle, ProcessHandle hTargetProcess, out SafeWaitHandle targetHandle, int dwDesiredAccess, [MarshalAs(UnmanagedType.Bool)] bool bInheritHandle, int dwOptions);
public static extern bool DeviceIoControl(SafeHandle hDevice, int IoControlCode, [MarshalAs(UnmanagedType.AsAny), In] object InBuffer, int nInBufferSize, IntPtr OutBuffer, int nOutBufferSize, out int pBytesReturned, IntPtr pOverlapped);
public static extern bool MiniDumpWriteDump( IntPtr hProcess, UInt32 ProcessId, // DWORD is a 32 bit unsigned integer SafeHandle hFile, MiniDumpType DumpType, IntPtr ExceptionParam, IntPtr UserStreamParam, IntPtr CallbackParam);
public bool ResetDevice(SafeHandle interfaceHandle) { LibUsbRequest req = new LibUsbRequest(); int ret; req.Timeout = UsbConstants.DEFAULT_TIMEOUT; return LibUsbDriverIO.UsbIOSync(interfaceHandle, LibUsbIoCtl.RESET_DEVICE, req, LibUsbRequest.Size, IntPtr.Zero, 0, out ret); }
public static extern bool MiniDumpWriteDump( IntPtr hProcess, uint processId, SafeHandle hFile, MINIDUMP_TYPE dumpType, IntPtr expParam, IntPtr userStreamParam, IntPtr callbackParam);
/// <summary> /// Gets the Win32 handle for a given RegistryKey. /// </summary> /// <param name="registryKey">registry key you want the handle for</param> /// <returns>Desired handle</returns> public static int getRegistryHandle(RegistryKey registryKey) { Type type = registryKey.GetType(); FieldInfo fieldInfo = type.GetField("hkey", BindingFlags.Instance | BindingFlags.NonPublic); System.Runtime.InteropServices.SafeHandle i = (System.Runtime.InteropServices.SafeHandle)fieldInfo.GetValue(registryKey); return(((IntPtr)i.DangerousGetHandle()).ToInt32()); }
/// <nodoc /> public static bool DuplicateHandle(ProcessHandle hSourceProcessHandle, SafeHandle hSourceHandle, ProcessHandle hTargetProcess, out SafeWaitHandle targetHandle, int dwDesiredAccess, bool bInheritHandle, int dwOptions) => s_nativeMethods.DuplicateHandle(hSourceProcessHandle, hSourceHandle, hTargetProcess, out targetHandle, dwDesiredAccess, bInheritHandle, dwOptions);
public DelayedFinalizer(SafeHandle safeHandle) { _safeHandle = safeHandle; }
public SafeNCryptKeyHandle(IntPtr handle, System.Runtime.InteropServices.SafeHandle parentHandle) : base(handle, parentHandle) { }
/// <inheritdoc /> public bool DuplicateHandle(ProcessHandle hSourceProcessHandle, SafeHandle hSourceHandle, ProcessHandle hTargetProcess, out SafeWaitHandle targetHandle, int dwDesiredAccess, bool bInheritHandle, int dwOptions) => ExternDuplicateHandle(hSourceProcessHandle, hSourceHandle, hTargetProcess, out targetHandle, dwDesiredAccess, bInheritHandle, dwOptions);
/// <inheritdoc /> public bool DuplicateHandle(ProcessHandle hSourceProcessHandle, SafeHandle hSourceHandle, ProcessHandle hTargetProcess, out SafeWaitHandle targetHandle, int dwDesiredAccess, bool bInheritHandle, int dwOptions) => throw new NotImplementedException();
public static bool BindHandle(System.Runtime.InteropServices.SafeHandle osHandle) => throw new NotImplementedException();
/// <summary> /// Used in Marshalling code /// Call safeHandle.InitializeHandle to set the internal _handle field /// </summary> public static void InitializeHandle(SafeHandle safeHandle, IntPtr win32Handle) { InteropExtensions.InitializeHandle(safeHandle, win32Handle); }
protected SafeNCryptHandle(IntPtr handle, System.Runtime.InteropServices.SafeHandle parentHandle) : base(false) { throw new NotImplementedException(); }
// Used by MCG's SafeHandle marshalling code to initialize a handle public static void InitializeHandle(SafeHandle safeHandle, IntPtr win32Handle) { safeHandle.InitializeHandle(win32Handle); }