public void TransferTo(AlternativeCompositeByteBuf buf)
{
DataBuffer copy = ShallowCopy();
foreach (var buffer in copy._buffers)
{
buf.AddComponent(buffer);
AlreadyTransferred += buffer.ReadableBytes;
}
}
public bool DecodeDone(AlternativeCompositeByteBuf buffer, IPublicKey publicKey, ISignatureFactory signatureFactory)
{
if (IsSigned)
{
if (publicKey == PeerBuilder.EmptyPublicKey)
{
PublicKey = publicKey;
}
return(DecodeDone(buffer, signatureFactory));
}
return(true);
}
public bool DecodeDone(AlternativeCompositeByteBuf buffer, ISignatureFactory signatureFactory)
{
if (IsSigned)
{
Signature = signatureFactory.SignatureCodec;
if (buffer.ReadableBytes < Signature.SignatureSize)
{
return(false);
}
Signature.Read(buffer);
}
return(true);
}
public bool EncodeBuffer(AlternativeCompositeByteBuf buffer)
{
var already = _buffer.AlreadyTransferred;
var remaining = Length - already;
if (remaining == 0)
{
// already finished
return(true);
}
_buffer.TransferTo(buffer);
return(_buffer.AlreadyTransferred == Length);
}
/// <summary>
/// Add data to the buffer.
/// </summary>
/// <param name="buffer">The buffer to append.</param>
/// <returns></returns>
public bool DecodeBuffer(AlternativeCompositeByteBuf buffer)
{
int already = _buffer.AlreadyTransferred;
int remaining = Length - already;
if (remaining == 0)
{
// already finished
return(true);
}
// make sure it gets not garbage collected. But we need to keep track of
// it and when this object gets collected, we need to release the buffer
int transfered = _buffer.TransferFrom(buffer, remaining);
return(transfered == remaining);
}
public void EncodeDone(AlternativeCompositeByteBuf buffer, ISignatureFactory signatureFactory, IPrivateKey messagePrivateKey)
{
if (IsSigned)
{
if (Signature == null && PrivateKey != null)
{
Signature = signatureFactory.Sign(PrivateKey, _buffer.ToByteBuf());
}
else if (Signature == null && messagePrivateKey != null)
{
Signature = signatureFactory.Sign(messagePrivateKey, _buffer.ToByteBuf());
}
else if (Signature == null)
{
throw new ArgumentException("A private key is required to sign.");
}
Signature.Write(buffer);
}
}
public static Data DeocdeHeader(AlternativeCompositeByteBuf buffer, ISignatureFactory signatureFactory)
{
// 2 is the smallest packet size, we could start if we know 1 byte to
// decode the header, but we always need a second byte. Thus, we are waiting for at least 2 bytes.
if (buffer.ReadableBytes < 2 * Utils.Utils.ByteByteSize)
{
return(null);
}
int header = buffer.GetUByte(buffer.ReaderIndex);
DataType type = Type(header);
// length
int length;
int indexLength = Utils.Utils.ByteByteSize;
int indexTtl;
switch (type)
{
case DataType.Small:
length = buffer.GetUByte(buffer.ReaderIndex + indexLength);
indexTtl = indexLength + Utils.Utils.ByteByteSize;
break;
case DataType.Large:
indexTtl = indexLength + Utils.Utils.IntegerByteSize;
if (buffer.ReadableBytes < indexTtl)
{
return(null);
}
length = buffer.GetInt(buffer.ReaderIndex + indexLength);
break;
default:
throw new ArgumentException("Unknown DataType.");
}
// TTL
int ttl;
int indexBasedOnNr;
if (CheckHasTtl(header))
{
indexBasedOnNr = indexTtl + Utils.Utils.IntegerByteSize;
if (buffer.ReadableBytes < indexBasedOnNr)
{
return(null);
}
ttl = buffer.GetInt(buffer.ReaderIndex + indexTtl);
}
else
{
indexBasedOnNr = indexTtl;
ttl = -1;
}
// nr basedOn + basedOn
int numBasedOn;
int indexPublicKeySize;
int indexBasedOn;
var basedOn = new List <Number160>();
if (CheckHasBasedOn(header))
{
// get nr of basedOn keys
indexBasedOn = indexBasedOnNr + Utils.Utils.ByteByteSize;
if (buffer.ReadableBytes < indexBasedOn)
{
return(null);
}
numBasedOn = buffer.GetUByte(buffer.ReaderIndex + indexBasedOn) + 1;
indexPublicKeySize = indexBasedOn + (numBasedOn * Number160.ByteArraySize);
if (buffer.ReadableBytes < indexPublicKeySize)
{
return(null);
}
// get basedOn
int index = buffer.ReaderIndex + indexBasedOnNr + Utils.Utils.ByteByteSize;
var me = new sbyte[Number160.ByteArraySize];
for (int i = 0; i < numBasedOn; i++)
{
buffer.GetBytes(index, me);
index += Number160.ByteArraySize;
basedOn.Add(new Number160(me));
}
}
else
{
indexPublicKeySize = indexBasedOnNr;
numBasedOn = 0;
}
// public key + size
int publicKeySize;
int indexPublicKey;
int indexEnd;
IPublicKey publicKey;
if (CheckHasPublicKey(header))
{
// get public key size
indexPublicKey = indexPublicKeySize + Utils.Utils.ShortByteSize;
if (buffer.ReadableBytes < indexPublicKey)
{
return(null);
}
publicKeySize = buffer.GetUShort(buffer.ReaderIndex + indexPublicKeySize);
indexEnd = indexPublicKey + publicKeySize;
if (buffer.ReadableBytes < indexEnd)
{
return(null);
}
// get public key
buffer.SkipBytes(indexPublicKeySize);
publicKey = signatureFactory.DecodePublicKey(buffer);
}
else
{
publicKeySize = 0;
indexPublicKey = indexPublicKeySize;
buffer.SkipBytes(indexPublicKey);
publicKey = null;
}
// now, we have read the header and the length
var data = new Data(header, length);
data.TtlSeconds = ttl;
data.BasedOnSet = basedOn;
data.PublicKey = publicKey;
return(data);
}
public void EncodeDone(AlternativeCompositeByteBuf buffer, ISignatureFactory signatureFactory)
{
EncodeDone(buffer, signatureFactory, null);
}
public void EncodeHeader(AlternativeCompositeByteBuf buffer, ISignatureFactory signatureFactory)
{
int header = (int)_type; // TODO check if works
if (HasPrepareFlag)
{
header |= 0x02;
}
if (IsFlag1)
{
header |= 0x04;
}
if (IsFlag2)
{
header |= 0x08;
}
if (_ttl)
{
header |= 0x10;
}
if (IsSigned && HasPublicKey && IsProtectedEntry)
{
header |= (0x20 | 0x40);
}
else if (IsSigned && HasPublicKey)
{
header |= 0x40;
}
else if (HasPublicKey)
{
header |= 0x20;
}
if (_basedOnFlag)
{
header |= 0x80;
}
switch (_type)
{
case DataType.Small:
buffer.WriteByte((sbyte)header); // TODO remove cast
buffer.WriteByte((sbyte)Length);
break;
case DataType.Large:
buffer.WriteByte((sbyte)header); // TODO remove cast
buffer.WriteInt(Length);
break;
default:
throw new ArgumentException("Unknown DataType.");
}
if (_ttl)
{
buffer.WriteInt(TtlSeconds);
}
if (_basedOnFlag)
{
buffer.WriteByte((sbyte)(BasedOnSet.Count() - 1)); // TODO remove cast
foreach (var basedOn in BasedOnSet)
{
buffer.WriteBytes(basedOn.ToByteArray());
}
}
if (HasPublicKey)
{
if (PublicKey == null)
{
buffer.WriteShort(0);
}
else
{
signatureFactory.EncodePublicKey(PublicKey, buffer);
}
}
}
