internal bool DisconnectExBlocking(SafeCloseSocket socketHandle, IntPtr overlapped, int flags, int reserved)
{
EnsureDynamicWinsockMethods();
DisconnectExDelegateBlocking disconnectEx_Blocking = _dynamicWinsockMethods.GetDelegate<DisconnectExDelegateBlocking>(socketHandle);
return disconnectEx_Blocking(socketHandle, overlapped, flags, reserved);
}
internal bool DisconnectEx(SafeCloseSocket socketHandle, SafeHandle overlapped, int flags, int reserved)
{
EnsureDynamicWinsockMethods();
DisconnectExDelegate disconnectEx = _dynamicWinsockMethods.GetDelegate<DisconnectExDelegate>(socketHandle);
return disconnectEx(socketHandle, overlapped, flags, reserved);
}
public static SocketError GetAvailable(SafeCloseSocket handle, out int available)
{
int value = 0;
SocketError errorCode = Interop.Winsock.ioctlsocket(
handle,
Interop.Winsock.IoctlSocketConstants.FIONREAD,
ref value);
available = value;
return errorCode == SocketError.SocketError ? GetLastSocketError() : SocketError.Success;
}
private Socket GetOrCreateAcceptSocket(Socket acceptSocket, bool unused, string propertyName, out SafeCloseSocket handle)
{
// AcceptSocket is not supported on Unix.
if (acceptSocket != null)
{
throw new PlatformNotSupportedException();
}
handle = null;
return null;
}
internal bool ConnectEx(SafeCloseSocket socketHandle,
IntPtr socketAddress,
int socketAddressSize,
IntPtr buffer,
int dataLength,
out int bytesSent,
SafeHandle overlapped)
{
EnsureDynamicWinsockMethods();
ConnectExDelegate connectEx = _dynamicWinsockMethods.GetDelegate<ConnectExDelegate>(socketHandle);
return connectEx(socketHandle, socketAddress, socketAddressSize, buffer, dataLength, out bytesSent, overlapped);
}
public static SocketError SetBlocking(SafeCloseSocket handle, bool shouldBlock, out bool willBlock)
{
int intBlocking = shouldBlock ? 0 : -1;
SocketError errorCode;
errorCode = Interop.Winsock.ioctlsocket(
handle,
Interop.Winsock.IoctlSocketConstants.FIONBIO,
ref intBlocking);
if (errorCode == SocketError.SocketError)
{
errorCode = (SocketError)Marshal.GetLastWin32Error();
}
willBlock = intBlocking == 0;
return errorCode;
}
internal bool AcceptEx(SafeCloseSocket listenSocketHandle,
SafeCloseSocket acceptSocketHandle,
IntPtr buffer,
int len,
int localAddressLength,
int remoteAddressLength,
out int bytesReceived,
SafeHandle overlapped)
{
EnsureDynamicWinsockMethods();
AcceptExDelegate acceptEx = _dynamicWinsockMethods.GetDelegate<AcceptExDelegate>(listenSocketHandle);
return acceptEx(listenSocketHandle,
acceptSocketHandle,
buffer,
len,
localAddressLength,
remoteAddressLength,
out bytesReceived,
overlapped);
}
protected static void CreateSocket(InnerSafeCloseSocket socket, SafeCloseSocket target)
{
if ((socket != null) && socket.IsInvalid)
{
target.SetHandleAsInvalid();
}
else
{
bool success = false;
RuntimeHelpers.PrepareConstrainedRegions();
try
{
socket.DangerousAddRef(ref success);
}
catch
{
if (success)
{
socket.DangerousRelease();
success = false;
}
}
finally
{
if (success)
{
target.SetInnerSocket(socket);
socket.Close();
}
else
{
target.SetHandleAsInvalid();
}
}
}
}
private Socket(SafeCloseSocket fd)
{
this.willBlock = true;
this.willBlockInternal = true;
this.m_CloseTimeout = -1;
s_LoggingEnabled = Logging.On;
if (s_LoggingEnabled)
{
Logging.Enter(Logging.Sockets, this, "Socket", (string) null);
}
InitializeSockets();
if ((fd == null) || fd.IsInvalid)
{
throw new ArgumentException(SR.GetString("net_InvalidSocketHandle"));
}
this.m_Handle = fd;
this.addressFamily = System.Net.Sockets.AddressFamily.Unknown;
this.socketType = System.Net.Sockets.SocketType.Unknown;
this.protocolType = System.Net.Sockets.ProtocolType.Unknown;
if (s_LoggingEnabled)
{
Logging.Exit(Logging.Sockets, this, "Socket", (string) null);
}
}
public static SocketError Send(SafeCloseSocket handle, byte[] buffer, int offset, int count, SocketFlags socketFlags, out int bytesTransferred)
{
if (!handle.IsNonBlocking)
{
return handle.AsyncContext.Send(buffer, offset, count, socketFlags, handle.SendTimeout, out bytesTransferred);
}
bytesTransferred = 0;
SocketError errorCode;
bool completed = TryCompleteSendTo(handle.FileDescriptor, buffer, ref offset, ref count, socketFlags, null, 0, ref bytesTransferred, out errorCode);
return completed ? errorCode : SocketError.WouldBlock;
}
private Socket GetOrCreateAcceptSocket(Socket acceptSocket, bool checkDisconnected, string propertyName, out SafeCloseSocket handle)
{
// If an acceptSocket isn't specified, then we need to create one.
if (acceptSocket == null)
{
acceptSocket = new Socket(_addressFamily, _socketType, _protocolType);
}
else
{
if (acceptSocket._rightEndPoint != null && (!checkDisconnected || !acceptSocket._isDisconnected))
{
throw new InvalidOperationException(SR.Format(SR.net_sockets_namedmustnotbebound, propertyName));
}
}
handle = acceptSocket._handle;
return acceptSocket;
}
internal static extern SocketError listen(
[In] SafeCloseSocket socketHandle,
[In] int backlog);
internal static extern SocketError getpeername(
[In] SafeCloseSocket socketHandle,
[Out] byte[] socketAddress,
[In, Out] ref int socketAddressSize);
internal SocketError DoOperationSendTo(SafeCloseSocket handle, out int bytesTransferred)
{
PrepareIOCPOperation();
SocketError socketError;
if (_buffer != null)
{
// Single buffer case.
socketError = Interop.Winsock.WSASendTo(
handle,
ref _wsaBuffer,
1,
out bytesTransferred,
_socketFlags,
_ptrSocketAddressBuffer,
_socketAddress.Size,
_ptrNativeOverlapped,
IntPtr.Zero);
}
else
{
socketError = Interop.Winsock.WSASendTo(
handle,
_wsaBufferArray,
_wsaBufferArray.Length,
out bytesTransferred,
_socketFlags,
_ptrSocketAddressBuffer,
_socketAddress.Size,
_ptrNativeOverlapped,
IntPtr.Zero);
}
if (socketError == SocketError.SocketError)
{
socketError = SocketPal.GetLastSocketError();
}
return socketError;
}
public static SocketError ReceiveFrom(SafeCloseSocket handle, byte[] buffer, int offset, int count, SocketFlags socketFlags, byte[] socketAddress, ref int socketAddressLen, out int bytesTransferred)
{
if (!handle.IsNonBlocking)
{
return handle.AsyncContext.ReceiveFrom(buffer, offset, count, ref socketFlags, socketAddress, ref socketAddressLen, handle.ReceiveTimeout, out bytesTransferred);
}
SocketError errorCode;
bool completed = TryCompleteReceiveFrom(handle.FileDescriptor, buffer, offset, count, socketFlags, socketAddress, ref socketAddressLen, out bytesTransferred, out socketFlags, out errorCode);
return completed ? errorCode : SocketError.WouldBlock;
}
public static unsafe SocketError SetSockOpt(SafeCloseSocket handle, SocketOptionLevel optionLevel, SocketOptionName optionName, int optionValue)
{
if (optionLevel == SocketOptionLevel.Socket)
{
if (optionName == SocketOptionName.ReceiveTimeout)
{
handle.ReceiveTimeout = optionValue == 0 ? -1 : optionValue;
return SocketError.Success;
}
else if (optionName == SocketOptionName.SendTimeout)
{
handle.SendTimeout = optionValue == 0 ? -1 : optionValue;
return SocketError.Success;
}
}
Interop.Error err = Interop.Sys.SetSockOpt(handle.FileDescriptor, optionLevel, optionName, (byte*)&optionValue, sizeof(int));
return err == Interop.Error.SUCCESS ? SocketError.Success : GetSocketOptionErrorForErrorCode(err);
}
internal static extern SocketError getsockopt(
[In] SafeCloseSocket socketHandle,
[In] SocketOptionLevel optionLevel,
[In] SocketOptionName optionName,
[Out] byte[] optionValue,
[In, Out] ref int optionLength);
internal static extern SocketError getsockopt(
[In] SafeCloseSocket socketHandle,
[In] SocketOptionLevel optionLevel,
[In] SocketOptionName optionName,
[Out] out IPv6MulticastRequest optionValue,
[In, Out] ref int optionLength);
internal static extern bool WSAGetOverlappedResult(
[In] SafeCloseSocket socketHandle,
[In] SafeHandle overlapped,
[Out] out uint bytesTransferred,
[In] bool wait,
[Out] out SocketFlags socketFlags);
internal static extern SocketError WSAEventSelect(
[In] SafeCloseSocket socketHandle,
[In] IntPtr Event,
[In] AsyncEventBits NetworkEvents);
internal static extern SocketError WSAEnumNetworkEvents(
[In] SafeCloseSocket socketHandle,
[In] SafeWaitHandle Event,
[In, Out] ref NetworkEvents networkEvents);
internal static extern SocketError bind(
[In] SafeCloseSocket socketHandle,
[In] byte[] socketAddress,
[In] int socketAddressSize);
internal static extern SocketError setsockopt(
[In] SafeCloseSocket socketHandle,
[In] SocketOptionLevel optionLevel,
[In] SocketOptionName optionName,
[In] ref IPv6MulticastRequest mreq,
[In] int optionLength);
public static SocketError Receive(SafeCloseSocket handle, IList<ArraySegment<byte>> buffers, ref SocketFlags socketFlags, out int bytesTransferred)
{
SocketError errorCode;
if (!handle.IsNonBlocking)
{
errorCode = handle.AsyncContext.Receive(buffers, ref socketFlags, handle.ReceiveTimeout, out bytesTransferred);
}
else
{
int socketAddressLen = 0;
if (!TryCompleteReceiveFrom(handle.FileDescriptor, buffers, socketFlags, null, ref socketAddressLen, out bytesTransferred, out socketFlags, out errorCode))
{
errorCode = SocketError.WouldBlock;
}
}
return errorCode;
}
internal static extern SocketError setsockopt(
[In] SafeCloseSocket socketHandle,
[In] SocketOptionLevel optionLevel,
[In] SocketOptionName optionName,
[In] ref Linger linger,
[In] int optionLength);
public static SocketError ReceiveMessageFrom(Socket socket, SafeCloseSocket handle, byte[] buffer, int offset, int count, ref SocketFlags socketFlags, Internals.SocketAddress socketAddress, out Internals.SocketAddress receiveAddress, out IPPacketInformation ipPacketInformation, out int bytesTransferred)
{
byte[] socketAddressBuffer = socketAddress.Buffer;
int socketAddressLen = socketAddress.Size;
bool isIPv4, isIPv6;
Socket.GetIPProtocolInformation(socket.AddressFamily, socketAddress, out isIPv4, out isIPv6);
SocketError errorCode;
if (!handle.IsNonBlocking)
{
errorCode = handle.AsyncContext.ReceiveMessageFrom(buffer, offset, count, ref socketFlags, socketAddressBuffer, ref socketAddressLen, isIPv4, isIPv6, handle.ReceiveTimeout, out ipPacketInformation, out bytesTransferred);
}
else
{
if (!TryCompleteReceiveMessageFrom(handle.FileDescriptor, buffer, offset, count, socketFlags, socketAddressBuffer, ref socketAddressLen, isIPv4, isIPv6, out bytesTransferred, out socketFlags, out ipPacketInformation, out errorCode))
{
errorCode = SocketError.WouldBlock;
}
}
socketAddress.InternalSize = socketAddressLen;
receiveAddress = socketAddress;
return errorCode;
}
internal unsafe SocketError DoOperationConnect(Socket socket, SafeCloseSocket handle, out int bytesTransferred)
{
PrepareIOCPOperation();
SocketError socketError = SocketError.Success;
if (!socket.ConnectEx(
handle,
_ptrSocketAddressBuffer,
_socketAddress.Size,
_ptrSingleBuffer,
Count,
out bytesTransferred,
_ptrNativeOverlapped))
{
socketError = SocketPal.GetLastSocketError();
}
return socketError;
}
public static SocketError IoctlInternal(SafeCloseSocket handle, IOControlCode ioControlCode, IntPtr optionInValue, int inValueLength, IntPtr optionOutValue, int outValueLength, out int optionLength)
{
// TODO: can this be supported in some reasonable fashion?
throw new PlatformNotSupportedException();
}
internal unsafe SocketError DoOperationReceiveMessageFrom(Socket socket, SafeCloseSocket handle, out int bytesTransferred)
{
PrepareIOCPOperation();
SocketError socketError = socket.WSARecvMsg(
handle,
_ptrWSAMessageBuffer,
out bytesTransferred,
_ptrNativeOverlapped,
IntPtr.Zero);
if (socketError == SocketError.SocketError)
{
socketError = SocketPal.GetLastSocketError();
}
return socketError;
}
internal unsafe SocketError DoOperationAccept(Socket socket, SafeCloseSocket handle, SafeCloseSocket acceptHandle, out int bytesTransferred)
{
PrepareIOCPOperation();
SocketError socketError = SocketError.Success;
if (!socket.AcceptEx(
handle,
acceptHandle,
(_ptrSingleBuffer != IntPtr.Zero) ? _ptrSingleBuffer : _ptrAcceptBuffer,
(_ptrSingleBuffer != IntPtr.Zero) ? Count - _acceptAddressBufferCount : 0,
_acceptAddressBufferCount / 2,
_acceptAddressBufferCount / 2,
out bytesTransferred,
_ptrNativeOverlapped))
{
socketError = SocketPal.GetLastSocketError();
}
return socketError;
}
internal static extern SocketError ioctlsocket(
[In] SafeCloseSocket socketHandle,
[In] int cmd,
[In, Out] ref int argp);
internal unsafe SocketError DoOperationReceiveFrom(SafeCloseSocket handle, out SocketFlags flags, out int bytesTransferred)
{
PrepareIOCPOperation();
flags = _socketFlags;
SocketError socketError;
if (_buffer != null)
{
socketError = Interop.Winsock.WSARecvFrom(
handle,
ref _wsaBuffer,
1,
out bytesTransferred,
ref flags,
_ptrSocketAddressBuffer,
_ptrSocketAddressBufferSize,
_ptrNativeOverlapped,
IntPtr.Zero);
}
else
{
socketError = Interop.Winsock.WSARecvFrom(
handle,
_wsaBufferArray,
_wsaBufferArray.Length,
out bytesTransferred,
ref flags,
_ptrSocketAddressBuffer,
_ptrSocketAddressBufferSize,
_ptrNativeOverlapped,
IntPtr.Zero);
}
if (socketError == SocketError.SocketError)
{
socketError = SocketPal.GetLastSocketError();
}
return socketError;
}
// Called by the class to create a socket to accept an incoming request.
private Socket(SafeCloseSocket fd)
{
s_loggingEnabled = Logging.On;
if (s_loggingEnabled)
{
Logging.Enter(Logging.Sockets, this, "Socket", null);
}
InitializeSockets();
// NOTE: if this ctor is re-publicized/protected, check
// that fd is valid socket handle.
// This should never happen.
if (fd == null || fd.IsInvalid)
{
throw new ArgumentException(SR.net_InvalidSocketHandle);
}
_handle = fd;
_addressFamily = Sockets.AddressFamily.Unknown;
_socketType = Sockets.SocketType.Unknown;
_protocolType = Sockets.ProtocolType.Unknown;
if (s_loggingEnabled)
{
Logging.Exit(Logging.Sockets, this, "Socket", null);
}
}
internal SocketError DoOperationSendPackets(Socket socket, SafeCloseSocket handle)
{
PrepareIOCPOperation();
bool result = socket.TransmitPackets(
handle,
_ptrSendPacketsDescriptor,
_sendPacketsDescriptor.Length,
_sendPacketsSendSize,
_ptrNativeOverlapped);
return result ? SocketError.Success : SocketPal.GetLastSocketError();
}
private Socket GetOrCreateAcceptSocket(Socket acceptSocket, bool unused, string propertyName, out SafeCloseSocket handle)
{
// AcceptSocket is not supported on Unix.
if (acceptSocket != null)
{
throw new PlatformNotSupportedException();
}
handle = null;
return(null);
}
internal bool TransmitPackets(SafeCloseSocket socketHandle, IntPtr packetArray, int elementCount, int sendSize, SafeNativeOverlapped overlapped)
{
EnsureDynamicWinsockMethods();
TransmitPacketsDelegate transmitPackets = _dynamicWinsockMethods.GetDelegate<TransmitPacketsDelegate>(socketHandle);
// UseDefaultWorkerThread = 0.
return transmitPackets(socketHandle, packetArray, elementCount, sendSize, overlapped, 0);
}
public static SocketError Disconnect(Socket socket, SafeCloseSocket handle, bool reuseSocket)
{
throw new PlatformNotSupportedException();
}
public static SocketError Send(SafeCloseSocket handle, IList<ArraySegment<byte>> buffers, SocketFlags socketFlags, out int bytesTransferred)
{
var bufferList = buffers;
if (!handle.IsNonBlocking)
{
return handle.AsyncContext.Send(bufferList, socketFlags, handle.SendTimeout, out bytesTransferred);
}
bytesTransferred = 0;
int bufferIndex = 0;
int offset = 0;
SocketError errorCode;
bool completed = TryCompleteSendTo(handle.FileDescriptor, bufferList, ref bufferIndex, ref offset, socketFlags, null, 0, ref bytesTransferred, out errorCode);
return completed ? errorCode : SocketError.WouldBlock;
}
internal static extern SocketError shutdown(
[In] SafeCloseSocket socketHandle,
[In] int how);
internal SocketError WSARecvMsg(SafeCloseSocket socketHandle, IntPtr msg, out int bytesTransferred, SafeHandle overlapped, IntPtr completionRoutine)
{
EnsureDynamicWinsockMethods();
WSARecvMsgDelegate recvMsg = _dynamicWinsockMethods.GetDelegate<WSARecvMsgDelegate>(socketHandle);
return recvMsg(socketHandle, msg, out bytesTransferred, overlapped, completionRoutine);
}
public static SocketError Accept(SafeCloseSocket handle, byte[] buffer, ref int nameLen, out SafeCloseSocket socket)
{
return SafeCloseSocket.Accept(handle, buffer, ref nameLen, out socket);
}
#pragma warning restore
// CreateAcceptSocket - pulls unmanaged results and assembles them into a new Socket object.
internal Socket CreateAcceptSocket(SafeCloseSocket fd, EndPoint remoteEP)
{
// Internal state of the socket is inherited from listener.
Socket socket = new Socket(fd);
return UpdateAcceptSocket(socket, remoteEP);
}
public static SocketError Connect(SafeCloseSocket handle, byte[] socketAddress, int socketAddressLen)
{
if (!handle.IsNonBlocking)
{
return handle.AsyncContext.Connect(socketAddress, socketAddressLen, -1);
}
SocketError errorCode;
bool completed = TryStartConnect(handle.FileDescriptor, socketAddress, socketAddressLen, out errorCode);
return completed ? errorCode : SocketError.WouldBlock;
}
