/// <inheritdoc />
public override Task WriteAsync(byte[] bytes, int offset, int count)
{
//We are making the assumption they are writing a full payload
//and opcode. So we only need to serialize ushort length
//and then the length and opcode should be encrypted
OutgoingClientPacketHeader header = new OutgoingClientPacketHeader(count - 2, (NetworkOperationCode)bytes.Reinterpret <short>(offset));
//We subtract 2 from the payload data length because first 2 bytes are opcode and header contains opcode.
//Then we reinterpet the first 2 bytes of the payload data because it's the opcode we need to use.
byte[] clientPacketHeader = Serializer.Serialize(header);
return(CryptAndSend(bytes, clientPacketHeader, offset, count));
}
/// <inheritdoc />
public virtual Task WriteAsync(TWritePayloadBaseType payload)
{
//Serializer the payload first so we can build the header
byte[] payloadData = Serializer.Serialize(payload);
OutgoingClientPacketHeader header = new OutgoingClientPacketHeader(payloadData.Length - 2, (NetworkOperationCode)payloadData.Reinterpret <short>(0));
//Console.WriteLine($"New ClientHeader: OpCode: {header.OperationCode} PacketSize: {header.PacketSize} PayloadSize: {header.PayloadSize}");
//We subtract 2 from the payload data length because first 2 bytes are opcode and header contains opcode.
//Then we reinterpet the first 2 bytes of the payload data because it's the opcode we need to use.
byte[] clientPacketHeader = Serializer.Serialize(header);
return(CryptAndSend(payloadData, clientPacketHeader, 0, payloadData.Length));
}
public async Task <NetworkIncomingMessage <TReadPayloadBaseType> > ReadAsync(CancellationToken token)
{
IPacketHeader header = null;
TReadPayloadBaseType payload = null;
using (await readSynObj.LockAsync(token).ConfigureAwait(false))
{
await ReadAsync(PacketPayloadReadBuffer, 0, 6, token)
.ConfigureAwait(false);
//Check crypto first. We may need to decrypt this header
if (CryptoService.isInitialized)
{
CryptoService.DecryptionService.ProcessBytes(PacketPayloadReadBuffer, 0, 6, PacketPayloadReadBuffer, 0);
}
OutgoingClientPacketHeader clientHeader = Serializer.Deserialize <OutgoingClientPacketHeader>(PacketPayloadReadBuffer, 0, 6);
//TODO: Enable this logging on Debug
//Console.WriteLine($"New ClientHeader: OpCode: {clientHeader.OperationCode} PacketSize: {clientHeader.PacketSize} PayloadSize: {clientHeader.PayloadSize}");
header = clientHeader;
//Console.WriteLine($"Recieved OpCode: {clientHeader.OperationCode}:{(ushort)clientHeader.OperationCode} from client Encrypted:{CryptoService.isInitialized}");
//If the header is null it means the socket disconnected
if (header == null)
{
return(null);
}
//if was canceled the header reading probably returned null anyway
if (token.IsCancellationRequested)
{
return(null);
}
//We need to start reading at 2 bytes so we can manually insert the opcode
//into the payload buffer
await ReadAsync(PacketPayloadReadBuffer, 2, header.PayloadSize, token)
.ConfigureAwait(false); //TODO: Should we timeout?
//RACE CONDITION. WE NEED TO LOCK AROUND READING FRM THIS BUFF
byte[] reinterpretedOpCode = ((short)clientHeader.OperationCode).Reinterpret();
PacketPayloadReadBuffer[0] = reinterpretedOpCode[0];
PacketPayloadReadBuffer[1] = reinterpretedOpCode[1];
//If the token was canceled then the buffer isn't filled and we can't make a message
if (token.IsCancellationRequested)
{
return(null);
}
//TODO: Revisit thbis to check if +2 is ok
//Deserialize the bytes starting from the begining but ONLY read up to the payload size. We reuse this buffer and it's large
//so if we don't specify the length we could end up with an issue.
//We have to read for and additional two bytes due to the payyload data shifted 2 bytes forward
payload = Serializer.Deserialize <TReadPayloadBaseType>(PacketPayloadReadBuffer, 0, header.PayloadSize + 2);
}
return(new NetworkIncomingMessage <TReadPayloadBaseType>(header, payload));
}