public static byte[] GetByteArrayFromPacket(Packets.Packet p)
{
if (p.Subpackets == null || p.Subpackets.Count == 0)
{
return(null);
}
byte[] bytes = new byte[0];
byte[] header = ByteUtils.ConvertStructToByteArray(p.Header);
foreach (Subpacket sp in p.Subpackets)
{
byte[] subheader = ByteUtils.ConvertStructToByteArray(sp.SubpacketHeader);
Array.Copy(subheader, 0, bytes, bytes.Length, 0);
if (sp.PacketData.GetType().Equals(typeof(List <Object>)))
{
foreach (Object d in (List <Object>)sp.PacketData)
{
byte[] subbody = ByteUtils.ConvertStructToByteArray(d);
Array.Copy(subbody, 0, bytes, bytes.Length, 0);
}
}
else
{
byte[] subbody = ByteUtils.ConvertStructToByteArray(sp.PacketData);
Array.Copy(subbody, 0, bytes, bytes.Length, 0);
}
}
return(bytes);
}
public unsafe void SendPacket(Packets.Packet pkt)
{
bool worked = false;
if (pkt.Outbound)
{
ETH_REQUEST Request = new ETH_REQUEST();
INTERMEDIATE_BUFFER *ib = pkt.IB;
Request.EthPacket.Buffer = (IntPtr)ib;
Request.hAdapterHandle = adapterHandle;
if (!Ndisapi.SendPacketToAdapter(hNdisapi, ref Request))
{
worked = false;
}
else
{
worked = true;
}
}
else
{
ETH_REQUEST Request = new ETH_REQUEST();
INTERMEDIATE_BUFFER *ib = pkt.IB;
Request.EthPacket.Buffer = (IntPtr)ib;
Request.hAdapterHandle = adapterHandle;
worked = Ndisapi.SendPacketToMstcp(hNdisapi, ref Request);
}
if (pkt.CodeGenerated)
{
pkt.ClearGeneratedPacket();
}
}
public override void Execute(Peer peer, bool hasReceivedArguments, string arguments = "")
{
Game _game = Program.ResolveDependency <Game>();
PlayerManager _playerManager = Program.ResolveDependency <PlayerManager>();
try
{
var s = arguments.Split(' ');
if (s.Length < 2)
{
_owner.SendDebugMsgFormatted(DebugMsgType.SYNTAXERROR);
ShowSyntax();
return;
}
var opcode = Convert.ToByte(s[1], 16);
var packet = new Packets.Packet((PacketCmdS2C)opcode);
var buffer = packet.getBuffer();
for (int i = 2; i < s.Length; i++)
{
if (s[i] == "netid")
{
buffer.Write(_playerManager.GetPeerInfo(peer).Champion.NetId);
}
else
{
buffer.Write(Convert.ToByte(s[i], 16));
}
}
_game.PacketHandlerManager.sendPacket(peer, packet, Channel.CHL_S2C);
}
catch { }
}
protected override void OnFillRequestDataPacket(Packets.Packet requestPacket)
{
base.OnFillRequestDataPacket(requestPacket);
requestPacket.DATA.Add(Setting.ChannelTrafficTimeout);
requestPacket.DATA.Add(Setting.InterCharacterTimeout);
requestPacket.DATA.Add(Setting.ResponseTimeout);
requestPacket.DATA.Add(Setting.NumberOfRetries);
}
//Force-trigger the IncreaseIndex() function within TargetApplication
//through our DLL.
public void TriggerIncreaseIndex()
{
Packets.Packet packet = new Packets.Packet()
{
Id = Packets.PacketType.IncreaseIndex
};
this._communication.Send <Packets.Packet>(packet);
}
protected override void OnFillRequestDataPacket(Packets.Packet requestPacket)
{
// <authenticate> ::= 53H <auth-req-length><auth-request>
byte[] authenticationRequest = DESEncryptor.EncryptTicket(_authenticationType.Ticket, _password);
base.OnFillRequestDataPacket(requestPacket);
requestPacket.DATA.AddRange(new byte[] { (byte)(authenticationRequest.Length + 1), 0x00 }); // muy raro pero hay que colocar un 0x00 antes del password encriptado.
requestPacket.DATA.AddRange(authenticationRequest);
}
/// <summary>
/// Event raised when a network packet is read from the file.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void Parser_PacketRead(object sender, PacketReadEventArgs e)
{
var packet = e.PacketRecord;
recordCount++;
try
{
var etherPacket = packet.EthernetPacket;
if (etherPacket != null && etherPacket.Proto == EtherType.IPv4)
{
var ipPacket = etherPacket.Data as IPv4Packet;
// Ignore loopback traffic. We can't distinguish direction if both sides are local.
// TODO create a more complex algoritm that allows this, but uses port instead. Would require client to not use server port range though.
if (ipPacket.SrcAddr.IsLocal && ipPacket.DestAddr.IsLocal)
{
return;
}
if (ipPacket != null && ipPacket.Proto == IPProtocolType.UDP)
{
var udpPacket = ipPacket.Data as UdpPacket;
// Only process udp packets inwhich one direction is within our server port range
if (
udpPacket != null &&
((udpPacket.SrcPort >= serverPortStart && udpPacket.SrcPort <= serverPortEnd) ||
(udpPacket.DestPort >= serverPortStart && udpPacket.DestPort <= serverPortEnd))
)
{
var sourceIP = new System.Net.IPEndPoint(ipPacket.SrcAddr.LongAddress, udpPacket.SrcPort);
// Create an Packet using byte data. Packet parses AC headers and fragments from the data.
#if NETWORKDEBUG
// Packet number for reference in UI
var ACPacket = new Packets.Packet(udpPacket.Data, sourceIP, packet.PacketNum);
#else
var ACPacket = new Packets.Packet(udpPacket.Data, sourceIP);
#endif
// Pass packet to defragmenter to extract messages
if (ipPacket.SrcAddr.IsLocal)
{
c2sDefragmenter.ProcessPacket(ACPacket);
}
else
{
s2cDefragmenter.ProcessPacket(ACPacket);
}
}
}
}
}
catch (Exception ex2)
{
string error = "Exception at packet " + packet.PacketNum + " of file " + FilePath.FullName;
var newEx = new Exception(error, ex2);
exceptions.Add(newEx);
}
}
public bool AnswerContactRequest(ContactRequest req, bool ack, out string message)
{
try
{
// Prepare the packet to send
Packets.ContactReqPacket packet = new Packets.ContactReqPacket(
(ack) ? Packets.PacketTypes.AcceptNewContact : Packets.PacketTypes.RegNewContact,
alea,
req.From.Username,
profile.Username
);
// send the package
udp.SendMessage(packet.Pack());
// Recieve packet
byte[] data = udp.RecieveMessage();
// Unpack the data and check the type
Packets.Packet p = Packets.Packet.Unpack <Packets.Packet>(data);
switch ((Packets.PacketTypes)p.Type)
{
case Packets.PacketTypes.ContactAck:
if (ack)
{
// Todo: Get Contacts info
DebugInfo("Answer Contact Request: Accepted " + req.From.Username + " correctly.");
}
else
{
DebugInfo("Answer Contact Request: Refused " + req.From.Username + " correctly.");
}
// Update the request list
GetContactRequestList(out message);
message = "Answered correctly";
return(true);
case Packets.PacketTypes.Error:
message = "Error: " + Packets.Packet.Unpack <Packets.AckErrorPacket>(data).Message;
DebugInfo("Answer Contact Request: " + message);
break;
default:
DebugInfo("Answer Contact Request: Unexpected type.");
message = "Error, unexpected type.";
break;
}
return(false);
}
catch (System.Net.Sockets.SocketException)
{
DebugInfo("Server is offline.");
message = "Server is offline.";
return(false);
}
}
//Unhook our DLL from TargetApplication, which restores it back to normal.
private void Unhook()
{
Packets.Packet packet = new Packets.Packet()
{
Id = Packets.PacketType.Terminate
};
this._communication.Send <Packets.Packet>(packet);
this._isHooked = false;
}
private void ServerClient_OnData(object sender, Packets.Packet e)
{
switch (e)
{
case ClientPacket cp:
ProcessClientPacket(cp);
break;
default:
_logger.LogWarning("Received from gameserver unknown packet: {0}", e.GetType().Name);
break;
}
}
public bool GetContactRequestList(out string message)
{
try
{
// Prepare the packet to send
Packets.BasicReqPacket packet = new Packets.BasicReqPacket(
Packets.PacketTypes.ListContactReq,
alea,
profile.Username
);
// send the package
udp.SendMessage(packet.Pack());
// Recieve packet
byte[] data = udp.RecieveMessage();
// Unpack the data and check the type
Packets.Packet p = Packets.Packet.Unpack <Packets.Packet>(data);
switch ((Packets.PacketTypes)p.Type)
{
case Packets.PacketTypes.ContactAck:
// Update contact requests list
Packets.ContactReqListPacket contactsRequests =
Packets.Packet.Unpack <Packets.ContactReqListPacket>(data);
profile.RecievedContactRequests = contactsRequests.Recieved;
profile.SentContactRequests = contactsRequests.Sent;
message = "Recieved list correctly";
return(true);
case Packets.PacketTypes.Error:
message = "Error: " + Packets.Packet.Unpack <Packets.AckErrorPacket>(data).Message;
DebugInfo("Contact request list: " + message);
break;
default:
DebugInfo("Contact request list: Unexpected type.");
message = "Error, unexpected type.";
break;
}
return(false);
}
catch (System.Net.Sockets.SocketException)
{
DebugInfo("Server is offline.");
message = "Server is offline.";
return(false);
}
}
public void SendPacket(Packets.Packet packet)
{
if (_DebugLogOutgoing)
{
Console.ForegroundColor = ConsoleColor.Blue;
Console.WriteLine("0x" + ((byte)packet.PacketId).ToString("X2") + ' ' + packet.PacketId.ToString());
if (_PacketDumpOutgoing)
{
packet.Dump();
}
}
stream.WriteByte((byte)packet.PacketId);
byte[] data = packet.Data;
stream.Write(data, 0, data.Length);
if (_DebugLogOutgoing)
{
Console.ForegroundColor = ConsoleColor.Gray;
}
}
public ClientPacketInfo(int i, Packets.Packet p)
{
id = i;
packet = p;
}
protected override void OnFillRequestDataPacket(Packets.Packet requestPacket)
{
base.OnFillRequestDataPacket(requestPacket);
requestPacket.DATA.Add(WaitTime);
}
internal PacketReceivedEventArgs(Packets.Packet netPacket)
{
Packet = netPacket;
}
public void ProcessPacket(Packets.Packet pkt)
{
processQueue.Enqueue(pkt);
}
public ClientPacketInfo(int i, Packets.Packet p)
{
id = i;
packet = p;
}
private void RunConnectedLoop()
{
while (connection.Connected)
{
try
{
int packetId_ = stream.ReadByte();
if (packetId_ == -1)
{
break;
}
byte packetId = (byte)packetId_;
Packets.Packet packet = Packets.Deserialize(packetId, stream);
if (_DebugLogIncoming)
{
Console.WriteLine("0x" + ((byte)packet.PacketId).ToString("X2") + ' ' + packet.PacketId.ToString());
if (_PacketDumpIncoming)
{
packet.Dump();
}
}
switch (packet.PacketId)
{
case Packets.PacketId.KeepAlive:
OnPacket_KeepAlive((Packets.KeepAlive)packet);
break;
case Packets.PacketId.LoginRequest:
OnPacket_LoginRequest((Packets.LoginRequestIncoming)packet);
break;
case Packets.PacketId.Handshake:
OnPacket_Handshake((Packets.HandshakeIncoming)packet);
break;
case Packets.PacketId.ChatMessage:
OnPacket_ChatMessage((Packets.ChatMessage)packet);
break;
case Packets.PacketId.TimeUpdate:
OnPacket_TimeUpdate((Packets.TimeUpdate)packet);
break;
case Packets.PacketId.EntityEquipment:
OnPacket_EntityEquipment((Packets.EntityEquipment)packet);
break;
case Packets.PacketId.SpawnPosition:
OnPacket_SpawnPosition((Packets.SpawnPosition)packet);
break;
case Packets.PacketId.UseEntity:
OnPacket_UseEntity((Packets.UseEntity)packet);
break;
case Packets.PacketId.UpdateHealth:
OnPacket_UpdateHealth((Packets.UpdateHealth)packet);
break;
case Packets.PacketId.Respawn:
OnPacket_Respawn((Packets.Respawn)packet);
break;
case Packets.PacketId.Player:
OnPacket_Player((Packets.Player)packet);
break;
case Packets.PacketId.PlayerPosition:
OnPacket_PlayerPosition((Packets.PlayerPosition)packet);
break;
case Packets.PacketId.PlayerLook:
OnPacket_PlayerLook((Packets.PlayerLook)packet);
break;
case Packets.PacketId.PlayerPositionAndLook:
OnPacket_PlayerPositionAndLook((Packets.PlayerPositionAndLookIncoming)packet);
break;
case Packets.PacketId.PlayerDigging:
OnPacket_PlayerDigging((Packets.PlayerDigging)packet);
break;
case Packets.PacketId.PlayerBlockPlacement:
OnPacket_PlayerBlockPlacement((Packets.PlayerBlockPlacement)packet);
break;
case Packets.PacketId.HoldingChange:
OnPacket_HoldingChange((Packets.HoldingChange)packet);
break;
case Packets.PacketId.UseBed:
OnPacket_UseBed((Packets.UseBed)packet);
break;
case Packets.PacketId.Animation:
OnPacket_Animation((Packets.Animation)packet);
break;
case Packets.PacketId.EntityAction:
OnPacket_EntityAction((Packets.EntityAction)packet);
break;
case Packets.PacketId.NamedEntitySpawn:
OnPacket_NamedEntitySpawn((Packets.NamedEntitySpawn)packet);
break;
case Packets.PacketId.PickupSpawn:
OnPacket_PickupSpawn((Packets.PickupSpawn)packet);
break;
case Packets.PacketId.CollectItem:
OnPacket_CollectItem((Packets.CollectItem)packet);
break;
case Packets.PacketId.AddObjectVehicle:
OnPacket_AddObjectVehicle((Packets.AddObjectVehicle)packet);
break;
case Packets.PacketId.MobSpawn:
OnPacket_MobSpawn((Packets.MobSpawn)packet);
break;
case Packets.PacketId.EntityPainting:
OnPacket_EntityPainting((Packets.EntityPainting)packet);
break;
case Packets.PacketId.UNKNOWN_1B:
OnPacket_UNKNOWN_1B((Packets.UNKNOWN_1B)packet);
break;
case Packets.PacketId.EntityVelocity:
OnPacket_EntityVelocity((Packets.EntityVelocity)packet);
break;
case Packets.PacketId.DestroyEntity:
OnPacket_DestroyEntity((Packets.DestroyEntity)packet);
break;
case Packets.PacketId.Entity:
OnPacket_Entity((Packets.Entity)packet);
break;
case Packets.PacketId.EntityRelativeMove:
OnPacket_EntityRelativeMove((Packets.EntityRelativeMove)packet);
break;
case Packets.PacketId.EntityLook:
OnPacket_EntityLook((Packets.EntityLook)packet);
break;
case Packets.PacketId.EntityLookAndRelativeMove:
OnPacket_EntityLookAndRelativeMove((Packets.EntityLookAndRelativeMove)packet);
break;
case Packets.PacketId.EntityTeleport:
OnPacket_EntityTeleport((Packets.EntityTeleport)packet);
break;
case Packets.PacketId.EntityStatus:
OnPacket_EntityStatus((Packets.EntityStatus)packet);
break;
case Packets.PacketId.AttachEntity:
OnPacket_AttachEntity((Packets.AttachEntity)packet);
break;
case Packets.PacketId.EntityMetadata:
OnPacket_EntityMetadata((Packets.EntityMetadata)packet);
break;
case Packets.PacketId.PreChunk:
OnPacket_PreChunk((Packets.PreChunk)packet);
break;
case Packets.PacketId.MapChunk:
OnPacket_MapChunk((Packets.MapChunk)packet);
break;
case Packets.PacketId.MultiBlockChange:
OnPacket_MultiBlockChange((Packets.MultiBlockChange)packet);
break;
case Packets.PacketId.BlockChange:
OnPacket_BlockChange((Packets.BlockChange)packet);
break;
case Packets.PacketId.PlayNoteBlock:
OnPacket_PlayNoteBlock((Packets.PlayNoteBlock)packet);
break;
case Packets.PacketId.Explosion:
OnPacket_Explosion((Packets.Explosion)packet);
break;
case Packets.PacketId.NewInvalidState:
OnPacket_NewInvalidState((Packets.NewInvalidState)packet);
break;
case Packets.PacketId.Thunderbolt:
OnPacket_Thunderbolt((Packets.Thunderbolt)packet);
break;
case Packets.PacketId.OpenWindow:
OnPacket_OpenWindow((Packets.OpenWindow)packet);
break;
case Packets.PacketId.CloseWindow:
OnPacket_CloseWindow((Packets.CloseWindow)packet);
break;
case Packets.PacketId.WindowClick:
OnPacket_WindowClick((Packets.WindowClick)packet);
break;
case Packets.PacketId.SetSlot:
OnPacket_SetSlot((Packets.SetSlot)packet);
break;
case Packets.PacketId.WindowItems:
OnPacket_WindowItems((Packets.WindowItems)packet);
break;
case Packets.PacketId.UpdateProgressBar:
OnPacket_UpdateProgressBar((Packets.UpdateProgressBar)packet);
break;
case Packets.PacketId.Transaction:
OnPacket_Transaction((Packets.Transaction)packet);
break;
case Packets.PacketId.UpdateSign:
OnPacket_UpdateSign((Packets.UpdateSign)packet);
break;
case Packets.PacketId.IncrementStatistic:
OnPacket_IncrementStatistic((Packets.IncrementStatistic)packet);
break;
case Packets.PacketId.DisconnectKick:
OnPacket_DisconnectKick((Packets.DisconnectKick)packet);
break;
default:
string message = "";
if (Enum.IsDefined(typeof(Packets.PacketId), packetId))
{
message = "Sambuca encountered unimplemented packet 0x" + packetId.ToString("X2") + " " + ((Packets.PacketId)packetId).ToString();
}
else
{
message = "Sambuca encountered unrecognised packet 0x" + packetId.ToString("X2");
}
SendPacket(new Packets.DisconnectKick(message));
Console.WriteLine(message);
connection.Close(); // DEBUG OPTION
break;
}
}
catch (Exception ex) { Console.WriteLine(ex.ToString()); }
}
}
