//private ConsoleGameServer consoleGameServer; public SocketServer(ConsoleGameServer consoleGameServer) { signal = new AutoResetEvent(false); PacketFactory.Register(PacketIdentity.MoveTo, () => new MoveToPacket()); ServerPacketHandler.Register(PacketIdentity.MoveTo, new MoveToPacketHandler()); PacketFactory.Register(PacketIdentity.AimTo, () => new AimToPacket()); ServerPacketHandler.Register(PacketIdentity.AimTo, new AimToPacketHandler()); PacketFactory.Register(PacketIdentity.Auth, () => new AuthPacket()); ServerPacketHandler.Register(PacketIdentity.Auth, new AuthPacketHandler()); PacketFactory.Register(PacketIdentity.PerformAbility, () => new PerformAbilityPacket()); ServerPacketHandler.Register(PacketIdentity.PerformAbility, new PerformAbilityPacketHandler()); PacketFactory.Register(PacketIdentity.UseItem, () => new UseItemPacket()); ServerPacketHandler.Register(PacketIdentity.UseItem, new UseItemPacketHandler()); PacketFactory.Register(PacketIdentity.MoveItem, () => new MoveItemPacket()); ServerPacketHandler.Register(PacketIdentity.MoveItem, new MoveItemPacketHandler()); PacketFactory.Register(PacketIdentity.ChatMessage, () => new ChatMessagePacket()); ServerPacketHandler.Register(PacketIdentity.ChatMessage, new ChatMessagePacketHandler()); PacketFactory.Register(PacketIdentity.ChatStatus, () => new ChatStatusPacket()); ServerPacketHandler.Register(PacketIdentity.ChatStatus, new ChatStatusPacketHandler()); acceptedQueue = new Queue <Socket>(); onAccept = new AsyncCallback(BeginAcceptCallback); netStatesWithPacketQueue = new ThreadQueue <NetState>(); }
public Task Start(ProxyStartConfig config) { proxyStartConfig = config; Console.Info($"Default protocol version: {config.ProtocolVersion}"); Console.Info($"Encryption: {config.Encryption}"); if (config.LoginEncryptionKey.HasValue) { Console.Info($"Encryption key {config.LoginEncryptionKey.Value}"); } packetRegistry = PacketDefinitionRegistryFactory.CreateClassicClient(proxyStartConfig.ProtocolVersion); serverPacketHandler = new ServerPacketHandler(packetRegistry); clientPacketHandler = new ClientPacketHandler(packetRegistry); serverPacketHandler.RegisterFilter(RedirectConnectToGameServer); clientPacketHandler.Subscribe(PacketDefinitions.ExtendedLoginSeed, HandleExtendedLoginSeed); LegacyApi = new Legacy(LogConfig, commandHandler, new UltimaServer(serverPacketHandler, SendToServer, packetRegistry), new UltimaClient(clientPacketHandler, SendToClient), Console, packetRegistry, ConfigRepository, injectionWindow, SoundPlayer); UO.Initialize(LegacyApi); commandHandler.RegisterCommand(new Command("dump", DumpPacketLog, false, true, "Dumps packet log - log of network communication between game client and server. Network communication logs are very useful for diagnosing issues like crashes.", executionMode: CommandExecutionMode.Direct)); commandHandler.RegisterCommand(new Command("help", HelpCommand, false, true, "Shows command help.")); commandHandler.RegisterCommand(new Command(ListCommandName, ListRunningCommands, false, true, "Lists running commands")); commandHandler.RegisterCommand(new Command("proxy-latency", PrintProxyLatency, false, true, "Shows proxy latency.")); serverEndpoint = config.ServerEndPoint; return(Main(config.LocalProxyPort, packetRingBufferLogger)); }
public HeadlessClient(Legacy legacyApi, IConsole console, HeadlessStartConfig startConfig) { this.legacyApi = legacyApi; this.console = console; this.startConfig = startConfig; packetRegistry = PacketDefinitionRegistryFactory.CreateClassicClient(startConfig.ClientVersion); diagnosticProvider = new InfusionDiagnosticPushStreamProvider(LogConfig, console); serverDiagnosticPushStream = new CompositeDiagnosticPushStream(new ConsoleDiagnosticPushStream(packetLogger, "headless -> server", packetRegistry), new InfusionBinaryDiagnosticPushStream(DiagnosticStreamDirection.ClientToServer, diagnosticProvider.GetStream)); serverDiagnosticPullStream = new ConsoleDiagnosticPullStream(packetLogger, "server -> headless", packetRegistry); serverConnection = new ServerConnection(ServerConnectionStatus.Initial, serverDiagnosticPullStream, serverDiagnosticPushStream, packetRegistry, startConfig.Encryption); serverConnection.PacketReceived += ServerConnectionOnPacketReceived; ultimaServer = new UltimaServer(serverPacketHandler, SendToServer, packetRegistry); serverPacketHandler = new ServerPacketHandler(packetRegistry); clientPacketHandler = new ClientPacketHandler(packetRegistry); serverEndpoint = startConfig.ServerEndPoint; ultimaClient = new UltimaClient(clientPacketHandler, SendToClient); serverPacketHandler.RegisterFilter(FilterServerPacket); serverPacketHandler.Subscribe(PacketDefinitions.GameServerList, HandleGameServerList); serverPacketHandler.Subscribe(PacketDefinitions.CharactersStartingLocations, HandleCharactersStartingLocationsPacket); serverPacketHandler.Subscribe(PacketDefinitions.EnableLockedClientFeatures, HandleEnableLockedClientFeatures); clientPacketHandler.Subscribe(PacketDefinitions.LoginRequest, HandleLoginRequest); clientPacketHandler.Subscribe(PacketDefinitions.GameServerLoginRequest, HandleGameServerLoginRequest); clientPacketHandler.Subscribe(PacketDefinitions.SelectServerRequest, HandleSelectServerRequest); }
internal InfusionTestProxy(ITimeSource timeSource, PacketDefinitionRegistry packetRegistry = null) { packetRegistry = packetRegistry ?? PacketDefinitionRegistryFactory.CreateClassicClient(); ServerPacketHandler = new ServerPacketHandler(PacketDefinitionRegistryFactory.CreateClassicClient()); ClientPacketHandler = new ClientPacketHandler(PacketDefinitionRegistryFactory.CreateClassicClient()); Server = new UltimaServer(ServerPacketHandler, packet => { var filteredPacket = ClientPacketHandler.FilterOutput(packet); if (filteredPacket.HasValue) { packetsSentToServer.Add(filteredPacket.Value); } }, packetRegistry); Client = new UltimaClient(ClientPacketHandler, packet => { var filteredPacket = ServerPacketHandler.FilterOutput(packet); if (filteredPacket.HasValue) { packetsSentToClient.Add(filteredPacket.Value); } }); var console = new NullConsole(); Api = new Legacy(new LogConfiguration(), new CommandHandler(console), Server, Client, console, packetRegistry, timeSource, ClilocSource, KeywordSource, new MemoryConfigBagRepository(), new NullInjectionWindow(), new NullSoundPlayer()); UO.Initialize(Api); ServerApi = new TestServerApi(PacketReceivedFromServer, Api); }
public ServerCore(bool isDedic) { LogAdd("Starting server..."); if (instance == null) { isDedicatedServer = isDedic; db = new DataBase(); stNet = new Stopwatch(); stUpdate = new Stopwatch(); config = new NetPeerConfiguration("BFSR"); config.EnableMessageType(NetIncomingMessageType.ConnectionApproval); config.Port = 25565; //config.SimulatedMinimumLatency = 0.2f; server = new NetServer(config); loginHandler = new LoginHandler(this); packetHandler = new ServerPacketHandler(this); instance = this; this.Start(); } else { instance.isDedicatedServer = isDedic; instance.Start(); } LogAdd("Server started"); }
public InfusionTestProxy() { ServerPacketHandler = new ServerPacketHandler(); ClientPacketHandler = new ClientPacketHandler(); Server = new UltimaServer(ServerPacketHandler, packet => { var filteredPacket = ClientPacketHandler.FilterOutput(packet); if (filteredPacket.HasValue) { packetsSentToServer.Add(filteredPacket.Value); } }); Client = new UltimaClient(ClientPacketHandler, packet => { var filteredPacket = ServerPacketHandler.FilterOutput(packet); if (filteredPacket.HasValue) { packetsSentToClient.Add(filteredPacket.Value); } }); var logger = new NullLogger(); Api = new Legacy(new Configuration(), new CommandHandler(logger), Server, Client, logger); }
/// <summary> /// Register a packet handler for the given ID. /// </summary> /// <param name="packetId">The server packet ID.</param> /// <param name="handler">The handler for the data.</param> private void RegisterServerPacketHandler(ServerPacketId packetId, ServerPacketHandler handler) { if (_serverPacketHandlers.ContainsKey(packetId)) { Logger.Get().Error(this, $"Tried to register already existing client packet handler: {packetId}"); return; } _serverPacketHandlers[packetId] = handler; }
private void SocketServer_ProcessPacket(object sender, IPacket packet) { NetState netState = (NetState)sender; ServerPacketHandler packetHandler = ServerPacketHandler.GetHandler(packet.PacketId); if (packetHandler != null) { packetHandler.Handle(packet, netState, worldState); } }
private void Awake() { Assert.IsNotNull(registryPrefab); registry = Instantiate(registryPrefab); ServerPacketHandler packetHandler = new ServerPacketHandler(this); serverTCP = new ServerTCPConnection(packetHandler); serverTCP.SetupServer(); Application.targetFrameRate = serverFrameRate; QualitySettings.vSyncCount = 0; }
/// <summary> /// Method responsible for put packet handler in the list of packet handlers. /// </summary> /// <param name="packet">The value of packet handler.</param> /// <param name="serverPacketHandler">The server packet handler callback implementation.</param> public void PutHandler <TPacket>(TPacket packet, ServerPacketHandler serverPacketHandler) where TPacket : IConvertible { try { if (Enum.IsDefined(typeof(TPacket), packet)) { if (_serverPacketHandlers.ContainsKey((byte)(IConvertible)packet)) { _serverPacketHandlers.Remove((byte)(IConvertible)packet); } _serverPacketHandlers.Add((byte)(IConvertible)packet, serverPacketHandler); } } catch (Exception ex) { Console.WriteLine($"Error: {ex.Message}."); } }
/// <summary> /// Register a packet handler for server addon data. /// </summary> /// <param name="addonId">The ID of the addon.</param> /// <param name="packetId">The ID of the packet data for the addon.</param> /// <param name="handler">The handler for the data.</param> /// <exception cref="InvalidOperationException">Thrown if there is already a handler registered for the /// given ID.</exception> public void RegisterServerAddonPacketHandler( byte addonId, byte packetId, ServerPacketHandler handler ) { if (!_serverAddonPacketHandlers.TryGetValue(addonId, out var addonPacketHandlers)) { addonPacketHandlers = new Dictionary <byte, ServerPacketHandler>(); _serverAddonPacketHandlers[addonId] = addonPacketHandlers; } if (addonPacketHandlers.ContainsKey(packetId)) { throw new InvalidOperationException("There is already a packet handler for the given ID"); } addonPacketHandlers[packetId] = handler; }
public ServerTCPConnection(ServerPacketHandler packetHandler /*, TODO: ServerConfig config*/) { this.packetHandler = packetHandler; }
public Client(ServerPacketHandler packetHandler) { this.packetHandler = packetHandler; }
public Packet?PacketReceivedFromServer(byte[] payload) => ServerPacketHandler.HandlePacket(new Packet(payload[0], payload));
public Packet?PacketReceivedFromServer(Packet packet) => ServerPacketHandler.HandlePacket(packet);
public override void handlePacket(int command, int length, sbyte[] data) { // sbyte[] to byte[] // (byte[])(Array) signed; // byte[] to sbyte[] // (sbyte[]) (Array) unsigned; var cmd = (ServerPacketTypes)command; Debug.Log("Packet Recieved: " + cmd + " " + command + " - " + length); // var udata = (byte[])(Array)data; if (command == 117) { lastPing = CurrentTimeMillis(); streamClass.createPacket(5); streamClass.formatPacket(); } if (cmd == ServerPacketTypes.SET_SERVER_INDEX) { ServerPacketHandler.InitiateServerInfo(data, length); } if (cmd == ServerPacketTypes.SET_SLEEP_IMAGE) { // var image = MainForm.GetSleepImage(udata); } if (cmd == ServerPacketTypes.SET_SKILLS) { // Debug.Log("Before stats update"); ServerPacketHandler.UpdatePlayerSkills(data, length); // Debug.Log("Player stats updated: " + MobManager.MyPlayer.StatCurrent[0] + " " + MobManager.MyPlayer.StatCurrent[1] + MobManager.MyPlayer.StatCurrent[2] + " " + MobManager.MyPlayer.StatCurrent[3] + " " + MobManager.MyPlayer.StatCurrent[4] + "..."); } if (cmd == ServerPacketTypes.PLAYER_APPEARANCE_UPDATE) { ServerPacketHandler.UpdatePlayerAppearance(data, length); } if (cmd == ServerPacketTypes.PLAYER_POS_UPDATE) { ServerPacketHandler.UpdatePlayerPositionData(data, length); } if (cmd == ServerPacketTypes.NPC_POS_UPDATE) { ServerPacketHandler.UpdateNpcPositionData(data, length); } if (cmd == ServerPacketTypes.ITEM_POS_UPDATE) { ServerPacketHandler.UpdateItemPositionData(data, length); } if (cmd == ServerPacketTypes.SET_INVENTORY_ITEMS) { ServerPacketHandler.SetInventoryItems(data, length); } if (cmd == ServerPacketTypes.RECIEVE_PRIVATE_MESSAGE) { var tmpMsg = ChatMessage.bytesToString(data, 1, length - 2); // string tmpBytes = "[" + string.Join(",", data) + "]"; } }