internal static unsafe SocketError CreateSocket(AddressFamily addressFamily, SocketType socketType, ProtocolType protocolType, out SafeSocketHandle socket) { SocketError errorCode; socket = CreateSocket(InnerSafeCloseSocket.CreateSocket(addressFamily, socketType, protocolType, out errorCode)); return(errorCode); }
public static InnerSafeCloseSocket CreateSocket(int fileDescriptor) { var res = new InnerSafeCloseSocket(); res.SetHandle((IntPtr)fileDescriptor); return(res); }
internal static SafeCloseSocket Accept( SafeCloseSocket socketHandle, byte[] socketAddress, ref int socketAddressSize) { return(CreateSocket(InnerSafeCloseSocket.Accept(socketHandle, socketAddress, ref socketAddressSize))); }
protected override bool ReleaseHandle() { if (GlobalLog.IsEnabled) { GlobalLog.Print( "SafeCloseSocket#" + LoggingHash.HashString(this) + "::ReleaseHandle() m_InnerSocket=" + _innerSocket == null ? "null" : LoggingHash.HashString(_innerSocket)); } _released = true; InnerSafeCloseSocket innerSocket = _innerSocket == null ? null : Interlocked.Exchange <InnerSafeCloseSocket>(ref _innerSocket, null); if (innerSocket != null) { #if DEBUG // On AppDomain unload we may still have pending Overlapped operations. // ThreadPoolBoundHandle should handle this scenario by canceling them. innerSocket.LogRemainingOperations(); #endif innerSocket.DangerousRelease(); } InnerReleaseHandle(); return(true); }
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(); } } }
private static SafeCloseSocket CreateSocket(InnerSafeCloseSocket socket) { SafeCloseSocket ret = new SafeCloseSocket(); CreateSocket(socket, ret); return(ret); }
public static unsafe InnerSafeCloseSocket CreateSocket(AddressFamily addressFamily, SocketType socketType, ProtocolType protocolType) { int af = SocketPal.GetPlatformAddressFamily(addressFamily); int sock = SocketPal.GetPlatformSocketType(socketType); int pt = (int)protocolType; int fd = Interop.libc.socket(af, sock, pt); if (fd != -1) { // The socket was created successfully; make it non-blocking and enable // IPV6_V6ONLY by default for AF_INET6 sockets. int err = Interop.Sys.Fcntl.SetIsNonBlocking(fd, 1); if (err != 0) { Interop.Sys.Close(fd); fd = -1; } else if (addressFamily == AddressFamily.InterNetworkV6) { int on = 1; err = Interop.libc.setsockopt(fd, Interop.libc.IPPROTO_IPV6, Interop.libc.IPV6_V6ONLY, &on, (uint)sizeof(int)); if (err != 0) { Interop.Sys.Close(fd); fd = -1; } } } var res = new InnerSafeCloseSocket(); res.SetHandle((IntPtr)fd); return(res); }
internal static unsafe SocketError Accept(SafeSocketHandle socketHandle, byte[] socketAddress, ref int socketAddressSize, out SafeSocketHandle socket) { SocketError errorCode; socket = CreateSocket(InnerSafeCloseSocket.Accept(socketHandle, socketAddress, ref socketAddressSize, out errorCode)); return(errorCode); }
protected override bool ReleaseHandle() { if (NetEventSource.IsEnabled) { NetEventSource.Info(this, $"_innerSocket={_innerSocket}"); } _released = true; InnerSafeCloseSocket innerSocket = _innerSocket == null ? null : Interlocked.Exchange <InnerSafeCloseSocket>(ref _innerSocket, null); if (innerSocket != null) { #if DEBUG // On AppDomain unload we may still have pending Overlapped operations. // ThreadPoolBoundHandle should handle this scenario by canceling them. innerSocket.LogRemainingOperations(); #endif innerSocket.DangerousRelease(); } InnerReleaseHandle(); return(true); }
internal static InnerSafeCloseSocket CreateSocket(IntPtr fileDescriptor) { var res = new InnerSafeCloseSocket(); res.SetHandle(fileDescriptor); return(res); }
private void SetInnerSocket(InnerSafeCloseSocket socket) { _innerSocket = socket; SetHandle(socket.DangerousGetHandle()); #if DEBUG _innerSocketCopy = socket; #endif }
internal static InnerSafeCloseSocket Accept(SafeCloseSocket socketHandle, byte[] socketAddress, ref int socketAddressSize) { InnerSafeCloseSocket result = UnsafeNclNativeMethods.SafeNetHandles.accept(socketHandle.DangerousGetHandle(), socketAddress, ref socketAddressSize); if (result.IsInvalid) { result.SetHandleAsInvalid(); } return(result); }
private static SafeCloseSocket CreateSocket(InnerSafeCloseSocket socket) { SafeCloseSocket ret = new SafeCloseSocket(); CreateSocket(socket, ret); GlobalLog.Print("SafeCloseSocket#" + Logging.HashString(ret) + "::CreateSocket()"); return(ret); }
internal static InnerSafeCloseSocket CreateWSASocket(AddressFamily addressFamily, SocketType socketType, ProtocolType protocolType) { InnerSafeCloseSocket result = Interop.Winsock.WSASocketW(addressFamily, socketType, protocolType, IntPtr.Zero, 0, Interop.Winsock.SocketConstructorFlags.WSA_FLAG_OVERLAPPED); if (result.IsInvalid) { result.SetHandleAsInvalid(); } return(result); }
internal static InnerSafeCloseSocket Accept(SafeCloseSocket socketHandle, byte[] socketAddress, ref int socketAddressSize) { InnerSafeCloseSocket result = Interop.Winsock.accept(socketHandle.DangerousGetHandle(), socketAddress, ref socketAddressSize); if (result.IsInvalid) { result.SetHandleAsInvalid(); } return(result); }
internal unsafe static InnerSafeCloseSocket CreateWSASocket(byte *pinnedBuffer) { //-1 is the value for FROM_PROTOCOL_INFO InnerSafeCloseSocket result = UnsafeNclNativeMethods.OSSOCK.WSASocket((AddressFamily)(-1), (SocketType)(-1), (ProtocolType)(-1), pinnedBuffer, 0, SocketConstructorFlags.WSA_FLAG_OVERLAPPED); if (result.IsInvalid) { result.SetHandleAsInvalid(); } return(result); }
protected override bool ReleaseHandle() { this.m_Released = true; InnerSafeCloseSocket socket = (this.m_InnerSocket == null) ? null : Interlocked.Exchange <InnerSafeCloseSocket>(ref this.m_InnerSocket, null); if (socket != null) { socket.DangerousRelease(); } return(true); }
protected override bool ReleaseHandle() { m_Released = true; InnerSafeCloseSocket innerSocket = m_InnerSocket == null ? null : Interlocked.Exchange <InnerSafeCloseSocket>(ref m_InnerSocket, null); if (innerSocket != null) { innerSocket.DangerousRelease(); } return(true); }
internal unsafe static InnerSafeCloseSocket CreateWSASocket(byte *pinnedBuffer) { // NOTE: -1 is the value for FROM_PROTOCOL_INFO. InnerSafeCloseSocket result = Interop.Winsock.WSASocketW((AddressFamily)(-1), (SocketType)(-1), (ProtocolType)(-1), pinnedBuffer, 0, Interop.Winsock.SocketConstructorFlags.WSA_FLAG_OVERLAPPED); if (result.IsInvalid) { result.SetHandleAsInvalid(); } return(result); }
internal void CloseAsIs(bool abortive) { if (NetEventSource.IsEnabled) { NetEventSource.Info(this, $"_innerSocket={_innerSocket}"); } #if DEBUG // If this throws it could be very bad. try { #endif InnerSafeCloseSocket innerSocket = _innerSocket == null ? null : Interlocked.Exchange <InnerSafeCloseSocket>(ref _innerSocket, null); Dispose(); if (innerSocket != null) { bool canceledOperations = false; // Wait until it's safe. SpinWait sw = new SpinWait(); while (!_released) { // The socket was not released due to the SafeHandle being used. // Try to make those on-going calls return. // On Linux, TryUnblockSocket will unblock current operations but it doesn't prevent // a new one from starting. So we must call TryUnblockSocket multiple times. canceledOperations |= innerSocket.TryUnblockSocket(abortive, _hasShutdownSend); sw.SpinOnce(); } canceledOperations |= DoReleaseHandle(); // In case we cancel operations, switch to an abortive close. // Unless the user requested a normal close using Socket.Shutdown. if (canceledOperations && !_hasShutdownSend) { abortive = true; } innerSocket.Close(abortive); } #if DEBUG } catch (Exception exception) when(!ExceptionCheck.IsFatal(exception)) { NetEventSource.Fail(this, $"handle:{handle}, error:{exception}"); throw; } #endif }
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); }
private static SafeSocketHandle CreateSocket(InnerSafeCloseSocket socket) { SafeSocketHandle ret = new SafeSocketHandle(); CreateSocket(socket, ret); if (NetEventSource.IsEnabled) { NetEventSource.Info(null, ret); } return(ret); }
internal static SafeCloseSocketAndEvent CreateWSASocketWithEvent(AddressFamily addressFamily, SocketType socketType, ProtocolType protocolType, bool autoReset, bool signaled) { SafeCloseSocketAndEvent result = new SafeCloseSocketAndEvent(); CreateSocket(InnerSafeCloseSocket.CreateWSASocket(addressFamily, socketType, protocolType), result); if (result.IsInvalid) { throw new SocketException(); } result._waitHandle = new AutoResetEvent(false); CompleteInitialization(result); return(result); }
internal void CloseAsIs() { if (GlobalLog.IsEnabled) { GlobalLog.Print( "SafeCloseSocket#" + LoggingHash.HashString(this) + "::CloseAsIs() m_InnerSocket=" + _innerSocket == null ? "null" : LoggingHash.HashString(_innerSocket)); } #if DEBUG // If this throws it could be very bad. try { #endif InnerSafeCloseSocket innerSocket = _innerSocket == null ? null : Interlocked.Exchange <InnerSafeCloseSocket>(ref _innerSocket, null); Dispose(); if (innerSocket != null) { // Wait until it's safe. SpinWait sw = new SpinWait(); while (!_released) { sw.SpinOnce(); } // Now free it with blocking. innerSocket.BlockingRelease(); } InnerReleaseHandle(); #if DEBUG } catch (Exception exception) { if (!ExceptionCheck.IsFatal(exception)) { if (GlobalLog.IsEnabled) { GlobalLog.Assert("SafeCloseSocket::CloseAsIs(handle:" + handle.ToString("x") + ")", exception.Message); } Debug.Fail("SafeCloseSocket::CloseAsIs(handle:" + handle.ToString("x") + ")", exception.Message); } throw; } #endif }
internal void AddRef() { try { // The inner socket can be closed by CloseAsIs and when SafeHandle runs ReleaseHandle. InnerSafeCloseSocket innerSocket = Volatile.Read(ref _innerSocket); if (innerSocket != null) { innerSocket.AddRef(); } } catch (Exception e) { Debug.Fail("SafeSocketHandle.AddRef after inner socket disposed." + e); } }
public void Release() { try { // The inner socket can be closed by CloseAsIs and when SafeHandle runs ReleaseHandle. InnerSafeCloseSocket innerSocket = Volatile.Read(ref _innerSocket); if (innerSocket != null) { innerSocket.Release(); } } catch (Exception e) { Debug.Assert(false, "SafeCloseSocket.Release after inner socket disposed." + e); } }
public static unsafe InnerSafeCloseSocket Accept(SafeCloseSocket socketHandle, byte[] socketAddress, ref int socketAddressLen, out SocketError errorCode) { int 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((IntPtr)acceptedFd); return(res); }
public static unsafe InnerSafeCloseSocket CreateSocket(AddressFamily addressFamily, SocketType socketType, ProtocolType protocolType, out SocketError errorCode) { int fd; Interop.Error error = Interop.Sys.Socket(addressFamily, socketType, protocolType, &fd); if (error == Interop.Error.SUCCESS) { Debug.Assert(fd != -1); errorCode = SocketError.Success; // The socket was created successfully; make it non-blocking and enable // IPV6_V6ONLY by default for AF_INET6 sockets. int err = Interop.Sys.Fcntl.SetIsNonBlocking((IntPtr)fd, 1); if (err != 0) { Interop.Sys.Close((IntPtr)fd); fd = -1; errorCode = SocketError.SocketError; } else if (addressFamily == AddressFamily.InterNetworkV6) { int on = 1; error = Interop.Sys.SetSockOpt(fd, SocketOptionLevel.IPv6, SocketOptionName.IPv6Only, (byte *)&on, sizeof(int)); if (error != Interop.Error.SUCCESS) { Interop.Sys.Close((IntPtr)fd); fd = -1; errorCode = SocketPal.GetSocketErrorForErrorCode(error); } } } else { Debug.Assert(fd == -1); errorCode = SocketPal.GetSocketErrorForErrorCode(error); } var res = new InnerSafeCloseSocket(); res.SetHandle((IntPtr)fd); return(res); }
internal void CloseAsIs(bool abortive) { if (NetEventSource.IsEnabled) { NetEventSource.Info(this, $"_innerSocket={_innerSocket}"); } #if DEBUG // If this throws it could be very bad. try { #endif InnerSafeCloseSocket innerSocket = _innerSocket == null ? null : Interlocked.Exchange <InnerSafeCloseSocket>(ref _innerSocket, null); Dispose(); if (innerSocket != null) { // Wait until it's safe. SpinWait sw = new SpinWait(); while (!_released) { // The socket was not released due to the SafeHandle being used. // Try to make those on-going calls return. // On Linux, TryUnblockSocket will unblock current operations but it doesn't prevent // a new one from starting. So we must call TryUnblockSocket multiple times. abortive |= innerSocket.TryUnblockSocket(); sw.SpinOnce(); } abortive |= InnerReleaseHandle(); innerSocket.Close(abortive); } #if DEBUG } catch (Exception exception) when(!ExceptionCheck.IsFatal(exception)) { NetEventSource.Fail(this, $"handle:{handle}, error:{exception}"); throw; } #endif }
internal void CloseAsIs() { RuntimeHelpers.PrepareConstrainedRegions(); try { } finally { InnerSafeCloseSocket socket = (this.m_InnerSocket == null) ? null : Interlocked.Exchange <InnerSafeCloseSocket>(ref this.m_InnerSocket, null); base.Close(); if (socket != null) { while (!this.m_Released) { Thread.SpinWait(1); } socket.BlockingRelease(); } } }
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(); } } } }
public static InnerSafeCloseSocket CreateSocket(IntPtr fileDescriptor) { var res = new InnerSafeCloseSocket(); res.SetHandle(fileDescriptor); return res; }
public static unsafe InnerSafeCloseSocket CreateSocket(AddressFamily addressFamily, SocketType socketType, ProtocolType protocolType) { int af = SocketPal.GetPlatformAddressFamily(addressFamily); int sock = SocketPal.GetPlatformSocketType(socketType); int pt = (int)protocolType; int fd = Interop.libc.socket(af, sock, pt); if (fd != -1) { // The socket was created successfully; make it non-blocking and enable // IPV6_V6ONLY by default for AF_INET6 sockets. int err = Interop.Sys.Fcntl.SetIsNonBlocking(fd, 1); if (err != 0) { Interop.Sys.Close(fd); fd = -1; } else if (addressFamily == AddressFamily.InterNetworkV6) { int on = 1; Interop.Error error = Interop.Sys.SetSockOpt(fd, SocketOptionLevel.IPv6, SocketOptionName.IPv6Only, (byte*)&on, sizeof(int)); if (error != Interop.Error.SUCCESS) { Interop.Sys.Close(fd); fd = -1; } } } var res = new InnerSafeCloseSocket(); res.SetHandle((IntPtr)fd); return res; }
private static SafeCloseSocket CreateSocket(InnerSafeCloseSocket socket) { SafeCloseSocket ret = new SafeCloseSocket(); CreateSocket(socket, ret); GlobalLog.Print("SafeCloseSocket#" + Logging.HashString(ret) + "::CreateSocket()"); return ret; }
public static unsafe InnerSafeCloseSocket CreateSocket(AddressFamily addressFamily, SocketType socketType, ProtocolType protocolType) { int af = SocketPal.GetPlatformAddressFamily(addressFamily); int sock = SocketPal.GetPlatformSocketType(socketType); int pt = (int)protocolType; int fd = Interop.libc.socket(af, sock, pt); if (fd != -1) { // The socket was created successfully; make it non-blocking and enable // IPV6_V6ONLY by default for AF_INET6 sockets. int err = Interop.Sys.Fcntl.SetIsNonBlocking(fd, 1); if (err != 0) { Interop.Sys.Close(fd); fd = -1; } if (addressFamily == AddressFamily.InterNetworkV6) { int on = 1; err = Interop.libc.setsockopt(fd, Interop.libc.IPPROTO_IPV6, Interop.libc.IPV6_V6ONLY, &on, (uint)sizeof(int)); if (err != 0) { Interop.Sys.Close(fd); fd = -1; } } } var res = new InnerSafeCloseSocket(); res.SetHandle((IntPtr)fd); return res; }
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; }
public static unsafe InnerSafeCloseSocket Accept(SafeCloseSocket socketHandle, byte[] socketAddress, ref int socketAddressLen) { int acceptedFd; if (!socketHandle.IsNonBlocking) { socketHandle.AsyncContext.Accept(socketAddress, ref socketAddressLen, -1, out acceptedFd); } else { SocketError unused; SocketPal.TryCompleteAccept(socketHandle.FileDescriptor, socketAddress, ref socketAddressLen, out acceptedFd, out unused); } var res = new InnerSafeCloseSocket(); res.SetHandle((IntPtr)acceptedFd); return res; }
private static SafeCloseSocket CreateSocket(InnerSafeCloseSocket socket) { SafeCloseSocket ret = new SafeCloseSocket(); CreateSocket(socket, ret); if (NetEventSource.IsEnabled) NetEventSource.Info(null, ret); return ret; }
public static unsafe InnerSafeCloseSocket CreateSocket(AddressFamily addressFamily, SocketType socketType, ProtocolType protocolType, out SocketError errorCode) { int fd; Interop.Error error = Interop.Sys.Socket(addressFamily, socketType, protocolType, &fd); if (error == Interop.Error.SUCCESS) { Debug.Assert(fd != -1); errorCode = SocketError.Success; // The socket was created successfully; make it non-blocking and enable // IPV6_V6ONLY by default for AF_INET6 sockets. int err = Interop.Sys.Fcntl.SetIsNonBlocking(fd, 1); if (err != 0) { Interop.Sys.Close(fd); fd = -1; errorCode = SocketError.SocketError; } else if (addressFamily == AddressFamily.InterNetworkV6) { int on = 1; error = Interop.Sys.SetSockOpt(fd, SocketOptionLevel.IPv6, SocketOptionName.IPv6Only, (byte*)&on, sizeof(int)); if (error != Interop.Error.SUCCESS) { Interop.Sys.Close(fd); fd = -1; errorCode = SocketPal.GetSocketErrorForErrorCode(error); } } } else { errorCode = SocketPal.GetSocketErrorForErrorCode(error); } var res = new InnerSafeCloseSocket(); res.SetHandle((IntPtr)fd); return res; }
public static unsafe InnerSafeCloseSocket CreateSocket(AddressFamily addressFamily, SocketType socketType, ProtocolType protocolType, out SocketError errorCode) { IntPtr fd; Interop.Error error = Interop.Sys.Socket(addressFamily, socketType, protocolType, &fd); if (error == Interop.Error.SUCCESS) { Debug.Assert(fd != (IntPtr)(-1), "fd should not be -1"); errorCode = SocketError.Success; // The socket was created successfully; enable IPV6_V6ONLY by default for AF_INET6 sockets. if (addressFamily == AddressFamily.InterNetworkV6) { int on = 1; error = Interop.Sys.SetSockOpt(fd, SocketOptionLevel.IPv6, SocketOptionName.IPv6Only, (byte*)&on, sizeof(int)); if (error != Interop.Error.SUCCESS) { Interop.Sys.Close(fd); fd = (IntPtr)(-1); errorCode = SocketPal.GetSocketErrorForErrorCode(error); } } } else { Debug.Assert(fd == (IntPtr)(-1), $"Unexpected fd: {fd}"); errorCode = SocketPal.GetSocketErrorForErrorCode(error); } var res = new InnerSafeCloseSocket(); res.SetHandle(fd); return res; }
private static SafeCloseSocket CreateSocket(InnerSafeCloseSocket socket) { SafeCloseSocket ret = new SafeCloseSocket(); CreateSocket(socket, ret); return ret; }
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; }
private void SetInnerSocket(InnerSafeCloseSocket socket) { this.m_InnerSocket = socket; base.SetHandle(socket.DangerousGetHandle()); }