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); }
internal static SafeCloseSocket Accept( SafeCloseSocket socketHandle, byte[] socketAddress, ref int socketAddressSize) { return CreateSocket(InnerSafeCloseSocket.Accept(socketHandle, socketAddress, ref socketAddressSize)); }
internal unsafe SocketError DoOperationAccept(Socket socket, SafeCloseSocket handle, SafeCloseSocket acceptHandle, out int bytesTransferred) { Debug.Assert(acceptHandle == null); bytesTransferred = 0; return handle.AsyncContext.AcceptAsync(_buffer ?? _acceptBuffer, _acceptAddressBufferCount / 2, AcceptCompletionCallback); }
public void Close(bool resetOwner) { if (resetOwner) { _socketHandle = null; } Dispose(); }
public unsafe SafeNativeOverlapped(SafeCloseSocket socketHandle, NativeOverlapped* handle) : this((IntPtr)handle) { _safeCloseSocket = socketHandle; GlobalLog.Print("SafeNativeOverlapped#" + Logging.HashString(this) + "::ctor(socket#" + Logging.HashString(socketHandle) + ")"); #if DEBUG _safeCloseSocket.AddRef(); #endif }
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; }
public unsafe SafeNativeOverlapped(SafeCloseSocket socketHandle, NativeOverlapped* handle) : this((IntPtr)handle) { SocketHandle = socketHandle; if (NetEventSource.IsEnabled) NetEventSource.Info(this, $"socketHandle:{socketHandle}"); #if DEBUG SocketHandle.AddRef(); #endif }
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); }
internal unsafe SocketError DoOperationAccept(Socket socket, SafeCloseSocket handle, SafeCloseSocket acceptHandle, out int bytesTransferred) { if (_buffer != null) { throw new PlatformNotSupportedException(SR.net_sockets_accept_receive_notsupported); } Debug.Assert(acceptHandle == null, $"Unexpected acceptHandle: {acceptHandle}"); bytesTransferred = 0; return handle.AsyncContext.AcceptAsync(_acceptBuffer, _acceptAddressBufferCount / 2, AcceptCompletionCallback); }
public unsafe SafeNativeOverlapped(SafeCloseSocket socketHandle, NativeOverlapped* handle) : this((IntPtr)handle) { SocketHandle = socketHandle; if (GlobalLog.IsEnabled) { GlobalLog.Print("SafeNativeOverlapped#" + LoggingHash.HashString(this) + "::ctor(socket#" + LoggingHash.HashString(socketHandle) + ")"); } #if DEBUG SocketHandle.AddRef(); #endif }
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); }
private static unsafe int Receive(SafeCloseSocket socket, SocketFlags flags, byte[] buffer, int offset, int count, byte[] socketAddress, ref int socketAddressLen, out SocketFlags receivedFlags, out Interop.Error errno) { Debug.Assert(socketAddress != null || socketAddressLen == 0, $"Unexpected values: socketAddress={socketAddress}, socketAddressLen={socketAddressLen}"); long received; int sockAddrLen = 0; if (socketAddress != null) { sockAddrLen = socketAddressLen; } fixed (byte* sockAddr = socketAddress) fixed (byte* b = buffer) { var iov = new Interop.Sys.IOVector { Base = (b == null) ? null : &b[offset], Count = (UIntPtr)count }; var messageHeader = new Interop.Sys.MessageHeader { SocketAddress = sockAddr, SocketAddressLen = sockAddrLen, IOVectors = &iov, IOVectorCount = 1 }; errno = Interop.Sys.ReceiveMessage(socket, &messageHeader, flags, &received); receivedFlags = messageHeader.Flags; sockAddrLen = messageHeader.SocketAddressLen; } if (errno != Interop.Error.SUCCESS) { return -1; } socketAddressLen = sockAddrLen; return checked((int)received); }
private static SafeCloseSocket CreateSocket(InnerSafeCloseSocket socket) { SafeCloseSocket ret = new SafeCloseSocket(); CreateSocket(socket, ret); if (GlobalLog.IsEnabled) { GlobalLog.Print("SafeCloseSocket#" + LoggingHash.HashString(ret) + "::CreateSocket()"); } return ret; }
internal unsafe SocketError DoOperationAccept(Socket socket, SafeCloseSocket handle, SafeCloseSocket acceptHandle, out int bytesTransferred) { if (_buffer != null) { throw new PlatformNotSupportedException(SR.net_sockets_accept_receive_notsupported); } Debug.Assert(acceptHandle == null, $"Unexpected acceptHandle: {acceptHandle}"); bytesTransferred = 0; return(handle.AsyncContext.AcceptAsync(_acceptBuffer, _acceptAddressBufferCount / 2, AcceptCompletionCallback)); }
public static SocketError Listen(SafeCloseSocket handle, int backlog) { SocketError errorCode = Interop.Winsock.listen(handle, backlog); return(errorCode == SocketError.SocketError ? GetLastSocketError() : SocketError.Success); }
internal SocketError DoOperationSendPackets(Socket socket, SafeCloseSocket handle) { throw new PlatformNotSupportedException(); }
public static unsafe SocketError Accept(SafeCloseSocket socketHandle, byte[] socketAddress, ref int socketAddressSize, out SafeCloseSocket socket) { SocketError errorCode; socket = CreateSocket(InnerSafeCloseSocket.Accept(socketHandle, socketAddress, ref socketAddressSize, out errorCode)); return(errorCode); }
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); }
public static SafeCloseSocket Accept(SafeCloseSocket handle, byte[] buffer, ref int nameLen) { return(SafeCloseSocket.Accept(handle, buffer, ref nameLen)); }
internal unsafe SocketError DoOperationConnect(Socket socket, SafeCloseSocket handle, out int bytesTransferred) { bytesTransferred = 0; return(handle.AsyncContext.ConnectAsync(_socketAddress.Buffer, _socketAddress.Size, ConnectCompletionCallback)); }
internal unsafe SocketError DoOperationDisconnect(Socket socket, SafeCloseSocket handle) { throw new PlatformNotSupportedException(); }
internal unsafe SocketError DoOperationAccept(Socket socket, SafeCloseSocket handle, SafeCloseSocket acceptHandle, out int bytesTransferred) { Debug.Assert(acceptHandle == null); bytesTransferred = 0; return(handle.AsyncContext.AcceptAsync(_buffer ?? _acceptBuffer, _acceptAddressBufferCount / 2, AcceptCompletionCallback)); }
public static unsafe SocketError Receive(SafeCloseSocket handle, byte[] buffer, int offset, int size, SocketFlags socketFlags, out int bytesTransferred) => Receive(handle, new Span <byte>(buffer, offset, size), socketFlags, out bytesTransferred);
public static unsafe SocketError Send(SafeCloseSocket handle, byte[] buffer, int offset, int size, SocketFlags socketFlags, out int bytesTransferred) => Send(handle, new ReadOnlySpan <byte>(buffer, offset, size), socketFlags, out bytesTransferred);
public unsafe static SocketError CreateSocket(AddressFamily addressFamily, SocketType socketType, ProtocolType protocolType, out SafeCloseSocket socket) { SocketError errorCode; socket = CreateSocket(InnerSafeCloseSocket.CreateSocket(addressFamily, socketType, protocolType, out errorCode)); return errorCode; }
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 unsafe SocketError DoOperationAccept(Socket socket, SafeCloseSocket handle, SafeCloseSocket acceptHandle) { if (!_buffer.Equals(default))
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; }
public bool TryRegister(SafeCloseSocket socket, Interop.Sys.SocketEvents current, Interop.Sys.SocketEvents events, out Interop.Error error) { Debug.Assert(WasAllocated, "Expected WasAllocated to be true"); return(_engine.TryRegister(socket, current, events, _handle, out error)); }
public static SafeCloseSocket CreateSocket(AddressFamily addressFamily, SocketType socketType, ProtocolType protocolType) { return(SafeCloseSocket.CreateWSASocket(addressFamily, socketType, protocolType)); }
public static unsafe SocketError CreateSocket(AddressFamily addressFamily, SocketType socketType, ProtocolType protocolType, out SafeCloseSocket socket) { SocketError errorCode; socket = CreateSocket(InnerSafeCloseSocket.CreateSocket(addressFamily, socketType, protocolType, out errorCode)); return(errorCode); }
public static unsafe SocketError SetSockOpt(SafeCloseSocket handle, SocketOptionLevel optionLevel, SocketOptionName optionName, int optionValue) { Interop.Error err; if (optionLevel == SocketOptionLevel.Socket) { if (optionName == SocketOptionName.ReceiveTimeout) { handle.ReceiveTimeout = optionValue == 0 ? -1 : optionValue; err = Interop.Sys.SetReceiveTimeout(handle.FileDescriptor, optionValue); return err == Interop.Error.SUCCESS ? SocketError.Success : GetSocketErrorForErrorCode(err); } else if (optionName == SocketOptionName.SendTimeout) { handle.SendTimeout = optionValue == 0 ? -1 : optionValue; err = Interop.Sys.SetSendTimeout(handle.FileDescriptor, optionValue); return err == Interop.Error.SUCCESS ? SocketError.Success : GetSocketErrorForErrorCode(err); } } err = Interop.Sys.SetSockOpt(handle.FileDescriptor, optionLevel, optionName, (byte*)&optionValue, sizeof(int)); return err == Interop.Error.SUCCESS ? SocketError.Success : GetSocketErrorForErrorCode(err); }
internal SocketError DoOperationDisconnect(Socket socket, SafeCloseSocket handle) { throw new PlatformNotSupportedException(SR.net_sockets_disconnect_notsupported); }
public static unsafe SocketError SetIPv6MulticastOption(SafeCloseSocket handle, SocketOptionName optionName, IPv6MulticastOption optionValue) { Debug.Assert(optionName == SocketOptionName.AddMembership || optionName == SocketOptionName.DropMembership); Interop.Sys.MulticastOption optName = optionName == SocketOptionName.AddMembership ? Interop.Sys.MulticastOption.MULTICAST_ADD : Interop.Sys.MulticastOption.MULTICAST_DROP; var opt = new Interop.Sys.IPv6MulticastOption { Address = optionValue.Group.GetNativeIPAddress(), InterfaceIndex = (int)optionValue.InterfaceIndex }; Interop.Error err = Interop.Sys.SetIPv6MulticastOption(handle.FileDescriptor, optName, &opt); return err == Interop.Error.SUCCESS ? SocketError.Success : GetSocketErrorForErrorCode(err); }
internal unsafe SocketError DoOperationAccept(Socket socket, SafeCloseSocket handle, SafeCloseSocket acceptHandle) { if (_buffer != null) { throw new PlatformNotSupportedException(SR.net_sockets_accept_receive_notsupported); } Debug.Assert(acceptHandle == null, $"Unexpected acceptHandle: {acceptHandle}"); IntPtr acceptedFd; int socketAddressLen = _acceptAddressBufferCount / 2; SocketError socketError = handle.AsyncContext.AcceptAsync(_acceptBuffer, ref socketAddressLen, out acceptedFd, AcceptCompletionCallback); if (socketError != SocketError.IOPending) { CompleteAcceptOperation(acceptedFd, _acceptBuffer, socketAddressLen, socketError); FinishOperationSync(socketError, 0, SocketFlags.None); } return(socketError); }
public static unsafe SocketError GetSockOpt(SafeCloseSocket handle, SocketOptionLevel optionLevel, SocketOptionName optionName, out int optionValue) { if (optionLevel == SocketOptionLevel.Socket) { if (optionName == SocketOptionName.ReceiveTimeout) { optionValue = handle.ReceiveTimeout == -1 ? 0 : handle.ReceiveTimeout; return SocketError.Success; } else if (optionName == SocketOptionName.SendTimeout) { optionValue = handle.SendTimeout == -1 ? 0 : handle.SendTimeout; return SocketError.Success; } } int value = 0; int optLen = sizeof(int); Interop.Error err = Interop.Sys.GetSockOpt(handle.FileDescriptor, optionLevel, optionName, (byte*)&value, &optLen); optionValue = value; return err == Interop.Error.SUCCESS ? SocketError.Success : GetSocketErrorForErrorCode(err); }
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 unsafe static SafeCloseSocket Accept(SafeCloseSocket socketHandle, byte[] socketAddress, ref int socketAddressSize) { return(CreateSocket(InnerSafeCloseSocket.Accept(socketHandle, socketAddress, ref socketAddressSize))); }
public static SocketError Disconnect(Socket socket, SafeCloseSocket handle, bool reuseSocket) { throw new PlatformNotSupportedException(); }
public static unsafe SocketError AcceptAsync(Socket socket, SafeCloseSocket handle, SafeCloseSocket acceptHandle, int receiveSize, int socketAddressSize, AcceptOverlappedAsyncResult asyncResult) { // The buffer needs to contain the requested data plus room for two sockaddrs and 16 bytes // of associated data for each. int addressBufferSize = socketAddressSize + 16; byte[] buffer = new byte[receiveSize + ((addressBufferSize) * 2)]; // Set up asyncResult for overlapped AcceptEx. // This call will use completion ports on WinNT. asyncResult.SetUnmanagedStructures(buffer, addressBufferSize); // This can throw ObjectDisposedException. int bytesTransferred; SocketError errorCode = SocketError.Success; if (!socket.AcceptEx( handle, acceptHandle, Marshal.UnsafeAddrOfPinnedArrayElement(asyncResult.Buffer, 0), receiveSize, addressBufferSize, addressBufferSize, out bytesTransferred, asyncResult.OverlappedHandle)) { errorCode = GetLastSocketError(); } return(errorCode); }
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 unused, string propertyName, out SafeCloseSocket handle) { // AcceptSocket is not supported on Unix. if (acceptSocket != null) { throw new PlatformNotSupportedException(); } handle = null; return(null); }
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 void ReplaceHandleIfNecessaryAfterFailedConnect() { if (!_handle.LastConnectFailed) { return; } // Copy out values from key options. The copied values should be kept in sync with the // handling in SafeCloseSocket.TrackOption. Note that we copy these values out first, before // we change _handle, so that we can use the helpers on Socket which internally access _handle. // Then once _handle is switched to the new one, we can call the setters to propagate the retrieved // values back out to the new underlying socket. bool broadcast = false, dontFragment = false, noDelay = false; int receiveSize = -1, receiveTimeout = -1, sendSize = -1, sendTimeout = -1; short ttl = -1; LingerOption linger = null; if (_handle.IsTrackedOption(TrackedSocketOptions.DontFragment)) { dontFragment = DontFragment; } if (_handle.IsTrackedOption(TrackedSocketOptions.EnableBroadcast)) { broadcast = EnableBroadcast; } if (_handle.IsTrackedOption(TrackedSocketOptions.LingerState)) { linger = LingerState; } if (_handle.IsTrackedOption(TrackedSocketOptions.NoDelay)) { noDelay = NoDelay; } if (_handle.IsTrackedOption(TrackedSocketOptions.ReceiveBufferSize)) { receiveSize = ReceiveBufferSize; } if (_handle.IsTrackedOption(TrackedSocketOptions.ReceiveTimeout)) { receiveTimeout = ReceiveTimeout; } if (_handle.IsTrackedOption(TrackedSocketOptions.SendBufferSize)) { sendSize = SendBufferSize; } if (_handle.IsTrackedOption(TrackedSocketOptions.SendTimeout)) { sendTimeout = SendTimeout; } if (_handle.IsTrackedOption(TrackedSocketOptions.Ttl)) { ttl = Ttl; } // Then replace the handle with a new one SafeCloseSocket oldHandle = _handle; SocketError errorCode = SocketPal.CreateSocket(_addressFamily, _socketType, _protocolType, out _handle); oldHandle.TransferTrackedState(_handle); oldHandle.Dispose(); if (errorCode != SocketError.Success) { throw new SocketException((int)errorCode); } // And put back the copied settings. For DualMode, we use the value stored in the _handle // rather than querying the socket itself, as on Unix stacks binding a dual-mode socket to // an IPv6 address may cause the IPv6Only setting to revert to true. if (_handle.IsTrackedOption(TrackedSocketOptions.DualMode)) { DualMode = _handle.DualMode; } if (_handle.IsTrackedOption(TrackedSocketOptions.DontFragment)) { DontFragment = dontFragment; } if (_handle.IsTrackedOption(TrackedSocketOptions.EnableBroadcast)) { EnableBroadcast = broadcast; } if (_handle.IsTrackedOption(TrackedSocketOptions.LingerState)) { LingerState = linger; } if (_handle.IsTrackedOption(TrackedSocketOptions.NoDelay)) { NoDelay = noDelay; } if (_handle.IsTrackedOption(TrackedSocketOptions.ReceiveBufferSize)) { ReceiveBufferSize = receiveSize; } if (_handle.IsTrackedOption(TrackedSocketOptions.ReceiveTimeout)) { ReceiveTimeout = receiveTimeout; } if (_handle.IsTrackedOption(TrackedSocketOptions.SendBufferSize)) { SendBufferSize = sendSize; } if (_handle.IsTrackedOption(TrackedSocketOptions.SendTimeout)) { SendTimeout = sendTimeout; } if (_handle.IsTrackedOption(TrackedSocketOptions.Ttl)) { Ttl = ttl; } _handle.LastConnectFailed = false; }
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(); }
public static unsafe SocketError AcceptAsync(Socket socket, SafeCloseSocket handle, SafeCloseSocket acceptHandle, int receiveSize, int socketAddressSize, AcceptOverlappedAsyncResult asyncResult) { // The buffer needs to contain the requested data plus room for two sockaddrs and 16 bytes // of associated data for each. int addressBufferSize = socketAddressSize + 16; byte[] buffer = new byte[receiveSize + ((addressBufferSize) * 2)]; // Set up asyncResult for overlapped AcceptEx. // This call will use completion ports on WinNT. asyncResult.SetUnmanagedStructures(buffer, addressBufferSize); try { // This can throw ObjectDisposedException. int bytesTransferred; bool success = socket.AcceptEx( handle, acceptHandle, Marshal.UnsafeAddrOfPinnedArrayElement(asyncResult.Buffer, 0), receiveSize, addressBufferSize, addressBufferSize, out bytesTransferred, asyncResult.DangerousOverlappedPointer); // SafeHandle was just created in SetUnmanagedStructures return(asyncResult.ProcessOverlappedResult(success, 0)); } catch { asyncResult.ReleaseUnmanagedStructures(); throw; } }
public static unsafe SocketError SetSockOpt(SafeCloseSocket handle, SocketOptionLevel optionLevel, SocketOptionName optionName, byte[] optionValue) { Interop.Error err; if (optionValue == null || optionValue.Length == 0) { err = Interop.Sys.SetSockOpt(handle.FileDescriptor, optionLevel, optionName, null, 0); } else { fixed (byte* pinnedValue = optionValue) { err = Interop.Sys.SetSockOpt(handle.FileDescriptor, optionLevel, optionName, pinnedValue, optionValue.Length); } } return err == Interop.Error.SUCCESS ? SocketError.Success : GetSocketErrorForErrorCode(err); }
public static SocketError Accept(SafeCloseSocket handle, byte[] buffer, ref int nameLen, out SafeCloseSocket socket) { socket = SafeCloseSocket.Accept(handle, buffer, ref nameLen); return(socket.IsInvalid ? GetLastSocketError() : SocketError.Success); }
public static unsafe SocketError SetLingerOption(SafeCloseSocket handle, LingerOption optionValue) { var opt = new Interop.Sys.LingerOption { OnOff = optionValue.Enabled ? 1 : 0, Seconds = optionValue.LingerTime }; Interop.Error err = Interop.Sys.SetLingerOption(handle.FileDescriptor, &opt); return err == Interop.Error.SUCCESS ? SocketError.Success : GetSocketErrorForErrorCode(err); }
public static unsafe SocketError ReceiveMessageFrom(Socket socket, SafeCloseSocket handle, byte[] buffer, int offset, int size, ref SocketFlags socketFlags, Internals.SocketAddress socketAddress, out Internals.SocketAddress receiveAddress, out IPPacketInformation ipPacketInformation, out int bytesTransferred) { bool ipv4, ipv6; Socket.GetIPProtocolInformation(socket.AddressFamily, socketAddress, out ipv4, out ipv6); bytesTransferred = 0; receiveAddress = socketAddress; ipPacketInformation = default(IPPacketInformation); fixed(byte *ptrBuffer = buffer) fixed(byte *ptrSocketAddress = socketAddress.Buffer) { Interop.Winsock.WSAMsg wsaMsg; wsaMsg.socketAddress = (IntPtr)ptrSocketAddress; wsaMsg.addressLength = (uint)socketAddress.Size; wsaMsg.flags = socketFlags; WSABuffer wsaBuffer; wsaBuffer.Length = size; wsaBuffer.Pointer = (IntPtr)(ptrBuffer + offset); wsaMsg.buffers = (IntPtr)(&wsaBuffer); wsaMsg.count = 1; if (ipv4) { Interop.Winsock.ControlData controlBuffer; wsaMsg.controlBuffer.Pointer = (IntPtr)(&controlBuffer); wsaMsg.controlBuffer.Length = sizeof(Interop.Winsock.ControlData); if (socket.WSARecvMsgBlocking( handle.DangerousGetHandle(), (IntPtr)(&wsaMsg), out bytesTransferred, IntPtr.Zero, IntPtr.Zero) == SocketError.SocketError) { return(GetLastSocketError()); } ipPacketInformation = GetIPPacketInformation(&controlBuffer); } else if (ipv6) { Interop.Winsock.ControlDataIPv6 controlBuffer; wsaMsg.controlBuffer.Pointer = (IntPtr)(&controlBuffer); wsaMsg.controlBuffer.Length = sizeof(Interop.Winsock.ControlDataIPv6); if (socket.WSARecvMsgBlocking( handle.DangerousGetHandle(), (IntPtr)(&wsaMsg), out bytesTransferred, IntPtr.Zero, IntPtr.Zero) == SocketError.SocketError) { return(GetLastSocketError()); } ipPacketInformation = GetIPPacketInformation(&controlBuffer); } else { wsaMsg.controlBuffer.Pointer = IntPtr.Zero; wsaMsg.controlBuffer.Length = 0; if (socket.WSARecvMsgBlocking( handle.DangerousGetHandle(), (IntPtr)(&wsaMsg), out bytesTransferred, IntPtr.Zero, IntPtr.Zero) == SocketError.SocketError) { return(GetLastSocketError()); } } socketFlags = wsaMsg.flags; } return(SocketError.Success); }
protected static void CreateSocket(InnerSafeCloseSocket socket, SafeCloseSocket target) { if (socket != null && socket.IsInvalid) { target.SetHandleAsInvalid(); return; } bool b = false; try { socket.DangerousAddRef(ref b); } catch { if (b) { socket.DangerousRelease(); b = false; } } finally { if (b) { target.SetInnerSocket(socket); socket.Dispose(); } else { target.SetHandleAsInvalid(); } } }
public static SocketError CreateSocket(AddressFamily addressFamily, SocketType socketType, ProtocolType protocolType, out SafeCloseSocket socket) { socket = SafeCloseSocket.CreateWSASocket(addressFamily, socketType, protocolType); return(socket.IsInvalid ? GetLastSocketError() : SocketError.Success); }
public static unsafe InnerSafeCloseSocket Accept(SafeCloseSocket socketHandle, byte[] socketAddress, ref int socketAddressLen, out SocketError errorCode) { IntPtr acceptedFd; if (!socketHandle.IsNonBlocking) { errorCode = socketHandle.AsyncContext.Accept(socketAddress, ref socketAddressLen, -1, out acceptedFd); } else { SocketPal.TryCompleteAccept(socketHandle, socketAddress, ref socketAddressLen, out acceptedFd, out errorCode); } var res = new InnerSafeCloseSocket(); res.SetHandle(acceptedFd); return res; }
public static SocketError GetPeerName(SafeCloseSocket handle, byte[] buffer, ref int nameLen) { SocketError errorCode = Interop.Winsock.getpeername(handle, buffer, ref nameLen); return(errorCode == SocketError.SocketError ? GetLastSocketError() : SocketError.Success); }
public unsafe static SocketError Accept(SafeCloseSocket socketHandle, byte[] socketAddress, ref int socketAddressSize, out SafeCloseSocket socket) { SocketError errorCode; socket = CreateSocket(InnerSafeCloseSocket.Accept(socketHandle, socketAddress, ref socketAddressSize, out errorCode)); return errorCode; }
public static SocketError Bind(SafeCloseSocket handle, byte[] buffer, int nameLen) { SocketError errorCode = Interop.Winsock.bind(handle, buffer, nameLen); return(errorCode == SocketError.SocketError ? GetLastSocketError() : SocketError.Success); }