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); } } }