protected override void ChannelRead0(IChannelHandlerContext ctx, DatagramPacket packet) { var content = packet.Content; var address = packet.Sender; byte[] msg = new byte[content.ReadableBytes]; content.ReadBytes(msg); if (msg.Length < 98) { _logger.Error($"Incorrect message, length: {msg.Length}, sender: {address}"); ctx.DisconnectAsync(); return; } var typeRaw = msg[97]; if (!Enum.IsDefined(typeof(MessageType), (int)typeRaw)) { if (_logger.IsDebug) { _logger.Debug($"Unsupported message type: {typeRaw}, sender: {address}, message {msg.ToHexString()}"); } ctx.DisconnectAsync(); return; } var type = (MessageType)typeRaw; if (_logger.IsTrace) { _logger.Trace($"Received message: {type}"); } DiscoveryMessage message; try { message = Deserialize(type, msg); message.FarAddress = (IPEndPoint)address; } catch (Exception e) { if (_logger.IsDebug) { _logger.Debug($"Error during deserialization of the message, type: {type}, sender: {address}, msg: {msg.ToHexString()}, {e.Message}"); } return; } try { _discoveryManager.OnIncomingMessage(message); } catch (Exception e) { _logger.Error($"Error while processing message, type: {type}, sender: {address}, message: {message}", e); } }
public override void ExceptionCaught(IChannelHandlerContext context, Exception exception) { //In case of SocketException we log it as debug to avoid noise string clientId = _session?.Node?.ToString("c") ?? $"unknown {_session?.RemoteHost}"; if (exception is SocketException) { if (_logger.IsTrace) { _logger.Trace($"Error in communication with {clientId} (SocketException): {exception}"); } } else { if (_logger.IsDebug) { _logger.Debug($"Error in communication with {clientId}: {exception}"); } } if (_session?.Node?.IsStatic != true) { context.DisconnectAsync().ContinueWith(x => { if (x.IsFaulted && _logger.IsTrace) { _logger.Trace($"Error while disconnecting on context on {this} : {x.Exception}"); } }); } else { base.ExceptionCaught(context, exception); } }
public virtual async Task Process(IChannelHandlerContext ctx, RpcMessage rpcMessage) { if (ChannelManager.IsRegistered(ctx.Channel)) { await OnRequestMessage(ctx, rpcMessage); } else { try { if (Logger().IsEnabled(LogLevel.Debug)) { Logger().LogInformation($"closeChannelHandlerContext channel:{ctx.Channel}"); } await ctx.DisconnectAsync(); await ctx.CloseAsync(); } catch (Exception exx) { Logger().LogError(exx, exx.Message); } if (Logger().IsEnabled(LogLevel.Debug)) { Logger().LogInformation($"close a unhandled connection! [{ctx.Channel}]"); } } }
public override void ExceptionCaught(IChannelHandlerContext context, Exception exception) { //In case of SocketException we log it as debug to avoid noise if (exception is SocketException) { if (_logger.IsTrace) { _logger.Trace($"Exception when processing discovery messages (SocketException): {exception}"); } } else { if (_logger.IsError) { _logger.Error("Exception when processing discovery messages", exception); } } context.DisconnectAsync().ContinueWith(x => { if (x.IsFaulted && _logger.IsTrace) { _logger.Trace($"Error while disconnecting on context on {this} : {x.Exception}"); } }); }
public virtual async Task Process(IChannelHandlerContext ctx, RpcMessage rpcMessage) { if (_futures.TryRemove(rpcMessage.Id, out MessageFuture messageFuture) && messageFuture != null) { messageFuture.ResultMessage = rpcMessage.Body; } else { if (ChannelManager.IsRegistered(ctx.Channel)) { await OnResponseMessage(ctx, rpcMessage); } else { try { if (Logger().IsEnabled(LogLevel.Debug)) { Logger().LogInformation("closeChannelHandlerContext channel:" + ctx.Channel); } await ctx.DisconnectAsync(); await ctx.CloseAsync(); } catch (Exception exx) { Logger().LogError(exx, exx.Message); } if (Logger().IsEnabled(LogLevel.Debug)) { Logger().LogInformation($"close a unhandled connection! [{ctx.Channel}]"); } } } }
public void Disconnect() { if (channelHandlerContext != null) { channelHandlerContext.DisconnectAsync(); } }
public override Task DisconnectAsync(IChannelHandlerContext ctx) { if (this.Logger.IsEnabled(this.InternalLevel)) { this.Logger.Log(this.InternalLevel, this.Format(ctx, "DISCONNECT")); } return(ctx.DisconnectAsync()); }
/// <inheritdoc /> public override void Disconnect(IChannelHandlerContext ctx, IPromise promise) { if (Logger.IsEnabled(MsLogLevel.Information)) { Logger.LogInformation("Channel {0} disconnect", ctx.Channel); } ctx.DisconnectAsync(promise); }
public override void Disconnect(IChannelHandlerContext ctx, IPromise promise) { if (Logger.IsEnabled(InternalLevel)) { Logger.Log(InternalLevel, Format(ctx, "DISCONNECT")); } ctx.DisconnectAsync(promise); }
public void Error_on_context_when_disconnecting_channels_does_not_prevent_the_event() { bool wasCalled = false; Session session = new(30312, new Node(TestItem.PublicKeyA, "127.0.0.1", 8545), _channel, NullDisconnectsAnalyzer.Instance, LimboLogs.Instance); _channelHandlerContext.DisconnectAsync().Returns(Task.FromException<Exception>(new Exception())); session.Disconnected += (s, e) => wasCalled = true; session.Handshake(TestItem.PublicKeyA); session.Init(5, _channelHandlerContext, _packetSender); session.MarkDisconnected(DisconnectReason.Other, DisconnectType.Local, "test"); Assert.True(wasCalled); }
public void Dispose() { if (GetHabbo() != null) { GetHabbo().OnDisconnect(); } MachineId = string.Empty; _disconnected = true; _habbo = null; channel.DisconnectAsync(); }
public override void ExceptionCaught(IChannelHandlerContext context, Exception exception) { //In case of SocketException we log it as debug to avoid noise if (exception is SocketException) { if (_logger.IsTrace) { _logger.Trace($"Exception when processing discovery messages (SocketException): {exception}"); } } else { if (_logger.IsError) { _logger.Error("Exception when processing discovery messages", exception); } } context.DisconnectAsync(); }
public override void ExceptionCaught(IChannelHandlerContext context, Exception exception) { //In case of SocketException we log it as debug to avoid noise string clientId = _session?.Node?.ToString("c") ?? $"unknown {_session?.RemoteHost}"; if (exception is SocketException) { if (_logger.IsTrace) { _logger.Trace($"Error in communication with {clientId} (SocketException): {exception}"); } } else { if (_logger.IsDebug) { _logger.Debug($"Error in communication with {clientId}: {exception}"); } } context.DisconnectAsync(); }
public Task DisconnectAsync(IChannelHandlerContext context) { return context.DisconnectAsync(); }
private void HandleRpcError(IChannelHandlerContext ctx, long messageReqMsgId, TRpcError error) { Log.Warn($"#{ClientSettings.ClientSession.SessionId}: Recieve error from server: {error.ErrorMessage}"); if (Log.IsDebugEnabled) { var jMessages = JsonConvert.SerializeObject(error); Log.Debug(jMessages); } switch (error.ErrorMessage) { case "PHONE_CODE_INVALID": RequestService.ReturnException(messageReqMsgId, new PhoneCodeInvalidException()); break; case "SESSION_PASSWORD_NEEDED": RequestService.ReturnException(messageReqMsgId, new CloudPasswordNeededException()); break; case var phoneMigrate when phoneMigrate.StartsWith("PHONE_MIGRATE_"): case var userMigrate when userMigrate.StartsWith("USER_MIGRATE_"): case var netwokMigrate when netwokMigrate.StartsWith("NETWORK_MIGRATE_"): var dcNumber = int.Parse(Regex.Match(error.ErrorMessage, @"\d+").Value); var dcOption = ClientSettings.Config.DcOptions.First(option => option.Id == dcNumber); ClientSettings.ClientSession.AuthKey = null; ClientSettings.ClientSession.ServerAddress = dcOption.IpAddress; ClientSettings.ClientSession.Port = dcOption.Port; ctx.Flush(); SessionWriter.Save(ClientSettings.ClientSession) .ContinueWith(_ => ctx.DisconnectAsync()); break; case var fileMigrate when fileMigrate.StartsWith("FILE_MIGRATE_"): var fileMigrateDcNumber = Regex.Match(fileMigrate, @"\d+").Value; var fileMigrateDcIdx = int.Parse(fileMigrateDcNumber); RequestService.ReturnException(messageReqMsgId, new FileMigrationException(fileMigrateDcIdx)); break; case var floodMessage when floodMessage.StartsWith("FLOOD_WAIT_"): var floodMessageTime = Regex.Match(floodMessage, @"\d+").Value; var seconds = int.Parse(floodMessageTime); RequestService.ReturnException(messageReqMsgId, new FloodWaitException(TimeSpan.FromSeconds(seconds))); break; case "AUTH_KEY_UNREGISTERED": ClientSettings.ClientSession.AuthKey = null; ClientSettings.ClientSession.UserId = null; SessionWriter.Save(ClientSettings.ClientSession).ContinueWith(_ => RequestService.ReturnException(messageReqMsgId, new UserNotAuthorizeException())); break; default: RequestService.ReturnException(messageReqMsgId, new UnhandledException(error.ErrorMessage)); break; } }
public override Task DisconnectAsync(IChannelHandlerContext ctx) { _log.Info("Channel {0} disconnect", ctx.Channel); return(ctx.DisconnectAsync()); }
public Task DisconnectAsync(IChannelHandlerContext context) { return(context.DisconnectAsync()); }
public override Task DisconnectAsync(IChannelHandlerContext context) { _logger.Debug($"{context.Channel} DISCONNECT"); return(context.DisconnectAsync()); }
public override Task DisconnectAsync(IChannelHandlerContext context) { // Try to flush one last time if flushes are pending before disconnect the channel. ResetReadAndFlushIfNeeded(context); return(context.DisconnectAsync()); }
public override Task DisconnectAsync(IChannelHandlerContext context) { RegisterFiredEvent(SupportedEvent.DisconnectAsync); return(context.DisconnectAsync()); }
public override async Task DisconnectAsync(IChannelHandlerContext ctx) { Logger().LogInformation($"Channel {ctx.Channel} disconnect"); await ctx.DisconnectAsync(); }
public virtual void Disconnect(IChannelHandlerContext context, IPromise promise) => context.DisconnectAsync(promise);
public override Task DisconnectAsync(IChannelHandlerContext context) { Log.Debug($"{context.Name}: DisconnectAsync"); return(context.DisconnectAsync()); }
public Task DisconnectAsync() => _ctx.DisconnectAsync();
public override void Disconnect(IChannelHandlerContext ctx, IPromise promise) { // Try to flush one last time if flushes are pending before disconnect the channel. ResetReadAndFlushIfNeeded(ctx); _ = ctx.DisconnectAsync(promise); }
protected override void ChannelRead0(IChannelHandlerContext ctx, DatagramPacket packet) { var content = packet.Content; var address = packet.Sender; byte[] msg = new byte[content.ReadableBytes]; content.ReadBytes(msg); if (msg.Length < 98) { if (_logger.IsDebug) { _logger.Debug($"Incorrect discovery message, length: {msg.Length}, sender: {address}"); } ctx.DisconnectAsync(); return; } var typeRaw = msg[97]; if (!Enum.IsDefined(typeof(MessageType), (int)typeRaw)) { if (_logger.IsDebug) { _logger.Debug($"Unsupported message type: {typeRaw}, sender: {address}, message {msg.ToHexString()}"); } ctx.DisconnectAsync(); return; } var type = (MessageType)typeRaw; if (_logger.IsTrace) { _logger.Trace($"Received message: {type}"); } DiscoveryMessage message; try { message = Deserialize(type, msg); message.FarAddress = (IPEndPoint)address; } catch (Exception e) { if (_logger.IsDebug) { _logger.Debug($"Error during deserialization of the message, type: {type}, sender: {address}, msg: {msg.ToHexString()}, {e.Message}"); } ctx.DisconnectAsync(); return; } try { if ((ulong)message.ExpirationTime < _timestamper.EpochSeconds) { if (_logger.IsDebug) { _logger.Debug($"Received a discovery message that has expired, type: {type}, sender: {address}, message: {message}"); } ctx.DisconnectAsync(); return; } if (!message.FarAddress.Equals((IPEndPoint)packet.Sender)) { if (_logger.IsDebug) { _logger.Debug($"Discovery fake IP detected - pretended {message.FarAddress} but was {ctx.Channel.RemoteAddress}, type: {type}, sender: {address}, message: {message}"); } ctx.DisconnectAsync(); return; } if (message.FarPublicKey == null) { if (_logger.IsDebug) { _logger.Debug($"Discovery message without a valid signature {message.FarAddress} but was {ctx.Channel.RemoteAddress}, type: {type}, sender: {address}, message: {message}"); } ctx.DisconnectAsync(); return; } _discoveryManager.OnIncomingMessage(message); } catch (Exception e) { if (_logger.IsDebug) { _logger.Error($"DEBUG/ERROR Error while processing message, type: {type}, sender: {address}, message: {message}", e); } ctx.DisconnectAsync(); } }
public override Task DisconnectAsync(IChannelHandlerContext ctx) { if (this.Logger.IsEnabled(this.InternalLevel)) { this.Logger.Log(this.InternalLevel, this.Format(ctx, "DISCONNECT")); } return ctx.DisconnectAsync(); }
public virtual Task DisconnectAsync(IChannelHandlerContext context) => context.DisconnectAsync();
public override void Disconnect(IChannelHandlerContext context, IPromise promise) { Log(Event.DISCONNECT); context.DisconnectAsync(promise); }