private static void FailOnFrameLengthLessThanLengthFieldEndOffset(IByteBuffer input, long frameLength, int lengthFieldEndOffset) { _ = input.SkipBytes(lengthFieldEndOffset); CThrowHelper.ThrowCorruptedFrameException_LengthFieldEndOffset(frameLength, lengthFieldEndOffset); }
public DefaultHeaders(IHashingStrategy <TKey> nameHashingStrategy, IValueConverter <TValue> valueConverter, INameValidator <TKey> nameValidator, int arraySizeHint) { if (nameHashingStrategy is null) { CThrowHelper.ThrowArgumentNullException(CExceptionArgument.nameHashingStrategy); } if (valueConverter is null) { CThrowHelper.ThrowArgumentNullException(CExceptionArgument.valueConverter); } if (nameValidator is null) { CThrowHelper.ThrowArgumentNullException(CExceptionArgument.nameValidator); } _hashingStrategy = nameHashingStrategy; ValueConverter = valueConverter; _nameValidator = nameValidator; // Enforce a bound of [2, 128] because hashMask is a byte. The max possible value of hashMask is one less // than the length of this array, and we want the mask to be > 0. _entries = new HeaderEntry <TKey, TValue> [FindNextPositivePowerOfTwo(Math.Max(2, Math.Min(arraySizeHint, 128)))]; _hashMask = (byte)(_entries.Length - 1); _head = new HeaderEntry <TKey, TValue>(); }
public bool TryGet(TKey name, out TValue value) { if (name is null) { CThrowHelper.ThrowArgumentNullException(CExceptionArgument.name); } bool found = false; int h = _hashingStrategy.HashCode(name); int i = Index(h); HeaderEntry <TKey, TValue> e = _entries[i]; value = default; // loop until the first header was found while (e is object) { if (e.Hash == h && _hashingStrategy.Equals(name, e._key)) { value = e._value; found = true; } e = e.Next; } return(found); }
/// <summary>Common constructor</summary> /// <param name="maxFrameLength"> /// The maximum length of the decoded frame /// NOTE: A see <see cref="DotNetty.Codecs.TooLongFrameException" /> is thrown if the length of the frame exceeds this /// value. /// </param> /// <param name="stripDelimiter">whether the decoded frame should strip out the delimiter or not</param> /// <param name="failFast"> /// If true, a <see cref="DotNetty.Codecs.TooLongFrameException" /> is /// thrown as soon as the decoder notices the length of the /// frame will exceed<tt>maxFrameLength</tt> regardless of /// whether the entire frame has been read. /// If false, a <see cref="DotNetty.Codecs.TooLongFrameException" /> is /// thrown after the entire frame that exceeds maxFrameLength has been read. /// </param> /// <param name="delimiters">delimiters</param> public DelimiterBasedFrameDecoder(int maxFrameLength, bool stripDelimiter, bool failFast, params IByteBuffer[] delimiters) { ValidateMaxFrameLength(maxFrameLength); if (delimiters is null) { CThrowHelper.ThrowNullReferenceException(CExceptionArgument.delimiters); } if (0u >= (uint)delimiters.Length) { CThrowHelper.ThrowArgumentException_EmptyDelimiters(); } if (IsLineBased(delimiters) && !IsSubclass()) { _lineBasedDecoder = new LineBasedFrameDecoder(maxFrameLength, stripDelimiter, failFast); _delimiters = null; } else { _delimiters = new IByteBuffer[delimiters.Length]; for (int i = 0; i < delimiters.Length; i++) { IByteBuffer d = delimiters[i]; ValidateDelimiter(d); _delimiters[i] = d.Slice(d.ReaderIndex, d.ReadableBytes); } _lineBasedDecoder = null; } _maxFrameLength = maxFrameLength; _stripDelimiter = stripDelimiter; _failFast = failFast; }
private static void FailOnFrameLengthLessThanInitialBytesToStrip(IByteBuffer input, int frameLength, int initialBytesToStrip) { _ = input.SkipBytes(frameLength); CThrowHelper.ThrowCorruptedFrameException_InitialBytesToStrip(frameLength, initialBytesToStrip); }
static void ValidateMaxFrameLength(int maxFrameLength) { if ((uint)(maxFrameLength - 1) > SharedConstants.TooBigOrNegative) // <= 0 { CThrowHelper.ThrowArgumentException_MaxFrameLengthMustBe(maxFrameLength); } }
public void ValidateName(T name) { if (name is null) { CThrowHelper.ThrowArgumentNullException(CExceptionArgument.name); } }
static void ValidateMaxContentLength(int maxContentLength) { if ((uint)maxContentLength > SharedConstants.TooBigOrNegative) // < 0 { CThrowHelper.ThrowArgumentException_MaxContentLength(maxContentLength); } }
protected DecoderResult(Exception cause) { if (cause is null) { CThrowHelper.ThrowArgumentNullException(CExceptionArgument.cause); } this.cause = cause; }
public static DecoderResult Failure(Exception cause) { if (cause is null) { CThrowHelper.ThrowArgumentNullException(CExceptionArgument.cause); } return(new DecoderResult(cause)); }
protected ByteToMessageDecoder() { // ReSharper disable once DoNotCallOverridableMethodsInConstructor -- used for safety check only if (IsSharable) { CThrowHelper.ThrowInvalidOperationException_ByteToMessageDecoder(); } }
/// <summary> /// Set the number of reads after which <see cref="IByteBuffer.DiscardSomeReadBytes"/> are called and so free up memory. /// The default is <code>16</code>. /// </summary> /// <param name="discardAfterReads"></param> public void SetDiscardAfterReads(int discardAfterReads) { if ((uint)(discardAfterReads - 1) > SharedConstants.TooBigOrNegative) // <= 0 { CThrowHelper.ThrowArgumentException_DiscardAfterReads(); } _discardAfterReads = discardAfterReads; }
/// <summary> /// Allocate a <see cref="IByteBuffer"/> which will be used as argument of <see cref="Encode(IChannelHandlerContext, T, IByteBuffer)"/>. /// Sub-classes may override this method to return <see cref="IByteBuffer"/> with a perfect matching <c>initialCapacity</c>. /// </summary> /// <param name="context"></param> /// <returns></returns> protected virtual IByteBuffer AllocateBuffer(IChannelHandlerContext context) { if (context is null) { CThrowHelper.ThrowArgumentNullException(CExceptionArgument.context); } return(context.Allocator.Buffer()); }
public virtual IHeaders <TKey, TValue> AddObject(TKey name, object value) { if (value is null) { CThrowHelper.ThrowArgumentNullException(CExceptionArgument.value); } return(Add(name, ValueConverter.ConvertObject(value))); }
public bool ContainsObject(TKey name, object value) { if (value is null) { CThrowHelper.ThrowArgumentNullException(CExceptionArgument.value); } return(Contains(name, ValueConverter.ConvertObject(value))); }
public virtual void Remove() { if (_isReadonly) { CThrowHelper.ThrowNotSupportedException_Readonly(); } Before.After = After; After.Before = Before; }
public virtual IHeaders <TKey, TValue> Add(IHeaders <TKey, TValue> headers) { if (ReferenceEquals(headers, this)) { CThrowHelper.ThrowArgumentException_CannotAddToItSelf(); } AddImpl(headers); return(this); }
/// <inheritdoc /> protected internal override void Encode(IChannelHandlerContext context, IByteBuffer message, List <object> output) { int length = message.ReadableBytes + this.lengthAdjustment; var lengthFieldLen = this.lengthFieldLength; if (this.lengthFieldIncludesLengthFieldLength) { length += lengthFieldLen; } uint nlen = unchecked ((uint)length); if (nlen > SharedConstants.TooBigOrNegative) { CThrowHelper.ThrowArgumentException_LessThanZero(length); } switch (lengthFieldLen) { case 1: if (nlen >= 256u) { CThrowHelper.ThrowArgumentException_Byte(length); } output.Add(context.Allocator.Buffer(1).WriteByte((byte)length)); break; case 2: if (nlen >= 65536u) { CThrowHelper.ThrowArgumentException_Short(length); } output.Add(context.Allocator.Buffer(2).WriteShort((short)length)); break; case 3: if (nlen >= 16777216u) { CThrowHelper.ThrowArgumentException_Medium(length); } output.Add(context.Allocator.Buffer(3).WriteMedium(length)); break; case 4: output.Add(context.Allocator.Buffer(4).WriteInt(length)); break; case 8: output.Add(context.Allocator.Buffer(8).WriteLong(length)); break; default: CThrowHelper.ThrowException_UnknownLen(); break; } output.Add(message.Retain()); }
/// <summary> /// Initializes a new instance of the <see cref="StringDecoder" /> class with the specified character /// set.. /// </summary> /// <param name="encoding">Encoding.</param> public StringDecoder(Encoding encoding) { if (encoding is null) { CThrowHelper.ThrowNullReferenceException(CExceptionArgument.encoding); } _encoding = encoding; }
/// <summary> /// Set the <see cref="ICumulator"/> to use for cumulate the received <see cref="IByteBuffer"/>s. /// </summary> /// <param name="cumulator"></param> public void SetCumulator(ICumulator cumulator) { if (cumulator is null) { CThrowHelper.ThrowArgumentNullException(CExceptionArgument.cumulator); } _cumulator = cumulator; }
/// <summary> /// Create an encoder that encodes the content in <see cref="IAddressedEnvelope{T}"/> to <see cref="DatagramPacket"/> using /// the specified message encoder. /// </summary> /// <param name="encoder">the specified message encoder</param> public DatagramPacketEncoder(MessageToMessageEncoder <T> encoder) { if (encoder is null) { CThrowHelper.ThrowArgumentNullException(CExceptionArgument.encoder); } this.encoder = encoder; }
/// <summary> /// Create a <see cref="DatagramPacket"/> decoder using the specified <see cref="IByteBuffer"/> decoder. /// </summary> /// <param name="decoder">the specified <see cref="IByteBuffer"/> decoder</param> public DatagramPacketDecoder(MessageToMessageDecoder <IByteBuffer> decoder) { if (decoder is null) { CThrowHelper.ThrowArgumentNullException(CExceptionArgument.decoder); } this.decoder = decoder; }
public long ConvertToTimeMillis(ICharSequence value) { DateTime?dateTime = DateFormatter.ParseHttpDate(value); if (dateTime is null) { CThrowHelper.ThrowFormatException(value); } return(dateTime.Value.Ticks / TimeSpan.TicksPerMillisecond); }
public bool TryGetAndRemove(TKey name, out TValue value) { if (name is null) { CThrowHelper.ThrowArgumentNullException(CExceptionArgument.name); } int h = _hashingStrategy.HashCode(name); return(TryRemove0(h, Index(h), name, out value)); }
/// <summary> /// Decodes the specified region of the buffer into an unadjusted frame length. The default implementation is /// capable of decoding the specified region into an unsigned 8/16/24/32/64 bit integer. Override this method to /// decode the length field encoded differently. /// Note that this method must not modify the state of the specified buffer (e.g. /// <see cref="IByteBuffer.ReaderIndex" />, /// <see cref="IByteBuffer.WriterIndex" />, and the content of the buffer.) /// </summary> /// <param name="buffer">The buffer we'll be extracting the frame length from.</param> /// <param name="offset">The offset from the absolute <see cref="IByteBuffer.ReaderIndex" />.</param> /// <param name="length">The length of the framelenght field. Expected: 1, 2, 3, 4, or 8.</param> /// <returns>A long integer that represents the unadjusted length of the next frame.</returns> protected static long GetUnadjustedFrameLength(IByteBuffer buffer, int offset, int length) { return(length switch { 1 => buffer.GetByte(offset), 2 => buffer.GetUnsignedShort(offset), 3 => buffer.GetUnsignedMedium(offset), 4 => buffer.GetInt(offset), 8 => buffer.GetLong(offset), _ => CThrowHelper.ThrowDecoderException(length), });
public virtual IHeaders <TKey, TValue> SetObject(TKey name, object value) { if (value is null) { CThrowHelper.ThrowArgumentNullException(CExceptionArgument.value); } TValue convertedValue = ValueConverter.ConvertObject(value); return(Set(name, convertedValue)); }
/// <inheritdoc /> public override void Write(IChannelHandlerContext context, object message, IPromise promise) { if (context is null) { CThrowHelper.ThrowArgumentNullException(CExceptionArgument.context); } IByteBuffer buffer = null; try { if (this.AcceptOutboundMessage(message)) { var input = (T)message; buffer = this.AllocateBuffer(context); try { this.Encode(context, input, buffer); } finally { _ = ReferenceCountUtil.Release(input); } if (buffer.IsReadable()) { _ = context.WriteAsync(buffer, promise); } else { _ = buffer.Release(); _ = context.WriteAsync(Unpooled.Empty, promise); } buffer = null; } else { _ = context.WriteAsync(message, promise); } } catch (EncoderException) { throw; } catch (Exception ex) { CThrowHelper.ThrowEncoderException(ex); } finally { _ = (buffer?.Release()); } }
void Fail(long frameLength) { if (frameLength > 0) { CThrowHelper.ThrowTooLongFrameException(_maxFrameLength, frameLength); } else { CThrowHelper.ThrowTooLongFrameException(_maxFrameLength); } }
static void ValidateDelimiter(IByteBuffer delimiter) { if (delimiter is null) { CThrowHelper.ThrowNullReferenceException(CExceptionArgument.delimiter); } if (!delimiter.IsReadable()) { CThrowHelper.ThrowArgumentException_EmptyDelimiter(); } }
/// <inheritdoc /> public override void ChannelRead(IChannelHandlerContext context, object message) { if (message is IByteBuffer data) { ThreadLocalObjectList output = ThreadLocalObjectList.NewInstance(); try { _first = _cumulation is null; _cumulation = _cumulator.Cumulate(context.Allocator, _first ? Unpooled.Empty : _cumulation, data); CallDecode(context, _cumulation, output); } catch (DecoderException) { throw; } catch (Exception ex) { CThrowHelper.ThrowDecoderException(ex); } finally { try { if (_cumulation is object && !_cumulation.IsReadable()) { _numReads = 0; _ = _cumulation.Release(); _cumulation = null; } else if (++_numReads >= _discardAfterReads) { // We did enough reads already try to discard some bytes so we not risk to see a OOME. // See https://github.com/netty/netty/issues/4275 _numReads = 0; DiscardSomeReadBytes(); } int size = output.Count; _firedChannelRead |= (uint)size > 0u; FireChannelRead(context, output, size); } finally { output.Return(); } } } else { _ = context.FireChannelRead(message); } }