public unsafe StreamHandle CreatePendingType() { Validate(); StreamHandle handle = null; int count = PendingCount(); if (count > 0) { IntPtr loopHandle = ((uv_stream_t *)InternalHandle)->loop; var loop = HandleContext.GetTarget <LoopContext>(loopHandle); uv_handle_type handleType = NativeMethods.PipePendingType(InternalHandle); switch (handleType) { case uv_handle_type.UV_TCP: handle = new Tcp(loop); break; case uv_handle_type.UV_NAMED_PIPE: handle = new Pipe(loop); break; default: throw ThrowHelper.GetInvalidOperationException_uv_handle_type_not_supported_or_IPC_over_Pipe_is_disabled(handleType); } NativeMethods.StreamAccept(InternalHandle, handle.InternalHandle); handle.ReadStart(); } return(handle); }
private static void OnReadCallback(IntPtr handle, IntPtr nread, ref uv_buf_t buf) { var stream = HandleContext.GetTarget <StreamHandle>(handle); IByteBuffer byteBuffer = stream._pipeline.GetBuffer(ref buf); stream.OnReadCallback(byteBuffer, (int)nread.ToInt64()); }
private static void OnConnectionCallback(IntPtr handle, int status) { var server = HandleContext.GetTarget <ServerStream>(handle); if (server is null) { return; } StreamHandle client = null; Exception error = null; try { if ((uint)status > SharedConstants.TooBigOrNegative) // < 0 { error = NativeMethods.CreateError((uv_err_code)status); } else { client = server.NewStream(); } server._connectionHandler(client, error); } catch { client?.Dispose(); throw; } }
internal ScheduleHandle( LoopContext loop, uv_handle_type handleType, object[] args = null) { if (loop is null) { ThrowHelper.ThrowArgumentNullException(ExceptionArgument.loop); } HandleContext initialHandle = NativeMethods.Initialize(loop.Handle, handleType, this, args); Debug.Assert(initialHandle is object); _handle = initialHandle; HandleType = handleType; }
// addr: // struct sockaddr ontaining the address of the sender. // Can be NULL. Valid for the duration of the callback only. // // flags: // One or more or’ed UV_UDP_* constants. // Right now only UV_UDP_PARTIAL is used private static void OnReceiveCallback(IntPtr handle, IntPtr nread, ref uv_buf_t buf, ref sockaddr addr, int flags) { var udp = HandleContext.GetTarget <Udp>(handle); IByteBuffer byteBuffer = udp.GetBuffer(); int count = (int)nread.ToInt64(); IPEndPoint remoteEndPoint = count > 0 ? addr.GetIPEndPoint() : null; // // Indicates message was truncated because read buffer was too small. // The remainder was discarded by the OS. Used in uv_udp_recv_cb. // if (flags == (int)uv_udp_flags.UV_UDP_PARTIAL) { Log.Handle_receive_result_truncated(handle, byteBuffer); } udp.OnReceivedCallback(byteBuffer, count, remoteEndPoint); }
protected internal override unsafe StreamHandle NewStream() { IntPtr loopHandle = ((uv_stream_t *)InternalHandle)->loop; var loop = HandleContext.GetTarget <LoopContext>(loopHandle); var client = new Tcp(loop); NativeMethods.StreamAccept(InternalHandle, client.InternalHandle); client.ReadStart(); #if DEBUG if (Log.DebugEnabled) { Log.Debug("{} {} client {} accepted", HandleType, InternalHandle, client.InternalHandle); } #endif return(client); }
private static void OnWalkCallback(IntPtr handle, IntPtr loopHandle) { if (handle == IntPtr.Zero) { return; } try { var target = HandleContext.GetTarget <IDisposable>(handle); if (Log.InfoEnabled) { Log.LoopWalkCallbackDisposed(loopHandle, handle, target); } target?.Dispose(); } catch (Exception exception) { Log.Loop_Walk_callback_attempt_to_close_handle_failed(loopHandle, handle, exception); } }
protected internal override unsafe StreamHandle NewStream() { IntPtr loopHandle = ((uv_stream_t *)InternalHandle)->loop; var loop = HandleContext.GetTarget <LoopContext>(loopHandle); uv_handle_type type = ((uv_stream_t *)InternalHandle)->type; StreamHandle client; switch (type) { case uv_handle_type.UV_NAMED_PIPE: client = new Pipe(loop, _ipc); break; case uv_handle_type.UV_TCP: client = new Tcp(loop); break; default: throw ThrowHelper.GetInvalidOperationException_Pipe_IPC_handle_not_supported(type); } NativeMethods.StreamAccept(InternalHandle, client.InternalHandle); if (!_ipc) { client.ReadStart(); } #if DEBUG if (Log.DebugEnabled) { Log.Debug("{} {1} client {} accepted. (IPC : {})", HandleType, InternalHandle, client.InternalHandle, _ipc); } #endif return(client); }
private static void OnWorkCallback(IntPtr handle) { var workHandle = HandleContext.GetTarget <WorkHandle>(handle); workHandle?.OnWorkCallback(); }
private static void OnFSEventCallback(IntPtr handle, string fileName, int events, int status) { var fsEvent = HandleContext.GetTarget <FSEvent>(handle); fsEvent?.OnFSEventCallback(fileName, events, status); }
private static void OnAllocateCallback(IntPtr handle, IntPtr suggestedSize, out uv_buf_t buf) { var udp = HandleContext.GetTarget <Udp>(handle); udp.OnAllocateCallback(out buf); }
private static void OnPollCallback(IntPtr handle, int status, int events) { var poll = HandleContext.GetTarget <Poll>(handle); poll?.OnPollCallback(status, events); }
private static void OnSignalCallback(IntPtr handle, int signum) { var signal = HandleContext.GetTarget <Signal>(handle); signal?.OnSignalCallback(signum); }
private static void OnFSPollCallback(IntPtr handle, int status, ref uv_stat_t prev, ref uv_stat_t curr) { var fsPoll = HandleContext.GetTarget <FSPoll>(handle); fsPoll?.OnFSPollCallback(status, ref prev, ref curr); }
private static void OnAllocateCallback(IntPtr handle, IntPtr suggestedSize, out uv_buf_t buf) { var stream = HandleContext.GetTarget <StreamHandle>(handle); stream.OnAllocateCallback(out buf); }