/// <summary>
/// Polls a File Descriptor for the passed in flags.
/// </summary>
/// <param name="fd">The descriptor to poll</param>
/// <param name="events">The events to poll for</param>
/// <param name="timeout">The amount of time to wait; -1 for infinite, 0 for immediate return, and a positive number is the number of milliseconds</param>
/// <param name="triggered">The events that were returned by the poll call. May be PollEvents.POLLNONE in the case of a timeout.</param>
/// <returns>An error or Error.SUCCESS.</returns>
internal static unsafe Error Poll(SafeHandle fd, PollEvents events, int timeout, out PollEvents triggered)
{
bool gotRef = false;
try
{
fd.DangerousAddRef(ref gotRef);
var pollEvent = new PollEvent
{
FileDescriptor = fd.DangerousGetHandle().ToInt32(),
Events = events,
};
uint unused;
Error err = Poll(&pollEvent, 1, timeout, &unused);
triggered = pollEvent.TriggeredEvents;
return err;
}
finally
{
if (gotRef)
{
fd.DangerousRelease();
}
}
}
/*
* 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 unsafe SecurityPackageInfoClass(SafeHandle safeHandle, int index)
{
if (safeHandle.IsInvalid)
{
if (NetEventSource.Log.IsEnabled())
{
NetEventSource.Info(this, $"Invalid handle: {safeHandle}");
}
return;
}
IntPtr unmanagedAddress = safeHandle.DangerousGetHandle() + (sizeof(SecurityPackageInfo) * index);
if (NetEventSource.Log.IsEnabled())
{
NetEventSource.Info(this, $"unmanagedAddress: {unmanagedAddress}");
}
SecurityPackageInfo *pSecurityPackageInfo = (SecurityPackageInfo *)unmanagedAddress;
Capabilities = pSecurityPackageInfo->Capabilities;
Version = pSecurityPackageInfo->Version;
RPCID = pSecurityPackageInfo->RPCID;
MaxToken = pSecurityPackageInfo->MaxToken;
IntPtr unmanagedString;
unmanagedString = pSecurityPackageInfo->Name;
if (unmanagedString != IntPtr.Zero)
{
Name = Marshal.PtrToStringUni(unmanagedString);
if (NetEventSource.Log.IsEnabled())
{
NetEventSource.Info(this, $"Name: {Name}");
}
}
unmanagedString = pSecurityPackageInfo->Comment;
if (unmanagedString != IntPtr.Zero)
{
Comment = Marshal.PtrToStringUni(unmanagedString);
if (NetEventSource.Log.IsEnabled())
{
NetEventSource.Info(this, $"Comment: {Comment}");
}
}
if (NetEventSource.Log.IsEnabled())
{
NetEventSource.Info(this, this.ToString());
}
}
internal NegotiationInfoClass(SafeHandle safeHandle, int negotiationState)
{
if (safeHandle.IsInvalid)
{
if (NetEventSource.IsEnabled)
{
NetEventSource.Info(this, $"Invalid handle:{safeHandle}");
}
return;
}
IntPtr packageInfo = safeHandle.DangerousGetHandle();
if (NetEventSource.IsEnabled)
{
NetEventSource.Info(this, $"packageInfo:{packageInfo} negotiationState:{negotiationState:x}");
}
if (negotiationState == Interop.SspiCli.SECPKG_NEGOTIATION_COMPLETE ||
negotiationState == Interop.SspiCli.SECPKG_NEGOTIATION_OPTIMISTIC)
{
string name = null;
unsafe
{
IntPtr unmanagedString = ((SecurityPackageInfo *)packageInfo)->Name;
if (unmanagedString != IntPtr.Zero)
{
name = Marshal.PtrToStringUni(unmanagedString);
}
}
if (NetEventSource.IsEnabled)
{
NetEventSource.Info(this, $"packageInfo:{packageInfo} negotiationState:{negotiationState:x} name:{name}");
}
// An optimization for future string comparisons.
if (string.Compare(name, Kerberos, StringComparison.OrdinalIgnoreCase) == 0)
{
AuthenticationPackage = Kerberos;
}
else if (string.Compare(name, NTLM, StringComparison.OrdinalIgnoreCase) == 0)
{
AuthenticationPackage = NTLM;
}
else
{
AuthenticationPackage = name;
}
}
}
private void AppendExecutionProvider(NativeOnnxObjectHandle providerFactory)
{
unsafe
{
bool success = false;
providerFactory.DangerousAddRef(ref success);
if (success)
{
NativeMethods.ONNXRuntimeSessionOptionsAppendExecutionProvider(_nativeOption.DangerousGetHandle(), providerFactory.DangerousGetHandle());
providerFactory.DangerousRelease();
}
}
}
public EPollAsyncContext(EPollThread thread, SafeHandle handle)
{
_epoll = thread;
_writeQueue = new Queue(thread);
_readQueue = new Queue(thread);
bool success = false;
handle.DangerousAddRef(ref success);
_fd = handle.DangerousGetHandle().ToInt32();
_handle = handle;
_epoll.Control(EPOLL_CTL_ADD, _fd, EPOLLIN | EPOLLOUT | EPOLLET, Key);
}
internal static IntPtr SafeHandleAddRef(SafeHandle pHandle, ref bool success)
{
if (pHandle == null)
{
throw new ArgumentNullException(Environment.GetResourceString("ArgumentNull_SafeHandle"));
}
pHandle.DangerousAddRef(ref success);
if (!success)
{
return(IntPtr.Zero);
}
return(pHandle.DangerousGetHandle());
}
/*
* 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 (GlobalLog.IsEnabled)
{
GlobalLog.Print("SecurityPackageInfoClass::.ctor() the pointer is invalid: " + (safeHandle.DangerousGetHandle()).ToString("x"));
}
return;
}
IntPtr unmanagedAddress = IntPtrHelper.Add(safeHandle.DangerousGetHandle(), SecurityPackageInfo.Size * index);
if (GlobalLog.IsEnabled)
{
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);
if (GlobalLog.IsEnabled)
{
GlobalLog.Print("Name: " + Name);
}
}
unmanagedString = Marshal.ReadIntPtr(unmanagedAddress, (int)Marshal.OffsetOf <SecurityPackageInfo>("Comment"));
if (unmanagedString != IntPtr.Zero)
{
Comment = Marshal.PtrToStringUni(unmanagedString);
if (GlobalLog.IsEnabled)
{
GlobalLog.Print("Comment: " + Comment);
}
}
if (GlobalLog.IsEnabled)
{
GlobalLog.Print("SecurityPackageInfoClass::.ctor(): " + ToString());
}
}
/*
* 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());
}
}
private unsafe IAsyncResult BeginReadCore(byte[] array, int offset, int count, AsyncCallback userCallback, Object stateObject)
{
CheckParametersForBegin(array, offset, count);
AsyncFileStream_AsyncResult asyncResult = new AsyncFileStream_AsyncResult(userCallback, stateObject, false);
if (count == 0)
{
asyncResult.SignalCompleted();
}
else
{
// Keep the array in one location in memory until the OS writes the
// relevant data into the array. Free GCHandle later.
asyncResult.PinBuffer(array);
fixed(byte *p = array)
{
int numBytesRead = 0;
bool res;
res = Native.ReadFile(m_handle.DangerousGetHandle(), p + offset, count, out numBytesRead, asyncResult.OverlappedPtr);
if (res == false)
{
if (HandleErrorSituation("BeginRead", false))
{
asyncResult.SignalCompleted();
}
else
{
m_outstandingRequests.Add(asyncResult);
}
}
}
}
return(asyncResult);
}
public static unsafe int Read(SafeHandle handle, Span <byte> buffer)
{
fixed(byte *b = buffer)
{
int bytesRead = Interop.SocketRead((int)handle.DangerousGetHandle(), b, buffer.Length);
if (bytesRead < 0)
{
throw new IOException("`read` operation failed");
}
return(bytesRead);
}
}
internal static bool Cancel(SafeHandle safeHandle, out MonoIOError error)
{
bool release = false;
try {
safeHandle.DangerousAddRef(ref release);
return(Cancel_internal(safeHandle.DangerousGetHandle(), out error));
} finally {
if (release)
{
safeHandle.DangerousRelease();
}
}
}
public static byte[] GetSignature(this SignerInfo signerInfo)
{
var field = typeof(SignerInfo).GetField("m_pbCmsgSignerInfo", BindingFlags.Instance | BindingFlags.NonPublic);
SafeHandle pbCmsgSignerInfo = (SafeHandle)field.GetValue(signerInfo);
byte[] ret;
unsafe
{
CMSG_SIGNER_INFO *ptr = (CMSG_SIGNER_INFO *)pbCmsgSignerInfo.DangerousGetHandle();
ret = new byte[ptr->EncryptedHash.cbData];
Marshal.Copy(ptr->EncryptedHash.pbData, ret, 0, ret.Length);
return(ret);
}
}
private static bool IsAdministrator(SafeHandle hTokenToCheck)
{
var token = hTokenToCheck.DangerousGetHandle();
if (token == IntPtr.Zero)
{
return(false);
}
using var id = new WindowsIdentity(token);
var principal = new WindowsPrincipal(id);
return(principal.IsInRole(WindowsBuiltInRole.Administrator));
}
public static MonoFileType GetFileType(SafeHandle safeHandle, out MonoIOError error)
{
bool release = false;
try {
safeHandle.DangerousAddRef(ref release);
return(GetFileType(safeHandle.DangerousGetHandle(), out error));
} finally {
if (release)
{
safeHandle.DangerousRelease();
}
}
}
void EnsureRecordBuffer(uint bytes)
{
if (bytes <= currentBufferSize)
{
return;
}
bufferHandle.Close();
currentBufferSize = bytes;
bufferHandle = SafeHGlobalHandleCritical.AllocHGlobal(currentBufferSize);
record.pbMDData = bufferHandle.DangerousGetHandle();
record.dwMDDataLen = currentBufferSize;
}
public static unsafe void Write(SafeHandle handle, byte* buffer, int length)
{
int totalBytesWritten = 0;
while (totalBytesWritten < length)
{
int bytesWritten = Interop.SocketWrite((int)handle.DangerousGetHandle(), buffer, length);
if (bytesWritten < 0)
{
throw new IOException("`write` operation failed");
}
totalBytesWritten += bytesWritten;
}
}
private ThreadPoolBoundHandle CreateThreadPoolBoundHandle(SafeHandle handle, [CallerMemberName] string memberName = null, [CallerLineNumber] int lineNumber = 0)
{
handle = handle ?? HandleFactory.CreateAsyncFileHandleForWrite(GetTestFilePath(null, memberName, lineNumber));
try
{
return(ThreadPoolBoundHandle.BindHandle(handle));
}
catch (ArgumentException ex) when(ex.GetType() == typeof(ArgumentException))
{
// TODO: Remove this try/catch, which is intended to help with debugging https://github.com/dotnet/corefx/issues/18058
throw new ArgumentException("Handle value: " + handle.DangerousGetHandle(), ex.ParamName, ex);
}
}
private unsafe void OpenFileViewAccessor(string path, Action <IntPtr, long, Action> callback)
{
if (callback == null || !File.Exists(path))
{
response.StatusCode = 404;
return;
}
MemoryMappedFile mmf = null;
MemoryMappedViewAccessor mmva = null;
Action closeMmf = () =>
{
if (mmva != null)
{
mmva.Dispose();
mmva = null;
}
if (mmf != null)
{
mmf.Dispose();
mmf = null;
}
};
bool immediate_shutdown = false;
try
{
mmf = MemoryMappedFile.CreateFromFile(path, FileMode.Open);
long totalcount = FileAuxiliary.GetFileLength64(path);
mmva = mmf.CreateViewAccessor(0, totalcount, MemoryMappedFileAccess.ReadWrite);
SafeHandle handle = mmva.SafeMemoryMappedViewHandle;
if (handle.IsInvalid)
{
immediate_shutdown = true;
response.StatusCode = 503;
}
else
{
callback(handle.DangerousGetHandle(), totalcount, closeMmf);
}
}
catch (Exception)
{
immediate_shutdown = true;
response.StatusCode = 500;
}
if (immediate_shutdown)
{
closeMmf();
}
}
static void Main(string[] args)
{
if (args.Length > 0)
{
System.Reflection.FieldInfo fieldInfo = null;
SafeHandle handle = (SafeHandle)fieldInfo.GetValue(args[0]);
IntPtr dangerousHandle = handle.DangerousGetHandle();
int? nullable = null;
Console.WriteLine(nullable.Value);
}
Console.WriteLine("Hello World!");
Environment.Exit(0);
}
internal NegotiationInfoClass(SafeHandle safeHandle, int negotiationState)
{
if (safeHandle.IsInvalid)
{
GlobalLog.Print("NegotiationInfoClass::.ctor() the handle is invalid:" + (safeHandle.DangerousGetHandle()).ToString("x"));
return;
}
IntPtr packageInfo = safeHandle.DangerousGetHandle();
GlobalLog.Print("NegotiationInfoClass::.ctor() packageInfo:" + packageInfo.ToString("x8") + " negotiationState:" + negotiationState.ToString("x8"));
const int SECPKG_NEGOTIATION_COMPLETE = 0;
const int SECPKG_NEGOTIATION_OPTIMISTIC = 1;
// const int SECPKG_NEGOTIATION_IN_PROGRESS = 2;
// const int SECPKG_NEGOTIATION_DIRECT = 3;
// const int SECPKG_NEGOTIATION_TRY_MULTICRED = 4;
if (negotiationState == SECPKG_NEGOTIATION_COMPLETE || negotiationState == SECPKG_NEGOTIATION_OPTIMISTIC)
{
IntPtr unmanagedString = Marshal.ReadIntPtr(packageInfo, SecurityPackageInfo.NameOffest);
string name = null;
if (unmanagedString != IntPtr.Zero)
{
name = Marshal.PtrToStringUni(unmanagedString);
}
GlobalLog.Print("NegotiationInfoClass::.ctor() packageInfo:" + packageInfo.ToString("x8") + " negotiationState:" + negotiationState.ToString("x8") + " name:" + Logging.ObjectToString(name));
// an optimization for future string comparisons
if (string.Compare(name, Kerberos, StringComparison.OrdinalIgnoreCase) == 0)
{
AuthenticationPackage = Kerberos;
}
else if (string.Compare(name, NTLM, StringComparison.OrdinalIgnoreCase) == 0)
{
AuthenticationPackage = NTLM;
}
else if (string.Compare(name, WDigest, StringComparison.OrdinalIgnoreCase) == 0)
{
AuthenticationPackage = WDigest;
}
else
{
AuthenticationPackage = name;
}
}
}
private Advapi32.SERVICE_STATUS_PROCESS ControlService(SafeHandle serviceHandle, uint control)
{
IntPtr lpServiceStatus = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(Advapi32.SERVICE_STATUS_PROCESS)));
if (!Advapi32.ControlService(
serviceHandle.DangerousGetHandle(),
control,
lpServiceStatus
))
{
throw new Win32Exception(Marshal.GetLastWin32Error());
}
return((Advapi32.SERVICE_STATUS_PROCESS)Marshal.PtrToStructure(lpServiceStatus, typeof(Advapi32.SERVICE_STATUS_PROCESS)));
}
/// <summary>
/// Add a Reference to and Get a Handle.
/// </summary>
/// <remarks>
/// <para>
/// Convenient method to add a reference to a handle before retrieving its wrapped pointer. If a
/// reference cannot be added to the handle, an exception is thrown. This follows Microsoft's
/// recommended best practice to add a reference to the handle before retrieving its wrapped pointer
/// to minimize the risk of handle recycle attacks. You, however, are responsible for releasing the
/// reference to the handle after you are done with it, using <c>SafeHandle.DangerousRelease()</c>,
/// otherwise you risk a memory leak.
/// </para>
/// <para>
/// This method is the equivalent to calling both <c>SafeHandle.DangerousAddRef()</c> and
/// <c>SafeHandle.DangerousGetHandle()</c>, except an exception is thrown if the operation fails. This
/// is for convenience if, and only if, you want to treat the failure of this operation as
/// exceptional! If you do not want to treat the failure of this operation as exceptional and you
/// instead have a non-exceptional back-off routine, do not call this method and perform your back-off
/// routine in an exception handler! You're better off simply calling both
/// <c>SafeHandle.DangerousAddRef()</c> and <c>SafeHandle.DangerousGetHandle()</c> yourself.
/// </para>
/// </remarks>
/// <param name="this">
/// A handle.
/// </param>
/// <returns>
/// The handle's wrapped pointer.
/// </returns>
/// <exception cref="System.ArgumentException">
/// Thrown if the handle is closed, or if the handle is invalid.
/// </exception>
/// <exception cref="System.ArgumentNullException">
/// Thrown if the handle is a null reference.
/// </exception>
/// <exception cref="System.InvalidOperationException">
/// Thrown if a reference to the handle could not be added.
/// </exception>
internal static IntPtr DangerousAddRefAndGetHandle(this SafeHandle @this)
{
var isReferenceAdded = false;
@this.DangerousAddRef(ref isReferenceAdded);
if (!isReferenceAdded)
{
const string detailMessage = "Unable to add a reference to a handle.";
throw new InvalidOperationException(detailMessage);
}
var pHandle = @this.DangerousGetHandle();
return(pHandle);
}
public static void DiskSetDriveLayoutEx(SafeHandle handle, DRIVE_LAYOUT_INFORMATION_EX layout)
{
var bufSize = Marshal.SizeOf(layout);
var buf = Marshal.AllocHGlobal(bufSize);
uint bytesReturned = 0;
Marshal.StructureToPtr(layout, buf, false);
var b = DeviceIoControl(handle.DangerousGetHandle(), IOCTL_DISK_SET_DRIVE_LAYOUT_EX, buf, (uint)bufSize, IntPtr.Zero, 0, ref bytesReturned, IntPtr.Zero);
Marshal.FreeHGlobal(buf);
if (!b)
{
throw Marshal.GetExceptionForHR(Marshal.GetHRForLastWin32Error());
}
}
private static IntPtr HKEYfromRegKey(RegistryKey regKey)
{
Type typeFromHandle = typeof(RegistryKey);
BindingFlags bindingAttr = BindingFlags.Instance | BindingFlags.NonPublic;
FieldInfo field = typeFromHandle.GetField("hkey", bindingAttr);
if (field == null)
{
field = typeFromHandle.GetField("_hkey", bindingAttr);
}
SafeHandle safeHandle = (SafeHandle)field.GetValue(regKey);
return(safeHandle.DangerousGetHandle());
}
internal NegotiationInfoClass(SafeHandle safeHandle, int negotiationState)
{
if (safeHandle.IsInvalid)
{
if (GlobalLog.IsEnabled)
{
GlobalLog.Print("NegotiationInfoClass::.ctor() the handle is invalid:" + (safeHandle.DangerousGetHandle()).ToString("x"));
}
return;
}
IntPtr packageInfo = safeHandle.DangerousGetHandle();
if (GlobalLog.IsEnabled)
{
GlobalLog.Print("NegotiationInfoClass::.ctor() packageInfo:" + packageInfo.ToString("x8") + " negotiationState:" + negotiationState.ToString("x8"));
}
if (negotiationState == Interop.SspiCli.SECPKG_NEGOTIATION_COMPLETE ||
negotiationState == Interop.SspiCli.SECPKG_NEGOTIATION_OPTIMISTIC)
{
IntPtr unmanagedString = Marshal.ReadIntPtr(packageInfo, SecurityPackageInfo.NameOffest);
string name = null;
if (unmanagedString != IntPtr.Zero)
{
name = Marshal.PtrToStringUni(unmanagedString);
}
if (GlobalLog.IsEnabled)
{
GlobalLog.Print("NegotiationInfoClass::.ctor() packageInfo:" + packageInfo.ToString("x8") + " negotiationState:" + negotiationState.ToString("x8") + " name:" + LoggingHash.ObjectToString(name));
}
// An optimization for future string comparisons.
if (string.Compare(name, Kerberos, StringComparison.OrdinalIgnoreCase) == 0)
{
AuthenticationPackage = Kerberos;
}
else if (string.Compare(name, NTLM, StringComparison.OrdinalIgnoreCase) == 0)
{
AuthenticationPackage = NTLM;
}
else
{
AuthenticationPackage = name;
}
}
}
public IntPtr MarshalManagedToNative(object ManagedObj)
{
if (ManagedObj == null)
{
return(IntPtr.Zero);
}
SafeHandle[] array = (SafeHandle[])ManagedObj;
int i = 0;
bool success = false;
try
{
for (i = 0; i < array.Length; success = false, i++)
{
SafeHandle current = array[i];
if (current != null && !current.IsClosed && !current.IsInvalid)
{
current.DangerousAddRef(ref success);
}
}
IntPtr result = Marshal.AllocHGlobal(array.Length * IntPtr.Size);
Marshal.WriteIntPtr(result, 0, GCHandle.ToIntPtr(GCHandle.Alloc(array, GCHandleType.Normal)));
for (int j = 0; j < array.Length; j++)
{
SafeHandle current = array[j];
if (current == null || current.IsClosed || current.IsInvalid)
{
// the memory for this element was initialized to null by AllocHGlobal
continue;
}
Marshal.WriteIntPtr(result, (j + 1) * IntPtr.Size, current.DangerousGetHandle());
}
return(result + IntPtr.Size);
}
catch
{
int total = success ? i + 1 : i;
for (int j = 0; j < total; j++)
{
SafeHandle current = array[j];
if (current != null)
{
current.DangerousRelease();
}
}
throw;
}
}
internal static unsafe Error GetBytesAvailable(SafeHandle socket, int* available)
{
bool release = false;
try
{
socket.DangerousAddRef(ref release);
return DangerousGetBytesAvailable((int)socket.DangerousGetHandle(), available);
}
finally
{
if (release)
{
socket.DangerousRelease();
}
}
}
internal static unsafe Error SendMessage(SafeHandle socket, MessageHeader* messageHeader, SocketFlags flags, long* sent)
{
bool release = false;
try
{
socket.DangerousAddRef(ref release);
return DangerousSendMessage((int)socket.DangerousGetHandle(), messageHeader, flags, sent);
}
finally
{
if (release)
{
socket.DangerousRelease();
}
}
}
internal static unsafe Error GetIPv6MulticastOption(SafeHandle socket, MulticastOption multicastOption, IPv6MulticastOption* option)
{
bool release = false;
try
{
socket.DangerousAddRef(ref release);
return DangerousGetIPv6MulticastOption((int)socket.DangerousGetHandle(), multicastOption, option);
}
finally
{
if (release)
{
socket.DangerousRelease();
}
}
}
internal static unsafe Error Accept(SafeHandle socket, byte* socketAddress, int* socketAddressLen, int* acceptedFd)
{
bool release = false;
try
{
socket.DangerousAddRef(ref release);
return DangerousAccept((int)socket.DangerousGetHandle(), socketAddress, socketAddressLen, acceptedFd);
}
finally
{
if (release)
{
socket.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();
}
}
}
internal static unsafe Error SetReceiveTimeout(SafeHandle socket, int millisecondsTimeout)
{
bool release = false;
try
{
socket.DangerousAddRef(ref release);
return DangerousSetReceiveTimeout((int)socket.DangerousGetHandle(), millisecondsTimeout);
}
finally
{
if (release)
{
socket.DangerousRelease();
}
}
}
internal static unsafe Error GetSockName(SafeHandle socket, byte* socketAddress, int* socketAddressLen)
{
bool release = false;
try
{
socket.DangerousAddRef(ref release);
return DangerousGetSockName((int)socket.DangerousGetHandle(), socketAddress, socketAddressLen);
}
finally
{
if (release)
{
socket.DangerousRelease();
}
}
}
internal static unsafe Error SetSockOpt(SafeHandle socket, SocketOptionLevel optionLevel, SocketOptionName optionName, byte* optionValue, int optionLen)
{
bool release = false;
try
{
socket.DangerousAddRef(ref release);
return DangerousSetSockOpt((int)socket.DangerousGetHandle(), optionLevel, optionName, optionValue, optionLen);
}
finally
{
if (release)
{
socket.DangerousRelease();
}
}
}
internal static Error Shutdown(SafeHandle socket, SocketShutdown how)
{
bool release = false;
try
{
socket.DangerousAddRef(ref release);
return DangerousShutdown((int)socket.DangerousGetHandle(), how);
}
finally
{
if (release)
{
socket.DangerousRelease();
}
}
}
internal static Error TryChangeSocketEventRegistration(int port, SafeHandle socket, SocketEvents currentEvents, SocketEvents newEvents, IntPtr data)
{
bool release = false;
try
{
socket.DangerousAddRef(ref release);
return DangerousTryChangeSocketEventRegistration(port, (int)socket.DangerousGetHandle(), currentEvents, newEvents, data);
}
finally
{
if (release)
{
socket.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();
}
}
}
internal static Error Listen(SafeHandle socket, int backlog)
{
bool release = false;
try
{
socket.DangerousAddRef(ref release);
return DangerousListen((int)socket.DangerousGetHandle(), backlog);
}
finally
{
if (release)
{
socket.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 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();
}
}
}
internal static unsafe Error GetSocketErrorOption(SafeHandle socket, Error* socketError)
{
bool release = false;
try
{
socket.DangerousAddRef(ref release);
return DangerousGetSocketErrorOption((int)socket.DangerousGetHandle(), socketError);
}
finally
{
if (release)
{
socket.DangerousRelease();
}
}
}
public static IEnumerable<string> GetProcessRuntimes(ICLRMetaHost host, SafeHandle hProcess)
{
if (host != null)
{
var buffer = new StringBuilder(1024);
IEnumUnknown ppEnumerator = host.EnumerateLoadedRuntimes(hProcess.DangerousGetHandle());
return ppEnumerator.Cast<ICLRRuntimeInfo>().Select(rti =>
{
var bufferLength = (uint)buffer.Capacity;
rti.GetVersionString(buffer, ref bufferLength);
return buffer.ToString(0, (int)bufferLength - 1);
}).ToList();
}
else
{
string buffer = GetVersionFromProcess(hProcess);
if (buffer != null)
{
return new[] { buffer };
}
}
return Enumerable.Empty<string>();
}