public static unsafe SocketError Poll(SafeSocketHandle handle, int microseconds, SelectMode mode, out bool status) { bool refAdded = false; try { handle.DangerousAddRef(ref refAdded); IntPtr rawHandle = handle.DangerousGetHandle(); IntPtr *fileDescriptorSet = stackalloc IntPtr[2] { (IntPtr)1, rawHandle }; Interop.Winsock.TimeValue IOwait = default; // A negative timeout value implies an indefinite wait. int socketCount; if (microseconds != -1) { MicrosecondsToTimeValue((long)(uint)microseconds, ref IOwait); socketCount = Interop.Winsock.select( 0, mode == SelectMode.SelectRead ? fileDescriptorSet : null, mode == SelectMode.SelectWrite ? fileDescriptorSet : null, mode == SelectMode.SelectError ? fileDescriptorSet : null, ref IOwait); } else { socketCount = Interop.Winsock.select( 0, mode == SelectMode.SelectRead ? fileDescriptorSet : null, mode == SelectMode.SelectWrite ? fileDescriptorSet : null, mode == SelectMode.SelectError ? fileDescriptorSet : null, IntPtr.Zero); } if ((SocketError)socketCount == SocketError.SocketError) { status = false; return(GetLastSocketError()); } status = (int)fileDescriptorSet[0] != 0 && fileDescriptorSet[1] == rawHandle; return(SocketError.Success); } finally { if (refAdded) { handle.DangerousRelease(); } } }
internal unsafe bool AcceptEx(SafeSocketHandle listenSocketHandle, SafeSocketHandle acceptSocketHandle, IntPtr buffer, int len, int localAddressLength, int remoteAddressLength, out int bytesReceived, NativeOverlapped *overlapped) { IntPtr __listenSocketHandle_gen_native = default; IntPtr __acceptSocketHandle_gen_native = default; bytesReceived = default; bool __retVal; int __retVal_gen_native = default; // // Setup // bool listenSocketHandle__addRefd = false; bool acceptSocketHandle__addRefd = false; try { // // Marshal // listenSocketHandle.DangerousAddRef(ref listenSocketHandle__addRefd); __listenSocketHandle_gen_native = listenSocketHandle.DangerousGetHandle(); acceptSocketHandle.DangerousAddRef(ref acceptSocketHandle__addRefd); __acceptSocketHandle_gen_native = acceptSocketHandle.DangerousGetHandle(); fixed(int *__bytesReceived_gen_native = &bytesReceived) { __retVal_gen_native = ((delegate * unmanaged <IntPtr, IntPtr, IntPtr, int, int, int, int *, NativeOverlapped *, int>)_target)(__listenSocketHandle_gen_native, __acceptSocketHandle_gen_native, buffer, len, localAddressLength, remoteAddressLength, __bytesReceived_gen_native, overlapped); } Marshal.SetLastPInvokeError(Marshal.GetLastSystemError()); // // Unmarshal // __retVal = __retVal_gen_native != 0; } finally { // // Cleanup // if (listenSocketHandle__addRefd) { listenSocketHandle.DangerousRelease(); } if (acceptSocketHandle__addRefd) { acceptSocketHandle.DangerousRelease(); } } return(__retVal); }
internal unsafe bool ConnectEx(SafeSocketHandle socketHandle, IntPtr socketAddress, int socketAddressSize, IntPtr buffer, int dataLength, out int bytesSent, NativeOverlapped *overlapped) { IntPtr __socketHandle_gen_native = default; bytesSent = default; bool __retVal; int __retVal_gen_native = default; // // Setup // bool socketHandle__addRefd = false; try { // // Marshal // socketHandle.DangerousAddRef(ref socketHandle__addRefd); __socketHandle_gen_native = socketHandle.DangerousGetHandle(); fixed(int *__bytesSent_gen_native = &bytesSent) { __retVal_gen_native = ((delegate * unmanaged <IntPtr, IntPtr, int, IntPtr, int, int *, NativeOverlapped *, int>)_target)(__socketHandle_gen_native, socketAddress, socketAddressSize, buffer, dataLength, __bytesSent_gen_native, overlapped); } Marshal.SetLastPInvokeError(Marshal.GetLastSystemError()); // // Unmarshal // __retVal = __retVal_gen_native != 0; } finally { // // Cleanup // if (socketHandle__addRefd) { socketHandle.DangerousRelease(); } } return(__retVal); }
internal unsafe bool TransmitPackets(SafeSocketHandle socketHandle, IntPtr packetArray, int elementCount, int sendSize, NativeOverlapped *overlapped, TransmitFileOptions flags) { IntPtr __socketHandle_gen_native; bool __retVal; int __retVal_gen_native; // // Setup // bool socketHandle__addRefd = false; try { // // Marshal // socketHandle.DangerousAddRef(ref socketHandle__addRefd); __socketHandle_gen_native = socketHandle.DangerousGetHandle(); __retVal_gen_native = ((delegate * unmanaged <IntPtr, IntPtr, int, int, NativeOverlapped *, TransmitFileOptions, int>)_target)(__socketHandle_gen_native, packetArray, elementCount, sendSize, overlapped, flags); Marshal.SetLastPInvokeError(Marshal.GetLastSystemError()); // // Unmarshal // __retVal = __retVal_gen_native != 0; } finally { // // Cleanup // if (socketHandle__addRefd) { socketHandle.DangerousRelease(); } } return(__retVal); }
internal unsafe SocketError WSARecvMsg(SafeSocketHandle socketHandle, IntPtr msg, out int bytesTransferred, NativeOverlapped *overlapped, IntPtr completionRoutine) { IntPtr __socketHandle_gen_native = default; bytesTransferred = default; SocketError __retVal; // // Setup // bool socketHandle__addRefd = false; try { // // Marshal // socketHandle.DangerousAddRef(ref socketHandle__addRefd); __socketHandle_gen_native = socketHandle.DangerousGetHandle(); fixed(int *__bytesTransferred_gen_native = &bytesTransferred) { __retVal = ((delegate * unmanaged <IntPtr, IntPtr, int *, NativeOverlapped *, IntPtr, SocketError>)_target)(__socketHandle_gen_native, msg, __bytesTransferred_gen_native, overlapped, completionRoutine); } Marshal.SetLastPInvokeError(Marshal.GetLastSystemError()); } finally { // // Cleanup // if (socketHandle__addRefd) { socketHandle.DangerousRelease(); } } return(__retVal); }
internal unsafe bool DisconnectEx(SafeSocketHandle socketHandle, NativeOverlapped *overlapped, int flags, int reserved) { IntPtr __socketHandle_gen_native; bool __retVal; int __retVal_gen_native; // // Setup // bool socketHandle__addRefd = false; try { // // Marshal // socketHandle.DangerousAddRef(ref socketHandle__addRefd); __socketHandle_gen_native = socketHandle.DangerousGetHandle(); __retVal_gen_native = ((delegate * unmanaged <IntPtr, NativeOverlapped *, int, int, int>)_target)(__socketHandle_gen_native, overlapped, flags, reserved); Marshal.SetLastPInvokeError(Marshal.GetLastSystemError()); // // Unmarshal // __retVal = __retVal_gen_native != 0; } finally { // // Cleanup // if (socketHandle__addRefd) { socketHandle.DangerousRelease(); } } return(__retVal); }
static void Blocking_internal (SafeSocketHandle safeHandle, bool block, out int error) { bool release = false; try { safeHandle.DangerousAddRef (ref release); Blocking_internal (safeHandle.DangerousGetHandle (), block, out error); } finally { if (release) safeHandle.DangerousRelease (); } }
static int Available_internal (SafeSocketHandle safeHandle, out int error) { bool release = false; try { safeHandle.DangerousAddRef (ref release); return Available_internal (safeHandle.DangerousGetHandle (), out error); } finally { if (release) safeHandle.DangerousRelease (); } }
static void Shutdown_internal (SafeSocketHandle safeHandle, SocketShutdown how, out int error) { bool release = false; try { safeHandle.DangerousAddRef (ref release); Shutdown_internal (safeHandle.DangerousGetHandle (), how, out error); } finally { if (release) safeHandle.DangerousRelease (); } }
static int IOControl_internal (SafeSocketHandle safeHandle, int ioctl_code, byte [] input, byte [] output, out int error) { bool release = false; try { safeHandle.DangerousAddRef (ref release); return IOControl_internal (safeHandle.DangerousGetHandle (), ioctl_code, input, output, out error); } finally { if (release) safeHandle.DangerousRelease (); } }
static void SetSocketOption_internal (SafeSocketHandle safeHandle, SocketOptionLevel level, SocketOptionName name, object obj_val, byte [] byte_val, int int_val, out int error) { bool release = false; try { safeHandle.DangerousAddRef (ref release); SetSocketOption_internal (safeHandle.DangerousGetHandle (), level, name, obj_val, byte_val, int_val, out error); } finally { if (release) safeHandle.DangerousRelease (); } }
static int Send_internal (SafeSocketHandle safeHandle, WSABUF[] bufarray, SocketFlags flags, out int error) { bool release = false; try { safeHandle.DangerousAddRef (ref release); return Send_internal (safeHandle.DangerousGetHandle (), bufarray, flags, out error); } finally { if (release) safeHandle.DangerousRelease (); } }
static void Listen_internal (SafeSocketHandle safeHandle, int backlog, out int error) { bool release = false; try { safeHandle.DangerousAddRef (ref release); Listen_internal (safeHandle.DangerousGetHandle (), backlog, out error); } finally { if (release) safeHandle.DangerousRelease (); } }
private static void Bind_internal (SafeSocketHandle safeHandle, SocketAddress sa, out int error) { bool release = false; try { safeHandle.DangerousAddRef (ref release); Bind_internal (safeHandle.DangerousGetHandle (), sa, out error); } finally { if (release) safeHandle.DangerousRelease (); } }
private static void GetSocketOption_arr_internal (SafeSocketHandle safeHandle, SocketOptionLevel level, SocketOptionName name, ref byte[] byte_val, out int error) { bool release = false; try { safeHandle.DangerousAddRef (ref release); GetSocketOption_arr_internal (safeHandle.DangerousGetHandle (), level, name, ref byte_val, out error); } finally { if (release) safeHandle.DangerousRelease (); } }
static SocketAddress RemoteEndPoint_internal (SafeSocketHandle safeHandle, int family, out int error) { bool release = false; try { safeHandle.DangerousAddRef (ref release); return RemoteEndPoint_internal (safeHandle.DangerousGetHandle (), family, out error); } finally { if (release) safeHandle.DangerousRelease (); } }
static bool Poll_internal (SafeSocketHandle safeHandle, SelectMode mode, int timeout, out int error) { bool release = false; try { safeHandle.DangerousAddRef (ref release); return Poll_internal (safeHandle.DangerousGetHandle (), mode, timeout, out error); } finally { if (release) safeHandle.DangerousRelease (); } }
static void Disconnect_internal (SafeSocketHandle safeHandle, bool reuse, out int error) { bool release = false; try { safeHandle.DangerousAddRef (ref release); Disconnect_internal (safeHandle.DangerousGetHandle (), reuse, out error); } finally { if (release) safeHandle.DangerousRelease (); } }