public HChatRecordData(HMessage packet)
{
object ReadContextValue(HMessage anotherMessage)
{
switch (anotherMessage.ReadShort())
{
case 0: return(anotherMessage.ReadBoolean());
case 1: return(anotherMessage.ReadInt32());
case 2: return(anotherMessage.ReadUTF8());
default: throw new System.Exception("Nothing");
}
}
Type = (HChatRecordType)packet.ReadBytes(1)[0];
int entryCount = packet.ReadShort();
Context = new Dictionary <string, object>(entryCount);
for (int i = 0; i < entryCount; i++)
{
Context.Add(packet.ReadUTF8(), ReadContextValue(packet));
}
Chatlogs = new List <HChatlineData>(packet.ReadShort());
for (int i = 0; i < Chatlogs.Capacity; i++)
{
Chatlogs.Add(new HChatlineData(packet));
}
}
private async Task ReadMessageAsync()
{
HMessage readMessage = await _externalContractor
.ReceiveAsync().ConfigureAwait(false);
var destination = (HDestination)readMessage.Header;
HandleMessage(readMessage.ReadBytes(readMessage.Length - 2), destination);
}
private async Task ReceiveRemoteModuleDataAsync()
{
try
{
HMessage packet = await RemoteModule.ReceivePacketAsync().ConfigureAwait(false);
if (packet == null)
{
DataAwaiters.Values.ToList().ForEach(awaiter =>
{
if (awaiter != null)
{
awaiter.SetResult(null);
}
});
RemoteModule = null;
Task grabRemoteModuleTask =
GrabRemoteModuleAsync();
return;
}
var response = new HMessage(packet.Header);
#region Switch: packet.Header
switch (packet.Header)
{
default: response = null; break;
case 0:
{
response.WriteShort((ushort)Hotel);
break;
}
case 1:
{
response.WriteString(Game?.Location);
if (!string.IsNullOrWhiteSpace(Game?.Location))
{
response.WriteString(Path.GetFullPath("Hashes.ini"));
}
break;
}
case 2:
{
response.WriteString(GameData.Source);
break;
}
case 3:
{
response.WriteShort(Connection.Port);
response.WriteString(Connection.Host);
response.WriteString(Connection.Address);
break;
}
case 4:
{
if (Connection != null)
{
int dataLength = packet.ReadInteger();
byte[] data = packet.ReadBytes(dataLength);
await Connection.SendToClientAsync(
data).ConfigureAwait(false);
response = null;
}
break;
}
case 5:
{
if (Connection != null)
{
int dataLength = packet.ReadInteger();
byte[] data = packet.ReadBytes(dataLength);
await Connection.SendToServerAsync(
data).ConfigureAwait(false);
response = null;
}
break;
}
case 6:
case 7:
{
string stamp = packet.ReadString();
if (DataAwaiters.ContainsKey(stamp))
{
var destination = (HDestination)(packet.Header - 6);
int step = packet.ReadInteger();
bool isBlocked = packet.ReadBoolean();
int dataLength = packet.ReadInteger();
byte[] data = packet.ReadBytes(dataLength);
var interPacket = new HMessage(data, destination);
var args = new DataInterceptedEventArgs(interPacket, step, (destination == HDestination.Server));
args.IsBlocked = isBlocked;
DataAwaiters[stamp].SetResult(args);
response = null;
}
break;
}
}
#endregion
if (response != null)
{
await RemoteModule.SendPacketAsync(response).ConfigureAwait(false);
}
}
finally
{
if (RemoteModule != null)
{
Task receiveRemModuDataTask =
ReceiveRemoteModuleDataAsync();
}
}
}
private async Task ReceiveRemoteContractorDataAsync()
{
try
{
HMessage packet = await _remoteContractor.ReceivePacketAsync().ConfigureAwait(false);
if (packet == null)
{
Environment.Exit(0);
}
#region Switch: packet.Header
switch (packet.Header)
{
case 0:
{
_initStep++;
_hotel = (HHotel)packet.ReadShort();
break;
}
case 1:
{
_initStep++;
_in = new Incoming();
_out = new Outgoing();
string location = packet.ReadString();
if (!string.IsNullOrWhiteSpace(location))
{
_game = new HGame(location);
_game.Disassemble();
_game.GenerateMessageHashes();
if (packet.Readable > 0)
{
string hashesPath = packet.ReadString();
_in.Load(_game, hashesPath);
_out.Load(_game, hashesPath);
}
_module.ModifyGame(_game);
}
break;
}
case 2:
{
_initStep++;
_gameData = new HGameData(packet.ReadString());
_module.ModifyGameData(_gameData);
break;
}
case 3:
{
_initStep++;
var connection = (ContractorProxy)_connection;
connection.Port = packet.ReadShort();
connection.Host = packet.ReadString();
connection.Address = packet.ReadString();
break;
}
case 4:
case 5:
{
var destination = (HDestination)(packet.Header - 4);
string stamp = packet.ReadString();
int step = packet.ReadInteger();
bool isBlocked = packet.ReadBoolean();
int dataLength = packet.ReadInteger();
byte[] data = packet.ReadBytes(dataLength);
var interPacket = new HMessage(data, destination);
var args = new DataInterceptedEventArgs(interPacket, step, (destination == HDestination.Server));
try
{
if (destination == HDestination.Server)
{
_module.HandleOutgoing(args);
}
else
{
_module.HandleIncoming(args);
}
}
finally
{
await SendInterceptedDataResponseAsync(
stamp, args).ConfigureAwait(false);
}
break;
}
}
#endregion
if (_initStep == 4)
{
_initializationSource?.SetResult(true);
}
}
finally
{
Task receiveRemContDataTask = ReceiveRemoteContractorDataAsync();
}
}
public static void AppendPacketStructure(StringBuilder sb, HMessage packet, StructureType[] structure)
{
int originalPosition = packet.Position;
try
{
packet.Position = 0;
for (int i = 0; i < structure.Length; i++)
{
sb.Append(" ");
switch (structure[i])
{
case StructureType.Boolean:
sb.Append(packet.ReadBoolean() ? "true" : "false");
break;
case StructureType.Byte:
sb.Append($"b:{packet.ReadBytes(1)[0]}");
break;
case StructureType.Short:
sb.Append($"s:{(short)packet.ReadShort()}");
break;
case StructureType.Integer:
sb.Append($"{packet.ReadInteger()}");
break;
case StructureType.String:
sb.Append($"\"{EscapeString(packet.ReadString())}\"");
break;
case StructureType.ByteArray:
int len = packet.ReadInteger();
byte[] bytes = packet.ReadBytes(len);
sb.Append("a:[");
for (int j = 0; j < bytes.Length; j++)
{
if (j > 0)
{
sb.Append(" ");
}
sb.Append(bytes[j].ToString("x2"));
}
sb.Append("]");
break;
default:
throw new Exception($"Unknown/unsupported structure type: {structure[i]}");
}
}
if (packet.Readable > 0)
{
byte[] extra = packet.ReadBytes(packet.Readable);
sb.Append(" [");
for (int i = 0; i < extra.Length; i++)
{
if (i > 0)
{
sb.Append(" ");
}
sb.Append(extra[i].ToString("x2"));
}
sb.Append("]");
}
}
finally { packet.Position = originalPosition; }
}
