/// <inheritdoc/> public override int Read(byte[] buffer, int offset, int count) { if (buffer == null) { throw new ArgumentNullException("buffer"); } if (offset < 0 || offset > buffer.Length) { throw new ArgumentOutOfRangeException("offset"); } if (count < 0 || offset + count > buffer.Length) { throw new ArgumentOutOfRangeException("count"); } ThrowIfDisposed(); if (_position >= _length) { return(0); } var available = _length - _position; if (count > available) { count = available; } _buffer.GetBytes(_position, buffer, offset, count); _position += count; return(count); }
public void TestCopyingToOutputStream() { IByteBuffer buf1 = Unpooled.DirectBuffer(10); IByteBuffer buf2 = Unpooled.Buffer(10); IByteBuffer buf3 = Unpooled.DirectBuffer(10); buf1.WriteBytes(Encoding.ASCII.GetBytes("a")); buf2.WriteBytes(Encoding.ASCII.GetBytes("b")); buf3.WriteBytes(Encoding.ASCII.GetBytes("c")); IByteBuffer composite = Unpooled.WrappedUnmodifiableBuffer(buf1, buf2, buf3); IByteBuffer copy = Unpooled.DirectBuffer(3); IByteBuffer copy2 = Unpooled.Buffer(3); var copyStream = new ByteBufferStream(copy); var copy2Stream = new ByteBufferStream(copy2); try { composite.GetBytes(0, copyStream, 3); composite.GetBytes(0, copy2Stream, 3); Assert.Equal(0, ByteBufferUtil.Compare(copy, composite)); Assert.Equal(0, ByteBufferUtil.Compare(copy2, composite)); Assert.Equal(0, ByteBufferUtil.Compare(copy, copy2)); } finally { copy.Release(); copy2.Release(); copyStream.Close(); copy2Stream.Close(); composite.Release(); } }
public override byte[] GetBytes() { if (_byteBuf is null) { return(Unpooled.Empty.Array); } var array = new byte[_byteBuf.ReadableBytes]; _ = _byteBuf.GetBytes(_byteBuf.ReaderIndex, array); return(array); }
public static byte[] Split(IByteBuffer buffer) { var rdx = 0; var crcBytes = new byte[2]; var crc = 0; var length = 0; var valid = false; while (true) { // 可读字节数小于最小报文长度 if (buffer.ReadableBytes < LoraConst.MinLength) { return(null); } // 确定帧头的位置 if (LoraConst.StartSign != buffer.GetByte(rdx)) { rdx = GetStartIndex(buffer, LoraConst.StartSign); } // 没有找到帧头 if (rdx == -1) { return(null); } buffer.SetReaderIndex(rdx); var lengthBytes = new byte[2]; buffer.GetBytes(rdx + 23, lengthBytes); length = BytesUtil.Bytes2Int16(lengthBytes); if (buffer.ReadableBytes < LoraConst.MinLength + length) { rdx++; buffer.SetReaderIndex(rdx); continue; } var content = new byte[25 + length]; buffer.GetBytes(rdx, content); buffer.GetBytes(rdx + 25 + length, crcBytes); crc = CRC16.calcCrc16(content); valid = BytesUtil.ByteArrayEquals(crcBytes, BytesUtil.Int16ToBytes((Int16)crc)); if (!valid) { rdx++; buffer.SetReaderIndex(rdx); continue; } var msg = new byte[LoraConst.MinLength + length]; buffer.ReadBytes(msg); return(msg); } }
/// <summary> /// Return an array of the underlying storage from <paramref name="buf"/> into a byte array. /// The copy will start at {@code start} and copy {@code length} bytes. /// If <paramref name="copy"/> is true a copy will be made of the memory. /// If <paramref name="copy"/> is false the underlying storage will be shared, if possible. /// </summary> /// <param name="buf"></param> /// <param name="start"></param> /// <param name="length"></param> /// <param name="copy"></param> /// <returns></returns> public static byte[] GetBytes(IByteBuffer buf, int start, int length, bool copy) { var capacity = buf.Capacity; if (MathUtil.IsOutOfBounds(start, length, capacity)) { ThrowHelper.ThrowIndexOutOfRangeException_Expected(start, length, capacity); } if (buf.HasArray) { if (copy || start != 0 || length != capacity) { int baseOffset = buf.ArrayOffset + start; var bytes = new byte[length]; PlatformDependent.CopyMemory(buf.Array, baseOffset, bytes, 0, length); return(bytes); } else { return(buf.Array); } } byte[] v = new byte[length]; _ = buf.GetBytes(start, v); return(v); }
public override void SetContent(IByteBuffer buffer) { Contract.Requires(buffer != null); try { this.Size = buffer.ReadableBytes; this.CheckSize(this.Size); if (this.DefinedSize > 0 && this.DefinedSize < this.Size) { throw new IOException($"Out of size: {this.Size} > {this.DefinedSize}"); } if (this.fileStream == null) { this.fileStream = this.TempFile(); } if (buffer.ReadableBytes == 0) { // empty file return; } buffer.GetBytes(buffer.ReaderIndex, this.fileStream, buffer.ReadableBytes); buffer.SetReaderIndex(buffer.ReaderIndex + buffer.ReadableBytes); this.fileStream.Flush(); this.SetCompleted(); } finally { // Release the buffer as it was retained before and we not need a reference to it at all // See https://github.com/netty/netty/issues/1516 buffer.Release(); } }
internal static void SetBytes(AbstractByteBuffer buf, byte *addr, int index, IByteBuffer src, int srcIndex, int length) { if (MathUtil.IsOutOfBounds(srcIndex, length, src.Capacity)) { throw new IndexOutOfRangeException($"srcIndex: {srcIndex}"); } if (length != 0) { if (src.HasMemoryAddress) { IntPtr ptr = src.AddressOfPinnedMemory(); if (ptr != IntPtr.Zero) { PlatformDependent.CopyMemory((byte *)(ptr + srcIndex), addr, length); } else { fixed(byte *source = &src.GetPinnableMemoryAddress()) { PlatformDependent.CopyMemory(source + srcIndex, addr, length); } } } else if (src.HasArray) { PlatformDependent.CopyMemory(src.Array, src.ArrayOffset + srcIndex, addr, length); } else { src.GetBytes(srcIndex, buf, index, length); } } }
private byte[] GetBytes(int length) { byte[] dest = new byte[length]; buffer.GetBytes(buffer.ReaderIndex, dest); return(dest); }
private byte[] ToByteArray(IByteBuffer buffer) { var bytes = new byte[buffer.Length]; buffer.GetBytes(0, bytes, 0, buffer.Length); return(bytes); }
/// <inheritdoc/> public void GetBytes(int position, byte[] destination, int offset, int count) { EnsureValidPositionAndCount(position, count); ThrowIfDisposed(); _buffer.GetBytes(position + _offset, destination, offset, count); }
public override void ChannelRead(IChannelHandlerContext context, object message) { IByteBuffer buffer = (IByteBuffer)message; try { byte[] data = new byte[buffer.ReadableBytes]; buffer.GetBytes(buffer.ReaderIndex, data); string datajson = LZ4MessagePackSerializer.ToJson(data); var convertedMsg = _serializer.Deserialize <string, TransportMsg>(datajson); if (convertedMsg.ContentType == typeof(RemoteCallData).FullName) { convertedMsg.Content = _serializer.Deserialize <object, RemoteCallData>(convertedMsg.Content); } else if (convertedMsg.ContentType == typeof(RemoteCallBackData).FullName) { convertedMsg.Content = _serializer.Deserialize <object, RemoteCallBackData>(convertedMsg.Content); } context.FireChannelRead(convertedMsg); } finally { buffer.Release(); } }
public void SetContentFromStream() { var random = new Random(); for (int i = 0; i < 20; i++) { // Generate input data bytes. int size = random.Next(short.MaxValue); var bytes = new byte[size]; random.NextBytes(bytes); // Generate parsed HTTP data block. var httpData = new TestHttpData("name", Encoding.UTF8, 0); httpData.SetContent(new MemoryStream(bytes)); // Validate stored data. IByteBuffer buffer = httpData.GetByteBuffer(); Assert.Equal(0, buffer.ReaderIndex); Assert.Equal(bytes.Length, buffer.WriterIndex); var data = new byte[bytes.Length]; buffer.GetBytes(buffer.ReaderIndex, data); Assert.True(data.SequenceEqual(bytes)); } }
public static IByteBuffer GetBytes(this IByteBuffer buf, int index, IByteBuffer destination, int length) { var writerIdx = destination.WriterIndex; _ = buf.GetBytes(index, destination, writerIdx, length); _ = destination.SetWriterIndex(writerIdx + length); return(buf); }
protected override void Decode(IChannelHandlerContext context, IByteBuffer message, List <object> output) { var len = message.ReadableBytes; var array = new byte[len]; message.GetBytes(message.ReaderIndex, array, 0, len); output.Add(_serialize.Deserializes <T>(array)); }
protected override void Decode(IChannelHandlerContext context, IByteBuffer message, List <object> output) { var len = message.ReadableBytes; var array = new byte[len]; message.GetBytes(message.ReaderIndex, array, 0, len); //output.Add(SerializerHelper.Deserialize<TransportMessage<T>>(array)); output.Add(Codec.Deserialize(array, typeof(T))); }
protected override void Decode(IChannelHandlerContext context, IByteBuffer input, List <object> output) { byte[] array = new byte[input.ReadableBytes]; input.GetBytes(input.ReaderIndex, array, 0, input.ReadableBytes); input.Clear(); var msg = new Message(); output.Add(msg.Prase(array)); }
private static void SetBytes0(AbstractByteBuffer buf, byte *addr, int index, IByteBuffer src, int srcIndex, int length) { if (src.HasArray) { PlatformDependent.CopyMemory(src.Array, src.ArrayOffset + srcIndex, addr, length); } else { _ = src.GetBytes(srcIndex, buf, index, length); } }
/// <summary> /// Copies a slice of a frame representing a part of a bigger string in a temporary buffer to be reassembled. </summary> /// <param name="startIndex"> starting index (inclusive) </param> /// <param name="endIndex"> ending index (exclusive) </param> private void copyLinePart(IByteBuffer buf, int startIndex, int endIndex) { try { buf.GetBytes(startIndex, linePart, endIndex - startIndex); } catch (IOException e) { log.Error("Unexpected exception", e); // should not happen } }
public static IByteBuffer DecompressGzip(this IByteBuffer buffer) { var data = buffer.GetBytes(); using (var compressedStream = new MemoryStream(data)) using (var zipStream = new GZipStream(compressedStream, CompressionMode.Decompress)) using (var resultStream = new MemoryStream()) { zipStream.CopyTo(resultStream); return(Unpooled.WrappedBuffer(resultStream.ToArray())); } }
public static IByteBuffer CompressGzip(this IByteBuffer buffer) { var data = buffer.GetBytes(); using (var compressedStream = new MemoryStream(data)) using (var zipStream = new GZipStream(compressedStream, CompressionMode.Compress)) { zipStream.Write(data, 0, data.Length); zipStream.Close(); return(Unpooled.WrappedBuffer(compressedStream.ToArray())); } }
public override IByteBuffer SetBytes(int index, IByteBuffer src, int srcIndex, int length) { this.CheckSrcIndex(index, length, srcIndex, src.Capacity); if (src.HasArray) { this.SetBytes(index, src.Array, src.ArrayOffset + srcIndex, length); } else { src.GetBytes(srcIndex, this.Memory, this.Idx(index), length); } return(this); }
public void SetContentFromStream() { // definedSize=0 TestHttpData test = new TestHttpData("test", Encoding.UTF8, 0); string contentStr = "foo_test"; var buf = Unpooled.WrappedBuffer(Encoding.UTF8.GetBytes(contentStr)); buf.MarkReaderIndex(); var bs = new ByteBufferStream(buf); try { test.SetContent(bs); Assert.False(buf.IsReadable()); Assert.Equal(test.GetString(Encoding.UTF8), contentStr); buf.ResetReaderIndex(); Assert.True(ByteBufferUtil.Equals(buf, test.GetByteBuffer())); } finally { bs.Close(); } var random = new Random(); for (int i = 0; i < 20; i++) { // Generate input data bytes. int size = random.Next(short.MaxValue); var bytes = new byte[size]; random.NextBytes(bytes); // Generate parsed HTTP data block. var httpData = new TestHttpData("name", Encoding.UTF8, 0); httpData.SetContent(new MemoryStream(bytes)); // Validate stored data. IByteBuffer buffer = httpData.GetByteBuffer(); Assert.Equal(0, buffer.ReaderIndex); Assert.Equal(bytes.Length, buffer.WriterIndex); var data = new byte[bytes.Length]; buffer.GetBytes(buffer.ReaderIndex, data); Assert.True(data.AsSpan().SequenceEqual(bytes)); } }
public bool IsAndroidQQProtocol(IByteBuffer buffer) { if (buffer.ReadableBytes < 9) { return(false); } byte[] tag = new byte[5]; buffer.GetBytes(buffer.ReaderIndex + 4, tag, 0, 5); return(((IStructuralEquatable)tag).Equals(ANDROIDQQ_PROTOCOL_MARK1, StructuralEqualityComparer) || ((IStructuralEquatable)tag).Equals(ANDROIDQQ_PROTOCOL_MARK2, StructuralEqualityComparer) || ((IStructuralEquatable)tag).Equals(ANDROIDQQ_PROTOCOL_MARK3, StructuralEqualityComparer) || ((IStructuralEquatable)tag).Equals(ANDROIDQQ_PROTOCOL_MARK4, StructuralEqualityComparer) || ((IStructuralEquatable)tag).Equals(ANDROIDQQ_PROTOCOL_MARK5, StructuralEqualityComparer) || ((IStructuralEquatable)tag).Equals(ANDROIDQQ_PROTOCOL_MARK6, StructuralEqualityComparer)); }
private void checkCRC(IByteBuffer @in, int startIndex) { int endIndex = @in.ReaderIndex; int expectedCrc = @in.ReadInt(); byte[] frame = new byte[endIndex - startIndex]; @in.GetBytes(startIndex, frame, 0, endIndex - startIndex); int actualCrc = CrcUtil.crc32(frame); if (expectedCrc != actualCrc) { string err = "CRC check failed!"; logger.LogError(err); throw new Exception(err); } }
/// <summary> /// Creates a new big-endian buffer whose content is a copy of the specified <see cref="Array" />. /// The new buffer's <see cref="IByteBuffer.ReaderIndex" /> and <see cref="IByteBuffer.WriterIndex" /> /// are <c>0</c> and <see cref="IByteBuffer.Capacity" /> respectively. /// </summary> /// <param name="buffer">A buffer we're going to copy.</param> /// <returns>The new buffer that copies the contents of <see cref="buffer" />.</returns> public static IByteBuffer CopiedBuffer(IByteBuffer buffer) { Contract.Requires(buffer != null); int length = buffer.ReadableBytes; if (length == 0) { return(Empty); } var copy = new byte[length]; // Duplicate the buffer so we do not adjust our position during our get operation IByteBuffer duplicate = buffer.Duplicate(); duplicate.GetBytes(0, copy); return(WrappedBuffer(copy).WithOrder(duplicate.Order)); }
public sealed override IByteBuffer SetBytes(int index, IByteBuffer src, int srcIndex, int length) { if (src is null) { ThrowHelper.ThrowArgumentNullException(ExceptionArgument.src); } CheckSrcIndex(index, length, srcIndex, src.Capacity); if (src.HasArray) { _ = SetBytes(index, src.Array, src.ArrayOffset + srcIndex, length); } else { _ = src.GetBytes(srcIndex, Memory, Idx(index), length); } return(this); }
/// <summary> /// Creates a new big-endian buffer whose content is a merged copy of the specified <see cref="Array" />. /// The new buffer's <see cref="IByteBuffer.ReaderIndex" /> and <see cref="IByteBuffer.WriterIndex" /> /// are <c>0</c> and <see cref="IByteBuffer.Capacity" /> respectively. /// </summary> /// <param name="buffers">Buffers we're going to copy.</param> /// <returns>The new buffer that copies the contents of buffers.</returns> public static IByteBuffer CopiedBuffer(params IByteBuffer[] buffers) { switch (buffers.Length) { case 0: return(Empty); case 1: return(CopiedBuffer(buffers[0])); } // Merge the specified buffers into one buffer. int length = 0; foreach (IByteBuffer b in buffers) { int bLen = b.ReadableBytes; if (bLen <= 0) { continue; } if (int.MaxValue - length < bLen) { throw new ArgumentException("The total length of the specified buffers is too big."); } length += bLen; } if (length == 0) { return(Empty); } var mergedArray = new byte[length]; for (int i = 0, j = 0; i < buffers.Length; i++) { IByteBuffer b = buffers[i]; int bLen = b.ReadableBytes; b.GetBytes(b.ReaderIndex, mergedArray, j, bLen); j += bLen; } return(WrappedBuffer(mergedArray)); }
/// <summary> /// 获取IByteBuffer中的byte[] /// </summary> /// <param name="byteBuffer">IByteBuffer</param> /// <returns></returns> public static byte[] ToArray(this IByteBuffer byteBuffer) { int readableBytes = byteBuffer.ReadableBytes; if (readableBytes == 0) { return ArrayExtensions.ZeroBytes; } if (byteBuffer.HasArray) { return byteBuffer.Array.Slice(byteBuffer.ArrayOffset + byteBuffer.ReaderIndex, readableBytes); } var bytes = new byte[readableBytes]; byteBuffer.GetBytes(byteBuffer.ReaderIndex, bytes); return bytes; }
/// <summary> /// Creates a new big-endian buffer whose content is a merged copy of the specified <see cref="Array" />. /// The new buffer's <see cref="IByteBuffer.ReaderIndex" /> and <see cref="IByteBuffer.WriterIndex" /> /// are <c>0</c> and <see cref="IByteBuffer.Capacity" /> respectively. /// </summary> /// <param name="buffers">Buffers we're going to copy.</param> /// <returns>The new buffer that copies the contents of buffers.</returns> public static IByteBuffer CopiedBuffer(params IByteBuffer[] buffers) { switch (buffers.Length) { case 0: return(Empty); case 1: return(CopiedBuffer(buffers[0])); } // Merge the specified buffers into one buffer. int length = 0; foreach (IByteBuffer b in buffers) { int bLen = b.ReadableBytes; if ((uint)(bLen - 1) > SharedConstants.TooBigOrNegative) // bLen <= 0 { continue; } if (int.MaxValue - length < bLen) { ThrowHelper.ThrowArgumentException_CopyBuffer(); } length += bLen; } if (0u >= (uint)length) { return(Empty); } var mergedArray = new byte[length]; for (int i = 0, j = 0; i < buffers.Length; i++) { IByteBuffer b = buffers[i]; int bLen = b.ReadableBytes; _ = b.GetBytes(b.ReaderIndex, mergedArray, j, bLen); j += bLen; } return(WrappedBuffer(mergedArray)); }
public override void AddContent(IByteBuffer buffer, bool last) { if (buffer is object) { try { int localsize = buffer.ReadableBytes; CheckSize(Size + localsize, MaxSize); if (DefinedSize > 0 && DefinedSize < Size + localsize) { ThrowHelper.ThrowIOException_OutOfSize(Size, DefinedSize); } if (_fileStream is null) { _fileStream = TempFile(); } _ = buffer.GetBytes(buffer.ReaderIndex, _fileStream, buffer.ReadableBytes); _ = buffer.SetReaderIndex(buffer.ReaderIndex + localsize); _fileStream.Flush(); Size += buffer.ReadableBytes; } finally { // Release the buffer as it was retained before and we not need a reference to it at all // See https://github.com/netty/netty/issues/1516 _ = buffer.Release(); } } if (last) { if (_fileStream is null) { _fileStream = TempFile(); } SetCompleted(); } else { if (buffer is null) { ThrowHelper.ThrowArgumentNullException(ExceptionArgument.buffer); } } }
private byte[] ToByteArray(IByteBuffer buffer) { var bytes = new byte[buffer.Length]; buffer.GetBytes(0, bytes, 0, buffer.Length); return bytes; }
public override IByteBuffer SetBytes(int index, IByteBuffer src, int srcIndex, int length) { this.CheckSrcIndex(index, length, srcIndex, src.Capacity); if (src.HasArray) { this.SetBytes(index, src.Array, src.ArrayOffset + srcIndex, length); } else { src.GetBytes(srcIndex, this.array, index, length); } return this; }