//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) + "]";
}
}
