/// <inheritdoc /> /// <exception cref="ArgumentNullException" /> /// <exception cref="ArgumentOutOfRangeException" /> public SocketListener(EndPoint listenEndPoint, int backlog, int maxConnections, IPacketProcessor packetProcessor) { if (listenEndPoint == null) { throw new ArgumentNullException(nameof(listenEndPoint)); } if (backlog <= 0) { throw new ArgumentOutOfRangeException(nameof(backlog)); } if (maxConnections <= 0) { throw new ArgumentOutOfRangeException(nameof(maxConnections)); } if (packetProcessor == null) { throw new ArgumentNullException(nameof(packetProcessor)); } this.listenEndPoint = listenEndPoint; this.backlog = backlog; this.maxConnections = maxConnections; this.packetProcessor = packetProcessor; this.sendOperation = SocketOperation.Asynchronization; this.bufferSize = SocketConstants.DefaultBufferSize; this.keepAlive = KeepAlive.OFF; this.maxConnectionsEnforcer = new Semaphore(maxConnections, maxConnections); this.statistics = new SocketListenerStatistics(); this.acceptEventArgs = new SocketAsyncEventArgs(); this.acceptEventArgs.Completed += new EventHandler <SocketAsyncEventArgs>(Accept_Completed); this.ioEventArgsPool = new ConcurrentStack <SocketAsyncEventArgs>(); }
public PacketReceiver(IPacketValidator packetValidator, IPacketProcessor packetProcessor, IQdafLogger logger) { _packetValidator = packetValidator; _packetProcessor = packetProcessor; _logger = logger; _errors = new Lazy<List<string>>(() => new List<string>()); }
/// <summary> /// Creates a channel and assigns a valid ID, port and manager to it /// </summary> /// <remarks> /// It is recommended to use this method whenever you wish to create a new channel. /// The only reason not to use this method is if you wish to create a channel with a specific ID /// which may cause issues /// </remarks> /// <typeparam name="T">The type of channel to create</typeparam> /// <returns>Returns a newly created channel ready to be added</returns> public T CreateChannel <T>(IPacketProcessor packetProcessor) where T : IServerChannel { var channel = (T)_channelMgr.CreateChannel <T>(); channel.PacketProcessor = packetProcessor; return(channel); }
public override void OnReceive(ISocketContext <MqttMessage> context, MqttMessage msg) { this._logger.LogTrace("receive Packet from {0}", context.RemoteEndPoint); if (msg?.Packet == null) { this._logger.LogWarning("receive receive message from {0}, but packet is null", context.RemoteEndPoint); return; } Task.Run( async() => { this._logger.LogDebug("receive Packet from {0}, type ={1}", context.RemoteEndPoint, msg.Packet.PacketType); MqttClientSession clientSession = this._sessionManager.GetClientSession(context, msg.Packet); IPacketProcessor processor = this._processorManager.GetProcessor(msg.Packet.PacketType); if (processor != null) { MqttMessage rsp = await processor.ProcessAsync(clientSession, msg.Packet); if (rsp != null) { if (rsp.Packet != null) { await context.SendAsync(rsp); } if (rsp.Code != 0) //主动断开 { await ShutdownChannel(context, msg.Packet); } } } else { this._logger.LogWarning("PacketType:{0} has no processor", msg.Packet.PacketType); } }).ConfigureAwait(false); /* * switch (msg.Packet.PacketType) * { * case PacketType.CONNECT: * Console.WriteLine("receive connect pack client_id = {0}",((ConnectPacket)msg.Packet).ClientId); * var ack = new ConnAckPacket { ReturnCode = ConnectReturnCode.Accepted, SessionPresent = true}; * context.SendAsync(new MqttMessage { Packet = ack}); * break; * case PacketType.PINGREQ: * context.SendAsync(new MqttMessage { Packet = PingRespPacket.Instance}); * break; * default: * Console.WriteLine("receive Packet from {0}, type ={1}",context.RemoteEndPoint,msg.Packet.PacketType); * break; * * }*/ }
protected AbstractServerStageUser(ISocket socket, IPacketProcessor <TStage, TUser> processor) : base(socket, processor) { var bytes = new byte[8]; var random = new Random(); random.NextBytes(bytes); Key = BitConverter.ToInt64(bytes, 0); }
public NetPacketParserTests() { _packetProcessor = new NetPacketProcessor(); _buffer = new List <int>(new[] { 16, 0, 0, 0, 12, 0, 0, 0, 72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33 }).Select(x => (byte)x).ToArray(); _bufferHeader = _buffer.Take(_packetProcessor.HeaderSize).ToArray(); _bufferContent = _buffer.Skip(_packetProcessor.HeaderSize).ToArray(); _messageContent = Encoding.UTF8.GetString(_bufferContent.Skip(sizeof(int)).ToArray()); _invalidBuffer = new List <int>(new[] { 255, 255, 255, 255, 12, 0, 0, 0, 72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33 }).Select(x => (byte)x).ToArray(); }
public PacketRouter(IPacketProcessor processor, IConnectionNegotiator connection) { RecvRoutingUpdate = new TrafficCounter(); RecvVoiceData = new TrafficCounter(); RecvTextData = new TrafficCounter(); RecvHandshakeResponse = new TrafficCounter(); _processor = processor; _connection = connection; }
public UNetClient(IPacketProcessor packetProcessor) { _channelManager = new ChannelManager(); PacketProcessor = packetProcessor; ActiveChannels = new List <IClientChannel> { CreateMainChannel() }; Identity = new SocketIdentity(0); _operationTable = new Dictionary <int, ISocketOperation>(); }
public Task RegisterAsync(IPacketProcessor processor, Type packetType) { if (_packetProcessors.ContainsKey(packetType)) { return(Task.CompletedTask); } _packetTypesByHeader.Add(packetType.GetCustomAttribute <PacketHeaderAttribute>().Identification, packetType); _packetProcessors[packetType] = processor; return(Task.CompletedTask); }
public HostedTzspListener ( ILogger logger, CommandLineArguments commandLineArguments, IPacketProcessor packetProcessor ) { _logger = logger.ForContext <HostedTzspListener>(); _args = commandLineArguments; _packetProcessor = packetProcessor; }
/// <inheritdoc /> public TcpClient(IPacketProcessor packetProcessor) { if (packetProcessor == null) { throw new ArgumentNullException(nameof(packetProcessor)); } this.packetProcessor = packetProcessor; this.bufferSize = SocketConstants.DefaultBufferSize; this.keepAlive = KeepAlive.OFF; }
public static void RegisterPacketType(Type type, IPacketProcessor processor) { if (currentPacketIndex + 1 > byte.MaxValue) { throw new InvalidOperationException("Cannot register packet type. Not enough space."); } PacketConverters.Add(type, currentPacketIndex); PacketBytes.Add(currentPacketIndex, type); Packets.Add(currentPacketIndex, processor); currentPacketIndex++; }
public LoginStage( LoginStageConfig config, ILogger <IStage <LoginStage, LoginStageUser> > logger, IServerRegistry serverRegistry, ISessionRegistry sessionRegistry, IMigrationRegistry migrationRegistry, IGuildService guildService, IPartyService partyService, IAccountRepository accountRepository, IAccountWorldRepository accountWorldRepository, ICharacterRepository characterRepository, ITickerManager timerManager, IPacketProcessor <LoginStage, LoginStageUser> processor, ITemplateRepository <WorldTemplate> worldTemplates, ITemplateRepository <ItemTemplate> itemTemplates ) : base( ServerStageType.Login, config, logger, serverRegistry, sessionRegistry, migrationRegistry, accountRepository, accountWorldRepository, characterRepository, timerManager, processor ) { Logger = logger; GuildService = guildService; PartyService = partyService; WorldTemplates = worldTemplates; ItemTemplates = itemTemplates; processor.Register(new CheckPasswordHandler(this)); processor.Register(new WorldInfoRequestHandler()); processor.Register(new SelectWorldHandler()); processor.Register(new CheckUserLimitHandler()); processor.Register(new SetGenderHandler()); processor.Register(new CheckPinCodeHandler()); processor.Register(new WorldRequestHandler()); processor.Register(new LogoutWorldHandler()); processor.Register(new CheckDuplicatedIDHandler()); processor.Register(new CreateNewCharacterHandler()); processor.Register(new DeleteCharacterHandler()); processor.Register(new ExceptionLogHandler(this)); processor.Register(new EnableSPWRequestHandler(false)); processor.Register(new CheckSPWRequestHandler(false)); }
public Connection(Socket stream, IPacketProcessor[] processors, int bufferSize = 1024 * 6) { _netStream = stream; BufferSize = bufferSize; _packetProcessors = processors; _readBuffer = new byte[bufferSize]; _readStream = new MemoryStream(_readBuffer); _reader = new BinaryReader(_readStream); _writeBuffer = new byte[bufferSize]; _writeStream = new MemoryStream(_writeBuffer); _writer = new BinaryWriter(_writeStream); }
public NetPacketParserTests() { this._packetProcessor = new NetPacketProcessor(); this._packetParser = new NetPacketParser(this._packetProcessor); this._buffer = new List <int>(new[] { 16, 0, 0, 0, 12, 0, 0, 0, 72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33 }).Select(x => (byte)x).ToArray(); this._bufferHeader = this._buffer.Take(this._packetProcessor.HeaderSize).ToArray(); this._bufferContent = this._buffer.Skip(this._packetProcessor.HeaderSize).ToArray(); this._bufferContentSize = this._bufferContent.Take(sizeof(int)).ToArray(); this._messageSize = BitConverter.ToInt32(this._bufferHeader); this._messageContentSize = BitConverter.ToInt32(this._bufferContentSize) + sizeof(int); // extra int size for string length this._messageContent = Encoding.UTF8.GetString(this._bufferContent.Skip(sizeof(int)).ToArray()); this._invalidBuffer = new List <int>(new[] { 255, 255, 255, 255, 12, 0, 0, 0, 72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33 }).Select(x => (byte)x).ToArray(); }
private void InternalProcess(GameClient Client, byte[] Packet) { fixed(byte *pPacket = Packet) { ushort *Size = (ushort *)(pPacket + 0); ushort *Type = (ushort *)(pPacket + 2); if (*Size != Packet.Length) { SizeMismatch(Client, *Size, Packet); return; } Kernel.HexDump(Packet, "Client -> Server"); IPacketProcessor processor = null; switch (*Type) { case 0x3E9: processor = new CreateCharacterProcessor(Database); break; case 0x3EC: processor = new ChatProcessor(Database, CommandProcessor, NpcScriptEngine); break; case 0x3ED: processor = new MovementProcessor(Database); break; case 0x3F1: processor = new ItemUsageProcessor(Database); break; case 0x3F2: processor = new GeneralDataProcessor(Database); break; case 0x3FE: processor = new AttackProcessor(Database); break; case 0x41C: processor = new LoginTransferProcessor(Database); break; case 0x7EF: case 0x7F0: processor = new NpcProcessor(Database, NpcScriptEngine); break; default: Client.Send(Packet); break; } if (processor != null) { processor.Execute(Client, pPacket); } } }
public BattleServer(string host, int port) { Configuration.Backlog = 50; Configuration.Host = host; Configuration.Port = port; Configuration.MaximumNumberOfConnections = 2; // Spectators allowed but not yet Configuration.BufferSize = 1024; Configuration.Blocking = true; battle = new PBEBattle(PBEBattleFormat.Double, PBESettings.DefaultSettings); battle.OnNewEvent += PBEBattle.ConsoleBattleEventHandler; battle.OnNewEvent += BattleEventHandler; battle.OnStateChanged += BattleStateHandler; PacketProcessor = new PBEPacketProcessor(battle); }
public static IPacketProcessor InstantiatePacketProcessor(Type type, IDictionary <string, string> argsDict) { // Predicate determining if a parameter could be provided Func <ParameterInfo, bool> parameterIsAvailable = param => argsDict.ContainsKey(param.Name) && IsAllowedConstructorParameterType(param.ParameterType); // Predicate determining if a constructor can be called Func <ConstructorInfo, bool> constructorCanBeCalled = ctor => ctor.GetParameters().All(p => parameterIsAvailable(p) || p.IsOptional); // Get the constructors for this type that we could call with the given arguments: var constructors = type.GetConstructors(BindingFlags.Instance | BindingFlags.Public) .Where(constructorCanBeCalled); // Try to instantiate the type, using the best constructor we can: // Prefer constructors where we can provide all the parameters to those where some will be their default values var sortedConstructors = constructors.OrderByDescending(ctor => ctor.GetParameters().Length) .ThenByDescending(ctor => ctor.GetParameters().Count(p => !p.IsOptional)); foreach (var constructor in sortedConstructors) { try { // Get the arguments for the constructor, converted to the proper types var arguments = GetArgumentsForConstructor(constructor, argsDict).ToArray(); // Invoke the constructor, instantiating the type #if MOREDEBUG Console.WriteLine("Invoking new {0}", ConstructorString(constructor, arguments)); #endif IPacketProcessor pp = (IPacketProcessor)constructor.Invoke(arguments); return(pp); } catch (Exception ex) when(ex is InvalidCastException || ex is FormatException || ex is KeyNotFoundException) { // If an exception is thrown, ignore it and try the next best constructor // But log it first: Debug.WriteLine("Constructor failed - {0}:", constructor.ToString()); Debug.WriteLine(ex); } } // If we reach this point, there were no constructors that we could use Console.WriteLine("No suitable constructor could be found."); return(null); }
public Nested_Chained_Test2() { mirror_cfg = Mirror.InitialConfig(PaxConfig_Lite.no_interfaces); Debug.Assert(PaxConfig_Lite.no_interfaces >= 3); mirror_cfg[0] = new ForwardingDecision.SinglePortForward(2); // Mirror port 0 to port 2 this.pp = new PacketProcessor_Chain(new List <IPacketProcessor>() { /* FIXME would be tidier to use this * new Mirror( * Mirror.InitialConfig(PaxConfig_Lite.no_interfaces).MirrorPort(0, 2) * ), */ new Mirror(mirror_cfg), new LearningSwitch(), }); }
public void Process(GameSession session, IPacket packet) { IPacketProcessor processor = processors.GetValue(packet.GetType()); if (processor == null) { return; } try { processor.Process(session, packet); } catch (Exception e) { Log.Error($"Error when processing packet {packet.GetType().Name}", e); } }
private void Reset() { resetEvent.Reset(); state = ServerState.Resetting; foreach (Player c in readyPlayers.ToArray()) { DisconnectClient(c.Id); c.ResetEvent.Close(); } battle = new PBEBattle(PBEBattleFormat.Double, PBESettings.DefaultSettings); battle.OnNewEvent += PBEBattle.ConsoleBattleEventHandler; battle.OnNewEvent += BattleEventHandler; battle.OnStateChanged += BattleStateHandler; packetProcessor = new PBEPacketProcessor(battle); battlers = null; spectatorPackets.Clear(); state = ServerState.WaitingForPlayers; resetEvent.Set(); }
public void Process(IClient client, IPacket packet) { IPacketProcessor processor = processors.GetValueOrDefault(packet.GetType()); if (processor == null) { Logger.Warn($"No packet processor for {packet.GetType().Name}"); return; } Logger.Trace($"Processing packet {packet.GetType().Name} using {processor.GetType().Name}"); try { processor.Process(client, packet); } catch (Exception e) { Logger.Error(e); } }
private static IPacketProcessor InstantiatePacketProcessor(Type type) { #if MOREDEBUG Console.WriteLine("Trying to instantiate {0}", type); #endif // Get the constructor arguments for this type from the config IDictionary <string, string> arguments = PaxConfig.configFile.handlers?.Where(handler => type.Name.Equals(handler.class_name)) .Select(intf => intf.args) .SingleOrDefault(); if (arguments == null) { arguments = new Dictionary <string, string>(); } #if MOREDEBUG Console.WriteLine(" Arguments:"); foreach (var pair in arguments) { Console.WriteLine(" {0} : {1}", pair.Key, pair.Value); } Console.WriteLine(" Public constructors:"); foreach (var ctor in type.GetConstructors(BindingFlags.Instance | BindingFlags.Public)) { Console.WriteLine(" {0}", PacketProcessorHelper.ConstructorString(ctor)); } #endif // Instantiate the packet processor IPacketProcessor pp = PacketProcessorHelper.InstantiatePacketProcessor(type, arguments); if (pp == null) { Console.WriteLine("Couldn't instantiate {0}", type.FullName); } check_version_exc(pp); return(pp); }
public void AddProcessor(IPacketProcessor processor) { processor.RegisterProcessor(new PacketProcessorConfig(_handlers, _defaultProcessors)); }
/// <inheritdoc /> public void SetPacketProcessor(IPacketProcessor packetProcessor) { _packetParser.PacketProcessor = packetProcessor; }
/// <summary> /// Creates a new <see cref="NetReceiver"/> instance. /// </summary> /// <param name="packetProcessor">Default packet processor.</param> public NetReceiver(IPacketProcessor packetProcessor) { _packetParser = new NetPacketParser(packetProcessor); }
public TextDumper(IPacketProcessor <Nothing> inner, StringBuilder sb) { this.inner = new NothingToBoolProcessor(inner); this.sb = sb; }
public TextDumper(IPacketProcessor <bool> inner, StringBuilder sb) { this.inner = inner; this.sb = sb; }
public LoginStageUser(ISocket socket, IPacketProcessor <LoginStage, LoginStageUser> processor) : base(socket, processor) { IsLoggingIn = true; State = LoginState.LoggedOut; }
public NetManager(IPacketProcessor p_PacketProcessor) { m_PlayerManager = Game.Instance.PlayerManager; m_PacketProcessor = p_PacketProcessor; }
/// <summary> /// Creates a new <see cref="NetPacketParser"/> instance. /// </summary> /// <param name="packetProcessor">Net packet processor used to parse the incoming data.</param> public NetPacketParser(IPacketProcessor packetProcessor) { this.PacketProcessor = packetProcessor; }
/// <inheritdoc /> public SocketListener(int port, int backlog, int maxConnections, IPacketProcessor packetProcessor) : this(new IPEndPoint(IPAddress.Any, port), backlog, maxConnections, packetProcessor) { }