public static void OnCharacterCreationStatus(NetworkClient Client, ProcessedPacket Packet)
{
CharacterCreationStatus CCStatus = (CharacterCreationStatus)Packet.ReadByte();
switch (CCStatus)
{
case CharacterCreationStatus.Success:
Guid CharacterGUID = new Guid();
//CityToken didn't exist, so transition to CityServer hasn't happened yet.
if (PlayerAccount.CityToken == "")
{
CharacterGUID = new Guid(Packet.ReadPascalString());
PlayerAccount.CityToken = Packet.ReadPascalString();
}
NetworkFacade.Controller._OnCharacterCreationStatus(CCStatus);
if(PlayerAccount.CityToken == "")
PlayerAccount.CurrentlyActiveSim.AssignGUID(CharacterGUID.ToString());
break;
case CharacterCreationStatus.ExceededCharacterLimit:
NetworkFacade.Controller._OnCharacterCreationStatus(CCStatus);
break;
case CharacterCreationStatus.NameAlreadyExisted:
NetworkFacade.Controller._OnCharacterCreationStatus(CCStatus);
break;
case CharacterCreationStatus.GeneralError:
NetworkFacade.Controller._OnCharacterCreationStatus(CCStatus);
break;
default:
break;
}
}
/// <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);
}
/// <summary>
/// Received a list of available cities from the login server.
/// </summary>
public void _OnCityList(NetworkClient Client, ProcessedPacket packet)
{
if (OnLoginProgress != null)
{
if (OnLoginStatus != null)
{
UIPacketHandlers.OnCityInfoResponse(packet);
OnLoginProgress(new ProgressEvent(EventCodes.PROGRESS_UPDATE)
{
Done = 5, Total = 5
});
OnLoginStatus(new LoginEvent(EventCodes.LOGIN_RESULT)
{
Success = true
});
}
else
{
//TODO: Error handling...
}
}
else
{
//TODO: Error handling...
}
}
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>
/// Received from the CityServer in response to a CITY_TOKEN packet.
/// </summary>
public static CityTransferStatus OnCityTokenResponse(NetworkClient Client, ProcessedPacket Packet)
{
Debug.WriteLine("Received OnCityTokenResponse");
CityTransferStatus Status = (CityTransferStatus)Packet.ReadByte();
return(Status);
}
public void _OnCityServerOffline(NetworkClient Client, ProcessedPacket Packet)
{
UIPacketHandlers.OnCityServerOffline(Client, Packet);
if (OnCityServerOffline != null)
{
OnCityServerOffline();
}
}
/// <summary>
/// A lot was deemed unbuildable/unpurchasable by city server.
/// </summary>
public void _OnLotUnbuildable(NetworkClient Client, ProcessedPacket Packet)
{
if (OnLotUnbuildable != null)
{
OnLotUnbuildable();
}
else
{
//TODO: Error handling...
}
}
public static LotTileEntry OnLotCostResponse(NetworkClient Client, ProcessedPacket Packet)
{
ushort X = Packet.ReadUInt16();
ushort Y = Packet.ReadUInt16();
int LotID = Packet.ReadInt32();
string LotName = Packet.ReadString();
//bit 0 = online, bit 1 = spotlight, bit 2 = locked, bit 3 = occupied, other bits free for whatever use
byte Flags = (byte)Packet.ReadByte();
int Cost = Packet.ReadInt32();
return(new LotTileEntry(LotID, LotName, (short)X, (short)Y, Flags, Cost));
}
public void _OnPlayerJoinedSession(NetworkClient Client, ProcessedPacket Packet)
{
LotTileEntry TileEntry = UIPacketHandlers.OnPlayerJoinedSession(Client, Packet);
if (TileEntry.lotid != 0)
{
if (OnPlayerJoined != null)
{
OnPlayerJoined(TileEntry);
}
}
}
public static void OnLotPurchaseFailed(NetworkClient Client, ProcessedPacket Packet)
{
EventObject Event;
switch (Packet.ReadByte())
{
case 0x00:
Event = new EventObject(EventCodes.TRANSACTION_RESULT);
EventSink.RegisterEvent(Event);
break;
}
}
/// <summary>
/// Received token from login server.
/// </summary>
public void _OnCityToken(NetworkClient Client, ProcessedPacket Packet)
{
if (OnCityToken != null)
{
UIPacketHandlers.OnCityToken(Client, Packet);
OnCityToken(PlayerAccount.CurrentlyActiveSim.ResidingCity);
}
else
{
//TODO: Error handling...
}
}
public void _OnLoginNotifyCity(NetworkClient Client, ProcessedPacket packet)
{
if (OnLoginNotifyCity != null)
{
UIPacketHandlers.OnLoginNotifyCity(Client, packet);
OnLoginNotifyCity();
}
else
{
//TODO: Error handling...
}
}
public void _OnRetireCharacterStatus(NetworkClient Client, ProcessedPacket Packet)
{
if (OnCharacterRetirement != null)
{
string GUID = UIPacketHandlers.OnCharacterRetirement(Client, Packet);
OnCharacterRetirement(GUID);
}
else
{
//TODO: Error handling...
}
}
public void _OnPlayerAlreadyOnline(NetworkClient Client, ProcessedPacket Packet)
{
if (OnPlayerAlreadyOnline != null)
{
//No need for handler, this packet only contains a dummy byte.
OnPlayerAlreadyOnline();
}
else
{
//TODO: Error handling...
}
}
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 (SandboxBans.Contains(client.RemoteIP))
{
SendGenericMessage(client, "Banned", "You have been banned from this sandbox server!");
ClientsToDC.Add(client);
return;
}
else if (((VMNetSimJoinCmd)cmd.Command).Version != VMNetSimJoinCmd.CurVer)
{
SendGenericMessage(client, "Version Mismatch", "Your game version does not match the server's. Please update your game.");
ClientsToDC.Add(client);
return;
}
((VMNetSimJoinCmd)cmd.Command).Ticket = client.RemoteIP + ":" + ((VMNetSimJoinCmd)cmd.Command).Name;
((VMNetSimJoinCmd)cmd.Command).Client = client; //remember client so we can bind it to persist id later
SendCommand(cmd.Command); //just go for it. will start the avatar retrieval process.
return;
}
else if (cmd.Type == VMCommandType.RequestResync)
{
lock (ClientsToSync)
{
//todo: throttle
ClientsToSync.Add(client);
}
}
lock (ClientToUID)
{
if (!ClientToUID.ContainsKey(client))
{
return; //client hasn't registered yet
}
cmd.Command.ActorUID = ClientToUID[client];
}
SendCommand(cmd.Command);
}
public void _OnCharacterCreationStatus(NetworkClient Client, ProcessedPacket Packet)
{
if (OnCharacterCreationStatus != null)
{
CharacterCreationStatus CCStatus = UIPacketHandlers.OnCharacterCreationStatus(Client, Packet);
OnCharacterCreationStatus(CCStatus);
}
else
{
//TODO: Error handling...
}
}
public void _OnNewCity(NetworkClient Client, ProcessedPacket Packet)
{
UIPacketHandlers.OnNewCityServer(Client, Packet);
if (OnNewCityServer != null)
{
OnNewCityServer();
}
else
{
//TODO: Error handling...
}
}
/// <summary>
/// City server sent the cost of a lot.
/// </summary>
public void _OnLotCost(NetworkClient Client, ProcessedPacket Packet)
{
LotTileEntry Entry = UIPacketHandlers.OnLotCostResponse(Client, Packet);
if (OnLotCost != null)
{
OnLotCost(Entry);
}
else
{
//TODO: Error handling...
}
}
/// <summary>
/// Lot purchase was successful, server sent correct amount of money for player's character's account.
/// </summary>
public void _OnLotPurchaseSuccessful(NetworkClient Client, ProcessedPacket Packet)
{
int Money = UIPacketHandlers.OnLotPurchaseSuccessful(Client, Packet);
if (OnLotPurchaseSuccessful != null)
{
OnLotPurchaseSuccessful(Money);
}
else
{
//TODO: Error handling...
}
}
public void _OnLoginFailureCity(NetworkClient Client, ProcessedPacket Packet)
{
Log.LogThis("Received OnLoginFailureCity!", eloglevel.info);
if (OnLoginFailureCity != null)
{
UIPacketHandlers.OnLoginFailResponse(ref NetworkFacade.Client, Packet);
OnLoginFailureCity();
}
else
{
//TODO: Error handling...
}
}
public void _OnLoginSuccessCity(NetworkClient Client, ProcessedPacket Packet)
{
Log.LogThis("Received OnLoginSuccessCity!", eloglevel.info);
if (OnLoginSuccessCity != null)
{
//No need for handler - only contains dummy byte.
OnLoginSuccessCity();
}
else
{
//TODO: Error handling...
}
}
/// <summary>
/// Response from city server.
/// </summary>
public void _OnCityTokenResponse(NetworkClient Client, ProcessedPacket Packet)
{
Log.LogThis("Received OnCityTokenResponse!", eloglevel.info);
if (OnCityTransferProgress != null)
{
CityTransferStatus Status = UIPacketHandlers.OnCityTokenResponse(Client, Packet);
OnCityTransferProgress(Status);
}
else
{
//TODO: Error handling...
}
}
/// <summary>
/// Progressing to city server (received from login server).
/// </summary>
public void _OnCharacterCreationProgress(NetworkClient Client, ProcessedPacket Packet)
{
Log.LogThis("Received OnCharacterCreationProgress!", eloglevel.info);
if (OnCharacterCreationProgress != null)
{
CharacterCreationStatus CCStatus = UIPacketHandlers.OnCharacterCreationProgress(Client, Packet);
OnCharacterCreationProgress(CCStatus);
}
else
{
//TODO: Error handling...
}
}
/// <summary>
/// A player left a session (game) in progress.
/// </summary>
public static void OnPlayerLeftSession(NetworkClient Client, ProcessedPacket Packet)
{
string GUID = Packet.ReadString();
lock (NetworkFacade.AvatarsInSession)
{
foreach (UISim Avatar in NetworkFacade.AvatarsInSession)
{
if (Avatar.GUID.ToString().Equals(GUID, StringComparison.CurrentCultureIgnoreCase))
{
NetworkFacade.AvatarsInSession.Remove(Avatar);
}
}
}
}
/// <summary>
/// Received list of characters for account from login server.
/// </summary>
public void _OnCharacterList(NetworkClient Client, ProcessedPacket packet)
{
if (OnLoginProgress != null)
{
OnLoginProgress(new ProgressEvent(EventCodes.PROGRESS_UPDATE)
{
Done = 4, Total = 5
});
UIPacketHandlers.OnCharacterInfoResponse(packet, NetworkFacade.Client);
}
else
{
//TODO: Error handling...
}
}
public void _OnTimeOfDay(NetworkClient Client, ProcessedPacket Packet)
{
DateTime CurrentTime = UIPacketHandlers.OnNewTimeOfDay(Client, Packet);
NetworkFacade.ServerTime = CurrentTime;
if (OnNewTimeOfDay != null)
{
OnNewTimeOfDay(CurrentTime);
}
else
{
//TODO: Error handling...
}
}
public void _OnInvalidVersion(NetworkClient Client, ProcessedPacket packet)
{
if (OnLoginStatus != null)
{
UIPacketHandlers.OnInvalidVersionResponse(ref NetworkFacade.Client, packet);
OnLoginStatus(new LoginEvent(EventCodes.LOGIN_RESULT)
{
Success = false, VersionOK = false
});
}
else
{
//TODO: Error handling...
}
}
/// <summary>
/// A client decided to retire a character.
/// </summary>
public static void HandleCharacterRetirement(NetworkClient Client, ProcessedPacket P)
{
int AccountID = P.ReadInt32();
string GUID = P.ReadString();
using (DataAccess db = DataAccess.Get())
{
IQueryable <Character> Query = db.Characters.GetForAccount(AccountID);
//F**K, I hate LINQ.
Guid CharGUID = new Guid(GUID);
Character Char = Query.Where(x => x.GUID == CharGUID).SingleOrDefault();
db.Characters.RetireCharacter(Char);
}
}
/// <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 = new Guid();
CharacterGUID = new Guid(Packet.ReadPascalString());
PlayerAccount.CityToken = Packet.ReadPascalString();
PlayerAccount.CurrentlyActiveSim.AssignGUID(CharacterGUID.ToString());
}
return CCStatus;
}
public void _OnLoginSuccess(NetworkClient Client, ProcessedPacket packet)
{
if (OnLoginProgress != null)
{
UIPacketHandlers.OnLoginSuccessResponse(ref NetworkFacade.Client, packet);
OnLoginProgress(new ProgressEvent(EventCodes.PROGRESS_UPDATE)
{
Done = 3, Total = 5
});
}
else
{
//TODO: Error handling...
}
}
/// <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>
/// An attempt to buy a lot failed, usually because player was out of money.
/// </summary>
public void _OnLotBuyFailed(NetworkClient Client, ProcessedPacket Packet)
{
UIPacketHandlers.OnLotPurchaseFailed(Client, Packet);
if (OnLotPurchaseFailed != null)
{
OnLotPurchaseFailed(new TransactionEvent(EventCodes.TRANSACTION_RESULT)
{
Success = false
});
}
else
{
//TODO: Error handling...
}
}
/// <summary>
/// New city server came online!
/// </summary>
public static void OnNewCityServer(NetworkClient Client, ProcessedPacket Packet)
{
lock (NetworkFacade.Cities)
{
CityInfo Info = new CityInfo(false);
Info.Name = Packet.ReadString();
Info.Description = Packet.ReadString();
Info.IP = Packet.ReadString();
Info.Port = Packet.ReadInt32();
Info.Status = (CityInfoStatus)Packet.ReadByte();
Info.Thumbnail = Packet.ReadUInt64();
Info.UUID = Packet.ReadString();
Info.Map = Packet.ReadUInt64();
NetworkFacade.Cities.Add(Info);
}
}
/// <summary>
/// A city server went offline!
/// </summary>
public static void OnCityServerOffline(NetworkClient Client, ProcessedPacket Packet)
{
lock (NetworkFacade.Cities)
{
string Name = Packet.ReadString();
foreach (CityInfo City in NetworkFacade.Cities)
{
if (City.Name.Equals(Name, StringComparison.CurrentCultureIgnoreCase))
{
NetworkFacade.Cities.Remove(City);
break;
}
}
}
}
/// <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());
}
/// <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;
}
/// <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)
{
//If the decrypted length == 1, it means that there were 0
//characters that needed to be updated, or that the user
//hasn't created any characters on his/her account yet.
//Since the Packet.Length property is equal to the length
//of the encrypted data, it cannot be used to get the length
//of the decrypted data.
if (Packet.DecryptedLength > 1)
{
byte NumCharacters = (byte)Packet.ReadByte();
List<Sim> FreshSims = new List<Sim>();
for (int i = 0; i < NumCharacters; i++)
{
int CharacterID = Packet.ReadInt32();
Sim FreshSim = new Sim(Packet.ReadString());
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.AppearanceType = (SimsLib.ThreeD.AppearanceType)Packet.ReadByte();
FreshSim.ResidingCity = new CityInfo(Packet.ReadString(), "", Packet.ReadUInt64(), Packet.ReadString(),
Packet.ReadUInt64(), Packet.ReadString(), Packet.ReadInt32());
FreshSims.Add(FreshSim);
}
NetworkFacade.Avatars = FreshSims;
Cache.CacheSims(FreshSims);
}
PacketStream CityInfoRequest = new PacketStream(0x06, 0);
CityInfoRequest.WriteByte(0x00); //Dummy
Client.SendEncrypted((byte)PacketType.CITY_LIST, CityInfoRequest.ToArray());
}
/// <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);
}
/// <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(TSOClient.Code.GameFacade.CDataRetriever.LotTileData)
TSOClient.Code.GameFacade.CDataRetriever.LotTileData = TileEntries;
return CCStatus;
}
public static void HandleCharacterInfoRequest(NetworkClient Client, ProcessedPacket P)
{
Logger.LogInfo("Received CharacterInfoRequest!");
DateTime Timestamp = DateTime.Parse(P.ReadPascalString());
//Database.CheckCharacterTimestamp(Client.Username, Client, TimeStamp);
Character[] Characters = new Character[] { };
using (var db = DataAccess.Get())
{
var account = db.Accounts.GetByUsername(Client.ClientEncryptor.Username);
Characters = db.Characters.GetForAccount((int)account.AccountID).ToArray();
}
if (Characters != null)
{
PacketStream Packet = new PacketStream((byte)PacketType.CHARACTER_LIST, 0);
MemoryStream PacketData = new MemoryStream();
BinaryWriter PacketWriter = new BinaryWriter(PacketData);
/**
* Whats the point of checking a timestamp here? It saves a few bytes on a packet
* sent once per user session. Premature optimization.
*/
PacketWriter.Write((byte)Characters.Length);
foreach (Character avatar in Characters)
{
PacketWriter.Write((int)avatar.CharacterID);
PacketWriter.Write(avatar.GUID.ToString());
PacketWriter.Write(avatar.LastCached);
PacketWriter.Write(avatar.Name);
PacketWriter.Write(avatar.Sex);
PacketWriter.Write(avatar.Description);
PacketWriter.Write((ulong)avatar.HeadOutfitID);
PacketWriter.Write((ulong)avatar.BodyOutfitID);
PacketWriter.Write((byte)avatar.AppearanceType);
PacketWriter.Write((string)avatar.CityName);
PacketWriter.Write((ulong)avatar.CityThumb);
PacketWriter.Write((string)avatar.City);
PacketWriter.Write((ulong)avatar.CityMap);
PacketWriter.Write((string)avatar.CityIp);
PacketWriter.Write((int)avatar.CityPort);
}
Packet.Write(PacketData.ToArray(), 0, (int)PacketData.Length);
PacketWriter.Close();
Client.SendEncrypted(0x05, Packet.ToArray());
}
else //No characters existed for the account.
{
PacketStream Packet = new PacketStream(0x05, 0);
Packet.WriteByte(0x00); //0 characters.
Client.SendEncrypted((byte)PacketType.CHARACTER_LIST, Packet.ToArray());
}
}
public static void HandleCityInfoRequest(NetworkClient Client, ProcessedPacket P)
{
//This packet only contains a dummy byte, don't bother reading it.
PacketStream Packet = new PacketStream((byte)PacketType.CITY_LIST, 0);
MemoryStream PacketData = new MemoryStream();
BinaryWriter PacketWriter = new BinaryWriter(PacketData);
PacketWriter.Write((byte)NetworkFacade.CServerListener.CityServers.Count);
foreach (CityServerClient City in NetworkFacade.CServerListener.CityServers)
{
PacketWriter.Write((string)City.ServerInfo.Name);
PacketWriter.Write((string)City.ServerInfo.Description);
PacketWriter.Write((string)City.ServerInfo.IP);
PacketWriter.Write((int)City.ServerInfo.Port);
//Hack (?) to ensure status is written correctly.
switch (City.ServerInfo.Status)
{
case CityInfoStatus.Ok:
PacketWriter.Write((byte)1);
break;
case CityInfoStatus.Busy:
PacketWriter.Write((byte)2);
break;
case CityInfoStatus.Full:
PacketWriter.Write((byte)3);
break;
case CityInfoStatus.Reserved:
PacketWriter.Write((byte)4);
break;
}
PacketWriter.Write((ulong)City.ServerInfo.Thumbnail);
PacketWriter.Write((string)City.ServerInfo.UUID);
PacketWriter.Write((ulong)City.ServerInfo.Map);
PacketWriter.Flush();
}
Packet.Write(PacketData.ToArray(), 0, PacketData.ToArray().Length);
PacketWriter.Close();
Client.SendEncrypted((byte)PacketType.CITY_LIST, Packet.ToArray());
}
public static void HandleCityTokenRequest(NetworkClient Client, ProcessedPacket P)
{
string AccountName = P.ReadPascalString();
string CityGUID = P.ReadPascalString();
string CharGUID = P.ReadPascalString();
string Token = new Guid().ToString();
foreach (CityServerClient CServer in NetworkFacade.CServerListener.CityServers)
{
if (CityGUID == CServer.ServerInfo.UUID)
{
using (var db = DataAccess.Get())
{
Account Acc = db.Accounts.GetByUsername(AccountName);
PacketStream CServerPacket = new PacketStream(0x01, 0);
CServerPacket.WriteHeader();
ushort PacketLength = (ushort)(PacketHeaders.UNENCRYPTED + 4 + (Client.RemoteIP.Length + 1)
+ (CharGUID.ToString().Length + 1) + (Token.ToString().Length + 1));
CServerPacket.WriteUInt16(PacketLength);
CServerPacket.WriteInt32(Acc.AccountID);
CServerPacket.WritePascalString(Client.RemoteIP);
CServerPacket.WritePascalString(CharGUID.ToString());
CServerPacket.WritePascalString(Token.ToString());
CServer.Send(CServerPacket.ToArray());
break;
}
}
}
PacketStream Packet = new PacketStream((byte)PacketType.REQUEST_CITY_TOKEN, 0);
Packet.WritePascalString(Token);
Client.SendEncrypted((byte)PacketType.REQUEST_CITY_TOKEN, Packet.ToArray());
}
public static void HandleCharacterCreate(NetworkClient Client, ProcessedPacket P)
{
Logger.LogInfo("Received CharacterCreate!");
string AccountName = SanitizeAccount(P.ReadPascalString());
using (var db = DataAccess.Get())
{
Account Acc = db.Accounts.GetByUsername(AccountName);
//TODO: Send GUID to client...
SimBase Char = new SimBase(Guid.NewGuid());
Char.Timestamp = P.ReadPascalString();
Char.Name = P.ReadPascalString();
Char.Sex = P.ReadPascalString();
Char.Description = P.ReadPascalString();
Char.HeadOutfitID = P.ReadUInt64();
Char.BodyOutfitID = P.ReadUInt64();
Char.Appearance = (AppearanceType)P.ReadByte();
Char.ResidingCity = new CityInfo(P.ReadPascalString(), "", P.ReadUInt64(), P.ReadPascalString(),
P.ReadUInt64(), P.ReadPascalString(), P.ReadInt32());
Char.CreatedThisSession = true;
var characterModel = new Character();
characterModel.Name = Char.Name;
characterModel.Sex = Char.Sex;
characterModel.Description = Char.Description;
characterModel.LastCached = Char.Timestamp;
characterModel.GUID = Char.GUID;
characterModel.HeadOutfitID = (long)Char.HeadOutfitID;
characterModel.BodyOutfitID = (long)Char.BodyOutfitID;
characterModel.AccountID = Acc.AccountID;
characterModel.AppearanceType = (int)Char.Appearance;
characterModel.City = Char.ResidingCity.UUID;
characterModel.CityName = Char.ResidingCity.Name;
characterModel.CityThumb = (long)Char.ResidingCity.Thumbnail;
characterModel.CityMap = (long)Char.ResidingCity.Map;
characterModel.CityIp = Char.ResidingCity.IP;
characterModel.CityPort = Char.ResidingCity.Port;
var status = db.Characters.CreateCharacter(characterModel);
//Need to be variable length, because the success packet contains a token.
PacketStream CCStatusPacket = new PacketStream((byte)PacketType.CHARACTER_CREATION_STATUS, 0);
switch (status)
{
case LoginDataModel.Entities.CharacterCreationStatus.NameAlreadyExisted:
CCStatusPacket.WriteByte((int)LoginDataModel.Entities.CharacterCreationStatus.NameAlreadyExisted);
Client.SendEncrypted(CCStatusPacket.PacketID, CCStatusPacket.ToArray());
break;
case LoginDataModel.Entities.CharacterCreationStatus.ExceededCharacterLimit:
CCStatusPacket.WriteByte((int)LoginDataModel.Entities.CharacterCreationStatus.ExceededCharacterLimit);
Client.SendEncrypted(CCStatusPacket.PacketID, CCStatusPacket.ToArray());
break;
case LoginDataModel.Entities.CharacterCreationStatus.Success:
CCStatusPacket.WriteByte((int)LoginDataModel.Entities.CharacterCreationStatus.Success);
CCStatusPacket.WritePascalString(Char.GUID.ToString());
Guid Token = Guid.NewGuid();
CCStatusPacket.WritePascalString(Token.ToString());
Client.SendEncrypted(CCStatusPacket.PacketID, CCStatusPacket.ToArray());
foreach (CityServerClient CServer in NetworkFacade.CServerListener.CityServers)
{
if (CServer.ServerInfo.UUID == Char.ResidingCity.UUID)
{
PacketStream CServerPacket = new PacketStream(0x01, 0);
CServerPacket.WriteHeader();
ushort PacketLength = (ushort)(PacketHeaders.UNENCRYPTED + 4 + (Client.RemoteIP.Length + 1)
+ (Char.GUID.ToString().Length + 1) + (Token.ToString().Length + 1));
CServerPacket.WriteUInt16(PacketLength);
CServerPacket.WriteInt32(Acc.AccountID);
CServerPacket.WritePascalString(Client.RemoteIP);
CServerPacket.WritePascalString(Char.GUID.ToString());
CServerPacket.WritePascalString(Token.ToString());
CServer.Send(CServerPacket.ToArray());
break;
}
}
break;
}
}
//Client was modified, so update it.
NetworkFacade.ClientListener.UpdateClient(Client);
}
/// <summary>
/// Client requested information about a city.
/// </summary>
public static void HandleCityInfoRequest(NetworkClient Client, ProcessedPacket P)
{
//This packet only contains a dummy byte, don't bother reading it.
PacketStream Packet = new PacketStream((byte)PacketType.CITY_LIST, 0);
Packet.WriteByte((byte)NetworkFacade.CServerListener.CityServers.Count);
if (NetworkFacade.CServerListener.CityServers.Count > 0)
{
lock (NetworkFacade.CServerListener.CityServers)
{
foreach (CityInfo CInfo in NetworkFacade.CServerListener.CityServers)
{
Packet.WriteString(CInfo.Name);
Packet.WriteString(CInfo.Description);
Packet.WriteString(CInfo.IP);
Packet.WriteInt32(CInfo.Port);
//Hack (?) to ensure status is written correctly.
switch (CInfo.Status)
{
case CityInfoStatus.Ok:
Packet.WriteByte(1);
break;
case CityInfoStatus.Busy:
Packet.WriteByte(2);
break;
case CityInfoStatus.Full:
Packet.WriteByte(3);
break;
case CityInfoStatus.Reserved:
Packet.WriteByte(4);
break;
}
Packet.WriteUInt64(CInfo.Thumbnail);
Packet.WriteString(CInfo.UUID);
Packet.WriteUInt64(CInfo.Map);
}
}
}
Client.SendEncrypted((byte)PacketType.CITY_LIST, Packet.ToArray());
}
public static DateTime OnNewTimeOfDay(NetworkClient Client, ProcessedPacket Packet)
{
return new DateTime(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day,
Packet.ReadInt32(), Packet.ReadInt32(), Packet.ReadInt32());
}
/// <summary>
/// A player left a session (game) in progress.
/// </summary>
public static void OnPlayerLeftSession(NetworkClient Client, ProcessedPacket Packet)
{
string GUID = Packet.ReadString();
lock (NetworkFacade.AvatarsInSession)
{
foreach (UISim Avatar in NetworkFacade.AvatarsInSession)
{
if (Avatar.GUID.ToString().Equals(GUID, StringComparison.CurrentCultureIgnoreCase))
NetworkFacade.AvatarsInSession.Remove(Avatar);
}
}
}
public static void OnCityTokenResponse(NetworkClient Client, ProcessedPacket Packet)
{
CityTransferStatus Status = (CityTransferStatus)Packet.ReadByte();
switch (Status)
{
case CityTransferStatus.Success:
NetworkFacade.Controller._OnCityTokenResponse(Status);
break;
case CityTransferStatus.GeneralError:
NetworkFacade.Controller._OnCityTokenResponse(Status);
break;
}
}
/// <summary>
/// Occurs when the client has been sucessfully authenticated by the loginserver.
/// Called by UILoginDialog.cs.
/// </summary>
/// <param name="Client">The client that received the packet.</param>
/// <param name="Packet">The packet that was received.</param>
public static void OnInitLoginNotify(NetworkClient Client, ProcessedPacket Packet)
{
//Account was authenticated, so add the client to the player's account.
PlayerAccount.Client = Client;
if (!Directory.Exists("CharacterCache"))
{
Directory.CreateDirectory("CharacterCache");
//The charactercache didn't exist, so send the current time, which is
//newer than the server's stamp. This will cause the server to send the entire cache.
UIPacketSenders.SendCharacterInfoRequest(DateTime.Now.ToString("yyyy.MM.dd hh:mm:ss"));
}
else
{
if (!File.Exists("CharacterCache\\Sims.cache"))
{
//The charactercache didn't exist, so send the current time, which is
//newer than the server's stamp. This will cause the server to send the entire cache.
UIPacketSenders.SendCharacterInfoRequest(DateTime.Now.ToString("yyyy.MM.dd hh:mm:ss"));
}
else
UIPacketSenders.SendCharacterInfoRequest(Cache.GetDateCached());
}
}
/// <summary>
/// Occurs when the client was not authenticated by the loginserver.
/// Called by UILoginDialog.cs.
/// </summary>
/// <param name="Client">The client that received the packet.</param>
/// <param name="Packet">The packet that was received.</param>
/// <param name="Screen">A UIScreen instance on which to display a messagebox to inform the player of the
/// failure state.</param>
public static void OnLoginFailResponse(ref NetworkClient Client, ProcessedPacket Packet)
{
EventObject Event;
switch (Packet.ReadByte())
{
case 0x01:
Event = new EventObject(EventCodes.BAD_USERNAME);
EventSink.RegisterEvent(Event);
break;
case 0x02:
Event = new EventObject(EventCodes.BAD_PASSWORD);
EventSink.RegisterEvent(Event);
break;
}
Client.Disconnect();
}
/// <summary>
/// Client created a character!
/// </summary>
public static void HandleCharacterCreate(NetworkClient Client, ProcessedPacket P)
{
Logger.LogInfo("Received CharacterCreate!");
string AccountName = SanitizeAccount(P.ReadString());
//Need to be variable length, because the success packet contains a token.
PacketStream CCStatusPacket = new PacketStream((byte)PacketType.CHARACTER_CREATION_STATUS, 0);
using (var db = DataAccess.Get())
{
Account Acc = db.Accounts.GetByUsername(AccountName);
if (Acc.NumCharacters >= 3)
{
CCStatusPacket.WriteByte((int)LoginDataModel.Entities.CharacterCreationStatus.ExceededCharacterLimit);
Client.SendEncrypted(CCStatusPacket.PacketID, CCStatusPacket.ToArray());
return;
}
//TODO: Send GUID to client...
var Char = new Character();
string LastCached = P.ReadString();
if (LastCached == string.Empty)
{
//TODO: Proper error...
CCStatusPacket.WriteByte((int)LoginDataModel.Entities.CharacterCreationStatus.NameAlreadyExisted);
Client.SendEncrypted(CCStatusPacket.PacketID, CCStatusPacket.ToArray());
return;
}
Char.LastCached = ProtoHelpers.ParseDateTime(LastCached);
Char.Name = P.ReadString();
Char.Sex = P.ReadString();
Char.Description = P.ReadString();
Char.GUID = Guid.NewGuid();
Char.HeadOutfitID = (long)P.ReadUInt64();
Char.BodyOutfitID = (long)P.ReadUInt64();
Char.AccountID = Acc.AccountID;
Char.AppearanceType = P.ReadByte();
Char.CityName = P.ReadString();
Char.CityThumb = (long)P.ReadUInt64();
Char.City = P.ReadString();
Char.CityMap = (long)P.ReadUInt64();
Char.CityIp = P.ReadString();
Char.CityPort = P.ReadInt32();
Char.Money = NetworkFacade.INITIAL_MONEY;
//These are going into DB, so be nazi. Sieg heil!
if (Char.Name == string.Empty || Char.Sex == string.Empty ||
Char.Description == string.Empty)
{
CCStatusPacket.WriteByte((int)LoginDataModel.Entities.CharacterCreationStatus.NameAlreadyExisted);
Client.SendEncrypted(CCStatusPacket.PacketID, CCStatusPacket.ToArray());
return;
}
var status = db.Characters.CreateCharacter(Char);
switch (status)
{
case LoginDataModel.Entities.CharacterCreationStatus.NameAlreadyExisted:
CCStatusPacket.WriteByte((int)LoginDataModel.Entities.CharacterCreationStatus.NameAlreadyExisted);
Client.SendEncrypted(CCStatusPacket.PacketID, CCStatusPacket.ToArray());
break;
case LoginDataModel.Entities.CharacterCreationStatus.NameTooLong:
CCStatusPacket.WriteByte((int)LoginDataModel.Entities.CharacterCreationStatus.NameTooLong);
Client.SendEncrypted(CCStatusPacket.PacketID, CCStatusPacket.ToArray());
break;
case LoginDataModel.Entities.CharacterCreationStatus.Success:
Guid Token = Guid.NewGuid();
//This actually updates the record, not sure how.
Acc.NumCharacters++;
//THIS NEEDS TO HAPPEN FIRST FOR CITY SERVER AUTHENTICATION TO WORK!
CityInfo CServer = NetworkFacade.CServerListener.GetCityServer(Char.City);
//Just in case...
if (CServer != null)
{
PacketStream CServerPacket = new PacketStream(0x01, 0);
CServerPacket.WriteHeader();
ushort PacketLength = (ushort)(PacketHeaders.UNENCRYPTED + 1 + 4 + (Client.RemoteIP.Length + 1)
+ 4 + (Char.GUID.ToString().Length + 1) + (Token.ToString().Length + 1));
CServerPacket.WriteUInt16(PacketLength);
CServerPacket.WriteByte(1); //CharacterCreate = true
CServerPacket.WriteInt32(Acc.AccountID);
CServerPacket.WriteString(Client.RemoteIP);
CServerPacket.WriteInt32(Client.RemotePort);
CServerPacket.WriteString(Char.GUID.ToString());
CServerPacket.WriteString(Token.ToString(""));
CServer.Client.Send(CServerPacket.ToArray());
}
CCStatusPacket.WriteByte((int)LoginDataModel.Entities.CharacterCreationStatus.Success);
CCStatusPacket.WriteString(Char.GUID.ToString());
CCStatusPacket.WriteString(Token.ToString());
Client.SendEncrypted(CCStatusPacket.PacketID, CCStatusPacket.ToArray());
break;
}
}
}
/// <summary>
/// Client sent a response to our challenge, as well as account name and password.
/// </summary>
public static void HandleChallengeResponse(NetworkClient Client, ProcessedPacket P)
{
PacketStream OutPacket;
if (P.BufferLength <= 1)
{
OutPacket = new PacketStream((byte)PacketType.LOGIN_FAILURE, 0);
OutPacket.WriteByte(0x03); //Bad challenge response.
Client.Send(OutPacket.ToArray());
Logger.LogInfo("Bad challenge response - sent SLoginFailResponse!\r\n");
return; //How does this even happen?!
}
int Length = P.ReadByte();
byte[] CResponse;
if (P.BufferLength >= Length)
CResponse = P.ReadBytes(Length);
else
return;
AESDecryptionArgs DecryptionArgs = Client.ClientEncryptor.GetDecryptionArgsContainer().AESDecryptArgs;
if (DecryptionArgs.Challenge.SequenceEqual(CResponse))
{
string AccountName = SanitizeAccount(P.ReadString());
Length = P.ReadByte();
byte[] PasswordHash;
if (P.BufferLength >= Length)
PasswordHash = P.ReadBytes(Length);
else
return;
// Check whether the accountname is empty or is/contains "username"
if (AccountName == string.Empty || AccountName.ToLower().Equals("username") || AccountName.ToLower().Contains("username"))
{
OutPacket = new PacketStream((byte)PacketType.LOGIN_FAILURE, 0);
OutPacket.WriteHeader();
OutPacket.WriteUInt16((ushort)(PacketHeaders.UNENCRYPTED + 1));
OutPacket.WriteByte(0x01);
Client.Send(OutPacket.ToArray());
Logger.LogInfo(@"Bad accountname (""" + AccountName + @""") - sent SLoginFailResponse!\r\n");
Client.Disconnect();
return;
}
using (var db = DataAccess.Get())
{
var account = db.Accounts.GetByUsername(AccountName);
if (!GlobalSettings.Default.CreateAccountsOnLogin)
{
Logger.LogInfo("Done reading LoginRequest, checking account...\r\n");
if (account == null)
{
OutPacket = new PacketStream((byte)PacketType.LOGIN_FAILURE, 0);
OutPacket.WriteHeader();
OutPacket.WriteUInt16((ushort)(PacketHeaders.UNENCRYPTED + 1));
OutPacket.WriteByte(0x01);
Client.Send(OutPacket.ToArray());
Logger.LogInfo(@"Bad accountname (""" + AccountName + @""") - sent SLoginFailResponse!\r\n");
Client.Disconnect();
return;
}
}
else
{
if (account == null)
{
try
{
if (!AccountName.ToLower().Equals("username") || !AccountName.ToLower().Contains("username"))
db.Accounts.Create(new Account
{
AccountName = AccountName.ToLower(),
Password = Convert.ToBase64String(PasswordHash)
});
}
catch (Exception)
{
OutPacket = new PacketStream((byte)PacketType.LOGIN_FAILURE, 0);
OutPacket.WriteHeader();
OutPacket.WriteUInt16((ushort)(PacketHeaders.UNENCRYPTED + 1));
OutPacket.WriteByte(0x01);
Client.Send(OutPacket.ToArray());
Logger.LogInfo(@"Bad accountname (""" + AccountName + @""") - sent SLoginFailResponse!\r\n");
Client.Disconnect();
return;
}
account = db.Accounts.GetByUsername(AccountName);
}
}
if (account.IsCorrectPassword(AccountName, PasswordHash))
{
OutPacket = new PacketStream((byte)PacketType.LOGIN_SUCCESS, 0);
OutPacket.WriteByte(0x01);
Client.ClientEncryptor.Username = AccountName;
Client.SendEncrypted((byte)PacketType.LOGIN_SUCCESS, OutPacket.ToArray());
Logger.LogInfo("Sent SLoginSuccessResponse!\r\n");
return;
}
else
{
OutPacket = new PacketStream((byte)PacketType.LOGIN_FAILURE, 0);
OutPacket.WriteHeader();
OutPacket.WriteUInt16((ushort)(PacketHeaders.UNENCRYPTED + 1));
OutPacket.WriteByte(0x02);
Client.Send(OutPacket.ToArray());
Logger.LogInfo("Bad password - sent SLoginFailResponse!\r\n");
Client.Disconnect();
return;
}
}
}
OutPacket = new PacketStream((byte)PacketType.LOGIN_FAILURE, 0);
OutPacket.WriteHeader();
OutPacket.WriteUInt16((ushort)(PacketHeaders.UNENCRYPTED + 1));
OutPacket.WriteByte(0x03); //Bad challenge response.
Client.Send(OutPacket.ToArray());
Logger.LogInfo("Bad challenge response - sent SLoginFailResponse!\r\n");
return;
}
/// <summary>
/// Client requested information about its characters.
/// </summary>
public static void HandleCharacterInfoRequest(NetworkClient Client, ProcessedPacket P)
{
Logger.LogInfo("Received CharacterInfoRequest!");
string DateTimeStr = P.ReadString();
DateTime Timestamp;
if (DateTimeStr != string.Empty)
Timestamp = DateTime.Parse(DateTimeStr);
else
{
//Unix epoch
Timestamp = new DateTime(1970, 1, 1, 0, 0, 1);
}
Character[] Characters = new Character[] { };
using (var db = DataAccess.Get())
{
var account = db.Accounts.GetByUsername(Client.ClientEncryptor.Username);
Characters = db.Characters.GetForAccount((int)account.AccountID).ToArray();
}
int NumChars = 0, NewChars = 0;
if (Characters != null)
{
PacketStream Packet = new PacketStream((byte)PacketType.CHARACTER_LIST, 0);
MemoryStream PacketData = new MemoryStream();
BinaryWriter PacketWriter = new BinaryWriter(PacketData);
NumChars = Characters.Length;
foreach (Character avatar in Characters)
{
//Zero means same, less than zero means T1 is earlier than T2, more than zero means T1 is later.
if (DateTime.Compare(Timestamp, avatar.LastCached) < 0)
{
NewChars++;
PacketWriter.Write((int)avatar.CharacterID);
PacketWriter.Write(avatar.GUID.ToString());
PacketWriter.Write(avatar.LastCached.ToString("yyyy.MM.dd hh:mm:ss",
CultureInfo.InvariantCulture));
PacketWriter.Write(avatar.Name);
PacketWriter.Write(avatar.Sex);
PacketWriter.Write(avatar.Description);
PacketWriter.Write((ulong)avatar.HeadOutfitID);
PacketWriter.Write((ulong)avatar.BodyOutfitID);
PacketWriter.Write((byte)avatar.AppearanceType);
PacketWriter.Write((string)avatar.CityName);
PacketWriter.Write((ulong)avatar.CityThumb);
PacketWriter.Write((string)avatar.City);
PacketWriter.Write((ulong)avatar.CityMap);
PacketWriter.Write((string)avatar.CityIp);
PacketWriter.Write((int)avatar.CityPort);
PacketWriter.Write((int)avatar.Money);
}
}
//NOTE: If Characters != null, but no chars were new, NumChars will be however many characters,
// and NewChars will be 0.
Packet.WriteByte((byte)NumChars);
Packet.WriteByte((byte)NewChars);
Packet.Write(PacketData.ToArray(), 0, (int)PacketData.Length);
PacketWriter.Close();
Client.SendEncrypted((byte)PacketType.CHARACTER_LIST, Packet.ToArray());
}
else //No characters existed for the account.
{
PacketStream Packet = new PacketStream(0x05, 0);
Packet.WriteByte((byte)NumChars); //0 characters.
Packet.WriteByte((byte)NewChars); //0 new characters.
Client.SendEncrypted((byte)PacketType.CHARACTER_LIST, Packet.ToArray());
}
}
/// <summary>
/// Client wanted to retire a character.
/// </summary>
public static void HandleCharacterRetirement(NetworkClient Client, ProcessedPacket P)
{
PacketStream Packet;
string AccountName = P.ReadString();
string GUID = P.ReadString();
if (AccountName == string.Empty || GUID == string.Empty)
return;
using (var db = DataAccess.Get())
{
Account Acc = db.Accounts.GetByUsername(AccountName);
IQueryable<Character> Query = db.Characters.GetForAccount(Acc.AccountID);
//F**K, I hate LINQ.
Guid CharGUID = new Guid(GUID);
Character Char = Query.Where(x => x.GUID == CharGUID).SingleOrDefault();
if (Char != null)
db.Characters.RetireCharacter(Char);
else
return;
//This actually updates the record, not sure how.
Acc.NumCharacters--;
if (Char != null)
{
CityInfo CInfo = NetworkFacade.CServerListener.GetCityServer(Char.City);
//Just in case...
if (CInfo != null)
{
Packet = new PacketStream(0x02, 0);
Packet.WriteHeader();
ushort PacketLength = (ushort)(PacketHeaders.UNENCRYPTED + 4 + GUID.Length + 1);
Packet.WriteUInt16(PacketLength);
Packet.WriteInt32(Acc.AccountID);
Packet.WriteString(GUID);
CInfo.Client.Send(Packet.ToArray());
}
}
}
Packet = new PacketStream((byte)PacketType.RETIRE_CHARACTER_STATUS, 0);
Packet.WriteString(GUID);
Client.SendEncrypted((byte)PacketType.RETIRE_CHARACTER_STATUS, Packet.ToArray());
}
public static void OnCityToken(NetworkClient Client, ProcessedPacket Packet)
{
PlayerAccount.CityToken = Packet.ReadString();
}
/// <summary>
/// Received a letter from another player in a session.
/// </summary>
public static void OnPlayerReceivedLetter(NetworkClient Client, ProcessedPacket Packet)
{
string From = Packet.ReadString();
string Subject = Packet.ReadString();
string Message = Packet.ReadString();
string GUID = string.Empty;
lock (NetworkFacade.AvatarsInSession)
{
foreach (UISim Sim in NetworkFacade.AvatarsInSession)
{
if (Sim.Name.Equals(From, StringComparison.CurrentCultureIgnoreCase))
GUID = Sim.GUID.ToString();
}
}
Code.UI.Panels.MessageAuthor Author = new TSOClient.Code.UI.Panels.MessageAuthor();
Author.Author = From;
if (GUID != string.Empty)
Author.GUID = GUID;
//Ignore this for now...
/*if (!Code.GameFacade.MessageController.ConversationExisted(Author))
Code.GameFacade.MessageController.PassEmail(Author, Subject, Message);
else*/
Code.GameFacade.MessageController.PassMessage(Author, Message);
//MessagesCache.CacheLetter(From, Subject, Message);
}
public static void OnCityInfoResponse(ProcessedPacket Packet)
{
byte NumCities = (byte)Packet.ReadByte();
if (Packet.DecryptedLength > 1)
{
for (int i = 0; i < NumCities; i++)
{
string Name = Packet.ReadString();
string Description = Packet.ReadString();
string IP = Packet.ReadString();
int Port = Packet.ReadInt32();
byte StatusByte = (byte)Packet.ReadByte();
CityInfoStatus Status = (CityInfoStatus)StatusByte;
ulong Thumbnail = Packet.ReadUInt64();
string UUID = Packet.ReadString();
ulong Map = Packet.ReadUInt64();
CityInfo Info = new CityInfo(Name, Description, Thumbnail, UUID, Map, IP, Port);
Info.Online = true;
Info.Status = Status;
NetworkFacade.Cities.Add(Info);
}
}
}
/// <summary>
/// A player joined a session (game) in progress.
/// </summary>
public static LotTileEntry OnPlayerJoinedSession(NetworkClient Client, ProcessedPacket Packet)
{
LotTileEntry TileEntry = new LotTileEntry(0, "", 0, 0, 0, 0);
UISim Avatar = new UISim(Packet.ReadString());
Avatar.Name = Packet.ReadString();
Avatar.Sex = Packet.ReadString();
Avatar.Description = Packet.ReadString();
Avatar.HeadOutfitID = Packet.ReadUInt64();
Avatar.BodyOutfitID = Packet.ReadUInt64();
Avatar.Avatar.Appearance = (AppearanceType)Packet.ReadInt32();
byte HasHouse = (byte)Packet.ReadByte();
if (HasHouse != 0)
{
TileEntry = new LotTileEntry(Packet.ReadInt32(), Packet.ReadString(), (short)Packet.ReadUInt16(),
(short)Packet.ReadUInt16(), (byte)Packet.ReadByte(), Packet.ReadInt32());
Avatar.LotID = TileEntry.lotid;
Avatar.HouseX = TileEntry.x;
Avatar.HouseY = TileEntry.y;
LotTileEntry[] TileEntries = new LotTileEntry[TSOClient.Code.GameFacade.CDataRetriever.LotTileData.Length + 1];
TileEntries[0] = TileEntry;
TSOClient.Code.GameFacade.CDataRetriever.LotTileData.CopyTo(TileEntries, 1);
}
lock (NetworkFacade.AvatarsInSession)
{
NetworkFacade.AvatarsInSession.Add(Avatar);
}
return TileEntry;
}
/**
* Actual packet handlers
*/
public static void HandleLoginRequest(NetworkClient Client, ProcessedPacket P)
{
Logger.LogInfo("Received LoginRequest!\r\n");
byte AccountStrLength = (byte)P.ReadByte();
byte[] AccountNameBuf = new byte[AccountStrLength];
P.Read(AccountNameBuf, 0, AccountStrLength);
string AccountName = SanitizeAccount(Encoding.ASCII.GetString(AccountNameBuf));
Logger.LogInfo("Accountname: " + AccountName + "\r\n");
byte HashLength = (byte)P.ReadByte();
byte[] HashBuf = new byte[HashLength];
P.Read(HashBuf, 0, HashLength);
if (AccountName == "")
{
PacketStream OutPacket = new PacketStream((byte)PacketType.LOGIN_FAILURE, 2);
OutPacket.WriteHeader();
OutPacket.WriteByte(0x01);
Client.Send(OutPacket.ToArray());
Logger.LogInfo("Bad accountname - sent SLoginFailResponse!\r\n");
Client.Disconnect();
return;
}
using (var db = DataAccess.Get())
{
var account = db.Accounts.GetByUsername(AccountName);
byte KeyLength = (byte)P.ReadByte();
byte[] EncKey = new byte[KeyLength];
P.Read(EncKey, 0, KeyLength);
//TODO: Do something with this...
byte Version1 = (byte)P.ReadByte();
byte Version2 = (byte)P.ReadByte();
byte Version3 = (byte)P.ReadByte();
byte Version4 = (byte)P.ReadByte();
string ClientVersion = Version1.ToString() + "." + Version2.ToString() + "." + Version3.ToString() +
"." + Version4.ToString();
if (ClientVersion != GlobalSettings.Default.ClientVersion)
{
PacketStream OutPacket = new PacketStream((byte)PacketType.INVALID_VERSION, 2);
OutPacket.WriteHeader();
OutPacket.WriteByte(0x01);
Client.Send(OutPacket.ToArray());
Logger.LogInfo("Bad version - sent SInvalidVersion!\r\n");
Client.Disconnect();
return;
}
if (!GlobalSettings.Default.CreateAccountsOnLogin)
{
Logger.LogInfo("Done reading LoginRequest, checking account...\r\n");
if (account == null)
{
PacketStream OutPacket = new PacketStream((byte)PacketType.LOGIN_FAILURE, 2);
OutPacket.WriteHeader();
OutPacket.WriteByte(0x01);
Client.Send(OutPacket.ToArray());
Logger.LogInfo("Bad accountname - sent SLoginFailResponse!\r\n");
Client.Disconnect();
return;
}
else
Client.ClientEncryptor = new ARC4Encryptor(account.Password, EncKey);
}
else
{
if (account == null)
{
try
{
db.Accounts.Create(new Account
{
AccountName = AccountName.ToLower(),
Password = Convert.ToBase64String(HashBuf)
});
}
catch (Exception)
{
PacketStream OutPacket = new PacketStream((byte)PacketType.LOGIN_FAILURE, 2);
OutPacket.WriteHeader();
OutPacket.WriteByte(0x01);
Client.Send(OutPacket.ToArray());
Logger.LogInfo("Bad accountname - sent SLoginFailResponse!\r\n");
Client.Disconnect();
return;
}
account = db.Accounts.GetByUsername(AccountName);
}
Client.ClientEncryptor = new ARC4Encryptor(account.Password, EncKey);
}
if (account.IsCorrectPassword(AccountName, HashBuf))
{
//0x01 = InitLoginNotify
PacketStream OutPacket = new PacketStream((byte)PacketType.LOGIN_NOTIFY, 1);
OutPacket.WriteHeader();
OutPacket.WriteByte(0x01);
Client.ClientEncryptor.Username = AccountName;
Client.Send(OutPacket.ToArray());
Logger.LogInfo("Sent InitLoginNotify!\r\n");
}
else
{
PacketStream OutPacket = new PacketStream((byte)PacketType.LOGIN_FAILURE, 2);
OutPacket.WriteHeader();
OutPacket.WriteByte(0x02);
Client.Send(OutPacket.ToArray());
Logger.LogInfo("Bad password - sent SLoginFailResponse!\r\n");
Client.Disconnect();
return;
}
}
//Client was modified, update it.
NetworkFacade.ClientListener.UpdateClient(Client);
}
/// <summary>
/// Client wanted to transfer to a city server.
/// </summary>
public static void HandleCityTokenRequest(NetworkClient Client, ProcessedPacket P)
{
string AccountName = P.ReadString();
string CityGUID = P.ReadString();
string CharGUID = P.ReadString();
if (AccountName == string.Empty || CityGUID == string.Empty || CharGUID == string.Empty)
return;
Guid Token = Guid.NewGuid();
CityInfo CServer = NetworkFacade.CServerListener.GetCityServer(CityGUID);
using (var db = DataAccess.Get())
{
Account Acc = db.Accounts.GetByUsername(AccountName);
PacketStream CServerPacket = new PacketStream(0x01, 0);
CServerPacket.WriteHeader();
ushort PacketLength = (ushort)(PacketHeaders.UNENCRYPTED + 1 + 4 + (Client.RemoteIP.Length + 1)
+ 4 + (CharGUID.ToString().Length + 1) + (Token.ToString().Length + 1));
CServerPacket.WriteUInt16(PacketLength);
CServerPacket.WriteByte(0); //CharacterCreate = false.
CServerPacket.WriteInt32(Acc.AccountID);
CServerPacket.WriteString(Client.RemoteIP);
CServerPacket.WriteInt32(Client.RemotePort);
CServerPacket.WriteString(CharGUID.ToString());
CServerPacket.WriteString(Token.ToString(""));
CServer.Client.Send(CServerPacket.ToArray());
}
}
/// <summary>
/// Client wanted to log in!
/// </summary>
public static void HandleLoginRequest(NetworkClient Client, ProcessedPacket P)
{
try
{
Logger.LogInfo("Received LoginRequest!\r\n");
byte Version1 = (byte)P.ReadByte();
byte Version2 = (byte)P.ReadByte();
byte Version3 = (byte)P.ReadByte();
byte Version4 = (byte)P.ReadByte();
string ClientVersion = Version1.ToString() + "." + Version2.ToString() + "." + Version3.ToString() +
"." + Version4.ToString();
if (ClientVersion != GlobalSettings.Default.ClientVersion)
{
PacketStream OutPacket = new PacketStream((byte)PacketType.INVALID_VERSION, 2);
OutPacket.WriteHeader();
OutPacket.WriteByte(0x01);
Client.Send(OutPacket.ToArray());
Logger.LogInfo("Bad version - sent SInvalidVersion!\r\n");
Client.Disconnect();
return;
}
PacketStream EncryptedPacket = new PacketStream((byte)PacketType.LOGIN_NOTIFY, 0);
EncryptedPacket.WriteHeader();
AESEncryptor Enc = (AESEncryptor)Client.ClientEncryptor;
if (Enc == null)
Enc = new AESEncryptor("");
Enc.PublicKey = P.ReadBytes((P.ReadByte()));
Enc.NOnce = P.ReadBytes((P.ReadByte()));
Enc.PrivateKey = NetworkFacade.ServerKey;
Client.ClientEncryptor = Enc;
MemoryStream StreamToEncrypt = new MemoryStream();
BinaryWriter Writer = new BinaryWriter(StreamToEncrypt);
Writer.Write(Enc.Challenge, 0, Enc.Challenge.Length);
Writer.Flush();
byte[] EncryptedData = StaticStaticDiffieHellman.Encrypt(NetworkFacade.ServerKey,
System.Security.Cryptography.ECDiffieHellmanCngPublicKey.FromByteArray(Enc.PublicKey,
System.Security.Cryptography.CngKeyBlobFormat.EccPublicBlob), Enc.NOnce, StreamToEncrypt.ToArray());
EncryptedPacket.WriteUInt16((ushort)(PacketHeaders.UNENCRYPTED +
(1 + NetworkFacade.ServerPublicKey.Length) +
(1 + EncryptedData.Length)));
EncryptedPacket.WriteByte((byte)NetworkFacade.ServerPublicKey.Length);
EncryptedPacket.WriteBytes(NetworkFacade.ServerPublicKey);
EncryptedPacket.WriteByte((byte)EncryptedData.Length);
EncryptedPacket.WriteBytes(EncryptedData);
Client.Send(EncryptedPacket.ToArray());
}
//This should HOPEFULLY wade off clients sending unreadable (I.E old protocol) packets...
catch (Exception E)
{
Logger.LogDebug("Error while handling login request, disconnecting client: " +
E.ToString());
Client.Disconnect();
return;
}
}
