public unsafe PosixResult TryGetPeerIPAddress(out IPEndPointStruct ep) { IPSocketAddress socketAddress; var rv = SocketInterop.GetPeerName(this, (byte *)&socketAddress, sizeof(IPSocketAddress)); if (rv.IsSuccess) { ep = socketAddress.ToIPEndPoint(); } else { ep = default(IPEndPointStruct); } return(rv); }
public static unsafe PosixResult TryGetPeerIPAddress(int socket, out IPEndPointStruct ep, IPAddress reuseAddress = null) { sockaddr_storage socketAddress; var rv = SocketInterop.GetPeerName(socket, &socketAddress); if (rv.IsSuccess) { if (!ToIPEndPointStruct(&socketAddress, out ep, reuseAddress)) { return(new PosixResult(PosixResult.EINVAL)); } } else { ep = default(IPEndPointStruct); } return(rv); }
public unsafe PosixResult TryReceiveSocket(out Socket socket, bool blocking) { return(SocketInterop.ReceiveSocket(this, out socket, blocking)); }
public unsafe PosixResult TryGetPeerIPAddress(out IPEndPointStruct ep) => SocketInterop.TryGetPeerIPAddress(this, out ep);
public unsafe PosixResult TryGetLocalIPAddress(out IPEndPointStruct ep, IPAddress reuseAddress = null) => SocketInterop.TryGetLocalIPAddress(this, out ep, reuseAddress);
public unsafe PosixResult TrySetSocketOption(int level, int optname, int value) { return(SocketInterop.SetSockOpt(this, level, optname, (byte *)&value, 4)); }
public unsafe PosixResult TrySend(iovec *ioVectors, int ioVectorLen) { return(SocketInterop.Send(this, ioVectors, ioVectorLen)); }
public unsafe PosixResult TryConnect(string unixPath) { UnixSocketAddress socketAddress = new UnixSocketAddress(unixPath); return(SocketInterop.Connect(this, (byte *)&socketAddress, sizeof(UnixSocketAddress))); }
private TSocket CreateAcceptSocket(IPEndPoint endPoint, SocketFlags flags) { int acceptSocketFd = -1; int port = endPoint.Port; try { bool ipv4 = endPoint.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork; SocketInterop.Socket(ipv4 ? AddressFamily.InterNetwork : AddressFamily.InterNetworkV6, SocketType.Stream, ProtocolType.Tcp, blocking: false, out acceptSocketFd).ThrowOnError(); TSocket acceptSocket = new TSocket(this, acceptSocketFd, flags); if (!ipv4) { // Kestrel does mapped ipv4 by default. acceptSocket.SetSocketOption(SocketOptionLevel.IPv6, SocketOptionName.IPv6Only, 0); } if (_transportOptions.ReceiveOnIncomingCpu) { if (_transportThread.CpuId != -1) { if (!acceptSocket.TrySetSocketOption(SocketOptionLevel.Socket, SocketOptionName.IncomingCpu, _transportThread.CpuId)) { _logger.LogWarning($"Cannot enable nameof{SocketOptionName.IncomingCpu} for {endPoint}"); } } } // Linux: allow bind during linger time acceptSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, 1); // Linux: allow concurrent binds and let the kernel do load-balancing acceptSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReusePort, 1); if ((flags & SocketFlags.DeferAccept) != 0) { // Linux: wait up to 1 sec for data to arrive before accepting socket acceptSocket.SetSocketOption(SocketOptionLevel.Tcp, SocketOptionName.DeferAccept, 1); } acceptSocket.ZeroCopyThreshold = LinuxTransportOptions.NoZeroCopy; if (_transportOptions.ZeroCopy && _transportOptions.ZeroCopyThreshold != LinuxTransportOptions.NoZeroCopy) { if (acceptSocket.TrySetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ZeroCopy, 1)) { acceptSocket.ZeroCopyThreshold = _transportOptions.ZeroCopyThreshold; } } acceptSocket.Bind(endPoint); if (port == 0) { // When testing we want the OS to select a free port port = acceptSocket.GetLocalIPAddress().Port; } acceptSocket.Listen(ListenBacklog); endPoint.Port = port; return(acceptSocket); } catch { if (acceptSocketFd != -1) { IOInterop.Close(acceptSocketFd); } throw; } }
public unsafe PosixResult TryAccept(out Socket clientSocket, bool blocking) { return(SocketInterop.Accept(this, blocking, out clientSocket)); }
public PosixResult TryGetAvailableBytes() { return(SocketInterop.GetAvailableBytes(this)); }
public PosixResult TryDuplicate(out Socket dup) { return(SocketInterop.Duplicate(this, out dup)); }
public unsafe PosixResult TrySetSocketOption(SocketOptionLevel optionLevel, SocketOptionName optionName, int value) { return(SocketInterop.SetSockOpt(this, optionLevel, optionName, (byte *)&value, 4)); }
public PosixResult TryListen(int backlog) { return(SocketInterop.Listen(this, backlog)); }
public unsafe PosixResult TryAcceptAndSendHandleTo(int toSocket) { return(SocketInterop.AcceptAndSendHandleTo(this, toSocket)); }
public unsafe PosixResult TryReceive(iovec *ioVectors, int ioVectorLen) { return(SocketInterop.Receive(this, ioVectors, ioVectorLen)); }
private TSocket CreateAcceptSocket(IPEndPoint endPoint, SocketFlags flags) { int acceptSocketFd = -1; int port = endPoint.Port; try { bool ipv4 = endPoint.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork; SocketInterop.Socket(ipv4 ? AF_INET : AF_INET6, SOCK_STREAM, IPPROTO_TCP, blocking: false, out acceptSocketFd).ThrowOnError(); TSocket acceptSocket = new TSocket(this, acceptSocketFd, flags); if (!ipv4) { // Kestrel does mapped ipv4 by default. acceptSocket.SetSocketOption(SOL_IPV6, IPV6_V6ONLY, 0); } if (_transportOptions.ReceiveOnIncomingCpu) { if (_transportThread.CpuId != -1) { if (!acceptSocket.TrySetSocketOption(SOL_SOCKET, SO_INCOMING_CPU, _transportThread.CpuId)) { _logger.LogWarning($"Cannot enable SO_INCOMING_CPU for {endPoint}"); } } } // Linux: allow bind during linger time acceptSocket.SetSocketOption(SOL_SOCKET, SO_REUSEADDR, 1); // Linux: allow concurrent binds and let the kernel do load-balancing acceptSocket.SetSocketOption(SOL_SOCKET, SO_REUSEPORT, 1); if ((flags & SocketFlags.DeferAccept) != 0) { // Linux: wait up to 1 sec for data to arrive before accepting socket acceptSocket.SetSocketOption(SOL_TCP, TCP_DEFER_ACCEPT, 1); } acceptSocket.ZeroCopyThreshold = LinuxTransportOptions.NoZeroCopy; if (_transportOptions.ZeroCopy && _transportOptions.ZeroCopyThreshold != LinuxTransportOptions.NoZeroCopy) { if (acceptSocket.TrySetSocketOption(SOL_SOCKET, SO_ZEROCOPY, 1)) { acceptSocket.ZeroCopyThreshold = _transportOptions.ZeroCopyThreshold; } } acceptSocket.Bind(endPoint); if (port == 0) { // When testing we want the OS to select a free port port = acceptSocket.GetLocalIPAddress().Port; } acceptSocket.Listen(ListenBacklog); endPoint.Port = port; return(acceptSocket); } catch { if (acceptSocketFd != -1) { IOInterop.Close(acceptSocketFd); } throw; } }
public PosixResult TryShutdown(int shutdown) { return(SocketInterop.Shutdown(this, shutdown)); }
public unsafe void Run() { try { Start(); CompleteStateChange(TransportThreadState.Started); } catch (Exception e) { CompleteStateChange(TransportThreadState.Stopped, e); return; } try { int notPacked = !EPoll.PackedEvents ? 1 : 0; var buffer = stackalloc int[EventBufferLength * (3 + notPacked)]; int statReadEvents = 0; int statWriteEvents = 0; int statAcceptEvents = 0; int statAccepts = 0; int statZeroCopySuccess = 0; int statZeroCopyCopied = 0; var acceptableSockets = new List <TSocket>(1); var readableSockets = new List <TSocket>(EventBufferLength); var writableSockets = new List <TSocket>(EventBufferLength); var reregisterEventSockets = new List <TSocket>(EventBufferLength); var zeroCopyCompletions = new List <TSocket>(EventBufferLength); bool pipeReadable = false; bool running = true; do { int numEvents = EPollInterop.EPollWait(_epollFd, buffer, EventBufferLength, timeout: EPoll.TimeoutInfinite).Value; // actions can be scheduled without unblocking epoll SetEpollNotBlocked(); // check events // we don't handle them immediately: // - this ensures we don't mismatch a closed socket with a new socket that have the same fd // ~ To have the same fd, the previous fd must be closed, which means it is removed from the epoll // ~ and won't show up in our next call to epoll.Wait. // ~ The old fd may be present in the buffer still, but lookup won't give a match, since it is removed // ~ from the dictionary before it is closed. If we were accepting already, a new socket could match. // - this also improves cache/cpu locality of the lookup int *ptr = buffer; lock (_sockets) { for (int i = 0; i < numEvents; i++) { // Packed Non-Packed // ------ ------ // 0:Events == Events // 1:Int1 = Key [Padding] // 2:Int2 = Key == Int1 = Key // 3:~~~~~~~~~~ Int2 = Key // ~~~~~~~~~~ EPollEvents events = (EPollEvents)ptr[0]; int key = ptr[2]; ptr += 3 + notPacked; TSocket tsocket; if (_sockets.TryGetValue(key, out tsocket)) { var type = tsocket.Type; if (type == SocketFlags.TypeClient) { lock (tsocket.Gate) { var pendingEventState = tsocket.PendingEventState; // zero copy if ((pendingEventState & EPollEvents.Error & events) != EPollEvents.None) { var copyResult = SocketInterop.CompleteZeroCopy(tsocket.Fd); if (copyResult != PosixResult.EAGAIN) { events &= ~EPollEvents.Error; pendingEventState &= ~EPollEvents.Error; zeroCopyCompletions.Add(tsocket); if (copyResult == SocketInterop.ZeroCopyCopied) { tsocket.ZeroCopyThreshold = LinuxTransportOptions.NoZeroCopy; statZeroCopyCopied++; } else if (copyResult == SocketInterop.ZeroCopySuccess) { statZeroCopySuccess++; } else { Environment.FailFast($"Error occurred while trying to complete zero copy: {copyResult}"); } } } // treat Error as Readable, Writable if ((events & EPollEvents.Error) != EPollEvents.None) { events |= EPollEvents.Readable | EPollEvents.Writable; } events &= pendingEventState & (EPollEvents.Readable | EPollEvents.Writable); // readable if ((events & EPollEvents.Readable) != EPollEvents.None) { readableSockets.Add(tsocket); pendingEventState &= ~EPollEvents.Readable; } // writable if ((events & EPollEvents.Writable) != EPollEvents.None) { writableSockets.Add(tsocket); pendingEventState &= ~EPollEvents.Writable; } // reregister tsocket.PendingEventState = pendingEventState; if ((pendingEventState & (EPollEvents.Readable | EPollEvents.Writable)) != EPollEvents.None) { tsocket.PendingEventState |= TSocket.EventControlPending; reregisterEventSockets.Add(tsocket); } } } else { statAcceptEvents++; acceptableSockets.Add(tsocket); } } else if (key == PipeKey) { pipeReadable = true; } } } // zero copy for (int i = 0; i < zeroCopyCompletions.Count; i++) { zeroCopyCompletions[i].OnZeroCopyCompleted(); } zeroCopyCompletions.Clear(); // handle accepts statAcceptEvents += acceptableSockets.Count; for (int i = 0; i < acceptableSockets.Count; i++) { statAccepts += HandleAccept(acceptableSockets[i]); } acceptableSockets.Clear(); // handle writes statWriteEvents += writableSockets.Count; for (int i = 0; i < writableSockets.Count; i++) { writableSockets[i].OnWritable(stopped: false); } writableSockets.Clear(); // handle reads statReadEvents += readableSockets.Count; if (!_transportOptions.AioReceive) { Span <MemoryHandle> receiveMemoryHandles = MemoryHandles; for (int i = 0; i < readableSockets.Count; i++) { TSocket socket = readableSockets[i]; var receiveResult = socket.Receive(receiveMemoryHandles); socket.OnReceiveFromSocket(receiveResult); } readableSockets.Clear(); } else if (readableSockets.Count > 0) { AioReceive(readableSockets); } // reregister for events for (int i = 0; i < reregisterEventSockets.Count; i++) { var tsocket = reregisterEventSockets[i]; lock (tsocket.Gate) { var pendingEventState = tsocket.PendingEventState & ~TSocket.EventControlPending; tsocket.PendingEventState = pendingEventState; UpdateEPollControl(tsocket, pendingEventState, registered: true); } } reregisterEventSockets.Clear(); // handle pipe if (pipeReadable) { PosixResult result; do { result = _pipeEnds.ReadEnd.TryReadByte(); if (result.Value == PipeStopSockets) { StopSockets(); } else if (result.Value == PipeStopThread) { running = false; } else if (result.Value == PipeCloseAccept) { CloseAccept(); } } while (result); pipeReadable = false; } // scheduled work // note: this may write a byte to the pipe DoScheduledWork(_transportOptions.AioSend); } while (running); _logger.LogDebug($"Stats A/AE:{statAccepts}/{statAcceptEvents} RE:{statReadEvents} WE:{statWriteEvents} ZCS/ZCC:{statZeroCopySuccess}/{statZeroCopyCopied}"); CompleteStateChange(TransportThreadState.Stopped); } catch (Exception ex) { Console.WriteLine(ex.Message); Console.WriteLine(ex.StackTrace); Environment.FailFast("TransportThread", ex); } }
public unsafe PosixResult TryConnect(IPEndPointStruct endpoint) { IPSocketAddress socketAddress = new IPSocketAddress(endpoint); return(SocketInterop.Connect(this, (byte *)&socketAddress, sizeof(IPSocketAddress))); }