public static ArbitraryWaitHandle FromSafeHandle(SafeHandle safeHandle) {
Contract.Requires(safeHandle != null);
Boolean success = false;
try {
safeHandle.DangerousAddRef(ref success);
if (!success) throw new InvalidOperationException("Couldn't AddRef");
return new ArbitraryWaitHandle(safeHandle.DangerousGetHandle());
}
finally {
safeHandle.DangerousRelease();
}
}
public static bool DuplicateHandle(HandleRef hSourceProcessHandle, SafeHandle hSourceHandle, HandleRef hTargetProcess,
out SafeWaitHandle targetHandle, int dwDesiredAccess, bool bInheritHandle, int dwOptions)
{
bool release = false;
try {
hSourceHandle.DangerousAddRef (ref release);
MonoIOError error;
IntPtr nakedTargetHandle;
bool ret = MonoIO.DuplicateHandle (hSourceProcessHandle.Handle, hSourceHandle.DangerousGetHandle (), hTargetProcess.Handle,
out nakedTargetHandle, dwDesiredAccess, bInheritHandle ? 1 : 0, dwOptions, out error);
if (error != MonoIOError.ERROR_SUCCESS)
throw MonoIO.GetException (error);
targetHandle = new SafeWaitHandle (nakedTargetHandle, true);
return ret;
} finally {
if (release)
hSourceHandle.DangerousRelease ();
}
}
private static IEnumerable<RecipientInfo> ToRecipientInfosForThisIndex(SafeHandle pCmsgCmsRecipientInfoMemory, int index)
{
bool mustRelease = false;
pCmsgCmsRecipientInfoMemory.DangerousAddRef(ref mustRelease);
try
{
unsafe
{
CMSG_CMS_RECIPIENT_INFO* pCMsgCmsRecipientInfo = (CMSG_CMS_RECIPIENT_INFO*)(pCmsgCmsRecipientInfoMemory.DangerousGetHandle());
switch (pCMsgCmsRecipientInfo->dwRecipientChoice)
{
case CMsgCmsRecipientChoice.CMSG_KEY_TRANS_RECIPIENT:
return new KeyTransRecipientInfo[] { new KeyTransRecipientInfo(new KeyTransRecipientInfoPalWindows(pCmsgCmsRecipientInfoMemory, index)) };
case CMsgCmsRecipientChoice.CMSG_KEY_AGREE_RECIPIENT:
{
CMSG_KEY_AGREE_RECIPIENT_INFO* pCmsKeyAgreeRecipientInfo = pCMsgCmsRecipientInfo->KeyAgree;
int numKeys = pCmsKeyAgreeRecipientInfo->cRecipientEncryptedKeys;
KeyAgreeRecipientInfo[] recipients = new KeyAgreeRecipientInfo[numKeys];
for (int subIndex = 0; subIndex < numKeys; subIndex++)
{
recipients[subIndex] = new KeyAgreeRecipientInfo(new KeyAgreeRecipientInfoPalWindows(pCmsgCmsRecipientInfoMemory, index, subIndex));
}
return recipients;
}
default:
throw ErrorCode.E_NOTIMPL.ToCryptographicException();
}
}
}
finally
{
if (mustRelease)
{
pCmsgCmsRecipientInfoMemory.DangerousRelease();
}
}
}
public static bool BindHandle(SafeHandle osHandle)
{
if (osHandle == null)
{
throw new ArgumentNullException("osHandle");
}
bool flag = false;
bool success = false;
RuntimeHelpers.PrepareConstrainedRegions();
try
{
osHandle.DangerousAddRef(ref success);
flag = BindIOCompletionCallbackNative(osHandle.DangerousGetHandle());
}
finally
{
if (success)
{
osHandle.DangerousRelease();
}
}
return flag;
}
public static void Unlock (SafeHandle safeHandle,
long position, long length,
out MonoIOError error)
{
bool release = false;
try {
safeHandle.DangerousAddRef (ref release);
Unlock (safeHandle.DangerousGetHandle (), position, length, out error);
} finally {
if (release)
safeHandle.DangerousRelease ();
}
}
public static bool SetFileTime (SafeHandle safeHandle,
long creation_time,
long last_access_time,
long last_write_time,
out MonoIOError error)
{
bool release = false;
try {
safeHandle.DangerousAddRef (ref release);
return SetFileTime (safeHandle.DangerousGetHandle (), creation_time, last_access_time, last_write_time, out error);
} finally {
if (release)
safeHandle.DangerousRelease ();
}
}
public static bool SetLength (SafeHandle safeHandle,
long length,
out MonoIOError error)
{
bool release = false;
try {
safeHandle.DangerousAddRef (ref release);
return SetLength (safeHandle.DangerousGetHandle (), length, out error);
} finally {
if (release)
safeHandle.DangerousRelease ();
}
}
public static bool Flush (SafeHandle safeHandle,
out MonoIOError error)
{
bool release = false;
try {
safeHandle.DangerousAddRef (ref release);
return Flush (safeHandle.DangerousGetHandle (), out error);
} finally {
if (release)
safeHandle.DangerousRelease ();
}
}
public static long Seek (SafeHandle safeHandle, long offset,
SeekOrigin origin,
out MonoIOError error)
{
bool release = false;
try {
safeHandle.DangerousAddRef (ref release);
return Seek (safeHandle.DangerousGetHandle (), offset, origin, out error);
} finally {
if (release)
safeHandle.DangerousRelease ();
}
}
public static int Write (SafeHandle safeHandle, byte [] src,
int src_offset, int count,
out MonoIOError error)
{
bool release = false;
try {
safeHandle.DangerousAddRef (ref release);
return Write (safeHandle.DangerousGetHandle (), src, src_offset, count, out error);
} finally {
if (release)
safeHandle.DangerousRelease ();
}
}
public static int Read (SafeHandle safeHandle, byte [] dest,
int dest_offset, int count,
out MonoIOError error)
{
bool release = false;
try {
safeHandle.DangerousAddRef (ref release);
return Read (safeHandle.DangerousGetHandle (), dest, dest_offset, count, out error);
} finally {
if (release)
safeHandle.DangerousRelease ();
}
}
static int WaitOneNative (SafeHandle waitableSafeHandle, uint millisecondsTimeout, bool hasThreadAffinity, bool exitContext)
{
bool release = false;
try {
#if !DISABLE_REMOTING
if (exitContext)
SynchronizationAttribute.ExitContext ();
#endif
waitableSafeHandle.DangerousAddRef (ref release);
return WaitOne_internal (waitableSafeHandle.DangerousGetHandle (), (int) millisecondsTimeout);
} finally {
if (release)
waitableSafeHandle.DangerousRelease ();
#if !DISABLE_REMOTING
if (exitContext)
SynchronizationAttribute.EnterContext ();
#endif
}
}
public static bool BindHandle(SafeHandle osHandle)
{
if (osHandle == null)
throw new ArgumentNullException("osHandle");
bool ret = false;
bool mustReleaseSafeHandle = false;
RuntimeHelpers.PrepareConstrainedRegions();
try {
osHandle.DangerousAddRef(ref mustReleaseSafeHandle);
ret = BindIOCompletionCallbackNative(osHandle.DangerousGetHandle());
}
finally {
if (mustReleaseSafeHandle)
osHandle.DangerousRelease();
}
return ret;
}
internal static void SafeHandleRelease(SafeHandle pHandle)
{
if (pHandle == null)
{
throw new ArgumentNullException(Environment.GetResourceString("ArgumentNull_SafeHandle"));
}
try
{
pHandle.DangerousRelease();
}
catch (Exception exception)
{
Mda.ReportErrorSafeHandleRelease(exception);
}
}
static internal void SafeHandleRelease(SafeHandle pHandle)
{
if (pHandle == null)
{
throw new ArgumentNullException(Environment.GetResourceString("ArgumentNull_SafeHandle"));
}
Contract.EndContractBlock();
try
{
pHandle.DangerousRelease();
}
#if MDA_SUPPORTED
catch (Exception ex)
{
Mda.ReportErrorSafeHandleRelease(ex);
}
#else // MDA_SUPPORTED
catch (Exception)
{ }
#endif // MDA_SUPPORTED
}
static int WaitOneNative (SafeHandle waitableSafeHandle, uint millisecondsTimeout, bool hasThreadAffinity, bool exitContext)
{
#if MONOTOUCH
if (exitContext)
throw new NotSupportedException ("exitContext == true is not supported");
#endif
bool release = false;
try {
if (exitContext)
SynchronizationAttribute.ExitContext ();
waitableSafeHandle.DangerousAddRef (ref release);
return WaitOne_internal (waitableSafeHandle.DangerousGetHandle (), (int) millisecondsTimeout, exitContext);
} finally {
if (release)
waitableSafeHandle.DangerousRelease ();
if (exitContext)
SynchronizationAttribute.EnterContext ();
}
}