public TestByteBuffer(byte[] buffer)
{
if (_useLegacyImplementation)
_bb = new LegacyByteBuffer(CopyBytes(buffer));
else
_bb = new ByteBuffer(CopyBytes(buffer), _useHighCapacityMode);
}
public TestByteBuffer()
{
if (_useLegacyImplementation)
_bb = new LegacyByteBuffer();
else
_bb = new ByteBuffer(_useHighCapacityMode);
}
public EchoClientHandler()
{
this.buffer = new byte[EchoClientSettings.Size];
this.initialMessage = Unpooled.Buffer(EchoClientSettings.Size);
byte[] messageBytes = Encoding.UTF8.GetBytes("Hello world");
this.initialMessage.WriteBytes(messageBytes);
}
public static IByteBuffer YbrFull422ToRgb(IByteBuffer data)
{
byte[] oldPixels = data.Data;
byte[] newPixels = new byte[(oldPixels.Length / 4) * 2 * 3];
unchecked
{
int y1, y2, cb, cr;
for (int n = 0, p = 0; n < oldPixels.Length;)
{
y1 = oldPixels[n++];
y2 = oldPixels[n++];
cb = oldPixels[n++];
cr = oldPixels[n++];
newPixels[p++] = (byte)(y1 + 1.4020 * (cr - 128) + 0.5);
newPixels[p++] = (byte)(y1 - 0.3441 * (cb - 128) - 0.7141 * (cr - 128) + 0.5);
newPixels[p++] = (byte)(y1 + 1.7720 * (cb - 128) + 0.5);
newPixels[p++] = (byte)(y2 + 1.4020 * (cr - 128) + 0.5);
newPixels[p++] = (byte)(y2 - 0.3441 * (cb - 128) - 0.7141 * (cr - 128) + 0.5);
newPixels[p++] = (byte)(y2 + 1.7720 * (cb - 128) + 0.5);
}
}
return new MemoryByteBuffer(newPixels);
}
public DuplicatedByteBuffer(IByteBuffer source)
: base(source.MaxCapacity)
{
var asDuplicate = source as DuplicatedByteBuffer;
this.buffer = asDuplicate != null ? asDuplicate.buffer : source;
this.SetIndex(source.ReaderIndex, source.WriterIndex);
}
protected static IByteBuffer ToLeakAwareBuffer(IByteBuffer buf)
{
IResourceLeak leak;
switch (ResourceLeakDetector.Level)
{
case ResourceLeakDetector.DetectionLevel.Simple:
leak = AbstractByteBuffer.LeakDetector.Open(buf);
if (leak != null)
{
buf = new SimpleLeakAwareByteBuffer(buf, leak);
}
break;
case ResourceLeakDetector.DetectionLevel.Advanced:
case ResourceLeakDetector.DetectionLevel.Paranoid:
leak = AbstractByteBuffer.LeakDetector.Open(buf);
if (leak != null)
{
buf = new AdvancedLeakAwareByteBuffer(buf, leak);
}
break;
case ResourceLeakDetector.DetectionLevel.Disabled:
break;
default:
throw new ArgumentOutOfRangeException();
}
return buf;
}
public SlicedByteBuffer(IByteBuffer buffer, int index, int length)
: base(length)
{
if (index < 0 || index > buffer.Capacity - length)
{
throw new ArgumentOutOfRangeException("index", buffer + ".slice(" + index + ", " + length + ')');
}
var slicedByteBuf = buffer as SlicedByteBuffer;
if (slicedByteBuf != null)
{
this.buffer = slicedByteBuf.buffer;
this.adjustment = slicedByteBuf.adjustment + index;
}
else if (buffer is DuplicatedByteBuffer)
{
this.buffer = buffer.Unwrap();
this.adjustment = index;
}
else
{
this.buffer = buffer;
this.adjustment = index;
}
this.length = length;
this.SetWriterIndex(length);
}
public static async Task ReadBytesAsync(this Stream stream, IByteBuffer buffer, int offset, int count, CancellationToken cancellationToken)
{
if (stream == null)
{
throw new ArgumentNullException("stream");
}
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");
}
while (count > 0)
{
var backingBytes = buffer.AccessBackingBytes(offset);
var bytesToRead = Math.Min(count, backingBytes.Count);
var bytesRead = await stream.ReadAsync(backingBytes.Array, backingBytes.Offset, bytesToRead, cancellationToken).ConfigureAwait(false);
if (bytesRead == 0)
{
throw new EndOfStreamException();
}
offset += bytesRead;
count -= bytesRead;
}
}
internal static void WriteStringToBuffer(IByteBuffer buffer, string input)
{
int typeBytes = Encoding.UTF8.GetByteCount(input);
buffer.WriteByte(typeBytes);
buffer.WriteBytes(Encoding.UTF8.GetBytes(input));
}
public DicomReaderEventArgs(long position, DicomTag tag, DicomVR vr, IByteBuffer data)
{
Position = position;
Tag = tag;
VR = vr;
Data = data;
}
int IEventHandler.Peek(BufferedSocket bufferedSocket, IByteBuffer msg, ref EndPoint ep)
{
Contract.Requires(ep != null);
//Contract.Requires(bufferedSocket != null);
return default(int);
}
int IEventHandler.Read(BufferedSocket socket, IByteBuffer msg, ref EndPoint ep)
{
//Contract.Requires(socket != null);
Contract.Requires(msg != null);
Contract.Requires(ep != null);
return default(int);
}
static IByteBuffer UnwrapIfNeeded(IByteBuffer buf)
{
if (buf is AdvancedLeakAwareByteBuffer || buf is SimpleLeakAwareByteBuffer)
{
return buf.Unwrap();
}
return buf;
}
protected internal sealed override void Decode(IChannelHandlerContext context, IByteBuffer input, List<object> output)
{
object decode = this.Decode(context, input);
if (decode != null)
{
output.Add(decode);
}
}
public DeviceStream(SystemServices systemServices)
{
Stream = null;
ByteBuffer = null;
SystemServices = systemServices;
DeviceError = false;
// use new synchronous byte buffer
GenThreadManager = null;
}
// constructors
/// <summary>
/// Initializes a new instance of the <see cref="LazyBsonDocument"/> class.
/// </summary>
/// <param name="slice">The slice.</param>
/// <exception cref="System.ArgumentNullException">slice</exception>
/// <exception cref="System.ArgumentException">LazyBsonDocument cannot be used with an IByteBuffer that needs disposing.</exception>
public LazyBsonDocument(IByteBuffer slice)
{
if (slice == null)
{
throw new ArgumentNullException("slice");
}
_slice = slice;
}
public DeviceStream(GenThreadManagement.GenThreadManager genThreadManager, SystemServices systemServices)
{
Stream = null;
ByteBuffer = null;
SystemServices = systemServices;
DeviceError = false;
// use original threaded byte buffer
GenThreadManager = genThreadManager;
}
// constructors
/// <summary>
/// Initializes a new instance of the <see cref="RawBsonArray"/> class.
/// </summary>
/// <param name="slice">The slice.</param>
/// <exception cref="System.ArgumentNullException">slice</exception>
/// <exception cref="System.ArgumentException">RawBsonArray cannot be used with an IByteBuffer that needs disposing.</exception>
public RawBsonArray(IByteBuffer slice)
{
if (slice == null)
{
throw new ArgumentNullException("slice");
}
_slice = slice;
}
/// <summary>
/// Returns {@code true} if and only if the two specified buffers are
/// identical to each other as described in {@link ByteBuf#equals(Object)}.
/// This method is useful when implementing a new buffer type.
/// </summary>
public static bool Equals(IByteBuffer bufferA, IByteBuffer bufferB)
{
int aLen = bufferA.ReadableBytes;
if (aLen != bufferB.ReadableBytes)
{
return false;
}
return Equals(bufferA, bufferA.ReaderIndex, bufferB, bufferB.ReaderIndex, aLen);
}
// constructors
/// <summary>
/// Initializes a new instance of the <see cref="ByteBufferStream"/> class.
/// </summary>
/// <param name="buffer">The buffer.</param>
/// <param name="ownsBuffer">Whether the stream owns the buffer and should Dispose it when done.</param>
public ByteBufferStream(IByteBuffer buffer, bool ownsBuffer = false)
{
if (buffer == null)
{
throw new ArgumentNullException("buffer");
}
_buffer = buffer;
_ownsBuffer = ownsBuffer;
_length = buffer.Length;
}
public static async Task WriteBufferAsync(this Stream stream, IByteBuffer buffer, int offset, int count, CancellationToken cancellationToken)
{
while (count > 0)
{
var backingBytes = buffer.AccessBackingBytes(offset);
var bytesToWrite = Math.Min(count, backingBytes.Count - backingBytes.Offset);
await stream.WriteAsync(backingBytes.Array, backingBytes.Offset, bytesToWrite, cancellationToken);
offset += bytesToWrite;
count -= bytesToWrite;
}
}
public void sendBlock(IByteBuffer data, Response response)
{
int sendId = getNextId();
IByteBuffer message = ByteBufferManager.Instance.GetObj();
int pos = data.getReadPos();
message.writeByte(data.readByte());
message.writeInt(sendId);
message.writeByteBuffer(data, data.available());
data.setReadPos(pos);
responses[sendId] = response;
con.send(message);
}
public void Return(IByteBuffer byteBuffer)
{
if (byteBuffer is ByteBufferSlab)
{
_manager.Return(byteBuffer as ByteBufferSlab);
return;
}
if (byteBuffer is TrackedByteBufferArray)
{
_allocated--;
}
}
public void OnElement(IByteSource source, DicomTag tag, DicomVR vr, IByteBuffer data)
{
_log.Log(
_level,
"{marker:x8}: {padding}{tag} {vrCode} {tagDictionaryEntryName} [{size}]",
source.Marker,
_pad,
tag,
vr.Code,
tag.DictionaryEntry.Name,
data.Size);
}
/// <summary>
/// Returns {@code true} if and only if the two specified buffers are
/// identical to each other for {@code length} bytes starting at {@code aStartIndex}
/// index for the {@code a} buffer and {@code bStartIndex} index for the {@code b} buffer.
/// A more compact way to express this is:
/// <p>
/// {@code a[aStartIndex : aStartIndex + length] == b[bStartIndex : bStartIndex + length]}
/// </summary>
public static bool Equals(IByteBuffer a, int aStartIndex, IByteBuffer b, int bStartIndex, int length)
{
if (aStartIndex < 0 || bStartIndex < 0 || length < 0)
{
throw new ArgumentException("All indexes and lengths must be non-negative");
}
if (a.WriterIndex - length < aStartIndex || b.WriterIndex - length < bStartIndex)
{
return false;
}
int longCount = unchecked((int)((uint)length >> 3));
int byteCount = length & 7;
if (a.Order == b.Order)
{
for (int i = longCount; i > 0; i --)
{
if (a.GetLong(aStartIndex) != b.GetLong(bStartIndex))
{
return false;
}
aStartIndex += 8;
bStartIndex += 8;
}
}
else
{
for (int i = longCount; i > 0; i --)
{
if (a.GetLong(aStartIndex) != SwapLong(b.GetLong(bStartIndex)))
{
return false;
}
aStartIndex += 8;
bStartIndex += 8;
}
}
for (int i = byteCount; i > 0; i --)
{
if (a.GetByte(aStartIndex) != b.GetByte(bStartIndex))
{
return false;
}
aStartIndex ++;
bStartIndex ++;
}
return true;
}
public SwappedByteBuffer(IByteBuffer buf)
{
Contract.Requires(buf != null);
this.buf = buf;
if (buf.Order == ByteOrder.BigEndian)
{
this.Order = ByteOrder.LittleEndian;
}
else
{
this.Order = ByteOrder.BigEndian;
}
}
/// <summary>
/// Convert 24 bits pixels from planar (RRR...GGG...BBB...) to interleaved (RGB)
/// </summary>
/// <param name="data">Pixels data in planar format (RRR...GGG...BBB...)</param>
/// <returns>Pixels data in interleaved format (RGB)</returns>
public static IByteBuffer PlanarToInterleaved24(IByteBuffer data) {
byte[] oldPixels = data.Data;
byte[] newPixels = new byte[oldPixels.Length];
int pixelCount = newPixels.Length / 3;
unchecked {
for (int n = 0; n < pixelCount; n++) {
newPixels[(n * 3) + 0] = oldPixels[n + (pixelCount * 0)];
newPixels[(n * 3) + 1] = oldPixels[n + (pixelCount * 1)];
newPixels[(n * 3) + 2] = oldPixels[n + (pixelCount * 2)];
}
}
return new MemoryByteBuffer(newPixels);
}
public static async Task FillBufferAsync(this Stream stream, IByteBuffer buffer, int offset, int count, CancellationToken cancellationToken)
{
while (count > 0)
{
var backingBytes = buffer.AccessBackingBytes(offset);
var bytesToRead = Math.Min(count, backingBytes.Count);
var bytesRead = await stream.ReadAsync(backingBytes.Array, backingBytes.Offset, bytesToRead, cancellationToken);
if (bytesRead == 0)
{
throw new EndOfStreamException();
}
offset += bytesRead;
count -= bytesRead;
}
}
public void OnElement(IByteSource source, DicomTag tag, DicomVR vr, IByteBuffer data) {
DicomElement element;
switch (vr.Code) {
case "AE": element = new DicomApplicationEntity(tag, data); break;
case "AS": element = new DicomAgeString(tag, data); break;
case "AT": element = new DicomAttributeTag(tag, data); break;
case "CS": element = new DicomCodeString(tag, data); break;
case "DA": element = new DicomDate(tag, data); break;
case "DS": element = new DicomDecimalString(tag, data); break;
case "DT": element = new DicomDateTime(tag, data); break;
case "FD": element = new DicomFloatingPointDouble(tag, data); break;
case "FL": element = new DicomFloatingPointSingle(tag, data); break;
case "IS": element = new DicomIntegerString(tag, data); break;
case "LO": element = new DicomLongString(tag, _encodings.Peek(), data); break;
case "LT": element = new DicomLongText(tag, _encodings.Peek(), data); break;
case "OB": element = new DicomOtherByte(tag, data); break;
case "OD": element = new DicomOtherDouble(tag, data); break;
case "OF": element = new DicomOtherFloat(tag, data); break;
case "OW": element = new DicomOtherWord(tag, data); break;
case "PN": element = new DicomPersonName(tag, _encodings.Peek(), data); break;
case "SH": element = new DicomShortString(tag, _encodings.Peek(), data); break;
case "SL": element = new DicomSignedLong(tag, data); break;
case "SS": element = new DicomSignedShort(tag, data); break;
case "ST": element = new DicomShortText(tag, _encodings.Peek(), data); break;
case "TM": element = new DicomTime(tag, data); break;
case "UC": element = new DicomUnlimitedCharacters(tag, _encodings.Peek(), data); break;
case "UI": element = new DicomUniqueIdentifier(tag, data); break;
case "UL": element = new DicomUnsignedLong(tag, data); break;
case "UN": element = new DicomUnknown(tag, data); break;
case "UR": element = new DicomUniversalResource(tag, _encodings.Peek(), data); break;
case "US": element = new DicomUnsignedShort(tag, data); break;
case "UT": element = new DicomUnlimitedText(tag, _encodings.Peek(), data); break;
default:
throw new DicomDataException("Unhandled VR in DICOM parser observer: {0}", vr.Code);
}
if (element.Tag == DicomTag.SpecificCharacterSet) {
Encoding encoding = _encodings.Peek();
if (element.Count > 0)
encoding = DicomEncoding.GetEncoding(element.Get<string>(0));
_encodings.Pop();
_encodings.Push(encoding);
}
DicomDataset ds = _datasets.Peek();
ds.Add(element);
}
public void processMessage(IByteBuffer data)
{
if (data.available() <= 0)
{
return;
}
int id = data.readByte();
if (id == 0)
{
onBlock(data);
}
else
{
data.setReadPos(data.getReadPos() - 1);
//messageArrived(data);
}
}
public void Serialize(IByteBuffer byteBuffer, GetBlockHeadersMessage message)
{
byte[] oldWay = Serialize(message);
byteBuffer.EnsureWritable(oldWay.Length, true);
byteBuffer.WriteBytes(oldWay);
}
protected internal override void Encode(IChannelHandlerContext context, WebSocketFrame message, List <object> output)
{
if (message is TextWebSocketFrame)
{
// Text frame
IByteBuffer data = message.Content;
output.Add(_0X00.Duplicate());
output.Add(data.Retain());
output.Add(_0XFF.Duplicate());
}
else if (message is CloseWebSocketFrame)
{
// Close frame, needs to call duplicate to allow multiple writes.
// See https://github.com/netty/netty/issues/2768
output.Add(_0XFF_0X00.Duplicate());
}
else
{
// Binary frame
IByteBuffer data = message.Content;
int dataLen = data.ReadableBytes;
IByteBuffer buf = context.Allocator.Buffer(5);
bool release = true;
try
{
// Encode type.
buf.WriteByte(0x80);
// Encode length.
int b1 = dataLen.RightUShift(28) & 0x7F;
int b2 = dataLen.RightUShift(14) & 0x7F;
int b3 = dataLen.RightUShift(7) & 0x7F;
int b4 = dataLen & 0x7F;
if (b1 == 0)
{
if (b2 == 0)
{
if (b3 == 0)
{
buf.WriteByte(b4);
}
else
{
buf.WriteByte(b3 | 0x80);
buf.WriteByte(b4);
}
}
else
{
buf.WriteByte(b2 | 0x80);
buf.WriteByte(b3 | 0x80);
buf.WriteByte(b4);
}
}
else
{
buf.WriteByte(b1 | 0x80);
buf.WriteByte(b2 | 0x80);
buf.WriteByte(b3 | 0x80);
buf.WriteByte(b4);
}
// Encode binary data.
output.Add(buf);
output.Add(data.Retain());
release = false;
}
finally
{
if (release)
{
buf.Release();
}
}
}
}
public GetBlockHeadersMessage Deserialize(IByteBuffer byteBuffer)
{
NettyRlpStream rlpStream = new NettyRlpStream(byteBuffer);
return(Deserialize(rlpStream));
}
public void Encode(IByteBuffer packet)
{
packet.WriteVInt(ClientTick);
}
public static IByteBuffer WriteStruct(this IByteBuffer @this, IByteBuffer data, int length)
{
@this.WriteScalar(length)
.WriteBytes(data, length);
return(@this);
}
public static IByteBuffer WriteStruct(this IByteBuffer @this, IByteBuffer data)
{
@this.WriteScalar(data.ReadableBytes)
.WriteBytes(data);
return(@this);
}
protected DefaultByteBufferHolder(IByteBuffer buffer)
{
Contract.Requires(buffer != null);
this.buffer = buffer;
}
public Http2HeaderBlockIOTest()
{
this.encoder = new DefaultHttp2HeadersEncoder();
this.decoder = new DefaultHttp2HeadersDecoder(false);
this.buffer = Unpooled.Buffer();
}
public RespondToAllianceJoinRequestMessage(Device device, IByteBuffer buffer) : base(device, buffer)
{
Id = 14321;
}
public static IByteBuffer WriteStruct(this IByteBuffer @this, byte[] data)
{
@this.WriteScalar(data.Length)
.WriteBytes(data);
return(@this);
}
public JoinAllianceMessage(Device device, IByteBuffer buffer) : base(device, buffer)
{
Id = 14305;
}
/// <summary>
/// Write bytes form the given {@link ByteBuf} to the underlying {@link java.nio.channels.Channel}.
/// @param buf the {@link ByteBuf} from which the bytes should be written
/// @return amount the amount of written bytes
/// </summary>
protected abstract int DoWriteBytes(IByteBuffer buf);
public override void FinishRead(SocketChannelAsyncOperation operation)
{
AbstractSocketByteChannel ch = this.Channel;
ch.ResetState(StateFlags.ReadScheduled);
IChannelConfiguration config = ch.Configuration;
if (!config.AutoRead && !ch.ReadPending)
{
// ChannelConfig.setAutoRead(false) was called in the meantime
//removeReadOp(); -- noop with IOCP, just don't schedule receive again
return;
}
IChannelPipeline pipeline = ch.Pipeline;
IByteBufferAllocator allocator = config.Allocator;
int maxMessagesPerRead = config.MaxMessagesPerRead;
IRecvByteBufAllocatorHandle allocHandle = this.RecvBufAllocHandle;
IByteBuffer byteBuf = null;
int messages = 0;
bool close = false;
try
{
operation.Validate();
int totalReadAmount = 0;
bool readPendingReset = false;
do
{
byteBuf = allocHandle.Allocate(allocator);
int writable = byteBuf.WritableBytes;
int localReadAmount = ch.DoReadBytes(byteBuf);
if (localReadAmount <= 0)
{
// not was read release the buffer
byteBuf.Release();
byteBuf = null;
close = localReadAmount < 0;
break;
}
if (!readPendingReset)
{
readPendingReset = true;
ch.ReadPending = false;
}
pipeline.FireChannelRead(byteBuf);
byteBuf = null;
if (totalReadAmount >= int.MaxValue - localReadAmount)
{
// Avoid overflow.
totalReadAmount = int.MaxValue;
break;
}
totalReadAmount += localReadAmount;
// stop reading
if (!config.AutoRead)
{
break;
}
if (localReadAmount < writable)
{
// Read less than what the buffer can hold,
// which might mean we drained the recv buffer completely.
break;
}
}while (++messages < maxMessagesPerRead);
pipeline.FireChannelReadComplete();
allocHandle.Record(totalReadAmount);
if (close)
{
this.CloseOnRead();
close = false;
}
}
catch (Exception t)
{
this.HandleReadException(pipeline, byteBuf, t, close);
}
finally
{
// Check if there is a readPending which was not processed yet.
// This could be for two reasons:
// /// The user called Channel.read() or ChannelHandlerContext.read() input channelRead(...) method
// /// The user called Channel.read() or ChannelHandlerContext.read() input channelReadComplete(...) method
//
// See https://github.com/netty/netty/issues/2254
if (!close && (config.AutoRead || ch.ReadPending))
{
ch.DoBeginRead();
}
}
}
public IMessage CreateMessage(string address, IByteBuffer payload) => throw new InvalidOperationException("Must not receive messages from a client.");
async void Receive()
{
Message message = null;
IByteBuffer messagePayload = null;
try
{
while (true)
{
message = await this.bridge.DeviceClient.ReceiveAsync(this.lifetimeCancellation.Token);
if (message == null)
{
this.messagingChannel.Close(null);
return;
}
PerformanceCounters.TotalCommandsReceived.Increment();
PerformanceCounters.CommandsReceivedPerSecond.Increment();
if (this.bridge.Settings.MaxOutboundRetransmissionEnforced && message.DeliveryCount > this.bridge.Settings.MaxOutboundRetransmissionCount)
{
CommonEventSource.Log.Info("Rejected message: high delivery count: " + message.DeliveryCount, null, this.bridge.DeviceId);
await this.RejectAsync(message.LockToken);
message.Dispose();
message = null;
continue;
}
using (Stream payloadStream = message.GetBodyStream())
{
long streamLength = payloadStream.Length;
if (streamLength > int.MaxValue)
{
throw new InvalidOperationException($"Message size ({streamLength.ToString()} bytes) is too big to process.");
}
int length = (int)streamLength;
messagePayload = this.allocator.Buffer(length, length);
await messagePayload.WriteBytesAsync(payloadStream, length);
Contract.Assert(messagePayload.ReadableBytes == length);
}
var msg = new IotHubClientMessage(message, messagePayload);
msg.Properties[TemplateParameters.DeviceIdTemplateParam] = this.bridge.DeviceId;
string address;
if (!this.addressFormatter(msg, out address))
{
CommonEventSource.Log.Info("Rejected message: could not format topic", null, this.bridge.DeviceId);
messagePayload.Release();
await this.RejectAsync(message.LockToken); // todo: fork await
message.Dispose();
message = null;
messagePayload = null;
continue;
}
msg.Address = address;
this.messagingChannel.Handle(msg, this);
message = null; // ownership has been transferred to messagingChannel
messagePayload = null;
}
}
catch (IotHubException ex)
{
this.messagingChannel.Close(ex.ToMessagingException());
}
catch (Exception ex)
{
this.messagingChannel.Close(ex);
}
finally
{
message?.Dispose();
if (messagePayload != null)
{
ReferenceCountUtil.SafeRelease(messagePayload);
}
}
}
public void OnFragmentSequenceItem(IByteSource source, IByteBuffer data)
{
_fragment.Add(data);
}
protected override async void DoBeginRead()
{
IByteBuffer byteBuffer = null;
IRecvByteBufAllocatorHandle allocHandle = null;
bool close = false;
try
{
if (!this.Open || this.ReadPending)
{
return;
}
this.ReadPending = true;
IByteBufferAllocator allocator = this.Configuration.Allocator;
allocHandle = this.Configuration.RecvByteBufAllocator.NewHandle();
allocHandle.Reset(this.Configuration);
do
{
byteBuffer = allocHandle.Allocate(allocator);
allocHandle.LastBytesRead = await this.DoReadBytes(byteBuffer);
if (allocHandle.LastBytesRead <= 0)
{
// nothing was read -> release the buffer.
byteBuffer.Release();
byteBuffer = null;
close = allocHandle.LastBytesRead < 0;
break;
}
this.Pipeline.FireChannelRead(byteBuffer);
allocHandle.IncMessagesRead(1);
}while (allocHandle.ContinueReading());
allocHandle.ReadComplete();
this.ReadPending = false;
this.Pipeline.FireChannelReadComplete();
}
catch (Exception e) when(!e.IsFatal())
{
Events.ReadException(this.correlationId, e);
// Since this method returns void, all exceptions must be handled here.
byteBuffer.SafeRelease();
allocHandle?.ReadComplete();
this.ReadPending = false;
// WebSocket should change its state when an exception is thrown,
// but it doesn't (see https://github.com/dotnet/corefx/issues/26219)
// so we'll abort the connection here.
this.Abort();
this.Pipeline.FireChannelReadComplete();
this.Pipeline.FireExceptionCaught(e);
close = true;
}
if (close)
{
if (this.Active)
{
await this.HandleCloseAsync();
}
}
}
public void SimpleSend(IByteBuffer source, bool bindClient, IByteBufferAllocator allocator, AddressFamily addressFamily, byte[] expectedData, int count)
{
SocketDatagramChannel serverChannel = null;
IChannel clientChannel = null;
var serverGroup = new MultithreadEventLoopGroup(1);
var clientGroup = new MultithreadEventLoopGroup(1);
try
{
var handler = new TestHandler(expectedData);
var serverBootstrap = new Bootstrap();
serverBootstrap
.Group(serverGroup)
.ChannelFactory(() => new SocketDatagramChannel(addressFamily))
.Option(ChannelOption.Allocator, allocator)
.Option(ChannelOption.SoBroadcast, true)
.Option(ChannelOption.IpMulticastLoopDisabled, false)
.Handler(new ActionChannelInitializer <IChannel>(channel =>
{
channel.Pipeline.AddLast(nameof(SocketDatagramChannelUnicastTest), handler);
}));
IPAddress address = NetUtil.GetLoopbackAddress(addressFamily);
this.Output.WriteLine($"Unicast server binding to:({addressFamily}){address}");
Task <IChannel> task = serverBootstrap.BindAsync(address, IPEndPoint.MinPort);
Assert.True(task.Wait(TimeSpan.FromMilliseconds(DefaultTimeOutInMilliseconds * 5)),
$"Unicast server binding to:({addressFamily}){address} timed out!");
serverChannel = (SocketDatagramChannel)task.Result;
var endPoint = (IPEndPoint)serverChannel.LocalAddress;
var clientBootstrap = new Bootstrap();
clientBootstrap
.Group(clientGroup)
.ChannelFactory(() => new SocketDatagramChannel(addressFamily))
.Option(ChannelOption.Allocator, allocator)
.Option(ChannelOption.SoBroadcast, true)
.Option(ChannelOption.IpMulticastLoopDisabled, false)
.Handler(new ActionChannelInitializer <IChannel>(channel =>
{
channel.Pipeline.AddLast("Dummy", new NetUtil.DummyHandler());
}));
var clientEndPoint = new IPEndPoint(
addressFamily == AddressFamily.InterNetwork ? IPAddress.Any : IPAddress.IPv6Any,
IPEndPoint.MinPort);
clientBootstrap
.LocalAddress(clientEndPoint)
.RemoteAddress(new IPEndPoint(address, endPoint.Port));
if (bindClient)
{
this.Output.WriteLine($"Unicast client binding to:({addressFamily}){address}");
task = clientBootstrap.BindAsync(clientEndPoint);
Assert.True(task.Wait(TimeSpan.FromMilliseconds(DefaultTimeOutInMilliseconds * 5)),
$"Unicast client binding to:({clientEndPoint}) timed out!");
clientChannel = task.Result;
}
else
{
this.Output.WriteLine($"Register client binding to:({addressFamily}){address}");
task = (Task <IChannel>)clientBootstrap.RegisterAsync();
Assert.True(task.Wait(TimeSpan.FromMilliseconds(DefaultTimeOutInMilliseconds)), "Unicast client register timed out!");
clientChannel = task.Result;
}
for (int i = 0; i < count; i++)
{
var packet = new DatagramPacket((IByteBuffer)source.Retain(), new IPEndPoint(address, endPoint.Port));
clientChannel.WriteAndFlushAsync(packet).Wait();
Assert.True(handler.WaitForResult());
var duplicatedPacket = (DatagramPacket)packet.Duplicate();
duplicatedPacket.Retain();
clientChannel.WriteAndFlushAsync(duplicatedPacket).Wait();
Assert.True(handler.WaitForResult());
}
}
finally
{
serverChannel?.CloseAsync().Wait(TimeSpan.FromMilliseconds(DefaultTimeOutInMilliseconds));
clientChannel?.CloseAsync().Wait(TimeSpan.FromMilliseconds(DefaultTimeOutInMilliseconds));
source.Release();
Task.WaitAll(
serverGroup.ShutdownGracefullyAsync(TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(1)),
clientGroup.ShutdownGracefullyAsync(TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(1)));
}
}
/// <summary>
/// Rent a buffer -> return it -> re-rent -> verify if it's array points to the previous location
/// </summary>
private bool CheckIsRentingPooledBuffer <T>(int length)
where T : struct
{
IByteBuffer buffer = this.manager.Allocate(length);
ref byte ptrToPreviousPosition0 = ref MemoryMarshal.GetReference <byte>(buffer.Array);
public static IByteBuffer WriteStruct(this IByteBuffer @this, byte[] data, int offset, int length)
{
@this.WriteScalar(length)
.WriteBytes(data, offset, length);
return(@this);
}
public virtual void Decode(IByteBuffer buffer)
{
}
protected override void Encode(IChannelHandlerContext context, IPacket message, IByteBuffer output)
{
var socket = context.Channel.GetAttribute(NettyAttributes.SocketKey).Get();
var dataLen = (short)message.Buffer.Length;
var buffer = message.Buffer.ToArray();
if (socket != null)
{
var seqSend = socket.SeqSend;
var rawSeq = (short)((seqSend >> 16) ^ -(_transport.Version + 1));
if (socket.EncryptData)
{
dataLen ^= rawSeq;
ShandaCipher.EncryptTransform(buffer);
_aesCipher.Transform(buffer, seqSend);
}
output.WriteShortLE(rawSeq);
output.WriteShortLE(dataLen);
output.WriteBytes(buffer);
socket.SeqSend = _igCipher.Hash(seqSend, 4, 0);
}
else
{
output.WriteShortLE(dataLen);
output.WriteBytes(buffer);
}
}
public void OnElement(IByteSource source, DicomTag tag, DicomVR vr, IByteBuffer data)
{
DicomElement element;
switch (vr.Code)
{
case "AE":
element = new DicomApplicationEntity(tag, data);
break;
case "AS":
element = new DicomAgeString(tag, data);
break;
case "AT":
element = new DicomAttributeTag(tag, data);
break;
case "CS":
element = new DicomCodeString(tag, data);
break;
case "DA":
element = new DicomDate(tag, data);
break;
case "DS":
element = new DicomDecimalString(tag, data);
break;
case "DT":
element = new DicomDateTime(tag, data);
break;
case "FD":
element = new DicomFloatingPointDouble(tag, data);
break;
case "FL":
element = new DicomFloatingPointSingle(tag, data);
break;
case "IS":
element = new DicomIntegerString(tag, data);
break;
case "LO":
element = new DicomLongString(tag, _encodings.Peek(), data);
break;
case "LT":
element = new DicomLongText(tag, _encodings.Peek(), data);
break;
case "OB":
element = new DicomOtherByte(tag, data);
break;
case "OD":
element = new DicomOtherDouble(tag, data);
break;
case "OF":
element = new DicomOtherFloat(tag, data);
break;
case "OW":
element = new DicomOtherWord(tag, data);
break;
case "PN":
element = new DicomPersonName(tag, _encodings.Peek(), data);
break;
case "SH":
element = new DicomShortString(tag, _encodings.Peek(), data);
break;
case "SL":
element = new DicomSignedLong(tag, data);
break;
case "SS":
element = new DicomSignedShort(tag, data);
break;
case "ST":
element = new DicomShortText(tag, _encodings.Peek(), data);
break;
case "TM":
element = new DicomTime(tag, data);
break;
case "UC":
element = new DicomUnlimitedCharacters(tag, _encodings.Peek(), data);
break;
case "UI":
element = new DicomUniqueIdentifier(tag, data);
break;
case "UL":
element = new DicomUnsignedLong(tag, data);
break;
case "UN":
element = new DicomUnknown(tag, data);
break;
case "UR":
element = new DicomUniversalResource(tag, _encodings.Peek(), data);
break;
case "US":
element = new DicomUnsignedShort(tag, data);
break;
case "UT":
element = new DicomUnlimitedText(tag, _encodings.Peek(), data);
break;
default:
throw new DicomDataException("Unhandled VR in DICOM parser observer: {0}", vr.Code);
}
if (element.Tag == DicomTag.SpecificCharacterSet)
{
Encoding encoding = _encodings.Peek();
if (element.Count > 0)
{
encoding = DicomEncoding.GetEncoding(element.Get <string>(0));
}
_encodings.Pop();
_encodings.Push(encoding);
}
DicomDataset ds = _datasets.Peek();
ds.Add(element);
}
protected override void DecodeLast(IChannelHandlerContext context, IByteBuffer input, List <object> output)
{
base.DecodeLast(context, input, output);
}
public virtual void Encode(IByteBuffer buffer) => FixedHeader.WriteTo(buffer);
public static IByteBuffer ReadStruct(this IByteBuffer @this)
{
var length = @this.ReadScalar();
return(@this.ReadSlice(length));
}
// todo: support FileRegion
///// <summary>
// /// Write a {@link FileRegion}
// *
// /// @param region the {@link FileRegion} from which the bytes should be written
// /// @return amount the amount of written bytes
// /// </summary>
//protected abstract long doWriteFileRegion(FileRegion region);
/// <summary>
/// Read bytes into the given {@link ByteBuf} and return the amount.
/// </summary>
protected abstract int DoReadBytes(IByteBuffer buf);
public static string ReadLongString(this IByteBuffer buffer, Encoding encoding)
{
int length = buffer.ReadInt();
return(length <= 0 ? string.Empty : buffer.ReadString(length, encoding));
}
public static IByteBuffer Decode(IByteBuffer src) => Decode(src, Base64Dialect.Standard);
public GoHomeMessage(Device device, IByteBuffer buffer) : base(device, buffer)
{
Id = 14101;
Save = true;
RequiredState = Device.State.Battle;
}
