private static bool TryReadCode(string input, ref int current, out int code) { code = 0; int codeLength = HttpRuleParser.GetNumberLength(input, current, false); // code must be a 3 digit value. We accept less digits, but we don't accept more. if ((codeLength == 0) || (codeLength > 3)) { return(false); } if (!HeaderUtilities.TryParseInt32(input, current, codeLength, out code)) { Debug.Fail("Unable to parse value even though it was parsed as <=3 digits string. Input: '" + input + "', Current: " + current + ", CodeLength: " + codeLength); return(false); } current = current + codeLength; int whitespaceLength = HttpRuleParser.GetWhitespaceLength(input, current); current = current + whitespaceLength; // Make sure the number is followed by at least one whitespace and that we have characters left to parse. if ((whitespaceLength == 0) || (current == input.Length)) { return(false); } return(true); }
private static unsafe bool TryParseNonNegativeInt64FromHeaderValue(int startIndex, string headerValue, out long result) { // Trim leading whitespace startIndex += HttpRuleParser.GetWhitespaceLength(headerValue, startIndex); // Match and skip '=', it also can't be the last character in the headerValue if (startIndex >= headerValue.Length - 1 || headerValue[startIndex] != '=') { result = 0; return(false); } startIndex++; // Trim trailing whitespace startIndex += HttpRuleParser.GetWhitespaceLength(headerValue, startIndex); // Try parse the number if (TryParseNonNegativeInt64(new StringSegment(headerValue, startIndex, HttpRuleParser.GetNumberLength(headerValue, startIndex, false)), out result)) { return(true); } result = 0; return(false); }
private static bool TryGetRangeLength(string input, ref int current, out int fromLength, out int toStartIndex, out int toLength) { fromLength = 0; toStartIndex = 0; toLength = 0; // Check if we have a value like 'bytes */133'. If yes, skip the range part and continue parsing the // length separator '/'. if (input[current] == '*') { current++; } else { // Parse first range value: <from> in '<unit> <from>-<to>/<length>' fromLength = HttpRuleParser.GetNumberLength(input, current, false); if ((fromLength == 0) || (fromLength > HttpRuleParser.MaxInt64Digits)) { return(false); } current = current + fromLength; current = current + HttpRuleParser.GetWhitespaceLength(input, current); // Afer the first value, the '-' character must follow. if ((current == input.Length) || (input[current] != '-')) { // We need a '-' character otherwise this can't be a valid range. return(false); } current++; // skip the '-' character current = current + HttpRuleParser.GetWhitespaceLength(input, current); if (current == input.Length) { return(false); } // Parse second range value: <to> in '<unit> <from>-<to>/<length>' toStartIndex = current; toLength = HttpRuleParser.GetNumberLength(input, current, false); if ((toLength == 0) || (toLength > HttpRuleParser.MaxInt64Digits)) { return(false); } current = current + toLength; } current = current + HttpRuleParser.GetWhitespaceLength(input, current); return(true); }
private static bool TryReadQuality(string input, StringWithQualityHeaderValue result, ref int index) { int current = index; // See if we have a quality value by looking for "q" if ((current == input.Length) || ((input[current] != 'q') && (input[current] != 'Q'))) { return(false); } current++; // skip 'q' identifier current = current + HttpRuleParser.GetWhitespaceLength(input, current); // If we found "q" it must be followed by "=" if ((current == input.Length) || (input[current] != '=')) { return(false); } current++; // skip '=' separator current = current + HttpRuleParser.GetWhitespaceLength(input, current); if (current == input.Length) { return(false); } int qualityLength = HttpRuleParser.GetNumberLength(input, current, true); if (qualityLength == 0) { return(false); } double quality = 0; if (!double.TryParse(input.Substring(current, qualityLength), NumberStyles.AllowDecimalPoint, NumberFormatInfo.InvariantInfo, out quality)) { return(false); } if ((quality < 0) || (quality > 1)) { return(false); } result._quality = quality; current = current + qualityLength; current = current + HttpRuleParser.GetWhitespaceLength(input, current); index = current; return(true); }
public void GetNumberLength_SetOfValidNumbers_ParsedCorrectly() { Assert.Equal(3, HttpRuleParser.GetNumberLength("123", 0, false)); Assert.Equal(4, HttpRuleParser.GetNumberLength("123.", 0, true)); Assert.Equal(7, HttpRuleParser.GetNumberLength("123.456", 0, true)); Assert.Equal(1, HttpRuleParser.GetNumberLength("1a", 0, false)); Assert.Equal(2, HttpRuleParser.GetNumberLength("1.a", 0, true)); Assert.Equal(2, HttpRuleParser.GetNumberLength("1..", 0, true)); Assert.Equal(3, HttpRuleParser.GetNumberLength("1.2.", 0, true)); Assert.Equal(1, HttpRuleParser.GetNumberLength("1.2.", 0, false)); Assert.Equal(5, HttpRuleParser.GetNumberLength("123456", 1, false)); Assert.Equal(1, HttpRuleParser.GetNumberLength("1.5", 0, false)); // parse until '.' Assert.Equal(1, HttpRuleParser.GetNumberLength("1 2 3", 2, true)); // GetNumberLength doesn't have any size restrictions. The caller needs to decide whether a value is // outside the valid range or not. Assert.Equal(30, HttpRuleParser.GetNumberLength("123456789012345678901234567890", 0, false)); Assert.Equal(61, HttpRuleParser.GetNumberLength( "123456789012345678901234567890.123456789012345678901234567890", 0, true)); }
protected override int GetParsedValueLength(string value, int startIndex, object storeValue, out object parsedValue) { parsedValue = null; int numberLength = HttpRuleParser.GetNumberLength(value, startIndex, false); if ((numberLength == 0) || (numberLength > HttpRuleParser.MaxInt64Digits)) { return(0); } long result = 0; if (!HeaderUtilities.TryParseInt64(value.Substring(startIndex, numberLength), out result)) { return(0); } parsedValue = result; return(numberLength); }
protected override int GetParsedValueLength(string value, int startIndex, object?storeValue, out object?parsedValue) { parsedValue = null; int numberLength = HttpRuleParser.GetNumberLength(value, startIndex, false); if ((numberLength == 0) || (numberLength > HttpRuleParser.MaxInt32Digits)) { return(0); } int result = 0; if (!HeaderUtilities.TryParseInt32(value, startIndex, numberLength, out result)) { return(0); } parsedValue = new TimeSpan(0, 0, result); return(numberLength); }
private static bool TryGetLengthLength(string input, ref int current, out int lengthLength) { lengthLength = 0; if (input[current] == '*') { current++; } else { // Parse length value: <length> in '<unit> <from>-<to>/<length>' lengthLength = HttpRuleParser.GetNumberLength(input, current, false); if ((lengthLength == 0) || (lengthLength > HttpRuleParser.MaxInt64Digits)) { return(false); } current = current + lengthLength; } current = current + HttpRuleParser.GetWhitespaceLength(input, current); return(true); }
public void GetNumberLength_SetOfInvalidNumbers_ReturnsZero() { Assert.Equal(0, HttpRuleParser.GetNumberLength(".456", 0, true)); Assert.Equal(0, HttpRuleParser.GetNumberLength("-1", 0, true)); Assert.Equal(0, HttpRuleParser.GetNumberLength("a", 0, true)); }
internal static int GetRetryConditionLength(string?input, int startIndex, out object?parsedValue) { Debug.Assert(startIndex >= 0); parsedValue = null; if (string.IsNullOrEmpty(input) || (startIndex >= input.Length)) { return(0); } int current = startIndex; // Caller must remove leading whitespace. DateTimeOffset date = DateTimeOffset.MinValue; int deltaSeconds = -1; // use -1 to indicate that the value was not set. 'delta' values are always >=0 // We either have a timespan or a date/time value. Determine which one we have by looking at the first char. // If it is a number, we have a timespan, otherwise we assume we have a date. char firstChar = input[current]; if ((firstChar >= '0') && (firstChar <= '9')) { int deltaStartIndex = current; int deltaLength = HttpRuleParser.GetNumberLength(input, current, false); // The value must be in the range 0..2^31 if ((deltaLength == 0) || (deltaLength > HttpRuleParser.MaxInt32Digits)) { return(0); } current = current + deltaLength; current = current + HttpRuleParser.GetWhitespaceLength(input, current); // RetryConditionHeaderValue only allows 1 value. There must be no delimiter/other chars after 'delta' if (current != input.Length) { return(0); } if (!HeaderUtilities.TryParseInt32(input, deltaStartIndex, deltaLength, out deltaSeconds)) { return(0); // int.TryParse() may return 'false' if the value has 10 digits and is > Int32.MaxValue. } } else { if (!HttpDateParser.TryParse(input.AsSpan(current), out date)) { return(0); } // If we got a valid date, then the parser consumed the whole string (incl. trailing whitespace). current = input.Length; } RetryConditionHeaderValue result = new RetryConditionHeaderValue(); if (deltaSeconds == -1) // we didn't change delta, so we must have found a date. { result._date = date; } else { result._delta = new TimeSpan(0, 0, deltaSeconds); } parsedValue = result; return(current - startIndex); }
internal static int GetRangeItemLength(string?input, int startIndex, out RangeItemHeaderValue?parsedValue) { Debug.Assert(startIndex >= 0); // This parser parses number ranges: e.g. '1-2', '1-', '-2'. parsedValue = null; if (string.IsNullOrEmpty(input) || (startIndex >= input.Length)) { return(0); } // Caller must remove leading whitespace. If not, we'll return 0. int current = startIndex; // Try parse the first value of a value pair. int fromStartIndex = current; int fromLength = HttpRuleParser.GetNumberLength(input, current, false); if (fromLength > HttpRuleParser.MaxInt64Digits) { return(0); } current = current + fromLength; current = current + HttpRuleParser.GetWhitespaceLength(input, current); // After the first value, the '-' character must follow. if ((current == input.Length) || (input[current] != '-')) { // We need a '-' character otherwise this can't be a valid range. return(0); } current++; // skip the '-' character current = current + HttpRuleParser.GetWhitespaceLength(input, current); int toStartIndex = current; int toLength = 0; // If we didn't reach the end of the string, try parse the second value of the range. if (current < input.Length) { toLength = HttpRuleParser.GetNumberLength(input, current, false); if (toLength > HttpRuleParser.MaxInt64Digits) { return(0); } current = current + toLength; current = current + HttpRuleParser.GetWhitespaceLength(input, current); } if ((fromLength == 0) && (toLength == 0)) { return(0); // At least one value must be provided in order to be a valid range. } // Try convert first value to int64 long from = 0; if ((fromLength > 0) && !HeaderUtilities.TryParseInt64(input, fromStartIndex, fromLength, out from)) { return(0); } // Try convert second value to int64 long to = 0; if ((toLength > 0) && !HeaderUtilities.TryParseInt64(input, toStartIndex, toLength, out to)) { return(0); } // 'from' must not be greater than 'to' if ((fromLength > 0) && (toLength > 0) && (from > to)) { return(0); } parsedValue = new RangeItemHeaderValue((fromLength == 0 ? (long?)null : (long?)from), (toLength == 0 ? (long?)null : (long?)to)); return(current - startIndex); }
// name=value; expires=Sun, 06 Nov 1994 08:49:37 GMT; max-age=86400; domain=domain1; path=path1; secure; samesite={Strict|Lax|None}; httponly private static int GetSetCookieLength(StringSegment input, int startIndex, out SetCookieHeaderValue?parsedValue) { Contract.Requires(startIndex >= 0); var offset = startIndex; parsedValue = null; if (StringSegment.IsNullOrEmpty(input) || (offset >= input.Length)) { return(0); } var result = new SetCookieHeaderValue(); // The caller should have already consumed any leading whitespace, commas, etc.. // Name=value; // Name var itemLength = HttpRuleParser.GetTokenLength(input, offset); if (itemLength == 0) { return(0); } result._name = input.Subsegment(offset, itemLength); offset += itemLength; // = (no spaces) if (!ReadEqualsSign(input, ref offset)) { return(0); } // value or "quoted value" // The value may be empty result._value = CookieHeaderParserShared.GetCookieValue(input, ref offset); // *(';' SP cookie-av) while (offset < input.Length) { if (input[offset] == ',') { // Divider between headers break; } if (input[offset] != ';') { // Expecting a ';' between parameters return(0); } offset++; offset += HttpRuleParser.GetWhitespaceLength(input, offset); // cookie-av = expires-av / max-age-av / domain-av / path-av / secure-av / samesite-av / httponly-av / extension-av itemLength = HttpRuleParser.GetTokenLength(input, offset); if (itemLength == 0) { // Trailing ';' or leading into garbage. Let the next parser fail. break; } var token = input.Subsegment(offset, itemLength); offset += itemLength; // expires-av = "Expires=" sane-cookie-date if (StringSegment.Equals(token, ExpiresToken, StringComparison.OrdinalIgnoreCase)) { // = (no spaces) if (!ReadEqualsSign(input, ref offset)) { return(0); } // We don't want to include comma, becouse date may contain it (eg. Sun, 06 Nov...) var dateString = ReadToSemicolonOrEnd(input, ref offset, includeComma: false); DateTimeOffset expirationDate; if (!HttpRuleParser.TryStringToDate(dateString, out expirationDate)) { // Invalid expiration date, abort return(0); } result.Expires = expirationDate; } // max-age-av = "Max-Age=" non-zero-digit *DIGIT else if (StringSegment.Equals(token, MaxAgeToken, StringComparison.OrdinalIgnoreCase)) { // = (no spaces) if (!ReadEqualsSign(input, ref offset)) { return(0); } itemLength = HttpRuleParser.GetNumberLength(input, offset, allowDecimal: false); if (itemLength == 0) { return(0); } var numberString = input.Subsegment(offset, itemLength); long maxAge; if (!HeaderUtilities.TryParseNonNegativeInt64(numberString, out maxAge)) { // Invalid expiration date, abort return(0); } result.MaxAge = TimeSpan.FromSeconds(maxAge); offset += itemLength; } // domain-av = "Domain=" domain-value // domain-value = <subdomain> ; defined in [RFC1034], Section 3.5, as enhanced by [RFC1123], Section 2.1 else if (StringSegment.Equals(token, DomainToken, StringComparison.OrdinalIgnoreCase)) { // = (no spaces) if (!ReadEqualsSign(input, ref offset)) { return(0); } // We don't do any detailed validation on the domain. result.Domain = ReadToSemicolonOrEnd(input, ref offset); } // path-av = "Path=" path-value // path-value = <any CHAR except CTLs or ";"> else if (StringSegment.Equals(token, PathToken, StringComparison.OrdinalIgnoreCase)) { // = (no spaces) if (!ReadEqualsSign(input, ref offset)) { return(0); } // We don't do any detailed validation on the path. result.Path = ReadToSemicolonOrEnd(input, ref offset); } // secure-av = "Secure" else if (StringSegment.Equals(token, SecureToken, StringComparison.OrdinalIgnoreCase)) { result.Secure = true; } // samesite-av = "SameSite=" samesite-value // samesite-value = "Strict" / "Lax" / "None" else if (StringSegment.Equals(token, SameSiteToken, StringComparison.OrdinalIgnoreCase)) { if (!ReadEqualsSign(input, ref offset)) { result.SameSite = SameSiteMode.Unspecified; } else { var enforcementMode = ReadToSemicolonOrEnd(input, ref offset); if (StringSegment.Equals(enforcementMode, SameSiteStrictToken, StringComparison.OrdinalIgnoreCase)) { result.SameSite = SameSiteMode.Strict; } else if (StringSegment.Equals(enforcementMode, SameSiteLaxToken, StringComparison.OrdinalIgnoreCase)) { result.SameSite = SameSiteMode.Lax; } else if (StringSegment.Equals(enforcementMode, SameSiteNoneToken, StringComparison.OrdinalIgnoreCase)) { result.SameSite = SameSiteMode.None; } else { result.SameSite = SameSiteMode.Unspecified; } } } // httponly-av = "HttpOnly" else if (StringSegment.Equals(token, HttpOnlyToken, StringComparison.OrdinalIgnoreCase)) { result.HttpOnly = true; } // extension-av = <any CHAR except CTLs or ";"> else { var tokenStart = offset - itemLength; ReadToSemicolonOrEnd(input, ref offset, includeComma: true); result.Extensions.Add(input.Subsegment(tokenStart, offset - tokenStart)); } } parsedValue = result; return(offset - startIndex); }