/// <summary> /// Parses the next <see cref="BList"/> from the stream. /// </summary> /// <param name="stream">The stream to parse from.</param> /// <returns>The parsed <see cref="BList"/>.</returns> /// <exception cref="InvalidBencodeException{BList}">Invalid bencode</exception> public override BList Parse(BencodeStream stream) { if (stream == null) { throw new ArgumentNullException(nameof(stream)); } if (stream.Length < MinimumLength) { throw InvalidBencodeException <BList> .BelowMinimumLength(MinimumLength, stream.Length, stream.Position); } // Lists must start with 'l' if (stream.ReadChar() != 'l') { throw InvalidBencodeException <BList> .UnexpectedChar('l', stream.ReadPreviousChar(), stream.Position); } var list = new BList(); // Loop until next character is the end character 'e' or end of stream while (stream.Peek() != 'e' && stream.Peek() != -1) { // Decode next object in stream var bObject = BencodeParser.Parse(stream); list.Add(bObject); } if (stream.ReadChar() != 'e') { throw InvalidBencodeException <BList> .InvalidEndChar(stream.ReadPreviousChar(), stream.Position); } return(list); }
/// <summary> /// Parses the next <see cref="BString"/> from the stream. /// </summary> /// <param name="stream">The stream to parse from.</param> /// <returns>The parsed <see cref="BString"/>.</returns> /// <exception cref="InvalidBencodeException{BString}">Invalid bencode</exception> /// <exception cref="UnsupportedBencodeException{BString}">The bencode is unsupported by this library</exception> public override BString Parse(BencodeStream stream) { if (stream == null) { throw new ArgumentNullException(nameof(stream)); } // Minimum valid bencode string is '0:' meaning an empty string if (stream.Length < MinimumLength) { throw InvalidBencodeException <BString> .BelowMinimumLength(MinimumLength, stream.Length, stream.Position); } var startPosition = stream.Position; var lengthString = new StringBuilder(); for (var c = stream.ReadChar(); c != ':' && c != default(char); c = stream.ReadChar()) { // Because of memory limitations (~1-2 GB) we know for certain we cannot handle more than 10 digits (10GB) if (lengthString.Length >= BString.LengthMaxDigits) { throw UnsupportedException( $"Length of string is more than {BString.LengthMaxDigits} digits (>10GB) and is not supported (max is ~1-2GB).", startPosition); } lengthString.Append(c); } long stringLength; if (!ParseUtil.TryParseLongFast(lengthString.ToString(), out stringLength)) { throw InvalidException($"Invalid length '{lengthString}' of string.", startPosition); } // Int32.MaxValue is ~2GB and is the absolute maximum that can be handled in memory if (stringLength > int.MaxValue) { throw UnsupportedException( $"Length of string is {stringLength:N0} but maximum supported length is {int.MaxValue:N0}.", startPosition); } var bytes = stream.Read((int)stringLength); // If the two don't match we've reached the end of the stream before reading the expected number of chars if (bytes.Length != stringLength) { throw InvalidException( $"Expected string to be {stringLength:N0} bytes long but could only read {bytes.Length:N0} bytes.", startPosition); } return(new BString(bytes, Encoding)); }
/// <summary> /// Parses the next <see cref="BString"/> from the reader. /// </summary> /// <param name="reader">The reader to parse from.</param> /// <returns>The parsed <see cref="BString"/>.</returns> /// <exception cref="InvalidBencodeException{BString}">Invalid bencode.</exception> /// <exception cref="UnsupportedBencodeException{BString}">The bencode is unsupported by this library.</exception> public override BString Parse(BencodeReader reader) { if (reader == null) { throw new ArgumentNullException(nameof(reader)); } // Minimum valid bencode string is '0:' meaning an empty string if (reader.Length < MinimumLength) { throw InvalidBencodeException <BString> .BelowMinimumLength(MinimumLength, reader.Length.Value, reader.Position); } var startPosition = reader.Position; var buffer = ArrayPool <char> .Shared.Rent(BString.LengthMaxDigits); try { var lengthString = buffer.AsSpan(); var lengthStringCount = 0; for (var c = reader.ReadChar(); c != default && c.IsDigit(); c = reader.ReadChar()) { EnsureLengthStringBelowMaxLength(lengthStringCount, startPosition); lengthString[lengthStringCount++] = c; } EnsurePreviousCharIsColon(reader.PreviousChar, reader.Position); var stringLength = ParseStringLength(lengthString, lengthStringCount, startPosition); var bytes = new byte[stringLength]; var bytesRead = reader.Read(bytes); EnsureExpectedBytesRead(bytesRead, stringLength, startPosition); return(new BString(bytes, Encoding)); } finally { ArrayPool <char> .Shared.Return(buffer); } }
/// <summary> /// Parses the next <see cref="BNumber"/> from the reader. /// </summary> /// <param name="reader">The reader to parse from.</param> /// <returns>The parsed <see cref="BNumber"/>.</returns> /// <exception cref="InvalidBencodeException{BNumber}">Invalid bencode.</exception> /// <exception cref="UnsupportedBencodeException{BNumber}">The bencode is unsupported by this library.</exception> public override BNumber Parse(BencodeReader reader) { if (reader == null) { throw new ArgumentNullException(nameof(reader)); } if (reader.Length < MinimumLength) { throw InvalidBencodeException <BNumber> .BelowMinimumLength(MinimumLength, reader.Length.Value, reader.Position); } var startPosition = reader.Position; // Numbers must start with 'i' if (reader.ReadChar() != 'i') { throw InvalidBencodeException <BNumber> .UnexpectedChar('i', reader.PreviousChar, startPosition); } using var digits = MemoryPool <char> .Shared.Rent(BNumber.MaxDigits); var digitCount = 0; for (var c = reader.ReadChar(); c != default && c != 'e'; c = reader.ReadChar()) { digits.Memory.Span[digitCount++] = c; } if (digitCount == 0) { throw NoDigitsException(startPosition); } // Last read character should be 'e' if (reader.PreviousChar != 'e') { throw InvalidBencodeException <BNumber> .MissingEndChar(startPosition); } return(ParseNumber(digits.Memory.Span.Slice(0, digitCount), startPosition)); }
/// <summary> /// Parses the next <see cref="BList"/> from the reader. /// </summary> /// <param name="reader">The reader to parse from.</param> /// <returns>The parsed <see cref="BList"/>.</returns> /// <exception cref="InvalidBencodeException{BList}">Invalid bencode.</exception> public override BList Parse(BencodeReader reader) { if (reader == null) { throw new ArgumentNullException(nameof(reader)); } if (reader.Length < MinimumLength) { throw InvalidBencodeException <BList> .BelowMinimumLength(MinimumLength, reader.Length.Value, reader.Position); } var startPosition = reader.Position; // Lists must start with 'l' if (reader.ReadChar() != 'l') { throw InvalidBencodeException <BList> .UnexpectedChar('l', reader.PreviousChar, startPosition); } var list = new BList(); // Loop until next character is the end character 'e' or end of stream while (reader.PeekChar() != 'e' && reader.PeekChar() != default) { // Decode next object in stream var bObject = BencodeParser.Parse(reader); list.Add(bObject); } if (reader.ReadChar() != 'e') { throw InvalidBencodeException <BList> .MissingEndChar(startPosition); } return(list); }
/// <summary> /// Parses the next <see cref="BDictionary"/> from the stream and its contained keys and values. /// </summary> /// <param name="stream">The stream to parse from.</param> /// <returns>The parsed <see cref="BDictionary"/>.</returns> /// <exception cref="InvalidBencodeException{BDictionary}">Invalid bencode</exception> public override BDictionary Parse(BencodeStream stream) { if (stream == null) { throw new ArgumentNullException(nameof(stream)); } var startPosition = stream.Position; if (stream.Length < MinimumLength) { throw InvalidBencodeException <BDictionary> .BelowMinimumLength(MinimumLength, stream.Length, startPosition); } // Dictionaries must start with 'd' if (stream.ReadChar() != 'd') { throw InvalidBencodeException <BDictionary> .UnexpectedChar('d', stream.ReadPreviousChar(), startPosition); } var dictionary = new BDictionary(); // Loop until next character is the end character 'e' or end of stream while (stream.Peek() != 'e' && stream.Peek() != -1) { BString key; try { // Decode next string in stream as the key key = BencodeParser.Parse <BString>(stream); } catch (BencodeException <BString> ex) { throw InvalidException("Could not parse dictionary key. Keys must be strings.", ex, startPosition); } IBObject value; try { // Decode next object in stream as the value value = BencodeParser.Parse(stream); } catch (BencodeException ex) { throw InvalidException( $"Could not parse dictionary value for the key '{key}'. There needs to be a value for each key.", ex, startPosition); } if (dictionary.ContainsKey(key)) { throw InvalidException( $"The dictionary already contains the key '{key}'. Duplicate keys are not supported.", startPosition); } dictionary.Add(key, value); } if (stream.ReadChar() != 'e') { if (stream.EndOfStream) { throw InvalidBencodeException <BDictionary> .MissingEndChar(); } throw InvalidBencodeException <BDictionary> .InvalidEndChar(stream.ReadPreviousChar(), stream.Position); } return(dictionary); }
/// <summary> /// Parses the next <see cref="BNumber"/> from the stream. /// </summary> /// <param name="stream">The stream to parse from.</param> /// <returns>The parsed <see cref="BNumber"/>.</returns> /// <exception cref="InvalidBencodeException{BNumber}">Invalid bencode</exception> /// <exception cref="UnsupportedBencodeException{BNumber}">The bencode is unsupported by this library</exception> public override BNumber Parse(BencodeStream stream) { if (stream == null) { throw new ArgumentNullException(nameof(stream)); } if (stream.Length < MinimumLength) { throw InvalidBencodeException <BNumber> .BelowMinimumLength(MinimumLength, stream.Length, stream.Position); } var startPosition = stream.Position; // Numbers must start with 'i' if (stream.ReadChar() != 'i') { throw InvalidBencodeException <BNumber> .UnexpectedChar('i', stream.ReadPreviousChar(), stream.Position); } var digits = new StringBuilder(); char c; for (c = stream.ReadChar(); c != 'e' && c != default(char); c = stream.ReadChar()) { digits.Append(c); } // Last read character should be 'e' if (c != 'e') { throw InvalidBencodeException <BNumber> .InvalidEndChar(c, stream.Position); } var isNegative = digits[0] == '-'; var numberOfDigits = isNegative ? digits.Length - 1 : digits.Length; // We do not support numbers that cannot be stored as a long (Int64) if (numberOfDigits > BNumber.MaxDigits) { throw UnsupportedException( $"The number '{digits}' has more than 19 digits and cannot be stored as a long (Int64) and therefore is not supported.", startPosition); } // We need at least one digit if (numberOfDigits < 1) { throw InvalidException("It contains no digits.", startPosition); } var firstDigit = isNegative ? digits[1] : digits[0]; // Leading zeros are not valid if (firstDigit == '0' && numberOfDigits > 1) { throw InvalidException($"Leading '0's are not valid. Found value '{digits}'.", startPosition); } // '-0' is not valid either if (firstDigit == '0' && numberOfDigits == 1 && isNegative) { throw InvalidException("'-0' is not a valid number.", startPosition); } long number; if (!ParseUtil.TryParseLongFast(digits.ToString(), out number)) { var nonSignChars = isNegative ? digits.ToString(1, digits.Length - 1) : digits.ToString(); if (nonSignChars.Any(x => !x.IsDigit())) { throw InvalidException($"The value '{digits}' is not a valid number.", startPosition); } throw UnsupportedException( $"The value '{digits}' is not a valid long (Int64). Supported values range from '{long.MinValue:N0}' to '{long.MaxValue:N0}'.", startPosition); } return(new BNumber(number)); }