public override void OnPacket(NetworkClient client, ProcessedPacket packet)
{
var cmd = new VMNetCommand();
try {
using (var reader = new BinaryReader(packet)) {
cmd.Deserialize(reader);
}
} catch (Exception)
{
ClientsToDC.Add(client);
return;
}
if (cmd.Type == VMCommandType.SimJoin)
{
if (((VMNetSimJoinCmd)cmd.Command).Version != VMNetSimJoinCmd.CurVer)
{
ClientsToDC.Add(client);
return;
}
lock (UIDs)
{
UIDs.Add(client, ((VMNetSimJoinCmd)cmd.Command).SimID);
}
}
SendCommand(cmd.Command);
}
/// <summary>
/// Initial response from server to client.
/// </summary>
/// <param name="Client">A NetworkClient instance.</param>
/// <param name="Packet">A ProcessedPacket instance.</param>
public static void HandleServerChallenge(NetworkClient Client, ProcessedPacket Packet)
{
Console.WriteLine("Client receives encrypted data - test 2");
ServerPublicKey = Packet.ReadBytes(Packet.ReadByte());
byte[] EncryptedData = Packet.ReadBytes(Packet.ReadByte());
AESEncryptor Enc = (AESEncryptor)Client.ClientEncryptor;
Enc.PublicKey = ServerPublicKey;
Client.ClientEncryptor = Enc;
NetworkFacade.Client.ClientEncryptor = Enc;
ECDiffieHellmanCng PrivateKey = Client.ClientEncryptor.GetDecryptionArgsContainer().AESDecryptArgs.PrivateKey;
byte[] NOnce = Client.ClientEncryptor.GetDecryptionArgsContainer().AESDecryptArgs.NOnce;
byte[] ChallengeResponse = StaticStaticDiffieHellman.Decrypt(PrivateKey,
ECDiffieHellmanCngPublicKey.FromByteArray(ServerPublicKey, CngKeyBlobFormat.EccPublicBlob),
NOnce, EncryptedData);
MemoryStream StreamToEncrypt = new MemoryStream();
BinaryWriter Writer = new BinaryWriter(StreamToEncrypt);
Writer.Write((byte)ChallengeResponse.Length);
Writer.Write(ChallengeResponse, 0, ChallengeResponse.Length);
Writer.Write(Client.ClientEncryptor.Username);
Writer.Write((byte)PasswordHash.Length);
Writer.Write(PasswordHash);
Writer.Flush();
Client.SendEncrypted(0x03, StreamToEncrypt.ToArray());
Console.WriteLine("Test 2: passed!");
}
/// <summary>
/// Sends a CharacterCreate packet to a CityServer.
/// </summary>
/// <param name="LoginArgs">Arguments used to log onto the CityServer.</param>
/// <param name="Character">The character to create on the CityServer.</param>
public static void SendCharacterCreateCity(NetworkClient Client, UISim Character)
{
PacketStream Packet = new PacketStream((byte)PacketType.CHARACTER_CREATE_CITY, 0);
MemoryStream PacketData = new MemoryStream();
BinaryWriter Writer = new BinaryWriter(PacketData);
Writer.Write((byte)Client.ClientEncryptor.Username.Length);
Writer.Write(Encoding.ASCII.GetBytes(Client.ClientEncryptor.Username), 0,
Encoding.ASCII.GetBytes(Client.ClientEncryptor.Username).Length);
Writer.Write(PlayerAccount.CityToken);
Writer.Write(Character.Timestamp);
Writer.Write(Character.Name);
Writer.Write(Character.Sex);
Writer.Write(Character.Description);
Writer.Write((ulong)Character.HeadOutfitID);
Writer.Write((ulong)Character.BodyOutfitID);
Writer.Write((byte)Character.Avatar.Appearance);
Packet.WriteBytes(PacketData.ToArray());
Writer.Close();
Client.SendEncrypted((byte)PacketType.CHARACTER_CREATE_CITY, Packet.ToArray());
}
public static void OnLoginSuccessResponse(ref NetworkClient Client, ProcessedPacket Packet)
{
string CacheDir = GlobalSettings.Default.DocumentsPath + "CharacterCache\\" + PlayerAccount.Username;
if (!Directory.Exists(CacheDir))
{
Directory.CreateDirectory(CacheDir);
//The charactercache didn't exist, so send the Unix epoch, which is
//older than the server's stamp. This will cause the server to send the entire cache.
PacketSenders.SendCharacterInfoRequest(new DateTime(1970, 1, 1, 0, 0, 0, 0).ToString(CultureInfo.InvariantCulture));
}
else
{
if (!File.Exists(CacheDir + "\\Sims.cache"))
{
//The charactercache didn't exist, so send the Unix epoch, which is
//older than the server's stamp. This will cause the server to send the entire cache.
PacketSenders.SendCharacterInfoRequest(new DateTime(1970, 1, 1, 0, 0, 0, 0).ToString(CultureInfo.InvariantCulture));
}
else
{
string LastDateCached = Cache.GetDateCached();
if (LastDateCached == "")
PacketSenders.SendCharacterInfoRequest(new DateTime(1970, 1, 1, 0, 0, 0, 0).ToString(CultureInfo.InvariantCulture));
else
PacketSenders.SendCharacterInfoRequest(LastDateCached);
}
}
}
/// <summary>
/// Send information about this CityServer to the LoginServer...
/// </summary>
/// <param name="Client">The client connected to the LoginServer.</param>
public static void SendServerInfo(NetworkClient Client)
{
PacketStream Packet = new PacketStream(0x64, 0);
Packet.WriteByte(0x64);
MemoryStream PacketBody = new MemoryStream();
BinaryWriter PacketWriter = new BinaryWriter(PacketBody);
PacketWriter.Write((string)GlobalSettings.Default.CityName);
PacketWriter.Write((string)GlobalSettings.Default.CityDescription);
PacketWriter.Write((string)Settings.BINDING.Address.ToString());
PacketWriter.Write((int)Settings.BINDING.Port);
PacketWriter.Write((byte)1); //CityInfoStatus.OK
PacketWriter.Write((ulong)GlobalSettings.Default.CityThumbnail);
PacketWriter.Write((string)GlobalSettings.Default.ServerID);
PacketWriter.Write((ulong)GlobalSettings.Default.Map);
PacketWriter.Flush();
Packet.WriteUInt16((ushort)(PacketBody.ToArray().Length + PacketHeaders.UNENCRYPTED));
Packet.Write(PacketBody.ToArray(), 0, (int)PacketWriter.BaseStream.Length);
Packet.Flush();
PacketWriter.Close();
Client.Send(Packet.ToArray());
}
/// <summary>
/// A cityserver requested a decryptionkey for a client!
/// </summary>
public static void HandleKeyFetch(NetworkClient Client, ProcessedPacket P)
{
string AccountName = P.ReadString();
byte[] EncKey = new byte[1];
foreach (NetworkClient Cl in NetworkFacade.CServerListener.Clients)
{
if (Cl.ClientEncryptor.Username == AccountName)
{
EncKey = Cl.ClientEncryptor.GetDecryptionArgsContainer().ARC4DecryptArgs.EncryptionKey;
//TODO: Figure out what to do about CurrentlyActiveSim...
//if (Cl.CurrentlyActiveSim.CreatedThisSession)
{
//TODO: Update the DB to reflect the city that
// this sim resides in.
//Database.UpdateCityForCharacter(Cl.CurrentlyActiveSim.Name, Client.ServerInfo.Name);
}
}
}
PacketStream OutPacket = new PacketStream(0x01, 0x00);
OutPacket.WriteByte((byte)0x01);
OutPacket.WriteByte((byte)(EncKey.Length + 2));
OutPacket.WriteByte((byte)EncKey.Length);
OutPacket.Write(EncKey, 0, EncKey.Length);
Client.Send(OutPacket.ToArray());
//For now, assume client has already disconnected and doesn't need to be disconnected manually.
NetworkFacade.CServerListener.TransferringClients.Remove(Client);
}
public static void HandlePlayerOnlineResponse(NetworkClient Client, ProcessedPacket P)
{
byte Result = (byte)P.ReadByte();
string Token = P.ReadString();
//NOTE: Might have to find another way to identify a client, since two people
// can be on the same account from the same IP.
string RemoteIP = P.ReadString();
int RemotePort = P.ReadInt32();
PacketStream Packet;
NetworkClient FoundClient;
switch(Result)
{
case 0x01:
Packet = new PacketStream((byte)PacketType.REQUEST_CITY_TOKEN, 0);
Packet.WriteString(Token);
FoundClient = NetworkFacade.ClientListener.GetClient(RemoteIP, RemotePort);
if(FoundClient != null)
FoundClient.SendEncrypted((byte)PacketType.REQUEST_CITY_TOKEN, Packet.ToArray());
break;
case 0x02: //Write player was already online packet!
Packet = new PacketStream((byte)PacketType.PLAYER_ALREADY_ONLINE, 0);
Packet.WriteByte(0x00); //Dummy
FoundClient = NetworkFacade.ClientListener.GetClient(RemoteIP, RemotePort);
if (FoundClient != null)
FoundClient.SendEncrypted((byte)PacketType.PLAYER_ALREADY_ONLINE, Packet.ToArray());
break;
}
}
/// <summary>
/// Player (admin?) broadcast a letter.
/// </summary>
public static void HandleBroadcastLetter(NetworkClient Client, ProcessedPacket Packet)
{
string Subject = Packet.ReadString();
string Msg = Packet.ReadString();
NetworkFacade.CurrentSession.SendBroadcastLetter(Client, Subject, Msg);
}
public static void HandleLoginNotify(NetworkClient Client, ProcessedPacket Packet)
{
//Should this be stored for permanent access?
byte[] ServerPublicKey = Packet.ReadBytes(Packet.ReadByte());
byte[] EncryptedData = Packet.ReadBytes(Packet.ReadByte());
AESEncryptor Enc = (AESEncryptor)Client.ClientEncryptor;
Enc.PublicKey = ServerPublicKey;
Client.ClientEncryptor = Enc;
NetworkFacade.Client.ClientEncryptor = Enc;
ECDiffieHellmanCng PrivateKey = Client.ClientEncryptor.GetDecryptionArgsContainer().AESDecryptArgs.PrivateKey;
byte[] NOnce = Client.ClientEncryptor.GetDecryptionArgsContainer().AESDecryptArgs.NOnce;
byte[] ChallengeResponse = StaticStaticDiffieHellman.Decrypt(PrivateKey,
ECDiffieHellmanCngPublicKey.FromByteArray(ServerPublicKey, CngKeyBlobFormat.EccPublicBlob),
NOnce, EncryptedData);
MemoryStream StreamToEncrypt = new MemoryStream();
BinaryWriter Writer = new BinaryWriter(StreamToEncrypt);
Writer.Write((byte)ChallengeResponse.Length);
Writer.Write(ChallengeResponse, 0, ChallengeResponse.Length);
Writer.Write(Client.ClientEncryptor.Username);
Writer.Write((byte)PlayerAccount.Hash.Length);
Writer.Write(PlayerAccount.Hash);
Writer.Flush();
//Encrypt data using key and IV from server, hoping that it'll be decrypted correctly at the other end...
Client.SendEncrypted((byte)PacketType.CHALLENGE_RESPONSE, StreamToEncrypt.ToArray());
}
public static void HandleChallengeResponse(NetworkClient Client, ProcessedPacket P)
{
PacketStream OutPacket;
if (P.DecryptedSuccessfully)
{
int Length = P.ReadByte();
byte[] CResponse;
if (P.BufferLength >= Length)
CResponse = P.ReadBytes(Length);
else
{
//Authentication failed, so send this packet unencrypted.
OutPacket = new PacketStream((byte)PacketType.LOGIN_FAILURE_CITY, 0);
OutPacket.WriteHeader();
OutPacket.WriteUInt16((ushort)(PacketHeaders.UNENCRYPTED + 1));
OutPacket.WriteByte(0x03); //Bad challenge response.
Client.Send(OutPacket.ToArray());
Logger.LogInfo("Sent LOGIN_FAILURE_CITY!");
return;
}
AESDecryptionArgs DecryptionArgs = Client.ClientEncryptor.GetDecryptionArgsContainer().AESDecryptArgs;
if (DecryptionArgs.Challenge.SequenceEqual(CResponse))
{
OutPacket = new PacketStream((byte)PacketType.LOGIN_SUCCESS_CITY, 0);
OutPacket.WriteByte(0x01);
Client.SendEncrypted((byte)PacketType.LOGIN_SUCCESS_CITY, OutPacket.ToArray());
Logger.LogInfo("Sent LOGIN_SUCCESS_CITY!");
}
else
{
//Authentication failed, so send this packet unencrypted.
OutPacket = new PacketStream((byte)PacketType.LOGIN_FAILURE_CITY, 0);
OutPacket.WriteHeader();
OutPacket.WriteUInt16((ushort)(PacketHeaders.UNENCRYPTED + 1));
OutPacket.WriteByte(0x03); //Bad challenge response.
Client.Send(OutPacket.ToArray());
Logger.LogInfo("Sent LOGIN_FAILURE_CITY!");
}
}
else
{
//Authentication failed, so send this packet unencrypted.
OutPacket = new PacketStream((byte)PacketType.LOGIN_FAILURE_CITY, 0);
OutPacket.WriteHeader();
OutPacket.WriteUInt16((ushort)(PacketHeaders.UNENCRYPTED + 1));
OutPacket.WriteByte(0x03); //Bad challenge response.
Client.Send(OutPacket.ToArray());
Debug.WriteLine("HandleChallengeResponse - decryption failed!");
Logger.LogInfo("Sent LOGIN_FAILURE_CITY!");
}
}
/// <summary>
/// Requests a token from the LoginServer, that can be used to log into a CityServer.
/// </summary>
/// <param name="Client">A NetworkClient instance.</param>
public static void RequestCityToken(NetworkClient Client, UISim SelectedCharacter)
{
PacketStream Packet = new PacketStream((byte)PacketType.REQUEST_CITY_TOKEN, 0);
Packet.WriteString(Client.ClientEncryptor.Username);
Packet.WriteString(SelectedCharacter.ResidingCity.UUID);
Packet.WriteString(SelectedCharacter.GUID.ToString());
Client.SendEncrypted((byte)PacketType.REQUEST_CITY_TOKEN, Packet.ToArray());
}
public static void Handle(NetworkClient Client, ProcessedPacket stream)
{
byte ID = (byte)stream.ReadByte();
if (m_Handlers.ContainsKey(ID))
{
m_Handlers[ID].Handler(Client, stream);
}
}
public static void HandleClientToken(NetworkClient Client, ProcessedPacket P)
{
ClientToken Token = new ClientToken();
Token.ClientIP = P.ReadPascalString();
Token.CharacterGUID = P.ReadPascalString();
Token.Token = P.ReadPascalString();
NetworkFacade.TransferringClients.AddItem(Token);
}
public static void ReceivedUnEncryptedPacket(NetworkClient Client, PacketStream Packet)
{
//NOTE: Normally, the client would only send its username, and that would be
// used to lookup the password from the database.
string Password = Packet.ReadPascalString();
Console.WriteLine("Received password from client: " + Password);
//TODO: Client should be passed by ref?
//ClientEncryptor must be initialized in order to decrypt encrypted messages!
Client.ClientEncryptor = new ARC4Encryptor(Password);
}
public VMClientDriver(string hostName, int port, OnStateChangeDelegate callback)
{
Commands = new Queue<VMNetCommandBodyAbstract>();
Client = new NetworkClient(hostName, port, EncryptionMode.NoEncryption, true);
Client.OnConnected += Client_OnConnected;
Client.OnDisconnect += Client_OnDisconnect;
OnStateChange += callback;
Client.Connect(null);
TickBuffer = new Queue<VMNetTick>();
}
public static void OnChallengeRecieved(NetworkClient Client, ProcessedPacket Packet)
{
byte[] CResponse = Packet.ReadBytes(Packet.ReadByte());
if (CResponse.SequenceEqual(ChallengeResponse))
Console.WriteLine("Received correct challenge response, client was authenticated!");
else
Console.WriteLine("Received incorrect challenge response, client was NOT authenticated!");
string Username = Packet.ReadString();
Console.WriteLine("Username: " + Username);
byte[] PasswordHash = Packet.ReadBytes(Packet.ReadByte());
Client.Disconnect();
}
private VM VMHook; //should probably always backreference the VM anyways, but just used by disconnect
#endregion Fields
#region Constructors
public VMClientDriver(string hostName, int port, OnStateChangeDelegate callback)
{
Commands = new Queue<VMNetCommandBodyAbstract>();
Client = new NetworkClient(hostName, port, EncryptionMode.NoEncryption, true);
Client.OnConnected += Client_OnConnected;
Client.OnDisconnect += Client_OnDisconnect;
OnStateChange += callback;
Client.Connect(null);
GlobalLink = null; //transactions only performed by server. transaction results
//are passed back to the clients as commands (for the primitive, at least)
TickBuffer = new Queue<VMNetTick>();
}
public static void HandleClientToken(NetworkClient Client, ProcessedPacket P)
{
try
{
ClientToken Token = new ClientToken();
Token.AccountID = P.ReadInt32();
Token.ClientIP = P.ReadPascalString();
Token.CharacterGUID = P.ReadPascalString();
Token.Token = P.ReadPascalString();
NetworkFacade.TransferringClients.AddItem(Token);
}
catch (Exception E)
{
Logger.LogDebug("Exception in HandleClientToken: " + E.ToString());
}
}
/// <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!");
}
/// <summary>
/// A cityserver logged in!
/// </summary>
public static void HandleCityServerLogin(NetworkClient Client, ProcessedPacket P)
{
Logger.LogInfo("CityServer logged in!\r\n");
string Name = P.ReadString();
string Description = P.ReadString();
string IP = P.ReadString();
int Port = P.ReadInt32();
CityInfoStatus Status = (CityInfoStatus)P.ReadByte();
ulong Thumbnail = P.ReadUInt64();
string UUID = P.ReadString();
ulong Map = P.ReadUInt64();
CityInfo Info = new CityInfo(true);
Info.Name = Name;
Info.Description = Description;
Info.IP = IP;
Info.Port = Port;
Info.Status = Status;
Info.Thumbnail = Thumbnail;
Info.UUID = UUID;
Info.Map = Map;
Info.Client = Client;
Info.Online = true;
NetworkFacade.CServerListener.CityServers.Add(Info);
NetworkFacade.CServerListener.PotentialLogins.TryTake(out Client);
NetworkClient[] Clients = new NetworkClient[NetworkFacade.ClientListener.Clients.Count];
NetworkFacade.ClientListener.Clients.CopyTo(Clients, 0);
PacketStream ClientPacket = new PacketStream((byte)PacketType.NEW_CITY_SERVER, 0);
ClientPacket.WriteString(Name);
ClientPacket.WriteString(Description);
ClientPacket.WriteString(IP);
ClientPacket.WriteInt32(Port);
ClientPacket.WriteByte((byte)Status);
ClientPacket.WriteUInt64(Thumbnail);
ClientPacket.WriteString(UUID);
ClientPacket.WriteUInt64(Map);
foreach(NetworkClient Receiver in Clients)
Receiver.SendEncrypted((byte)PacketType.NEW_CITY_SERVER, ClientPacket.ToArray());
}
public Form1()
{
InitializeComponent();
bool FoundConfig = ConfigurationManager.LoadCityConfig();
Logger.Initialize("Log.txt");
Logger.WarnEnabled = true;
Logger.DebugEnabled = true;
GonzoNet.Logger.OnMessageLogged += new GonzoNet.MessageLoggedDelegate(Logger_OnMessageLogged);
CityDataModel.Logger.OnMessageLogged += new CityDataModel.MessageLoggedDelegate(Logger_OnMessageLogged);
ProtocolAbstractionLibraryD.Logger.OnMessageLogged += new ProtocolAbstractionLibraryD.MessageLoggedDelegate(Logger_OnMessageLogged);
if (!FoundConfig)
{
Logger.LogWarning("Couldn't find a ServerConfig.ini file!");
//TODO: This doesn't work...
Application.Exit();
}
//This has to happen for the static constructor to be called...
NetworkFacade m_NetworkFacade = new NetworkFacade();
var dbConnectionString = System.Configuration.ConfigurationManager.ConnectionStrings["MAIN_DB"];
DataAccess.ConnectionString = dbConnectionString.ConnectionString;
m_Listener = new Listener();
//m_Listener.OnReceiveEvent += new OnReceiveDelegate(m_Listener_OnReceiveEvent);
m_LoginClient = new NetworkClient("127.0.0.1", 2108);
m_LoginClient.OnNetworkError += new NetworkErrorDelegate(m_LoginClient_OnNetworkError);
m_LoginClient.OnConnected += new OnConnectedDelegate(m_LoginClient_OnConnected);
m_LoginClient.Connect(null);
//Send a pulse to the LoginServer every second.
m_PulseTimer = new System.Timers.Timer(1000);
m_PulseTimer.AutoReset = true;
m_PulseTimer.Elapsed += new ElapsedEventHandler(m_PulseTimer_Elapsed);
m_PulseTimer.Start();
m_Listener.Initialize(Settings.BINDING);
}
static NetworkFacade()
{
Client = new NetworkClient(GlobalSettings.Default.LoginServerIP, GlobalSettings.Default.LoginServerPort,
GonzoNet.Encryption.EncryptionMode.AESCrypto, true);
Client.OnConnected += new OnConnectedDelegate(UIPacketSenders.SendLoginRequest);
Controller = new NetworkController();
Controller.Init(Client);
RNGCryptoServiceProvider Random = new RNGCryptoServiceProvider();
ClientNOnce = new byte[16];
Random.GetNonZeroBytes(ClientNOnce);
//PacketHandlers.Init();
PacketHandlers.Register((byte)PacketType.LOGIN_NOTIFY, false, 0, new OnPacketReceive(Controller._OnLoginNotify));
PacketHandlers.Register((byte)PacketType.LOGIN_FAILURE, false, 0, new OnPacketReceive(Controller._OnLoginFailure));
PacketHandlers.Register((byte)PacketType.LOGIN_SUCCESS, true, 0, new OnPacketReceive(Controller._OnLoginSuccess));
PacketHandlers.Register((byte)PacketType.INVALID_VERSION, false, 2, new OnPacketReceive(Controller._OnInvalidVersion));
PacketHandlers.Register((byte)PacketType.CHARACTER_LIST, true, 0, new OnPacketReceive(Controller._OnCharacterList));
PacketHandlers.Register((byte)PacketType.CITY_LIST, true, 0, new OnPacketReceive(Controller._OnCityList));
PacketHandlers.Register((byte)PacketType.NEW_CITY_SERVER, true, 0, new OnPacketReceive(Controller._OnNewCity));
PacketHandlers.Register((byte)PacketType.CITY_SERVER_OFFLINE, true, 0, new OnPacketReceive(Controller._OnCityServerOffline));
PacketHandlers.Register((byte)PacketType.CHARACTER_CREATION_STATUS, true, 0, new OnPacketReceive(Controller._OnCharacterCreationProgress));
PacketHandlers.Register((byte)PacketType.RETIRE_CHARACTER_STATUS, true, 0, new OnPacketReceive(Controller._OnRetireCharacterStatus));
PacketHandlers.Register((byte)PacketType.LOGIN_NOTIFY_CITY, false, 0, new OnPacketReceive(Controller._OnLoginNotifyCity));
PacketHandlers.Register((byte)PacketType.LOGIN_SUCCESS_CITY, true, 0, new OnPacketReceive(Controller._OnLoginSuccessCity));
PacketHandlers.Register((byte)PacketType.LOGIN_FAILURE_CITY, false, 0, new OnPacketReceive(Controller._OnLoginFailureCity));
PacketHandlers.Register((byte)PacketType.CHARACTER_CREATE_CITY, true, 0, new OnPacketReceive(Controller._OnCharacterCreationStatus));
PacketHandlers.Register((byte)PacketType.REQUEST_CITY_TOKEN, true, 0, new OnPacketReceive(Controller._OnCityToken));
PacketHandlers.Register((byte)PacketType.CITY_TOKEN, true, 0, new OnPacketReceive(Controller._OnCityTokenResponse));
PacketHandlers.Register((byte)PacketType.PLAYER_JOINED_SESSION, true, 0, new OnPacketReceive(Controller._OnPlayerJoinedSession));
PacketHandlers.Register((byte)PacketType.PLAYER_LEFT_SESSION, true, 0, new OnPacketReceive(Controller._OnPlayerLeftSession));
PacketHandlers.Register((byte)PacketType.PLAYER_RECV_LETTER, true, 0, new OnPacketReceive(Controller._OnPlayerRecvdLetter));
PacketHandlers.Register((byte)PacketType.PLAYER_ALREADY_ONLINE, true, 0, new OnPacketReceive(Controller._OnPlayerAlreadyOnline));
PacketHandlers.Register((byte)PacketType.TIME_OF_DAY, true, 0, new OnPacketReceive(Controller._OnTimeOfDay));
PacketHandlers.Register((byte)PacketType.LOT_COST, true, 0, new OnPacketReceive(Controller._OnLotCost));
PacketHandlers.Register((byte)PacketType.LOT_UNBUILDABLE, true, 0, new OnPacketReceive(Controller._OnLotUnbuildable));
PacketHandlers.Register((byte)PacketType.LOT_PURCHASE_FAILED, true, 0, new OnPacketReceive(Controller._OnLotBuyFailed));
PacketHandlers.Register((byte)PacketType.LOT_PURCHASE_SUCCESSFUL, true, 0, new OnPacketReceive(Controller._OnLotPurchaseSuccessful));
PacketHandlers.Register((byte)PacketType.LOT_NAME_TOO_LONG, true, 0, new OnPacketReceive(Controller._OnLotNameTooLong));
PacketHandlers.Register((byte)PacketType.VM_PACKET, false, 0, new OnPacketReceive(UIPacketHandlers.OnVMPacket));
}
/// <summary>
/// Adds a player to the current session.
/// </summary>
/// <param name="Client">The player's client.</param>
/// <param name="Char">The player's character.</param>
public void AddPlayer(NetworkClient Client, Character Char)
{
lock (m_PlayingCharacters)
{
foreach (KeyValuePair<NetworkClient, Character> KVP in m_PlayingCharacters)
{
SendPlayerJoinSession(KVP.Key, Char);
//Send a bunch of these in reverse (to the player joining the session).
SendPlayerJoinSession(Client, KVP.Value);
m_PlayingCharacters.TryAdd(KVP.Key, KVP.Value);
}
}
m_PlayingCharacters.TryAdd(Client, Char);
if (Char.HouseHouse != null)
m_Houses.TryAdd(Char, Char.HouseHouse);
}
/// <summary>
/// Received CharacterCreation packet from LoginServer.
/// </summary>
/// <returns>The result of the character creation.</returns>
public static CharacterCreationStatus OnCharacterCreationProgress(NetworkClient Client, ProcessedPacket Packet)
{
CharacterCreationStatus CCStatus = (CharacterCreationStatus)Packet.ReadByte();
if (CCStatus == CharacterCreationStatus.Success)
{
Guid CharacterGUID = Guid.NewGuid();
CharacterGUID = new Guid(Packet.ReadString());
PlayerAccount.CityToken = Packet.ReadString();
PlayerAccount.CurrentlyActiveSim.AssignGUID(CharacterGUID.ToString());
//This previously happened when clicking the accept button in CAS, causing
//all chars to be cached even if the new char wasn't successfully created.
lock(NetworkFacade.Avatars)
Cache.CacheSims(NetworkFacade.Avatars);
}
return CCStatus;
}
public override void OnPacket(NetworkClient client, ProcessedPacket packet)
{
lock (TickBuffer)
{
var tick = new VMNetTickList();
try {
using (var reader = new BinaryReader(packet))
{
tick.Deserialize(reader);
}
} catch (Exception)
{
client.Disconnect();
return;
}
for (int i = 0; i < tick.Ticks.Count; i++)
{
TickBuffer.Enqueue(tick.Ticks[i]);
}
}
}
/// <summary>
/// A cityserver logged in!
/// </summary>
public static void HandleCityServerLogin(NetworkClient Client, ProcessedPacket P)
{
CityServerClient CityClient = (CityServerClient)Client;
Logger.LogInfo("CityServer logged in!\r\n");
string Name = P.ReadString();
string Description = P.ReadString();
string IP = P.ReadString();
int Port = P.ReadInt32();
CityInfoStatus Status = (CityInfoStatus)P.ReadByte();
ulong Thumbnail = P.ReadUInt64();
string UUID = P.ReadString();
ulong Map = P.ReadUInt64();
CityInfo Info = new CityInfo(Name, Description, Thumbnail, UUID, Map, IP, Port);
Info.Status = Status;
CityClient.ServerInfo = Info;
//Client instance changed, so update it...
NetworkFacade.CServerListener.UpdateClient(CityClient);
}
//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>
/// Received CharacterCreation packet from CityServer.
/// </summary>
/// <returns>The result of the character creation.</returns>
public static CharacterCreationStatus OnCharacterCreationStatus(NetworkClient Client, ProcessedPacket Packet)
{
LogThis.Log.LogThis("Received OnCharacterCreationStatus!", LogThis.eloglevel.info);
CharacterCreationStatus CCStatus = (CharacterCreationStatus)Packet.ReadByte();
ushort NumHouses = Packet.ReadUInt16();
LotTileEntry[] TileEntries = new LotTileEntry[NumHouses];
if (NumHouses > 0)
{
for (int i = 0; i < NumHouses; i++)
{
TileEntries[i] = new LotTileEntry(Packet.ReadInt32(), Packet.ReadString(), (short)Packet.ReadUInt16(),
(short)Packet.ReadUInt16(), (byte)Packet.ReadByte(), Packet.ReadInt32());
}
}
lock(GameFacade.CDataRetriever.LotTileData)
GameFacade.CDataRetriever.LotTileData = TileEntries;
return CCStatus;
}
/// <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());
}
/// <summary>
/// Reroute to a VM, eventually these will be ID'd
/// </summary>
public static void OnVMPacket(NetworkClient Client, ProcessedPacket Packet)
{
if (NetworkFacade.VMs.Count > 0)
{
NetworkFacade.VMs[0].OnPacket(Client, Packet);
}
}