/*
* Buffer.BlockCopy(shortSamples, 0, packetBytes, 0, shortSamples.Length * sizeof(short)).
* -And the same trick works in reverse as well:
* Buffer.BlockCopy(packetBytes, readPosition, shortSamples, 0, payloadLength);
*/
public static bool UnpackPacket(byte[] buffer, int size,
NetworkChunkConstruct packet)
{
if (size < PACKET_HEADER_SIZE_WITHOUT_TOKEN ||
size > MAX_PACKET_SIZE)
{
Debug.Warning("network", $"packet too small, size={size}");
return(false);
}
packet.Flags = (PacketFlags)(buffer[0] >> 2);
packet.Ack = ((buffer[0] & 0x3) << 8) | buffer[1];
packet.NumChunks = buffer[2];
packet.DataSize = size - PACKET_HEADER_SIZE_WITHOUT_TOKEN;
packet.Token = 0;
if (packet.Flags.HasFlag(PacketFlags.CONNLESS))
{
if (size < DATA_OFFSET)
{
Debug.Warning("network", $"connection less packet too small, size={size}");
return(false);
}
packet.Flags = PacketFlags.CONNLESS;
packet.Ack = 0;
packet.NumChunks = 0;
packet.DataSize = size - DATA_OFFSET;
Buffer.BlockCopy(buffer, DATA_OFFSET, packet.Data, 0, packet.DataSize);
}
else
{
var dataStart = PACKET_HEADER_SIZE_WITHOUT_TOKEN;
if (packet.Flags.HasFlag(PacketFlags.TOKEN))
{
if (size < PACKET_HEADER_SIZE)
{
Debug.Warning("network", $"packet with token too small, {size}");
return(false);
}
dataStart = PACKET_HEADER_SIZE;
packet.DataSize -= 4;
packet.Token = buffer.ToUInt32(3);
}
if (packet.Flags.HasFlag(PacketFlags.COMPRESSION))
{
packet.DataSize = _huffman.Decompress(buffer, dataStart, packet.DataSize,
packet.Data, 0, MAX_PAYLOAD);
}
else
{
Buffer.BlockCopy(buffer, dataStart, packet.Data, 0, packet.DataSize);
}
/*if (flags.HasFlag(PacketFlags.COMPRESSION))
* {
* if (flags.HasFlag(PacketFlags.CONTROL))
* return false;
*
* dataSize = _huffman.Decompress(buffer, PACKET_HEADER_SIZE,
* dataSize, packet.Data, 0, MAX_PAYLOAD);
* }
* else
* {
* Buffer.BlockCopy(buffer, PACKET_HEADER_SIZE, packet.Data, 0, dataSize);
* }
*
* packet.Flags = flags;
* packet.Ack = ack;
* packet.NumChunks = numChunks;
* packet.DataSize = dataSize;*/
}
if (packet.DataSize < 0)
{
Debug.Warning("network", "error during packet decoding");
return(false);
}
return(true);
}
public static bool UnpackPacket(byte[] data, int dataSize,
ChunkConstruct chunkConstruct)
{
if (dataSize < PacketHeaderSize || dataSize > MaxPacketSize)
{
Debug.Log("network", $"packet size wrong, size={dataSize}");
return(false);
}
chunkConstruct.Flags = (PacketFlags)((data[0] & 0xfc) >> 2);
if (chunkConstruct.Flags.HasFlag(PacketFlags.Connless))
{
if (dataSize < PacketHeaderSizeConnless)
{
Debug.Log("network", $"connless packet too small, size={dataSize}");
return(false);
}
chunkConstruct.Flags = PacketFlags.Connless;
chunkConstruct.Ack = 0;
chunkConstruct.NumChunks = 0;
var version = data[0] & 0x3;
if (version != PacketVersion)
{
return(false);
}
chunkConstruct.DataSize = dataSize - PacketHeaderSizeConnless;
chunkConstruct.Token =
(uint)((data[1] << 24) |
(data[2] << 16) |
(data[3] << 8) |
(data[4]));
chunkConstruct.ResponseToken =
(uint)((data[5] << 24) |
(data[6] << 16) |
(data[7] << 8) |
(data[8]));
Buffer.BlockCopy(data, PacketHeaderSizeConnless,
chunkConstruct.Data, 0, chunkConstruct.DataSize);
}
else
{
if (dataSize - PacketHeaderSize > MaxPayload)
{
Debug.Log("network", $"packet payload too big, size={dataSize}");
return(false);
}
chunkConstruct.Ack = ((data[0] & 0x3) << 8) | data[1];
chunkConstruct.NumChunks = data[2];
chunkConstruct.DataSize = dataSize - PacketHeaderSize;
chunkConstruct.ResponseToken = TokenHelper.TokenNone;
chunkConstruct.Token =
(uint)((data[3] << 24) |
(data[4] << 16) |
(data[5] << 8) |
(data[6]));
if (chunkConstruct.Flags.HasFlag(PacketFlags.Compression))
{
chunkConstruct.DataSize = Huffman.Decompress(data, PacketHeaderSize,
chunkConstruct.DataSize, chunkConstruct.Data, 0, chunkConstruct.Data.Length);
}
else
{
Buffer.BlockCopy(data, PacketHeaderSize,
chunkConstruct.Data, 0, chunkConstruct.DataSize);
}
}
if (chunkConstruct.DataSize < 0)
{
Debug.Log("network", "error during packet decoding");
return(false);
}
if (chunkConstruct.Flags.HasFlag(PacketFlags.Control))
{
if (chunkConstruct.DataSize >= 5)
{
if (chunkConstruct.Data[0] == (int)ConnectionMessages.Connect ||
chunkConstruct.Data[0] == (int)ConnectionMessages.Token)
{
chunkConstruct.ResponseToken =
(uint)((chunkConstruct.Data[1] << 24) |
(chunkConstruct.Data[2] << 16) |
(chunkConstruct.Data[3] << 8) |
(chunkConstruct.Data[4]));
}
}
}
return(true);
}
