internal static Packet Instantiate(byte[] source, PacketDefinitionRegistry packetRegistry = null)
{
packetRegistry = packetRegistry ?? PacketDefinitionRegistryFactory.CreateClassicClient();
var processingStream = new MemoryStream(source);
var received = new byte[source.Length];
var packetReader = new StreamPacketReader(processingStream, received);
int packetId = packetReader.ReadByte();
if ((packetId < 0) || (packetId > 255))
{
throw new EndOfStreamException();
}
var packetDefinition = packetRegistry.Find(packetId);
var packetSize = packetDefinition.GetSize(packetReader);
packetReader.ReadBytes(packetSize - packetReader.Position);
var payload = new byte[packetSize];
Array.Copy(received, 0, payload, 0, packetSize);
var packet = new Packet(packetId, payload);
return(packet);
}
private Packet?FilterSeverTargetCursorPacket(Packet rawPacket)
{
if (rawPacket.Id == PacketDefinitions.TargetCursor.Id)
{
TargetInfo?targetInfo = null;
lock (nextTargetsLock)
{
if (nextTargets.Count > 0)
{
targetInfo = nextTargets.Dequeue();
}
}
if (targetInfo.HasValue && targetInfo.Value.Id.HasValue)
{
var packet = PacketDefinitionRegistry.Materialize <TargetCursorPacket>(rawPacket);
server.TargetItem(packet.CursorId, targetInfo.Value.Id.Value, packet.CursorType,
targetInfo.Value.Location, targetInfo.Value.ModelId);
return(null);
}
}
return(rawPacket);
}
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);
}
public void Receive(IPullStream inputStream)
{
var processingStream = GetReceiveStream(inputStream);
while (inputStream.DataAvailable)
{
var packetReader = new StreamPacketReader(processingStream, receiveBuffer);
int packetId = packetReader.ReadByte();
if ((packetId < 0) || (packetId > 255))
{
throw new EndOfStreamException();
}
diagnosticPullStream.StartPacket();
var packetDefinition = PacketDefinitionRegistry.Find(packetId);
var packetSize = packetDefinition.GetSize(packetReader);
packetReader.ReadBytes(packetSize - packetReader.Position);
var payload = new byte[packetSize];
Array.Copy(receiveBuffer, 0, payload, 0, packetSize);
var packet = new Packet(packetId, payload);
if (packetId == PacketDefinitions.ConnectToGameServer.Id)
{
Status = ServerConnectionStatus.PreGame;
}
diagnosticPullStream.FinishPacket(packet);
OnPacketReceived(packet);
}
}
public SoundObserver(IServerPacketSubject serverPacketHandler, IEventJournalSource eventJournalSource,
PacketDefinitionRegistry packetRegistry)
{
this.eventJournalSource = eventJournalSource;
this.packetRegistry = packetRegistry;
serverPacketHandler.RegisterFilter(FilterBlockedSounds);
}
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 PlayerObservers(Player player, UltimaClient client, UltimaServer server, IConsole console,
Legacy legacyApi, GameObjectCollection gameObjects, EventJournalSource eventJournalSource,
PacketDefinitionRegistry packetRegistry)
{
this.client = client;
this.server = server;
this.player = player;
this.console = console;
this.legacyApi = legacyApi;
this.gameObjects = gameObjects;
this.eventJournalSource = eventJournalSource;
this.packetRegistry = packetRegistry;
IClientPacketSubject clientPacketSubject = client;
clientPacketSubject.Subscribe(PacketDefinitions.MoveRequest, HandleMoveRequest);
clientPacketSubject.RegisterOutputFilter(FilterSentClientPackets);
server.RegisterFilter(FilterServerPackets);
server.Subscribe(PacketDefinitions.CharacterLocaleAndBody, HandleCharLocaleAndBodyPacket);
server.Subscribe(PacketDefinitions.DrawGamePlayer, HandleDrawGamePlayerPacket);
server.Subscribe(PacketDefinitions.CharMoveRejection, HandleCharMoveRejectionPacket);
server.Subscribe(PacketDefinitions.UpdateCurrentHealth, HandleUpdateCurrentHealthPacket);
server.Subscribe(PacketDefinitions.UpdateCurrentStamina, HandleUpdateCurrentStaminaPacket);
server.Subscribe(PacketDefinitions.UpdateCurrentMana, HandleUpdateCurrentManaPacket);
server.Subscribe(PacketDefinitions.StatusBarInfo, HandleStatusBarInfoPacket);
server.Subscribe(PacketDefinitions.SendSkills, HandleSendSkillsPacket);
server.Subscribe(PacketDefinitions.DrawObject, HandleDrawObjectPacket);
server.Subscribe(PacketDefinitions.AllowRefuseAttack, HandleAllowRefuseAttack);
server.Subscribe(PacketDefinitions.UpdatePlayer, HandleUpdatePlayerPacket);
server.Subscribe(PacketDefinitions.BoatMoving, HandleBoatMovingPacket);
clientPacketSubject.Subscribe(PacketDefinitions.RequestSkills, HandleRequestSkills);
}
private Packet?FilterClientSpeech(Packet rawPacket)
{
string text = null;
if (rawPacket.Id == PacketDefinitions.SpeechRequest.Id)
{
text = PacketDefinitionRegistry.Materialize <SpeechRequest>(rawPacket).Text;
}
else if (rawPacket.Id == PacketDefinitions.TalkRequest.Id)
{
text = PacketDefinitionRegistry.Materialize <TalkRequest>(rawPacket).Message;
}
if (text != null)
{
if (commandHandler.IsInvocationSyntax(text))
{
eventSource.Publish(new CommandRequestedEvent(text));
Task.Run(() =>
{
logger.Debug(text);
commandHandler.InvokeSyntax(text);
});
return(null);
}
logger.Debug(text);
eventSource.Publish(new SpeechRequestedEvent(text));
}
return(rawPacket);
}
public void DumpPacket(Packet packet)
{
if (needsNewLine)
{
builder.AppendLine();
needsNewLine = false;
}
builder.AppendFormat(
$"{DateTime.UtcNow:hh:mm:ss.fff} >>>> {header}: RawPacket {PacketDefinitionRegistry.Find(packet.Id).Name}, length = {packet.Length}");
builder.AppendLine();
bool justAppendedNewLine = true;
for (var i = 0; i < packet.Length; i++)
{
justAppendedNewLine = false;
builder.AppendFormat("0x{0:X2}, ", packet.Payload[i]);
if ((i + 1) % MaxColumns == 0)
{
builder.AppendLine();
justAppendedNewLine = true;
}
}
if (!justAppendedNewLine)
{
builder.AppendLine();
}
columns = 0;
requiresHeader = true;
}
public DialogBoxObservers(UltimaServer server, EventJournalSource eventJournalSource, PacketDefinitionRegistry packetRegistry)
{
this.server = server;
this.eventJournalSource = eventJournalSource;
this.packetRegistry = packetRegistry;
server.RegisterFilter(FilterServerPackets);
}
public UltimaServer(IServerPacketSubject packetSubject, Action <Packet> packetSender,
PacketDefinitionRegistry packetRegistry)
{
this.packetSubject = packetSubject;
this.packetSender = packetSender;
this.packetRegistry = packetRegistry;
}
public DiagnosticPacketReader(Stream inputStream, PacketDefinitionRegistry packetRegistry)
{
this.inputStream = inputStream;
this.packetRegistry = packetRegistry;
inputStreamReader = new BinaryReader(inputStream);
pullStream = new StreamToPullStreamAdapter(this.inputStream);
packetLogParser = new Parsers.PacketLogParser(packetRegistry);
}
public ItemObservers(IServerPacketSubject serverPacketSubject, IClientPacketSubject clientPacketSubject,
PacketDefinitionRegistry packetRegistry)
{
serverPacketSubject.Subscribe(PacketDefinitions.ObjectInfo, HandleObjectInfoPacket);
clientPacketSubject.RegisterOutputFilter(FilterSentClientPackets);
this.packetRegistry = packetRegistry;
}
public SpeechRequestObserver(IClientPacketSubject clientPacketSubject, CommandHandler commandHandler,
IEventJournalSource eventSource, ILogger logger, PacketDefinitionRegistry packetRegistry)
{
this.commandHandler = commandHandler;
this.eventSource = eventSource;
this.logger = logger;
this.packetRegistry = packetRegistry;
clientPacketSubject.RegisterFilter(FilterClientSpeech);
}
internal LightObserver(IServerPacketSubject serverPacketHandler, UltimaClient client, Player player, Legacy legacy,
PacketDefinitionRegistry packetRegistry)
{
this.client = client;
this.player = player;
this.legacy = legacy;
this.packetRegistry = packetRegistry;
serverPacketHandler.RegisterFilter(FilterBlockedServerPackets);
serverPacketHandler.Subscribe(PacketDefinitions.PersonalLightLevel, HandlePersonalLightLevelPacket);
}
public ServerObservers(UltimaServer server, IClientPacketSubject client, PacketDefinitionRegistry packetRegistry)
{
server.Subscribe(PacketDefinitions.ServerListing, HandleServerListing);
server.Subscribe(PacketDefinitions.GameServerList, HandleGameServerList);
server.RegisterFilter(HandleRunUOProtocolExtension);
client.Subscribe(PacketDefinitions.SelectServerRequest, HandleSelectServerRequest);
client.Subscribe(PacketDefinitions.LoginCharacter, HandleSelectLoginCharacterRequest);
this.packetRegistry = packetRegistry;
this.server = server;
}
private Packet?FilterSentClientPackets(Packet rawPacket)
{
if (rawPacket.Id == PacketDefinitions.RequestSkills.Id)
{
var packet = PacketDefinitionRegistry.Materialize <SkillRequest>(rawPacket);
lastSkill = packet.Skill;
}
return(rawPacket);
}
internal Phantoms(UltimaClient ultimaClient, IServerPacketSubject serverPacketSubject, PacketDefinitionRegistry packetRegistry)
{
this.ultimaClient = ultimaClient;
this.packetRegistry = packetRegistry;
var clientPacketSubject = (IClientPacketSubject)ultimaClient;
clientPacketSubject.RegisterFilter(PhantomsFilter);
serverPacketSubject.Subscribe(PacketDefinitions.DrawObject, HandleDrawObject);
}
private static int GetPacketLength(StreamPacketReader reader, int packetId)
{
PacketDefinition packetDefinition;
if (PacketDefinitionRegistry.TryFind(packetId, out packetDefinition))
{
return(packetDefinition.GetSize(reader));
}
throw new NotImplementedException($"Unknown packet type {packetId:X2}");
}
private static Packet?RedirectConnectToGameServer(Packet rawPacket)
{
if (rawPacket.Id == PacketDefinitions.ConnectToGameServer.Id)
{
var packet = PacketDefinitionRegistry.Materialize <ConnectToGameServerPacket>(rawPacket);
packet.GameServerIp = new byte[] { 0x7F, 0x00, 0x00, 0x01 };
packet.GameServerPort = proxyLocalPort;
rawPacket = packet.RawPacket;
needServerReconnect = true;
}
return(rawPacket);
}
private Packet?FilterClientTargetCursorPacket(Packet rawPacket)
{
if (rawPacket.Id != PacketDefinitions.TargetCursor.Id)
{
return(rawPacket);
}
var packet = PacketDefinitionRegistry.Materialize <TargetCursorPacket>(rawPacket);
if (discardNextTargetLocationRequestIfEmpty)
{
discardNextTargetLocationRequestIfEmpty = false;
if (packet.Location.X == 0xFFFF && packet.Location.Y == 0xFFFF &&
packet.ClickedOnId.Value == 0)
{
return(null);
}
}
if (packet.CursorId == new CursorId(0xDEADBEEF))
{
if (packet.Location.X == 0xFFFF && packet.Location.Y == 0xFFFF &&
packet.ClickedOnId.Value == 0)
{
lastTargetInfo = null;
lastItemIdInfo = null;
receivedTargetInfoEvent.Set();
return(null);
}
switch (packet.CursorTarget)
{
case CursorTarget.Location:
lastTargetInfo = new TargetInfo(packet.Location, TargetType.Tile, packet.ClickedOnType.Value,
null);
break;
case CursorTarget.Object:
lastTypeInfo = packet.ClickedOnType;
lastItemIdInfo = packet.ClickedOnId;
lastTargetInfo = new TargetInfo(packet.Location, TargetType.Object, packet.ClickedOnType,
packet.ClickedOnId);
break;
}
receivedTargetInfoEvent.Set();
return(null);
}
return(rawPacket);
}
private Packet?FilterBlockedServerPackets(Packet rawPacket)
{
if (rawPacket.Id == PacketDefinitions.OverallLightLevel.Id && enabled)
{
lastOverallLightLevelRawPacket = rawPacket.Clone();
var lastOverallLightLevelPacket =
PacketDefinitionRegistry.Materialize <OverallLightLevelPacket>(lastOverallLightLevelRawPacket
.Value);
this.player.LightLevel = lastOverallLightLevelPacket.Level;
return(CreateFullLightLevelPacket());
}
return(rawPacket);
}
public ServerConnection(ServerConnectionStatus status, IDiagnosticPullStream diagnosticPullStream,
IDiagnosticPushStream diagnosticPushStream, PacketDefinitionRegistry packetRegistry, EncryptionSetup encryptionSetup)
{
this.Status = status;
this.diagnosticPullStream = diagnosticPullStream;
this.diagnosticPushStream = diagnosticPushStream;
this.packetRegistry = packetRegistry;
this.encryptionSetup = encryptionSetup;
this.loginStream = new LoginPushStream();
this.receiveNewGameStream = new ServerNewGamePullStream();
this.sendNewGameStream = new ServerNewGamePushStream();
huffmanStream = new HuffmanStream(new PullStreamToStreamAdapter(receiveNewGameStream));
preLoginStream = new PullStreamToStreamAdapter(diagnosticPullStream);
}
public UltimaClientConnection(UltimaClientConnectionStatus status, IDiagnosticPullStream diagnosticPullStream,
IDiagnosticPushStream diagnosticPushStream, PacketDefinitionRegistry packetRegistry,
EncryptionSetup encryption, LoginEncryptionKey? configuedLoginEncryptionKey)
{
this.diagnosticPullStream = diagnosticPullStream;
this.diagnosticPushStream = diagnosticPushStream;
this.encryption = encryption;
this.configuedLoginEncryptionKey = configuedLoginEncryptionKey;
Status = status;
packetLogParser = new PacketLogParser(packetRegistry);
loginStream = new LoginPullStream();
loginStream.BaseStream = diagnosticPullStream;
receiveNewGameStream = new ClientNewGamePullStream();
receiveNewGameStream.BaseStream = diagnosticPullStream;
sendNewGameStream = new ClientNewGamePushStream();
}
public void Publish <TPacket>(Packet rawPacket) where TPacket : MaterializedPacket
{
ImmutableList <Delegate> observerList;
if (observers.TryGetValue(rawPacket.Id, out observerList))
{
var packet =
PacketDefinitionRegistry.Materialize <TPacket>(rawPacket);
foreach (var observer in observerList)
{
var observerAction = (Action <TPacket>)observer;
observerAction(packet);
}
}
}
private Packet?FilterServerPackets(Packet rawPacket)
{
if (rawPacket.Id == PacketDefinitions.OpenDialogBox.Id)
{
var packet = PacketDefinitionRegistry.Materialize <OpenDialogBoxPacket>(rawPacket);
var dialogBox = new DialogBox(packet.DialogId, packet.MenuId, packet.Question, packet.Responses);
CurrentDialogBox = dialogBox;
eventJournalSource.Publish(new DialogBoxOpenedEvent(dialogBox));
if (!ShowDialogBox)
{
return(null);
}
}
return(rawPacket);
}
private Packet?FilterGumpMenuSelection(Packet rawPacket)
{
if (rawPacket.Id == PacketDefinitions.GumpMenuSelection.Id && nextBlockedCancellationGumpId.HasValue)
{
lock (gumpLock)
{
var packet = PacketDefinitionRegistry.Materialize <GumpMenuSelectionRequest>(rawPacket);
var gumpId = nextBlockedCancellationGumpId.Value;
nextBlockedCancellationGumpId = null;
if (gumpId == packet.GumpTypeId)
{
return(null);
}
}
}
return(rawPacket);
}
public Targeting(UltimaServer server, UltimaClient client, Cancellation cancellation,
EventJournalSource eventSource, PacketDefinitionRegistry packetRegistry)
{
this.server = server;
this.client = client;
this.cancellation = cancellation;
this.eventSource = eventSource;
this.packetRegistry = packetRegistry;
server.Subscribe(PacketDefinitions.TargetCursor, HanldeServerTargetCursorPacket);
eventJournal = new EventJournal(eventSource, cancellation);
IClientPacketSubject clientPacketSubject = client;
clientPacketSubject.RegisterFilter(FilterClientTargetCursorPacket);
IServerPacketSubject serverPacketSubject = server;
serverPacketSubject.RegisterFilter(FilterSeverTargetCursorPacket);
}
private Packet?FilterSendGumpMenuDialog(Packet rawPacket)
{
if (rawPacket.Id == PacketDefinitions.GeneralInformationPacket.Id && rawPacket.Payload[4] == 4)
{
var packet = new CloseGenericGumpPacket();
packet.Deserialize(rawPacket);
eventSource.Publish(new ServerRequestedGumpCloseEvent(packet.GumpTypeId));
}
if (rawPacket.Id == PacketDefinitions.SendGumpMenuDialog.Id)
{
var nextGumpNotVisible = false;
lock (gumpLock)
{
var packet = PacketDefinitionRegistry.Materialize <SendGumpMenuDialogPacket>(rawPacket);
var gump = new Gump(packet.GumpId, packet.GumpTypeId, packet.Commands, packet.TextLines);
CurrentGump = gump;
eventSource.Publish(new GumpReceivedEvent(gump));
if (!showNextAwaitedGump)
{
currentGumpVisible = false;
nextGumpNotVisible = true;
showNextAwaitedGump = true;
}
else
{
currentGumpVisible = true;
}
}
gumpReceivedEvent.Set();
if (nextGumpNotVisible)
{
return(null);
}
}
return(rawPacket);
}
