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);
}
private void AynsReceive(IAsyncResult result)
{
Log.Info("接收到客户端发送信息");
int BytesTransferred = _Conn.EndReceive(result);
if (!_Closed)
{
if (BytesTransferred <= 0 || !_Conn.Connected)
{
_Conn.Close();
_Closed = true;
return;
}
_Conn.BeginReceive(Buffer, 0, Buffer.Length, SocketFlags.None, AynsReceive, null);
int PacketLength = BitConverter.ToUInt16(Buffer, 0);
PacketLength -= 2; //already read 2 bytes
byte[] Packet = new byte[PacketLength];
Array.Copy(Buffer, 2, Packet, 0, PacketLength);
bool DecryptReult = Decrypt(Packet);
if (DecryptReult)
{
ClientPacketHandler Handler = new ClientPacketHandler(this, Packet);
}
}
}
public void UsersListTest()
{
TCPPacketWriter writer = new TCPPacketWriter();
List <IUser> UsersList = new List <IUser>();
for (int i = 0; i < 10; i++)
{
UsersList.Add(new FeenAccount());
}
MemoryStream ms = new MemoryStream();
writer.SetStream(ms);
Packet.WriteUserList(writer, UsersList);
ClientPacketHandler handler = new ClientPacketHandler();
EventSource.OnUserList += EventSource_OnUserList;
LastUsersListEventData = null;
handler.Handle(new Queue <byte>(ms.ToArray()));
EventSource.OnUserList += EventSource_OnUserList;
Assert.IsNotNull(LastUsersListEventData);
Assert.AreEqual(UsersList.Count, LastUsersListEventData.Count);
for (int i = 0; i < UsersList.Count; i++)
{
Assert.AreEqual(UsersList[i].ID, LastUsersListEventData[i].ID);
Assert.AreEqual(UsersList[i].Username, LastUsersListEventData[i].Username);
Assert.AreEqual(UsersList[i].Nickname, LastUsersListEventData[i].Nickname);
Assert.AreEqual(UsersList[i].IsAdmin, LastUsersListEventData[i].IsAdmin);
}
}
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));
}
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 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);
}
private void Awake()
{
Assert.IsNotNull(registryPrefab, "Missing prefab ergistry.");
registry = Instantiate(registryPrefab);
ClientPacketHandler packetHandler = new ClientPacketHandler(this);
clientTCP = new ClientTCPConnection(packetHandler);
clientTCP.ConnectToServer();
}
public override void Initialize()
{
MessageReceiver.Initialize();
ProtocolTypeManager.Initialize();
Handler = new ClientPacketHandler();
Handler.RegisterAll(Context.PluginAssembly);
NetworkClient = new NetworkClient();
NetworkClient.Initialize();
}
/// <summary>
/// Register a packet handler for the given ID.
/// </summary>
/// <param name="packetId">The client packet ID.</param>
/// <param name="handler">The handler for the data.</param>
private void RegisterClientPacketHandler(
ClientPacketId packetId,
ClientPacketHandler handler
)
{
if (_clientPacketHandlers.ContainsKey(packetId))
{
Logger.Get().Error(this, $"Tried to register already existing client packet handler: {packetId}");
return;
}
_clientPacketHandlers[packetId] = handler;
}
/// <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="clientPacketHandler">The client packet handler callback implementation.</param>
public void PutHandler <TPacket>(TPacket packet, ClientPacketHandler clientPacketHandler) where TPacket : IConvertible
{
try
{
if (Enum.IsDefined(typeof(TPacket), packet))
{
if (_clientPacketHandlers.ContainsKey((byte)(IConvertible)packet))
{
_clientPacketHandlers.Remove((byte)(IConvertible)packet);
}
_clientPacketHandlers.Add((byte)(IConvertible)packet, clientPacketHandler);
}
}
catch (Exception ex)
{
Console.WriteLine($"Error: {ex.Message}.");
}
}
/// <summary>
/// Register a packet handler for client 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 RegisterClientAddonPacketHandler(
byte addonId,
byte packetId,
ClientPacketHandler handler
)
{
if (!_clientAddonPacketHandlers.TryGetValue(addonId, out var addonPacketHandlers))
{
addonPacketHandlers = new Dictionary <byte, ClientPacketHandler>();
_clientAddonPacketHandlers[addonId] = addonPacketHandlers;
}
if (addonPacketHandlers.ContainsKey(packetId))
{
throw new InvalidOperationException("There is already a packet handler for the given ID");
}
addonPacketHandlers[packetId] = handler;
}
public void AudioPacketTest()
{
TCPPacketWriter writer = new TCPPacketWriter();
MemoryStream ms = new MemoryStream();
writer.SetStream(ms);
byte[] audioData = new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };
Packet.WriteAudioData(writer, Guid.Empty, FeenPhone.Audio.Codecs.CodecID.Gsm610ChatCodec, audioData, 10);
ClientPacketHandler handler = new ClientPacketHandler();
EventSource.OnAudioData += EventSource_OnAudioData;
LastAudioDataEventArgs = null;
handler.Handle(new Queue <byte>(ms.ToArray()));
EventSource.OnAudioData += EventSource_OnAudioData;
Assert.IsNotNull(LastAudioDataEventArgs);
Assert.AreEqual(FeenPhone.Audio.Codecs.CodecID.Gsm610ChatCodec, LastAudioDataEventArgs.Codec);
Assert.AreEqual(10, LastAudioDataEventArgs.Data.Length);
Assert.AreEqual(10, LastAudioDataEventArgs.DataLen);
}
public Packet?PacketReceivedFromClient(Packet packet) => ClientPacketHandler.HandlePacket(packet);
public ModDialog()
{
packetHandler = new ClientPacketHandlerDialog();
}
public Packet?PacketReceivedFromClient(byte[] payload) => ClientPacketHandler.HandlePacket(new Packet(payload[0], payload));
//private byte[] _asyncBuffer = new byte[1024];
public ClientTCPConnection(ClientPacketHandler packetHandler)
{
this.packetHandler = packetHandler;
}
public static void Initialize()
{
Register(0x00, 0, EmptyHandler);
ClientPacketHandler.Initialize();
}
private static void DlgShow(object[] obj)
{
ClientPacketHandler.send_Dialog(GObjectManager.Players[PlayerHandle], Npc.DialogType.Npc, DialData);
}
public void Start()
{
this.packetHandler = new ClientPacketHandler(this);
this.networkThreaad = new FixedStepThread(Update, 3);
}
