public void Read(BinaryReaderBE Reader)
{
Flags.Read(Reader);
Length = Reader.ReadUInt16BE();
if (Flags.IsReliable())
{
MessageIndex.Read(Reader);
}
if (Flags.IsSequenced())
{
SequenceIndex.Read(Reader);
}
if (Flags.IsSequenced() || Flags.IsOrdered())
{
OrderIndex.Read(Reader);
OrderChannel = Reader.ReadByte();
}
if (Flags.Split)
{
SplitCount = Reader.ReadUInt32BE();
SplitId = Reader.ReadUInt16BE();
SplitIndex = Reader.ReadUInt32BE();
}
Payload = Reader.ReadBytes(Length);
}
private Packet DecodePacketDecapsulated(Byte id, BinaryReaderBE reader)
{
Packet packet = null;
switch ((PacketId)id)
{
case PacketId.ConnectedPing: packet = new ConnectedPing(); break;
case PacketId.ConnectionRequest: packet = new ConnectionRequest(); break;
case PacketId.ConnectionRequestAccepted: packet = new ConnectionRequestAccepted(); break;
case PacketId.DisconnectionNotification: packet = new DisconnectionNotification(); break;
default:
packet = PacketConstructor(id);
if (packet == null)
{
throw new InvalidDataException("Unrecognized encapsulated packet ID");
}
break;
}
packet.Read(reader);
return(packet);
}
public void Read(BinaryReaderBE reader)
{
Byte flags = reader.ReadByte();
Split = (flags & 0x10) == 0x10;
Reliability = (EncapsulatedReliability)(flags >> 5);
}
private void HandlePacketDecapsulated(Byte id, BinaryReaderBE reader)
{
var packet = DecodePacketDecapsulated(id, reader);
if (packet is ConnectedPing)
{
HandleConnectedPing(packet as ConnectedPing);
}
else if (packet is ConnectionRequestAccepted)
{
HandleConnectionRequestAccepted(packet as ConnectionRequestAccepted);
}
else if (packet is DisconnectionNotification)
{
HandleDisconnectionNotification(packet as DisconnectionNotification);
}
else if (id >= 0x80)
{
PacketReceived(this, packet);
}
else
{
throw new Exception("Unhandled encapsulated packet");
}
}
public void Read(BinaryReaderBE Reader)
{
Byte b1 = Reader.ReadByte();
Byte b2 = Reader.ReadByte();
Byte b3 = Reader.ReadByte();
Number = (UInt32)b1 | ((UInt32)b2 << 8) | ((UInt32)b3 << 16);
}
private void HandleEncapsulatedPayload(byte[] payload)
{
using (var encapMemory = new MemoryStream(payload))
using (var encapStream = new BinaryReaderBE(encapMemory))
{
var encapId = encapStream.ReadByte();
HandlePacketDecapsulated(encapId, encapStream);
}
}
public void HandlePacket(Byte id, BinaryReaderBE reader)
{
var packet = DecodePacket(id, reader);
if (packet is Acknowledgement)
{
// TODO - ACK mechanism not handled
}
else if (packet is DataPacket)
{
var encap = (packet as DataPacket).WrappedPacket as EncapsulatedPacket;
HandleEncapsulatedPacket(packet as DataPacket, encap);
}
else
{
throw new Exception("Unhandled packet");
}
}
private Packet DecodePacket(Byte id, BinaryReaderBE reader)
{
Packet packet = null;
switch ((PacketId)id)
{
case PacketId.OpenConnectionRequest1: packet = new OpenConnectionRequest1(); break;
case PacketId.OpenConnectionResponse1: packet = new OpenConnectionResponse1(); break;
case PacketId.OpenConnectionRequest2: packet = new OpenConnectionRequest2(); break;
case PacketId.OpenConnectionResponse2: packet = new OpenConnectionResponse2(); break;
default: throw new InvalidDataException("Unrecognized packet ID");
}
packet.Read(reader);
return(packet);
}
private Packet DecodePacket(Byte id, BinaryReaderBE reader)
{
Packet packet = null;
if (id >= 0x80 && id < 0xA0)
{
var dataPkt = new DataPacket();
dataPkt.WrappedPacket = new EncapsulatedPacket();
packet = dataPkt;
}
else
{
switch ((PacketId)id)
{
case PacketId.ACK: packet = new Acknowledgement(); break;
default: throw new InvalidDataException("Unrecognized packet ID");
}
}
packet.Read(reader);
return(packet);
}
private void OnPacketReceived(IPEndPoint address, byte[] packet)
{
using (var stream = new MemoryStream(packet))
using (var reader = new BinaryReaderBE(stream))
{
byte id = reader.ReadByte();
if (id < 0x80)
{
var decoded = DecodePacket(id, reader);
HandlePacket(address, decoded);
}
else
{
if (Session != null)
{
Session.HandlePacket(id, reader);
}
else
{
throw new Exception("Unhandled session packet - no session established!");
}
}
}
}
