/// <summary>
/// The read.
/// </summary>
/// <param name="client">
/// </param>
/// <param name="packet">
/// </param>
public static void Read(Client client, byte[] packet)
{
LogUtil.Debug(DebugInfoDetail.Network, "\r\nReceived:\r\n" + HexOutput.Output(packet));
MemoryStream m_stream = new MemoryStream(packet);
BinaryReader m_reader = new BinaryReader(m_stream);
// now we should do password check and then send OK or Error
// sending OK now
m_stream.Position = 8;
short userNameLength = IPAddress.NetworkToHostOrder(m_reader.ReadInt16());
string userName = Encoding.ASCII.GetString(m_reader.ReadBytes(userNameLength));
short loginKeyLength = IPAddress.NetworkToHostOrder(m_reader.ReadInt16());
string loginKey = Encoding.ASCII.GetString(m_reader.ReadBytes(loginKeyLength));
LoginEncryption loginEncryption = new LoginEncryption();
if (loginEncryption.IsValidLogin(loginKey, client.ServerSalt, userName))
{
client.IsBot = true;
byte[] chars = AccountCharacterList.Create(userName);
LogUtil.Debug(DebugInfoDetail.Network, "\r\nReceived:\r\n" + HexOutput.Output(chars));
client.Send(chars);
}
else
{
byte[] loginerr = LoginError.Create();
client.Send(loginerr);
client.Server.DisconnectClient(client);
}
}
/// <summary>
/// The new.
/// </summary>
/// <param name="client">
/// </param>
/// <param name="id">
/// The id.
/// </param>
/// <returns>
/// </returns>
public static byte[] Create(Client client, uint id)
{
PacketWriter writer = new PacketWriter(20);
writer.WriteUInt32(id);
writer.WriteString(client.Character.characterName);
return writer.Finish();
}
/// <summary>
/// Initializes a new instance of the <see cref="Character"/> class.
/// The character.
/// </summary>
/// <param name="characterId">
/// </param>
/// <param name="client">
/// </param>
public Character(uint characterId, Client client)
: base(characterId)
{
this.Client = client;
if (characterId != 0)
{
this.characterName = CharacterDao.Instance.GetCharacterNameById((int)characterId);
}
}
/// <summary>
/// Read private group invite player packet
/// </summary>
/// <param name="client">
/// Client sending
/// </param>
/// <param name="packet">
/// Packet data
/// </param>
public void Read(Client client, byte[] packet)
{
PacketReader reader = new PacketReader(ref packet);
reader.ReadUInt16(); // Packet ID
reader.ReadUInt16(); // Data length
this.playerId = reader.ReadUInt32();
client.Server.Debug(
client,
"{0} >> PrivGrpInvitePlayer: PlayerID: {1}",
client.Character.characterName,
this.playerId);
reader.Finish();
}
/// <summary>
/// The read.
/// </summary>
/// <param name="client">
/// </param>
/// <param name="packet">
/// </param>
public static void Read(Client client, byte[] packet)
{
byte[] senderId = BitConverter.GetBytes(client.Character.CharacterId);
Array.Reverse(senderId);
ChannelBase channel = client.ChatServer().GetChannel(packet);
PacketReader reader = new PacketReader(ref packet);
reader.ReadUInt16();
reader.ReadUInt16();
reader.ReadUInt16();
reader.ReadUInt16();
reader.ReadByte();
string text = reader.ReadString();
string channelName = channel.ChannelName;
// Check if it is a Chat Command (starting with a dot)
if (!ProcessServerCommand(text, client))
{
byte[] newpacket = new byte[packet.Length + 4];
Array.Copy(packet, 0, newpacket, 0, 9);
Array.Copy(senderId, 0, newpacket, 9, 4);
Array.Copy(packet, 9, newpacket, 13, packet.Length - 9);
newpacket[2] = (byte)(packet.Length >> 8);
newpacket[3] = (byte)packet.Length;
foreach (Client recipient in client.ChatServer().ConnectedClients.Values)
{
if (recipient.Channels.Contains(channel))
{
if (!recipient.KnownClients.Contains(client.Character.CharacterId)
&& (recipient.Character.CharacterId != client.Character.CharacterId))
{
byte[] pname = PlayerName.Create(client, client.Character.CharacterId);
recipient.Send(pname);
recipient.KnownClients.Add(client.Character.CharacterId);
}
recipient.Send(newpacket);
}
}
client.ChannelMessageReceived(channel, client.Character.characterName, text);
}
ChatLogger.WriteString(channelName, text, client.Character.characterName);
}
/// <summary>
/// Read private group message
/// </summary>
/// <param name="client">
/// Client sending
/// </param>
/// <param name="packet">
/// packet data
/// </param>
public void Read(Client client, byte[] packet)
{
PacketReader reader = new PacketReader(ref packet);
reader.ReadUInt16(); // Packet ID
reader.ReadUInt16(); // Data length
this.playerid = reader.ReadUInt32();
this.message = reader.ReadString();
client.Server.Debug(
client,
"{0} >> PrivGrpMessage: PlayerId: {1} Message: {2}",
client.Character.characterName,
this.playerid,
this.message);
reader.Finish();
}
/// <summary>
/// Read chat command packet
/// </summary>
/// <param name="client">
/// Client sending
/// </param>
/// <param name="packet">
/// packet data
/// </param>
public void Read(Client client, byte[] packet)
{
PacketReader reader = new PacketReader(ref packet);
reader.ReadUInt16(); // Packet ID
reader.ReadUInt16(); // Data length
reader.ReadUInt16(); // ?
this.command = reader.ReadString();
this.value = reader.ReadString();
client.Server.Debug(
client,
"{0} >> ChatCommand: Command: {1} Value: {2}",
client.Character.characterName,
this.command,
this.value);
reader.Finish();
}
/// <summary>
/// Read and send back Player name lookup packet
/// </summary>
/// <param name="client">
/// Client sending
/// </param>
/// <param name="packet">
/// Packet data
/// </param>
public static void Read(Client client, byte[] packet)
{
PacketReader reader = new PacketReader(ref packet);
reader.ReadUInt16(); // packet ID
reader.ReadUInt16(); // data length
uint playerId = uint.MaxValue;
string playerName = reader.ReadString();
if (playerName == string.Empty)
{
return;
}
if (playerName == ConfigReadWrite.Instance.CurrentConfig.RelayBotNick)
{
byte[] botlookup = NameLookupResult.Create(
0x80000000,
ConfigReadWrite.Instance.CurrentConfig.RelayBotNick);
client.Send(botlookup);
client.Send(BuddyOnlineStatus.Create(0x80000000, 1, new byte[] { 0x00, 0x01, 0x00 }));
return;
}
client.Server.Debug(
client,
"{0} >> PlayerNameLookup: PlayerName: {1}",
client.Character.characterName,
playerName);
reader.Finish();
DBCharacter character = CharacterDao.GetByCharName(playerName);
if (character != null)
{
playerId = (uint)character.Id;
}
byte[] namelookup = NameLookupResult.Create(playerId, playerName);
client.Send(namelookup);
client.Send(
BuddyOnlineStatus.Create(
playerId,
(uint)OnlineDao.IsOnline((int)playerId).Online,
new byte[] { 0x00, 0x01, 0x00 }));
client.KnownClients.Add(playerId);
}
/// <summary>
/// Read buddy add packet
/// </summary>
/// <param name="client">
/// Client sending
/// </param>
/// <param name="packet">
/// Packet data
/// </param>
public static void Read(Client client, byte[] packet)
{
PacketReader reader = new PacketReader(ref packet);
reader.ReadUInt16(); // Packet ID
reader.ReadUInt16(); // Data length
uint playerId = reader.ReadUInt32();
ushort unknown1 = reader.ReadUInt16();
byte unknown2 = reader.ReadByte();
client.Server.Debug(
client,
"{0} >> BuddyAdd: PlayerID {1} Unknown1: {2} Unknown2: {3}",
client.Character.characterName,
playerId,
unknown1,
unknown2);
reader.Finish();
}
/// <summary>
/// Channel Data packet read
/// </summary>
/// <param name="client">
/// Client sending
/// </param>
/// <param name="packet">
/// Packet data
/// </param>
public void Read(Client client, byte[] packet)
{
PacketReader reader = new PacketReader(ref packet);
reader.ReadUInt16(); // Packet ID
reader.ReadUInt16(); // Data length
this.channelId = reader.ReadBytes(5);
this.mute = reader.ReadUInt16();
this.data = reader.ReadString();
client.Server.Debug(
client,
"{0} >> ChannelDataSet: Channel {1} {2} Mute: {3} Data: {4}",
client.Character.characterName,
this.channelId[0],
BitConverter.ToUInt32(this.channelId, 1),
this.mute,
this.data);
reader.Finish();
}
/// <summary>
/// Read Channel Mode packet
/// </summary>
/// <param name="client">
/// Client sending
/// </param>
/// <param name="packet">
/// packet data
/// </param>
public void Read(Client client, byte[] packet)
{
PacketReader reader = new PacketReader(ref packet);
reader.ReadUInt16(); // Packet ID
reader.ReadUInt16(); // Data length
this.channelId = reader.ReadBytes(5);
this.arg1 = reader.ReadUInt16();
this.arg2 = reader.ReadUInt16();
this.arg3 = reader.ReadUInt16();
this.arg4 = reader.ReadUInt16();
client.Server.Debug(
client,
"{0} >> ChannelMode: Channel: {1} {2} Arg1: {3} Arg2: {4} Arg3: {5} Arg4: {6}",
client.Character.characterName,
this.channelId[0],
BitConverter.ToUInt32(this.channelId, 1),
this.arg1,
this.arg2,
this.arg3,
this.arg4);
reader.Finish();
}
/// <summary>
/// Read and process Tell message
/// </summary>
/// <param name="client">
/// Client sending
/// </param>
/// <param name="packet">
/// Packet data
/// </param>
public static void Read(Client client, byte[] packet)
{
PacketReader reader = new PacketReader(ref packet);
reader.ReadUInt16();
reader.ReadUInt16();
uint playerId = reader.ReadUInt32();
string message = reader.ReadString();
client.Server.Debug(client, "{0} >> Tell: PlayerId: {1}", client.Character.characterName, playerId);
reader.Finish();
if (client.ChatServer().ConnectedClients.ContainsKey(playerId))
{
Client tellClient = (Client)client.ChatServer().ConnectedClients[playerId];
if (!tellClient.KnownClients.Contains(client.Character.CharacterId))
{
byte[] pname = PlayerName.Create(client, client.Character.CharacterId);
tellClient.Send(pname);
tellClient.KnownClients.Add(client.Character.CharacterId);
// TODO: Check if status bytes are correct even for offline chars
client.Send(
BuddyOnlineStatus.Create(
(uint)tellClient.Character.CharacterId,
(uint)OnlineDao.IsOnline((int)tellClient.Character.CharacterId).Online,
new byte[] { 0x00, 0x01, 0x00 }));
}
byte[] pgroup = MsgPrivateGroup.Create(client.Character.CharacterId, message, string.Empty);
tellClient.Send(pgroup);
}
else
{
byte[] sysmsg = MsgSystem.Create("Player not online.");
client.Send(sysmsg);
}
}
/// <summary>
/// </summary>
/// <param name="client">
/// </param>
/// <returns>
/// </returns>
private bool CheckGmStatus(Client client)
{
return client.Character.CharacterGMLevel > 0;
}
/// <summary>
/// The read.
/// </summary>
/// <param name="client">
/// </param>
/// <param name="packet">
/// </param>
public static void Read(Client client, ref byte[] packet)
{
MemoryStream m_stream = new MemoryStream(packet);
BinaryReader m_reader = new BinaryReader(m_stream);
// now we should do password check and then send OK or Error
// sending OK now
m_stream.Position = 12;
short userNameLength = IPAddress.NetworkToHostOrder(m_reader.ReadInt16());
string userName = Encoding.ASCII.GetString(m_reader.ReadBytes(userNameLength));
short loginKeyLength = IPAddress.NetworkToHostOrder(m_reader.ReadInt16());
string loginKey = Encoding.ASCII.GetString(m_reader.ReadBytes(loginKeyLength));
uint characterId = BitConverter.ToUInt32(new[] { packet[11], packet[10], packet[9], packet[8] }, 0);
LoginEncryption loginEncryption = new LoginEncryption();
if (loginEncryption.IsValidLogin(loginKey, client.ServerSalt, userName)
&& loginEncryption.IsCharacterOnAccount(userName, characterId))
{
byte[] loginok = LoginOk.Create();
client.Send(loginok);
}
else
{
byte[] loginerr = LoginError.Create();
client.Send(loginerr);
client.Server.DisconnectClient(client);
byte[] invalid = BitConverter.GetBytes(characterId);
ZoneCom.SendMessage(99, invalid);
return;
}
// save characters ID in client - note, this is usually 0 if it is a chat client connecting
client.Character = new Character(characterId, client);
// add client to connected clients list
if (!client.ChatServer().ConnectedClients.ContainsKey(client.Character.CharacterId))
{
client.ChatServer().ConnectedClients.Add(client.Character.CharacterId, client);
}
// add yourself to that list
client.KnownClients.Add(client.Character.CharacterId);
// and give client its own name lookup
byte[] pname = PlayerName.Create(client, client.Character.CharacterId);
client.Send(pname);
// send server welcome message to client
byte[] anonv = MsgAnonymousVicinity.Create(
string.Empty,
string.Format(
client.ChatServer().MessageOfTheDay,
AssemblyInfoclass.RevisionName + " " + AssemblyInfoclass.AssemblyVersion),
string.Empty);
client.Send(anonv);
client.ChatServer().AddClientToChannels(client);
}
/// <summary>
/// </summary>
/// <param name="text">
/// </param>
/// <param name="client">
/// </param>
/// <returns>
/// </returns>
private static bool ProcessServerCommand(string text, Client client)
{
if (text.StartsWith("."))
{
Program.ISCom.BroadCast(
new CellAO.Communication.Messages.ChatCommand
{
CharacterId = (int)client.Character.CharacterId,
ChatCommandString = text
});
return true;
}
return false;
}
/// <summary>
/// </summary>
/// <param name="client">
/// </param>
/// <returns>
/// </returns>
private bool CheckOmniRestriction(Client client)
{
return client.Character.CharacterSide == (int)Side.Omni;
}
/// <summary>
/// </summary>
/// <param name="client">
/// </param>
/// <returns>
/// </returns>
private bool CheckNeutralRestriction(Client client)
{
return client.Character.CharacterSide == (int)Side.Neutral;
}
/// <summary>
/// </summary>
/// <param name="client">
/// </param>
/// <returns>
/// </returns>
private bool CheckMonsterRestriction(Client client)
{
return client.Character.CharacterSide == (int)Side.Monster;
}
/// <summary>
/// </summary>
/// <param name="client">
/// </param>
/// <returns>
/// </returns>
private bool CheckAdvisorStatus(Client client)
{
return client.Character.CharacterSide == (int)Side.Advisor;
}
/// <summary>
/// Read Login Character packet
/// </summary>
/// <param name="client">
/// Client sending
/// </param>
/// <param name="packet">
/// packet data
/// </param>
public static void Read(Client client, byte[] packet)
{
PacketReader reader = new PacketReader(ref packet);
reader.ReadUInt16(); // Packet ID
reader.ReadUInt16(); // Data length
uint playerId = reader.ReadUInt32();
client.Server.Debug(
client,
"{0} >> LoginCharacter: PlayerID: {1}",
client.Character.characterName,
playerId);
reader.Finish();
if (client.IsBot)
{
CharacterDao.Instance.SetOnline((int)playerId);
}
DBCharacter character = CharacterDao.Instance.Get((int)playerId);
client.Character.CharacterId = playerId;
client.Character.characterName = character.Name;
client.Character.characterFirstName = character.FirstName;
client.Character.characterLastName = character.LastName;
client.ChatServer().AddClientToChannels(client);
if (client.IsBot)
{
// and give client its own name lookup
byte[] pname = PlayerName.Create(client, client.Character.CharacterId);
client.Send(pname);
// send server welcome message to client
byte[] anonv = MsgAnonymousVicinity.Create(
string.Empty,
string.Format(
client.ChatServer().MessageOfTheDay,
AssemblyInfoclass.RevisionName + " " + AssemblyInfoclass.AssemblyVersion),
string.Empty);
client.Send(anonv);
// TODO: Add Buddies List/BuddyOnlineStatus messages
foreach (ChannelBase channel in client.Channels)
{
byte[] channelJoin = ChannelJoin.Create(
channel.channelType,
channel.ChannelId,
channel.ChannelName,
channel.channelFlags,
new byte[] { 0x00, 0x00 });
client.Send(channelJoin);
}
if (!client.ChatServer().ConnectedClients.ContainsKey(client.Character.CharacterId))
{
client.ChatServer().ConnectedClients.Add(client.Character.CharacterId, client);
}
// add yourself to that list
client.KnownClients.Add(client.Character.CharacterId);
}
}
/// <summary>
/// The read.
/// </summary>
/// <param name="client">
/// </param>
/// <param name="packet">
/// </param>
public static void Read(Client client, ref byte[] packet)
{
client.Server.Debug(client, "{0} >> PrivGrpKickEveryone", client.Character.characterName);
// this packet should have no data
}
/// <summary>
/// </summary>
/// <param name="client">
/// </param>
/// <returns>
/// </returns>
private bool CheckGuardianStatus(Client client)
{
return client.Character.CharacterSide == (int)Side.Guardian;
}
/// <summary>
/// </summary>
/// <param name="sourceClient">
/// </param>
/// <param name="text">
/// </param>
/// <param name="blob">
/// </param>
public void ChannelMessage(Client sourceClient, string text, string blob = "")
{
byte[] channelMessageBytes = Packets.ChannelMessage.Create(
this,
sourceClient.Character.CharacterId,
text,
blob);
foreach (IClient client in this.clients)
{
client.Send(channelMessageBytes);
}
if (this.OnChannelMessage != null)
{
this.OnChannelMessage(
this,
new ChannelMessageEventArgs() { PlayerName = sourceClient.Character.characterName, Text = text });
}
}
/// <summary>
/// </summary>
/// <param name="client">
/// </param>
/// <returns>
/// </returns>
private bool CheckMixedRestriction(Client client)
{
return client.Character.CharacterSide == (int)Side.Mixed;
}
