private PacketResult CertificationAck(Session arg1, Packet arg2)
{
var result = new PacketResult(PacketResultAction.Replace);
_certificationManager.ReadAck(arg2);
foreach (var redirect in this.Service.Settings.Redirections)
{
if (_certificationManager.NodeLinks.ContainsKey(redirect.CoordID))
{
var link = _certificationManager.NodeLinks[redirect.CoordID];
var parentNode = _certificationManager.NodeData[link.ParentNodeID];
//SPOOF
//parentNode.NodeType = redirect.MachineID;
parentNode.Port = redirect.Port;
_certificationManager.NodeData[link.ParentNodeID] = parentNode;
}
else
{
StaticLogger.Logger[this.Name].Fatal($"Coord({redirect.CoordID}) not found. Redirect impossible, please check Filter.xml!");
}
}
var packet = new Packet(arg2.Opcode, arg2.Encrypted, arg2.Massive);
_certificationManager.WriteAck(packet, true, true);
result.Add(packet);
return result;
}
private void Handle()
{
var channel = Server.Channels.FirstOrDefault(c => c.Id == PacketResult.ChannelId);
Packet_PLAYER_SELECT_LOBBY.ChannelResult result;
if (channel == null)
{
result = Packet_PLAYER_SELECT_LOBBY.ChannelResult.CannotFind;
}
else if (channel.IsFull())
{
result = Packet_PLAYER_SELECT_LOBBY.ChannelResult.IsFull;
}
else
{
//Se o player já está em um canal
if (Player.Channel != null)
{
//Remove Player do canal
Player.Channel.Players.Model.Remove(Player);
}
channel.PlayerJoin(Player);
result = Packet_PLAYER_SELECT_LOBBY.ChannelResult.AllowAcess;
}
Player.SendResponse(PacketResult.GetChannelResult(result));
}
public PacketResult Process(byte[] payload, Blowfish blowfish)
{
if (payload.Length < Header.Length)
{
return(PacketResult.Malformed);
}
PacketHeader = payload.Copy(0, Header.Length).UnMarshal <Header>();
// missing data, need to wait for remaining data and combine
if (PacketHeader.Size > payload.Length)
{
return(PacketResult.Fragmented);
}
if (PacketHeader.SubPackets == 0)
{
return(PacketResult.Malformed);
}
var payloadData = new byte[PacketHeader.Size - Header.Length];
Buffer.BlockCopy(payload, Header.Length, payloadData, 0, payloadData.Length);
if (PacketHeader.Compressed == 1)
{
if (!ZlibProvider.Deflate(payloadData, out payloadData))
{
return(PacketResult.Malformed);
}
}
using (var stream = new MemoryStream(payloadData))
{
using (var reader = new BinaryReader(stream))
{
for (uint i = 0u; i < PacketHeader.SubPackets; i++)
{
SubPacket subPacket;
PacketResult result = SubPacket.Process(reader, blowfish, out subPacket);
if (result != PacketResult.Ok)
{
return(result);
}
SubPackets.Add(subPacket);
}
}
}
return(PacketResult.Ok);
}
private void OnRecvFromClient(IAsyncResult iar)
{
lock (this.LOCK) {
if (!this.m_isDisconnecting && this.m_canPacketProcess)
{
try {
int recvCount = this.m_clientSocket.EndReceive(iar);
if (recvCount == 0)
{
this.Stop(ClientDisconnectType.ONRECV_FROM_CLIENT_SIZE_ZERO);
return;
}
this.m_clientSecurity.Recv(m_clientBuffer, 0, recvCount);
List <Packet> clientRecevivePackets = this.m_clientSecurity.TransferIncoming();
if (clientRecevivePackets != null)
{
for (int i = 0; i < clientRecevivePackets.Count; i++)
{
Packet packet = clientRecevivePackets[i];
if (this.ServiceComponent.OnPacketReceived != null)
{
PacketResult result = this.ServiceComponent.OnPacketReceived(this.Client, PacketDatabase.GetPacketFrom(packet, PacketSocketType.CLIENT), PacketSocketType.CLIENT);
if (packet.Opcode != 0x9000 && packet.Opcode != 0x5000 && packet.Opcode != 0x2001)
{
DOPacketTransfer(packet, PacketSocketType.SERVER, result);
}
}
}
}
this.TransferToService();
this.DoRecvFromClient();
} catch (SocketException) {
this.Stop(ClientDisconnectType.CLIENT_DISCONNECTED);
} catch {
this.Stop(ClientDisconnectType.ONRECV_FROM_CLIENT);
}
}
}
}
protected override PacketResult ProcessPacket(BinaryReader br)
{
var position = br.BaseStream.Position;
br.BaseStream.Seek(4, SeekOrigin.Current);
var single = br.ReadSingle();
var single1 = br.ReadSingle();
var single2 = br.ReadSingle();
br.BaseStream.Seek(68, SeekOrigin.Current);
var num = br.ReadInt32();
br.BaseStream.Seek(num, SeekOrigin.Current);
var packetResult = new PacketResult
{
Read = br.BaseStream.Position - position,
CurrentPosition = new Point3D(single, single1, single2)
};
return(packetResult);
}
protected override PacketResult ProcessPacket(BinaryReader br)
{
int num;
var position = br.BaseStream.Position;
br.BaseStream.Seek(4, SeekOrigin.Current);
var single = br.ReadSingle();
var single1 = br.ReadSingle();
var single2 = br.ReadSingle();
if (NetworkProtocol != 2001)
{
if (NetworkProtocol != 7108 && NetworkProtocol != 1028)
{
num = 144;
}
else
{
num = 296;
}
}
else
{
num = 144;
}
br.BaseStream.Seek(num, SeekOrigin.Current);
var num1 = br.ReadInt32();
br.BaseStream.Seek(num1, SeekOrigin.Current);
var packetResult = new PacketResult
{
Read = br.BaseStream.Position - position,
CurrentPosition = new Result.Point3D(single, single1, single2)
};
return(packetResult);
}
public Tlv Add(TlvType type, PacketResult value)
{
return(this.Add(new Tlv(type, (UInt32)value)));
}
private PacketResult CertificationReq(Session arg1, Packet arg2)
{
var result = new PacketResult(PacketResultAction.Replace);
var response = new Packet(arg2.Opcode, arg2.Encrypted, arg2.Massive);
_certificationManager.ReadReq(arg2);
//_certificationManager.RequestIP = "192.168.178.10";
_certificationManager.WriteReq(response);
result.Add(response);
return result;
}
private void DOPacketTransfer(Packet packet, PacketSocketType direction, PacketResult result)
{
Security security = (direction == PacketSocketType.CLIENT) ? this.m_clientSecurity : this.m_serviceSecurity;
PacketOperationType operation = result.ResultType;
PacketResult.PacketResultInfo resultInfo = result.ResultInfo;
switch (operation)
{
case PacketOperationType.DISCONNECT:
if (resultInfo != null)
{
if (resultInfo is PacketResult.PacketDisconnectResultInfo disconnect)
{
if (!string.IsNullOrEmpty(disconnect.Notice))
{
this.SendMessage(MessageType.NOTICE, disconnect.Notice.Trim());
}
if (disconnect.DisconnectReason != null)
{
int id = Convert.ToInt32(disconnect.DisconnectReason);
//TODO: Complete
}
if (ServiceComponent.IsDebugMode)
{
Logger.PACKET.Print(LogLevel.Warning, "Packet Operation (DISCONNECT) received : " + packet.HexOpcode);
}
this.Stop(ClientDisconnectType.PACKET_OPERATION_DISCONNECT);
}
}
break;
case PacketOperationType.REPLACE:
if (resultInfo != null)
{
if (resultInfo is PacketResult.PacketReplaceResultInfo replace)
{
if (replace.Packet == packet)
{
if (ServiceComponent.IsDebugMode)
{
Logger.PACKET.Print(LogLevel.Warning, "Packet Operation (REPLACE) received : " + packet.HexOpcode);
}
replace.ReplaceWith.ForEach(packets => {
security.Send(packets);
});
}
}
}
break;
case PacketOperationType.INJECT:
if (resultInfo != null)
{
if (resultInfo is PacketResult.PacketInjectResultInfo inject)
{
if (ServiceComponent.IsDebugMode)
{
Logger.PACKET.Print(LogLevel.Warning, "Packet Operation (INJECT) received : " + packet.HexOpcode);
}
if (!inject.AfterPacket)
{
security.Send(packet);
}
if (inject.Packet == packet)
{
inject.InjectWith.ForEach(packets => {
security.Send(packets);
});
}
if (inject.AfterPacket)
{
security.Send(packet);
}
}
}
break;
case PacketOperationType.IGNORE:
if (ServiceComponent.IsDebugMode)
{
Logger.PACKET.Print(LogLevel.Warning, "Packet Operation (IGNORE) received : " + packet.HexOpcode);
}
break;
case PacketOperationType.RESPONSE:
if (resultInfo != null)
{
if (resultInfo is PacketResult.PacketResponseResultInfo response)
{
if (ServiceComponent.IsDebugMode)
{
Logger.PACKET.Print(LogLevel.Warning, "Packet Operation (SEND) received : " + packet.HexOpcode);
}
response.Packets.ForEach(packets => {
security.Send(packets);
});
}
}
security.Send(packet);
break;
case PacketOperationType.NOTHING:
security.Send(packet);
break;
default:
security.Send(packet);
break;
}
if (direction == PacketSocketType.CLIENT)
{
TransferToClient();
}
else if (direction == PacketSocketType.SERVER)
{
TransferToService();
}
}
