| public WriteByte ( byte Value ) : void | ||
| Value | byte | The byte to write. |
| return | void | |
/// <summary>
/// Ticks the VM one step.
/// Should be called once every loop.
/// </summary>
public void Tick()
{
foreach (VirtualThread Thread in m_Threads)
{
Thread.Tick();
}
m_TickCounter++;
if (m_TickCounter == 4)
{
//TODO: Change ID...
PacketStream SimulationStatePacket = new PacketStream(0x10, 0x00);
SimulationStatePacket.WriteByte(0x10); //TODO: Change ID
SimulationStatePacket.WriteByte((byte)m_TickCounter); //Number of ticks since last update.
SimulationStatePacket.WriteInt32(m_Threads.Count); //Number of objects in this VM.
BinaryFormatter BinFormatter = new BinaryFormatter();
foreach (VirtualThread VThread in m_Threads)
BinFormatter.Serialize(SimulationStatePacket, VThread);
//TODO: Compress packet...
NewSimulationStateEvent(SimulationStatePacket);
m_TickCounter = 0;
}
}
/// <summary>
/// A client requested login.
/// </summary>
/// <param name="Client">NetworkClient instance.</param>
/// <param name="Packet">ProcessedPacket instance.</param>
public static void InitialClientConnect(NetworkClient Client, ProcessedPacket Packet)
{
Console.WriteLine("Server receives data - test 1");
PacketStream EncryptedPacket = new PacketStream(0x02, 0);
EncryptedPacket.WriteHeader();
ClientPublicKey = Packet.ReadBytes((Packet.ReadByte()));
AESEncryptor Enc = (AESEncryptor)Client.ClientEncryptor;
Enc.NOnce = Packet.ReadBytes((Packet.ReadByte()));
Enc.PublicKey = ClientPublicKey;
Enc.PrivateKey = ServerPrivateKey;
Client.ClientEncryptor = Enc;
//THIS IS IMPORTANT - public key must be derived from private!
ServerPublicKey = ServerPrivateKey.PublicKey.ToByteArray();
ChallengeResponse = new byte[16];
m_Random.GetNonZeroBytes(ChallengeResponse);
MemoryStream StreamToEncrypt = new MemoryStream();
BinaryWriter Writer = new BinaryWriter(StreamToEncrypt);
Writer.Write(ChallengeResponse, 0, ChallengeResponse.Length);
Writer.Flush();
byte[] EncryptedData = StaticStaticDiffieHellman.Encrypt(ServerPrivateKey,
ECDiffieHellmanCngPublicKey.FromByteArray(ClientPublicKey, CngKeyBlobFormat.EccPublicBlob), Enc.NOnce,
StreamToEncrypt.ToArray());
EncryptedPacket.WriteUInt16((ushort)(PacketHeaders.UNENCRYPTED +
(1 + ServerPublicKey.Length) +
(1 + EncryptedData.Length)));
EncryptedPacket.WriteByte((byte)ServerPublicKey.Length);
EncryptedPacket.WriteBytes(ServerPublicKey);
EncryptedPacket.WriteByte((byte)EncryptedData.Length);
EncryptedPacket.WriteBytes(EncryptedData);
Client.Send(EncryptedPacket.ToArray());
NetworkFacade.Listener.UpdateClient(Client);
Console.WriteLine("Test 1: passed!");
}
//First packet sent from client to server.
public static void SendInitialConnectPacket(NetworkClient Client, string Username)
{
PacketStream InitialPacket = new PacketStream(0x01, 0);
InitialPacket.WriteHeader();
ECDiffieHellmanCng PrivateKey = Client.ClientEncryptor.GetDecryptionArgsContainer().AESDecryptArgs.PrivateKey;
//IMPORTANT: Public key must derive from the private key!
PacketHandlers.ClientPublicKey = PrivateKey.PublicKey.ToByteArray();
byte[] NOnce = Client.ClientEncryptor.GetDecryptionArgsContainer().AESDecryptArgs.NOnce;
InitialPacket.WriteUInt16((ushort)((byte)PacketHeaders.UNENCRYPTED +
(PacketHandlers.ClientPublicKey.Length + 1) + (NOnce.Length + 1)));
InitialPacket.WriteByte((byte)PacketHandlers.ClientPublicKey.Length);
InitialPacket.WriteBytes(PacketHandlers.ClientPublicKey);
InitialPacket.WriteByte((byte)NOnce.Length);
InitialPacket.WriteBytes(NOnce);
Client.Send(InitialPacket.ToArray());
}
/// <summary>
/// Sends a CharacterCreate packet to the LoginServer.
/// </summary>
/// <param name="Character">The character to create.</param>
/// <param name="TimeStamp">The timestamp of when this character was created.</param>
public static void SendCharacterCreate(UISim Character, string TimeStamp)
{
PacketStream Packet = new PacketStream((byte)PacketType.CHARACTER_CREATE, 0);
Packet.WriteString(NetworkFacade.Client.ClientEncryptor.Username);
Packet.WriteString(TimeStamp);
Packet.WriteString(Character.Name);
Packet.WriteString(Character.Sex);
Packet.WriteString(Character.Description);
Packet.WriteUInt64(Character.HeadOutfitID);
Packet.WriteUInt64(Character.BodyOutfitID);
Packet.WriteByte((byte)Character.Avatar.Appearance);
Packet.WriteString(Character.ResidingCity.Name);
Packet.WriteUInt64(Character.ResidingCity.Thumbnail);
Packet.WriteString(Character.ResidingCity.UUID);
Packet.WriteUInt64(Character.ResidingCity.Map);
Packet.WriteString(Character.ResidingCity.IP);
Packet.WriteInt32(Character.ResidingCity.Port);
byte[] PacketData = Packet.ToArray();
NetworkFacade.Client.SendEncrypted((byte)PacketType.CHARACTER_CREATE, PacketData);
}
/// <summary>
/// LoginServer sent information about the player's characters.
/// </summary>
/// <param name="Packet">The packet that was received.</param>
public static void OnCharacterInfoResponse(ProcessedPacket Packet, NetworkClient Client)
{
byte NumCharacters = (byte)Packet.ReadByte();
byte NewCharacters = (byte)Packet.ReadByte();
List<UISim> FreshSims = new List<UISim>();
for (int i = 0; i < NewCharacters; i++)
{
int CharacterID = Packet.ReadInt32();
UISim FreshSim = new UISim(Packet.ReadString(), false);
FreshSim.CharacterID = CharacterID;
FreshSim.Timestamp = Packet.ReadString();
FreshSim.Name = Packet.ReadString();
FreshSim.Sex = Packet.ReadString();
FreshSim.Description = Packet.ReadString();
FreshSim.HeadOutfitID = Packet.ReadUInt64();
FreshSim.BodyOutfitID = Packet.ReadUInt64();
FreshSim.Avatar.Appearance = (AppearanceType)Packet.ReadByte();
FreshSim.ResidingCity = new CityInfo(false);
FreshSim.ResidingCity.Name = Packet.ReadString();
FreshSim.ResidingCity.Thumbnail = Packet.ReadUInt64();
FreshSim.ResidingCity.UUID = Packet.ReadString();
FreshSim.ResidingCity.Map = Packet.ReadUInt64();
FreshSim.ResidingCity.IP = Packet.ReadString();
FreshSim.ResidingCity.Port = Packet.ReadInt32();
FreshSims.Add(FreshSim);
}
lock (NetworkFacade.Avatars)
{
if ((NumCharacters < 3) && (NewCharacters > 0))
{
FreshSims = Cache.LoadCachedSims(FreshSims);
NetworkFacade.Avatars = FreshSims;
Cache.CacheSims(FreshSims);
}
if (NewCharacters == 0 && NumCharacters > 0)
NetworkFacade.Avatars = Cache.LoadAllSims();
else if (NewCharacters == 3 && NumCharacters == 3)
{
NetworkFacade.Avatars = FreshSims;
Cache.CacheSims(FreshSims);
}
else if (NewCharacters == 0 && NumCharacters == 0)
{
//Make sure if sims existed in the cache, they are deleted (because they didn't exist in DB).
Cache.DeleteCache();
}
else if (NumCharacters == 3 && NewCharacters == 3)
{
NetworkFacade.Avatars = FreshSims;
}
}
PacketStream CityInfoRequest = new PacketStream(0x06, 0);
CityInfoRequest.WriteByte(0x00); //Dummy
Client.SendEncrypted((byte)PacketType.CITY_LIST, CityInfoRequest.ToArray());
}
protected virtual void ReceiveCallback(IAsyncResult AR)
{
Socket Sock = (Socket)AR.AsyncState;
int NumBytesRead = 0;
try {
NumBytesRead = Sock.EndReceive(AR);
}
catch (SocketException)
{
Disconnect();
return;
}
if (NumBytesRead == 0)
{
return;
}
byte[] TmpBuf = new byte[NumBytesRead];
Buffer.BlockCopy(m_RecvBuf, 0, TmpBuf, 0, NumBytesRead);
int Offset = 0;
while (Offset < NumBytesRead)
{
if (m_TempPacket == null)
{
byte ID = TmpBuf[Offset++];
PacketStream TempPacket = new PacketStream(ID, 0);
TempPacket.WriteByte(ID);
m_HeaderBuild = new List <byte>();
while (Offset < NumBytesRead && m_HeaderBuild.Count < 4)
{
m_HeaderBuild.Add(TmpBuf[Offset++]);
}
if (m_HeaderBuild.Count < 4)
{
m_TempPacket = TempPacket;
//length got fragmented.
}
else
{
int Length = BitConverter.ToInt32(m_HeaderBuild.ToArray(), 0);
TempPacket.SetLength(Length);
TempPacket.WriteInt32(Length);
m_HeaderBuild = null;
byte[] TmpBuffer = new byte[Math.Min(NumBytesRead - Offset, TempPacket.Length - TempPacket.BufferLength)];
Buffer.BlockCopy(TmpBuf, Offset, TmpBuffer, 0, TmpBuffer.Length);
Offset += TmpBuffer.Length;
TempPacket.WriteBytes(TmpBuffer);
m_TempPacket = TempPacket;
}
}
else //fragmented, continue from last
{
if (m_HeaderBuild != null)
{
//we can safely assume that resuming from a fragmented length, it cannot get fragmented again.
while (m_HeaderBuild.Count < 4)
{
m_HeaderBuild.Add(TmpBuf[Offset++]);
}
int Length = BitConverter.ToInt32(m_HeaderBuild.ToArray(), 0);
m_TempPacket.SetLength(Length);
m_TempPacket.WriteInt32(Length);
m_HeaderBuild = null;
}
byte[] TmpBuffer = new byte[Math.Min(NumBytesRead - Offset, m_TempPacket.Length - m_TempPacket.BufferLength)];
Buffer.BlockCopy(TmpBuf, Offset, TmpBuffer, 0, TmpBuffer.Length);
Offset += TmpBuffer.Length;
m_TempPacket.WriteBytes(TmpBuffer);
}
if (m_TempPacket != null && m_TempPacket.BufferLength == m_TempPacket.Length)
{
var handler = FindPacketHandler(m_TempPacket.PacketID);
if (handler != null)
{
OnPacket(new ProcessedPacket(m_TempPacket.PacketID, handler.Encrypted,
handler.VariableLength, (int)m_TempPacket.Length, m_ClientEncryptor, m_TempPacket.ToArray()), handler);
}
m_TempPacket = null;
}
}
try
{
m_Sock.BeginReceive(m_RecvBuf, 0, m_RecvBuf.Length, SocketFlags.None,
new AsyncCallback(ReceiveCallback), m_Sock);
}
catch (SocketException)
{
Disconnect();
return;
}
}
protected virtual void ReceiveCallback(IAsyncResult AR)
{
Socket Sock = (Socket)AR.AsyncState;
int NumBytesRead = 0;
try {
NumBytesRead = Sock.EndReceive(AR);
}
catch (SocketException)
{
Disconnect();
return;
}
if (NumBytesRead == 0)
{
Disconnect();
return;
}
byte[] TmpBuf = new byte[NumBytesRead];
Buffer.BlockCopy(m_RecvBuf, 0, TmpBuf, 0, NumBytesRead);
int Offset = 0;
while (Offset < NumBytesRead)
{
if (m_TempPacket == null)
{
byte ID = TmpBuf[Offset++];
PacketStream TempPacket = new PacketStream(ID, 0);
TempPacket.WriteByte(ID);
m_HeaderBuild = new List<byte>();
while (Offset < NumBytesRead && m_HeaderBuild.Count < 4)
{
m_HeaderBuild.Add(TmpBuf[Offset++]);
}
if (m_HeaderBuild.Count < 4)
{
m_TempPacket = TempPacket;
//length got fragmented.
} else
{
int Length = BitConverter.ToInt32(m_HeaderBuild.ToArray(), 0);
TempPacket.SetLength(Length);
TempPacket.WriteInt32(Length);
m_HeaderBuild = null;
byte[] TmpBuffer = new byte[Math.Min(NumBytesRead - Offset, TempPacket.Length-TempPacket.BufferLength)];
Buffer.BlockCopy(TmpBuf, Offset, TmpBuffer, 0, TmpBuffer.Length);
Offset += TmpBuffer.Length;
TempPacket.WriteBytes(TmpBuffer);
m_TempPacket = TempPacket;
}
}
else //fragmented, continue from last
{
if (m_HeaderBuild != null)
{
//we can safely assume that resuming from a fragmented length, it cannot get fragmented again.
while (m_HeaderBuild.Count < 4)
{
m_HeaderBuild.Add(TmpBuf[Offset++]);
}
int Length = BitConverter.ToInt32(m_HeaderBuild.ToArray(), 0);
m_TempPacket.SetLength(Length);
m_TempPacket.WriteInt32(Length);
m_HeaderBuild = null;
}
byte[] TmpBuffer = new byte[Math.Min(NumBytesRead - Offset, m_TempPacket.Length - m_TempPacket.BufferLength)];
Buffer.BlockCopy(TmpBuf, Offset, TmpBuffer, 0, TmpBuffer.Length);
Offset += TmpBuffer.Length;
m_TempPacket.WriteBytes(TmpBuffer);
}
if (m_TempPacket != null && m_TempPacket.BufferLength == m_TempPacket.Length)
{
var handler = FindPacketHandler(m_TempPacket.PacketID);
if (handler != null)
{
OnPacket(new ProcessedPacket(m_TempPacket.PacketID, handler.Encrypted,
handler.VariableLength, (int)m_TempPacket.Length, m_ClientEncryptor, m_TempPacket.ToArray()), handler);
}
m_TempPacket = null;
}
}
try
{
m_Sock.BeginReceive(m_RecvBuf, 0, m_RecvBuf.Length, SocketFlags.None,
new AsyncCallback(ReceiveCallback), m_Sock);
}
catch (SocketException)
{
Disconnect();
return;
}
}
public static void SendLoginRequestCity(LoginArgsContainer Args)
{
PacketStream Packet = new PacketStream((byte)PacketType.LOGIN_REQUEST_CITY, 0);
Packet.WriteHeader();
//ECDiffieHellmanCng PrivateKey = Args.Client.ClientEncryptor.GetDecryptionArgsContainer()
// .AESDecryptArgs.PrivateKey;
//IMPORTANT: Public key must derive from the private key!
//byte[] ClientPublicKey = PrivateKey.PublicKey.ToByteArray();
byte[] NOnce = Args.Client.ClientEncryptor.GetDecryptionArgsContainer().AESDecryptArgs.NOnce;
//Packet.WriteInt32(((byte)PacketHeaders.UNENCRYPTED +
// (ClientPublicKey.Length + 1) + (NOnce.Length + 1)));
//Packet.WriteByte((byte)ClientPublicKey.Length);
//Packet.WriteBytes(ClientPublicKey);
Packet.WriteByte((byte)NOnce.Length);
Packet.WriteBytes(NOnce);
Args.Client.Send(Packet.ToArray());
}
public static void SendLoginRequest(LoginArgsContainer Args)
{
PacketStream InitialPacket = new PacketStream((byte)PacketType.LOGIN_REQUEST, 0);
InitialPacket.WriteHeader();
//ECDiffieHellmanCng PrivateKey = Args.Client.ClientEncryptor.GetDecryptionArgsContainer()
// .AESDecryptArgs.PrivateKey;
//IMPORTANT: Public key must derive from the private key!
//byte[] ClientPublicKey = PrivateKey.PublicKey.ToByteArray();
byte[] NOnce = Args.Client.ClientEncryptor.GetDecryptionArgsContainer().AESDecryptArgs.NOnce;
//InitialPacket.WriteInt32(((byte)PacketHeaders.UNENCRYPTED +
// /*4 is for version*/ 4 + (ClientPublicKey.Length + 1) + (NOnce.Length + 1)));
SaltedHash Hash = new SaltedHash(new SHA512Managed(), Args.Username.Length);
byte[] HashBuf = Hash.ComputePasswordHash(Args.Username, Args.Password);
PlayerAccount.Hash = HashBuf;
string[] Version = GlobalSettings.Default.ClientVersion.Split('.');
InitialPacket.WriteByte((byte)int.Parse(Version[0])); //Version 1
InitialPacket.WriteByte((byte)int.Parse(Version[1])); //Version 2
InitialPacket.WriteByte((byte)int.Parse(Version[2])); //Version 3
InitialPacket.WriteByte((byte)int.Parse(Version[3])); //Version 4
//InitialPacket.WriteByte((byte)ClientPublicKey.Length);
//InitialPacket.WriteBytes(ClientPublicKey);
InitialPacket.WriteByte((byte)NOnce.Length);
InitialPacket.WriteBytes(NOnce);
Args.Client.Send(InitialPacket.ToArray());
}
