public void StringSegment_IndexOfString_ReturnsCorrectValueForExistingCharacter()
{
var segment = new StringSegment("Hello, world!");
var result = segment.IndexOf("world");
TheResultingValue(result).ShouldBe(7);
}
public void CharReaderFromSegment()
{
var segment = new StringSegment(TestContent);
var reader = new CharReader(segment);
Assert.False(reader.IsDone);
Assert.Equal(-1, reader.Position);
}
public void Null()
{
var segment = new StringSegment(null);
Assert.Equal(0, segment.Length);
Assert.True(segment.IsEmpty);
Assert.True(segment.IsNull);
}
public void StringSegment_IndexOfString_ReturnsNegativeOneForNonExistingCharacter()
{
var segment = new StringSegment("Hello, world!");
var result = segment.IndexOf("zorld");
TheResultingValue(result).ShouldBe(-1);
}
public void Empty()
{
var segment = new StringSegment("");
Assert.Equal(0, segment.Length);
Assert.True(segment.IsEmpty);
Assert.False(segment.IsNull);
}
public void FormatFilter_ContextContainsFormat_DefaultFormat(
string format,
FormatSource place,
string contentType)
{
// Arrange
var mediaType = new StringSegment("application/json");
var mockObjects = new MockObjects(format, place);
var resultExecutingContext = mockObjects.CreateResultExecutingContext();
var resourceExecutingContext = mockObjects.CreateResourceExecutingContext(new IFilterMetadata[] { });
var filter = new FormatFilter(mockObjects.OptionsManager);
// Act
filter.OnResourceExecuting(resourceExecutingContext);
// Assert
Assert.Null(resourceExecutingContext.Result);
// Act
filter.OnResultExecuting(resultExecutingContext);
// Assert
var objectResult = Assert.IsType<ObjectResult>(resultExecutingContext.Result);
Assert.Equal(1, objectResult.ContentTypes.Count);
MediaTypeAssert.Equal(mediaType, objectResult.ContentTypes[0]);
}
public void CharReaderShouldReadToCharacter()
{
StringSegment source = new StringSegment("abc:123");
CharReader reader = new CharReader(source);
reader.ReadTo(':', false);
Assert.Equal(3, reader.Position);
}
/// <summary>
/// Converts the hexadecimal text of the specified <see cref="StringSegment"/> to an
/// instance of <see cref="Int32"/> if possible.
/// </summary>
/// <param name="segment">The string segment to convert.</param>
/// <param name="result">The converted value.</param>
/// <returns><see langword="true"/> if the conversion succeeded; otherwise, <see langword="false"/>.</returns>
public static Boolean TryParseHexadecimalInt32(StringSegment segment, out Int32 result)
{
var spaceCountLeading = CountLeadingSpace(ref segment);
var spaceCountTrailing = CountTrailingSpace(ref segment);
var valueStart = spaceCountLeading;
var valueLength = segment.Length - (spaceCountLeading + spaceCountTrailing);
var magnitude = (Int64)Math.Pow(16, valueLength - 1);
var digit = 0;
var total = 0L;
for (int i = 0; i < valueLength; i++)
{
if (!ConvertHexadecimalDigit(segment[valueStart + i], out digit))
{
result = 0;
return false;
}
total += (magnitude * digit);
magnitude /= 16;
}
if (total > Int32.MaxValue)
throw new OverflowException();
result = (Int32)total;
return true;
}
/// <summary>
/// Initializes a new instance of the <see cref="StringSource"/> structure.
/// </summary>
/// <param name="segment">The <see cref="StringSegment"/> that contains the string data.</param>
public StringSource(StringSegment segment)
{
this.str = segment.SourceString;
this.builder = segment.SourceStringBuilder;
this.Start = segment.Start;
this.Length = segment.Length;
}
public static UInt32 ParseUInt32(StringSegment segment)
{
UInt32 value;
if (!TryParseUInt32(segment, out value))
throw new FormatException();
return value;
}
public void StringSegment_CanBeCreatedFromString()
{
var source = "Hello, world!";
var segment = new StringSegment(source, 2, 4);
TheResultingString(segment.ToString())
.ShouldBe("llo,");
}
/// <summary>
/// Initializes a new instance of the <see cref="TextParserToken"/> structure.
/// </summary>
/// <param name="tokenType">The token's type.</param>
/// <param name="text">The token's text.</param>
/// <param name="sourceOffset">The offset of the first character in the source text that produced this token.</param>
/// <param name="sourceLength">The number of characters in the source text that produced this token.</param>
/// <param name="isNonBreakingSpace">A value indicating whether this token represents a non-breaking space.</param>
internal TextParserToken(TextParserTokenType tokenType, StringSegment text, Int32 sourceOffset, Int32 sourceLength, Boolean isNonBreakingSpace = false)
{
this.tokenType = tokenType;
this.text = text;
this.sourceOffset = sourceOffset;
this.sourceLength = sourceLength;
this.isNonBreakingSpace = isNonBreakingSpace;
}
public void DefaultConstructor()
{
var segment = new StringSegment();
Assert.Equal(0, segment.Length);
Assert.True(segment.IsEmpty);
Assert.True(segment.IsNull);
}
public void NoRunFactories()
{
WikiRunParser parser = new WikiRunParser(Enumerable.Empty<WikiRunFactory>());
StringSegment text = new StringSegment("we're");
List<WikiRun> runs = parser.Parse(text).ToList();
Assert.AreEqual(1, runs.Count);
Assert.AreEqual("we're", ((TextWikiRun) runs[0]).Text);
}
/// <summary>
/// Initializes a new instance of the <see cref="StringFormatterCommandInfo"/> structure.
/// </summary>
/// <param name="commandName">The name of the command being handled.</param>
/// <param name="commandArgs">The command's argument list.</param>
/// <param name="commandHandler">The command's handler.</param>
public StringFormatterCommandInfo(StringSegment commandName,
StringFormatterCommandArguments commandArgs,
StringFormatterCommandHandler commandHandler)
{
this.CommandName = commandName;
this.CommandArguments = commandArgs;
this.CommandHandler = commandHandler;
}
public void EqualMatchesEntireSubstring()
{
var segment = new StringSegment("abcdefghij", 2, 6);
segment.Equals("cdefgh", StringComparison.Ordinal).ShouldBe(true);
segment.Equals("cdefg", StringComparison.Ordinal).ShouldBe(false);
segment.Equals("cdefghi", StringComparison.Ordinal).ShouldBe(false);
segment.Equals("cDefgh", StringComparison.Ordinal).ShouldBe(false);
segment.Equals("cDefgh", StringComparison.OrdinalIgnoreCase).ShouldBe(true);
}
private WikiRun FindRunInText(StringSegment text)
{
Match match = text.Match(m_regex);
for (int runFactoryIndex = 0; runFactoryIndex < m_runFactories.Count; runFactoryIndex++)
if (match.Groups["z" + runFactoryIndex].Success)
return m_runFactories[runFactoryIndex].Parse(text, match);
return null;
}
/// <summary>
/// Initializes a new instance of the <see cref="TextLayoutToken"/> structure.
/// </summary>
/// <param name="text">The token's text.</param>
/// <param name="bounds">The token's bounds relative to its layout region.</param>
/// <param name="fontFace">The token's font face.</param>
/// <param name="icon">The token's icon.</param>
/// <param name="glyphShader">The token's glyph shader.</param>
/// <param name="color">The token's color.</param>
internal TextLayoutToken(StringSegment text, Rectangle bounds, SpriteFontFace fontFace, TextIconInfo? icon, GlyphShader glyphShader, Color? color)
{
this.text = text;
this.bounds = bounds;
this.fontFace = fontFace;
this.icon = icon;
this.glyphShader = glyphShader;
this.color = color;
}
public void BodyFromStringSegmentShouldHaveMatchingText()
{
string s = "abcHello, worlddef";
string bText = "Hello, world";
StringSegment ss = new StringSegment(s, 3, 14);
Body b = new Body(ss);
Assert.Equal(bText, b.Text);
Assert.Equal(bText, b.SourceText.ToString());
Assert.Equal(bText, b.ToString());
}
public void Contraction()
{
StringSegment text = new StringSegment("we're");
List<WikiRun> runs = m_parser.Parse(text).ToList();
int runIndex = 0;
Assert.AreEqual("we", ((TextWikiRun) runs[runIndex++]).Text);
Assert.AreEqual(SmartQuoteWikiRun.RightSingleQuote, ((SmartQuoteWikiRun) runs[runIndex++]).SmartQuote);
Assert.AreEqual("re", ((TextWikiRun) runs[runIndex++]).Text);
Assert.AreEqual(runIndex, runs.Count);
}
public void StringSegment_StringCtor_AllowsNullBuffers()
{
// Arrange & Act
var segment = new StringSegment(null);
// Assert
Assert.False(segment.HasValue);
Assert.Equal(0, segment.Offset);
Assert.Equal(0, segment.Length);
}
public void StringSegment_HasValue_Invalid()
{
// Arrange
var segment = new StringSegment();
// Act
var hasValue = segment.HasValue;
// Assert
Assert.False(hasValue);
}
public void PathTokenizer_Count(string path, StringSegment[] expectedSegments)
{
// Arrange
var tokenizer = new PathTokenizer(new PathString(path));
// Act
var count = tokenizer.Count;
// Assert
Assert.Equal(expectedSegments.Length, count);
}
/// <summary>
/// Gets a value indicating whether the string has the specified property.
/// </summary>
/// <param name="prop">The name of the property to evaluate.</param>
/// <returns><c>true</c> if the string has the specified property; otherwise, <c>false</c>.</returns>
public Boolean HasPropertyRef(ref StringSegment prop)
{
foreach (var kvp in properties)
{
if (prop.Equals(kvp.Key))
{
return true;
}
}
return false;
}
public void StringSegment_Value_Invalid()
{
// Arrange
var segment = new StringSegment();
// Act
var value = segment.Value;
// Assert
Assert.Null(value);
}
/// <inheritdoc/>
public override void HandleCommandLocalizedString(StringFormatter formatter,
StringBuilder output, StringSegment command, StringFormatterCommandArguments arguments, LocalizedString value)
{
if (value == null)
throw new FormatException(NucleusStrings.FmtCmdInvalidForGeneratedStrings.Format("variant"));
var variantName = arguments.GetArgument(0).Text;
var variant = value.GetVariant(ref variantName);
output.Append(variant);
}
public void StringSegment_Value_Valid()
{
// Arrange
var segment = new StringSegment("Hello, World!", 1, 4);
// Act
var value = segment.Value;
// Assert
Assert.Equal("ello", value);
}
public void StringSegment_HasValue_Valid()
{
// Arrange
var segment = new StringSegment("Hello, World!", 1, 4);
// Act
var hasValue = segment.HasValue;
// Assert
Assert.True(hasValue);
}
public void Segmented(string content, int start, int end, string expectedSegment)
{
var segment = new StringSegment(content, start, end);
Assert.Equal(end, segment.EndIndex);
Assert.False(segment.IsEmpty);
Assert.False(segment.IsNull);
Assert.Equal(expectedSegment.Length, segment.Length);
Assert.Equal(TestContent, segment.Source);
Assert.Equal(start, segment.StartIndex);
Assert.Equal(expectedSegment, segment.ToString());
}
public static void AppendSegment(this StringBuilder sb, StringSegment value)
{
Contract.Require(sb, nameof(sb));
if (value.IsEmpty)
return;
for (int i = 0; i < value.Length ; i++)
{
sb.Append(value[i]);
}
}
private bool HasFileContentDisposition(ContentDispositionHeaderValue contentDisposition)
{
// Content-Disposition: form-data; name="myfile1"; filename="Misc 002.jpg"
return(contentDisposition != null && contentDisposition.DispositionType.Equals("form-data") &&
(!StringSegment.IsNullOrEmpty(contentDisposition.FileName) || !StringSegment.IsNullOrEmpty(contentDisposition.FileNameStar)));
}
/// <inheritdoc />
public async Task OnResourceExecutionAsync(ResourceExecutingContext context, ResourceExecutionDelegate next)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (next == null)
{
throw new ArgumentNullException(nameof(next));
}
var request = context.HttpContext.Request;
if (HttpMethods.IsPost(request.Method))
{
// 1. Confirm a secure connection.
var errorResult = EnsureSecureConnection(ReceiverName, context.HttpContext.Request);
if (errorResult != null)
{
context.Result = errorResult;
return;
}
// 2. Get the expected hash from the signature header.
var header = GetRequestHeader(request, GitHubConstants.SignatureHeaderName, out errorResult);
if (errorResult != null)
{
context.Result = errorResult;
return;
}
var values = new TrimmingTokenizer(header, PairSeparators);
var enumerator = values.GetEnumerator();
enumerator.MoveNext();
var headerKey = enumerator.Current;
if (values.Count != 2 ||
!StringSegment.Equals(
headerKey,
GitHubConstants.SignatureHeaderKey,
StringComparison.OrdinalIgnoreCase))
{
Logger.LogWarning(
0,
$"Invalid '{GitHubConstants.SignatureHeaderName}' header value. Expecting a value of " +
$"'{GitHubConstants.SignatureHeaderKey}=<value>'.");
var message = string.Format(
CultureInfo.CurrentCulture,
GitHubConstants.SignatureHeaderName,
GitHubConstants.SignatureHeaderKey,
"<value>");
errorResult = new BadRequestObjectResult(message);
context.Result = errorResult;
return;
}
enumerator.MoveNext();
var headerValue = enumerator.Current.Value;
var expectedHash = FromHex(headerValue, GitHubConstants.SignatureHeaderName);
if (expectedHash == null)
{
context.Result = CreateBadHexEncodingResult(GitHubConstants.SignatureHeaderKey);
return;
}
// 3. Get the configured secret key.
var secretKey = Env.GetString("GITHUB_WEBHOOKS_SECRETKEY_DEFAULT");
if (secretKey == null)
{
context.Result = new NotFoundResult();
return;
}
var secret = Encoding.UTF8.GetBytes(secretKey);
// 4. Get the actual hash of the request body.
var actualHash = await ComputeRequestBodySha1HashAsync(request, secret);
// 5. Verify that the actual hash matches the expected hash.
if (!SecretEqual(expectedHash, actualHash))
{
// Log about the issue and short-circuit remainder of the pipeline.
errorResult = CreateBadSignatureResult(GitHubConstants.SignatureHeaderName);
context.Result = errorResult;
return;
}
}
await next();
}
private static bool IsPathCandidateForComponent(DocumentSnapshot documentSnapshot, StringSegment path)
{
if (documentSnapshot.FileKind != FileKinds.Component)
{
return(false);
}
var fileName = Path.GetFileNameWithoutExtension(documentSnapshot.FilePath);
return(new StringSegment(fileName).Equals(path, FilePathComparison.Instance));
}
public static StringSegment Trim(StringSegment segment, char[] separators)
{
Debug.Assert(separators?.Length != 0, "The separators collection shouldn't be null or empty.");
return(TrimEnd(TrimStart(segment, separators), separators));
}
public CommentStatement(StringSegment text)
{
Text = text.ToString();
}
private static string ValueWithPrefix(StringSegment prefixSegment, object val)
{
var prefix = prefixSegment.Subsegment(0, prefixSegment.Length - 1);
return((prefix.Length > 0) && (prefix[prefix.Length - 1] != '/') ? null : $"{prefix}{val}");
}
public static void GetDocIdFromInclude(BlittableJsonReaderObject docReader, StringSegment includePath,
HashSet <string> includedIds)
{
Func <object, StringSegment, string> valueHandler = null;
var indexOfPrefixStart = includePath.IndexOfAny(PrefixSeparatorChar, 0);
StringSegment pathSegment;
StringSegment?addition = null;
if (HasSuffixSeparator(includePath, out var indexOfSuffixStart))
{
addition = includePath.Subsegment(indexOfSuffixStart + 1);
if (!addition.Value[addition.Value.Length - 1].Equals(']') ||
((addition.Value.Length >= 4) &&
!addition.Value.Subsegment(0, 4).Equals(SuffixStart)))
{
return;
}
pathSegment = includePath.Subsegment(0, indexOfSuffixStart);
valueHandler = HandleSuffixValue;
}
else if (indexOfPrefixStart != -1)
{
addition = includePath.Subsegment(indexOfPrefixStart + 1);
if (!includePath[includePath.Length - 1].Equals(')'))
{
return;
}
pathSegment = includePath.Subsegment(0, indexOfPrefixStart);
valueHandler = HandlePrefixValue;
}
else
{
pathSegment = includePath;
}
if (BlittableJsonTraverser.Default.TryRead(docReader, pathSegment, out object value, out StringSegment leftPath) == false)
{
var json = value as BlittableJsonReaderObject;
if (json != null)
{
var isKey = leftPath == "$Keys"; // include on dictionary.Keys or dictionary.Values
if (isKey || leftPath == "$Values")
{
var property = new BlittableJsonReaderObject.PropertyDetails();
foreach (var propertyIndex in json.GetPropertiesByInsertionOrder())
{
json.GetPropertyByIndex(propertyIndex, ref property);
var val = isKey ? property.Name : property.Value;
if (val != null)
{
includedIds.Add(val.ToString());
}
}
}
}
return;
}
var collectionOfIds = value as IEnumerable;
if (collectionOfIds != null)
{
foreach (var item in collectionOfIds)
{
if (item == null)
{
continue;
}
if (addition != null)
{
var includedId = valueHandler(item, addition.Value);
if (includedId != null)
{
includedIds.Add(includedId);
}
}
includedIds.Add(BlittableValueToString(item));
}
}
else
{
if (addition != null)
{
var includedId = valueHandler(value, addition.Value);
if (includedId != null)
{
includedIds.Add(includedId);
}
}
includedIds.Add(BlittableValueToString(value));
}
}
public RangeHeaderValue(long?from, long?to)
{
// convenience ctor: "Range: bytes=from-to"
_unit = HeaderUtilities.BytesUnit;
Ranges.Add(new RangeItemHeaderValue(from, to));
}
public RangeHeaderValue()
{
_unit = HeaderUtilities.BytesUnit;
}
public static StringWithQualityHeaderValue Parse(StringSegment input)
{
var index = 0;
return(SingleValueParser.ParseValue(input, ref index));
}
public static bool TryParse(StringSegment input, out StringWithQualityHeaderValue parsedValue)
{
var index = 0;
return(SingleValueParser.TryParseValue(input, ref index, out parsedValue));
}
public MethodExpression(StringSegment name, List <QueryExpression> arguments)
{
Name = name;
Arguments = arguments;
Type = ExpressionType.Method;
}
// TODO: optimize this method
internal static List <ProxyRoute> BuildRoutes(Uri serviceName, Dictionary <string, string> labels)
{
var backendId = GetClusterId(serviceName, labels);
var routesNames = new Dictionary <StringSegment, string>();
foreach (var kvp in labels)
{
if (kvp.Key.Length > RoutesLabelsPrefix.Length && kvp.Key.StartsWith(RoutesLabelsPrefix, StringComparison.Ordinal))
{
var suffix = new StringSegment(kvp.Key).Subsegment(RoutesLabelsPrefix.Length);
var routeNameLength = suffix.IndexOf('.');
if (routeNameLength == -1)
{
// No route name encoded, the key is not valid. Throwing would suggest we actually check for all invalid keys, so just ignore.
continue;
}
var routeNameSegment = suffix.Subsegment(0, routeNameLength + 1);
if (routesNames.ContainsKey(routeNameSegment))
{
continue;
}
var routeName = routeNameSegment.Subsegment(0, routeNameSegment.Length - 1).ToString();
if (!_allowedRouteNamesRegex.IsMatch(routeName))
{
throw new ConfigException($"Invalid route name '{routeName}', should only contain alphanumerical characters, underscores or hyphens.");
}
routesNames.Add(routeNameSegment, routeName);
}
}
// Build the routes
var routes = new List <ProxyRoute>(routesNames.Count);
foreach (var routeNamePair in routesNames)
{
string hosts = null;
string path = null;
int? order = null;
var metadata = new Dictionary <string, string>();
var headerMatches = new Dictionary <string, RouteHeaderFields>();
var transforms = new Dictionary <string, Dictionary <string, string> >();
foreach (var kvp in labels)
{
if (!kvp.Key.StartsWith(RoutesLabelsPrefix, StringComparison.Ordinal))
{
continue;
}
var routeLabelKey = kvp.Key.AsSpan().Slice(RoutesLabelsPrefix.Length);
if (routeLabelKey.Length < routeNamePair.Key.Length || !routeLabelKey.StartsWith(routeNamePair.Key, StringComparison.Ordinal))
{
continue;
}
routeLabelKey = routeLabelKey.Slice(routeNamePair.Key.Length);
if (ContainsKey("Metadata.", routeLabelKey, out var keyRemainder))
{
metadata.Add(keyRemainder.ToString(), kvp.Value);
}
else if (ContainsKey("MatchHeaders.", routeLabelKey, out keyRemainder))
{
var headerIndexLength = keyRemainder.IndexOf('.');
if (headerIndexLength == -1)
{
// No header encoded, the key is not valid. Throwing would suggest we actually check for all invalid keys, so just ignore.
continue;
}
var headerIndex = keyRemainder.Slice(0, headerIndexLength).ToString();
if (!_allowedHeaderNamesRegex.IsMatch(headerIndex))
{
throw new ConfigException($"Invalid header matching index '{headerIndex}', should only contain alphanumerical characters, underscores or hyphens.");
}
if (!headerMatches.ContainsKey(headerIndex))
{
headerMatches.Add(headerIndex, new RouteHeaderFields());
}
var propertyName = keyRemainder.Slice(headerIndexLength + 1);
if (propertyName.Equals("Name", StringComparison.Ordinal))
{
headerMatches[headerIndex].Name = kvp.Value;
}
else if (propertyName.Equals("Values", StringComparison.Ordinal))
{
#if NET5_0
headerMatches[headerIndex].Values = kvp.Value.Split(',', StringSplitOptions.TrimEntries);
#elif NETCOREAPP3_1
headerMatches[headerIndex].Values = kvp.Value.Split(',').Select(val => val.Trim()).ToList();
#else
#error A target framework was added to the project and needs to be added to this condition.
#endif
}
else if (propertyName.Equals("IsCaseSensitive", StringComparison.Ordinal))
{
headerMatches[headerIndex].IsCaseSensitive = bool.Parse(kvp.Value);
}
else if (propertyName.Equals("Mode", StringComparison.Ordinal))
{
headerMatches[headerIndex].Mode = Enum.Parse <HeaderMatchMode>(kvp.Value);
}
else
{
throw new ConfigException($"Invalid header matching property '{propertyName.ToString()}', only valid values are Name, Values, IsCaseSensitive and Mode.");
}
}
else if (ContainsKey("Transforms.", routeLabelKey, out keyRemainder))
{
var transformNameLength = keyRemainder.IndexOf('.');
if (transformNameLength == -1)
{
// No transform index encoded, the key is not valid. Throwing would suggest we actually check for all invalid keys, so just ignore.
continue;
}
var transformName = keyRemainder.Slice(0, transformNameLength).ToString();
if (!_allowedTransformNamesRegex.IsMatch(transformName))
{
throw new ConfigException($"Invalid transform index '{transformName}', should be transform index wrapped in square brackets.");
}
if (!transforms.ContainsKey(transformName))
{
transforms.Add(transformName, new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase));
}
var propertyName = keyRemainder.Slice(transformNameLength + 1).ToString();
if (!transforms[transformName].ContainsKey(propertyName))
{
transforms[transformName].Add(propertyName, kvp.Value);
}
else
{
throw new ConfigException($"A duplicate transformation property '{transformName}.{propertyName}' was found.");
}
}
else if (ContainsKey("Hosts", routeLabelKey, out _))
{
hosts = kvp.Value;
}
else if (ContainsKey("Path", routeLabelKey, out _))
{
path = kvp.Value;
}
else if (ContainsKey("Order", routeLabelKey, out _))
{
order = ConvertLabelValue <int?>(kvp.Key, kvp.Value);
}
}
var route = new ProxyRoute
{
RouteId = $"{Uri.EscapeDataString(backendId)}:{Uri.EscapeDataString(routeNamePair.Value)}",
Match = new ProxyMatch
{
Hosts = SplitHosts(hosts),
Path = path,
Headers = headerMatches.Count > 0 ? headerMatches.Select(hm => new RouteHeader()
{
Name = hm.Value.Name,
Values = hm.Value.Values,
Mode = hm.Value.Mode,
IsCaseSensitive = hm.Value.IsCaseSensitive,
}).ToArray() : null
},
Order = order,
ClusterId = backendId,
Metadata = metadata,
Transforms = transforms.Count > 0 ? transforms.Select(tr => tr.Value).ToList().AsReadOnly() : null
};
routes.Add(route);
}
return(routes);
}
public override void VisitSelectFunctionBody(StringSegment func)
{
throw new NotSupportedException();
}
private bool HasFormDataContentDisposition(ContentDispositionHeaderValue contentDisposition)
{
// Content-Disposition: form-data; name="key";
return(contentDisposition != null && contentDisposition.DispositionType.Equals("form-data") &&
StringSegment.IsNullOrEmpty(contentDisposition.FileName) && StringSegment.IsNullOrEmpty(contentDisposition.FileNameStar));
}
public abstract ManifestEntry Traverse(StringSegment segment);
internal static int GetRangeItemLength(StringSegment input, int startIndex, out RangeItemHeaderValue parsedValue)
{
Contract.Requires(startIndex >= 0);
// This parser parses number ranges: e.g. '1-2', '1-', '-2'.
parsedValue = null;
if (StringSegment.IsNullOrEmpty(input) || (startIndex >= input.Length))
{
return(0);
}
// Caller must remove leading whitespaces. If not, we'll return 0.
var current = startIndex;
// Try parse the first value of a value pair.
var fromStartIndex = current;
var 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);
var toStartIndex = current;
var 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.TryParseNonNegativeInt64(input.Subsegment(fromStartIndex, fromLength), out from))
{
return(0);
}
// Try convert second value to int64
long to = 0;
if ((toLength > 0) && !HeaderUtilities.TryParseNonNegativeInt64(input.Subsegment(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);
}
private IActionResult ValidateHeader(string header)
{
var hasTimestamp = false;
var hasSignature = false;
var pairs = new TrimmingTokenizer(header, CommaSeparator);
foreach (var pair in pairs)
{
var keyValuePair = new TrimmingTokenizer(pair, EqualSeparator, maxCount: 2);
if (keyValuePair.Count != 2)
{
// Header is not formatted correctly.
Logger.LogWarning(
0,
$"The '{StripeConstants.SignatureHeaderName}' header value is invalid. '{{InvalidPair}}' " +
"should be a 'key=value' pair.",
pair);
var message = string.Format(
CultureInfo.CurrentCulture,
Resources.SignatureFilter_InvalidHeaderFormat,
StripeConstants.SignatureHeaderName);
return(new BadRequestObjectResult(message));
}
var enumerator = keyValuePair.GetEnumerator();
enumerator.MoveNext();
var key = enumerator.Current;
if (StringSegment.Equals(key, StripeConstants.SignatureKey, StringComparison.Ordinal))
{
enumerator.MoveNext();
hasSignature = !StringSegment.IsNullOrEmpty(enumerator.Current);
}
else if (StringSegment.Equals(key, StripeConstants.TimestampKey, StringComparison.Ordinal))
{
enumerator.MoveNext();
hasTimestamp = !StringSegment.IsNullOrEmpty(enumerator.Current);
}
}
if (!hasSignature)
{
Logger.LogWarning(
1,
$"The '{StripeConstants.SignatureHeaderName}' header value is invalid. Does not contain a " +
$"timestamp ('{StripeConstants.SignatureKey}') value.");
}
if (!hasTimestamp)
{
Logger.LogWarning(
2,
$"The '{StripeConstants.SignatureHeaderName}' header value is invalid. Does not contain a " +
$"signature ('{StripeConstants.TimestampKey}') value.");
}
if (!hasSignature || !hasTimestamp)
{
var message = string.Format(
CultureInfo.CurrentCulture,
Resources.SignatureFilter_HeaderMissingValue,
StripeConstants.SignatureHeaderName,
StripeConstants.TimestampKey,
StripeConstants.SignatureKey);
return(new BadRequestObjectResult(message));
}
// Success
return(null);
}
public static bool Contains(this StringSegment segment, string str) => Contains(segment, str, StringComparison.Ordinal);
public override ManifestEntry Traverse(StringSegment segment) => UnknownPath;
/// <summary>
/// Initializes a new instance of the <see cref="GrammerUnknownException"/> class.
/// </summary>
/// <param name="unexpectedGrammerStringSegment">The location of the unknown grammer.</param>
public GrammerUnknownException(StringSegment unexpectedGrammerStringSegment)
: base(unexpectedGrammerStringSegment, $"Unexpected token '{unexpectedGrammerStringSegment.Value}' found")
{
UnexpectedGrammerStringSegment = unexpectedGrammerStringSegment;
}
public static bool Contains(this StringSegment segment, char ch) => segment.IndexOf(ch) != -1;
public override void VisitUpdate(StringSegment update)
{
throw new NotSupportedException();
}
private static bool TryGetNextSegment(ref StringTokenizer.Enumerator enumerator, out StringSegment segment)
{
while (enumerator.MoveNext())
{
if (enumerator.Current.HasValue && enumerator.Current.Length > 0)
{
segment = enumerator.Current;
return(true);
}
}
segment = default(StringSegment);
return(false);
}
/// <summary>
/// Parses <paramref name="input"/> as a <see cref="RangeConditionHeaderValue"/> value.
/// </summary>
/// <param name="input">The values to parse.</param>
/// <returns>The parsed values.</returns>
public static RangeConditionHeaderValue Parse(StringSegment input)
{
var index = 0;
return(Parser.ParseValue(input, ref index) !);
}
protected override void ExecuteCore(RazorCodeDocument codeDocument, DocumentIntermediateNode documentNode)
{
if (codeDocument == null)
{
throw new ArgumentNullException(nameof(codeDocument));
}
if (documentNode == null)
{
throw new ArgumentNullException(nameof(documentNode));
}
var @namespace = documentNode.FindPrimaryNamespace();
var @class = documentNode.FindPrimaryClass();
if (@namespace == null || @class == null)
{
return;
}
var directives = documentNode.FindDirectiveReferences(ComponentPageDirective.Directive);
if (directives.Count == 0)
{
return;
}
// We don't allow @page directives in imports
for (var i = 0; i < directives.Count; i++)
{
var directive = directives[i];
if (FileKinds.IsComponentImport(codeDocument.GetFileKind()) || directive.Node.IsImported())
{
directive.Node.Diagnostics.Add(ComponentDiagnosticFactory.CreatePageDirective_CannotBeImported(directive.Node.Source.Value));
}
}
// Insert the attributes 'on-top' of the class declaration, since classes don't directly support attributes.
var index = 0;
for (; index < @namespace.Children.Count; index++)
{
if (object.ReferenceEquals(@class, @namespace.Children[index]))
{
break;
}
}
for (var i = 0; i < directives.Count; i++)
{
var pageDirective = (DirectiveIntermediateNode)directives[i].Node;
// The parser also adds errors for invalid syntax, we just need to not crash.
var routeToken = pageDirective.Tokens.FirstOrDefault();
if (routeToken != null &&
routeToken.Content.Length >= 3 &&
routeToken.Content[0] == '\"' &&
routeToken.Content[1] == '/' &&
routeToken.Content[routeToken.Content.Length - 1] == '\"')
{
var template = new StringSegment(routeToken.Content, 1, routeToken.Content.Length - 2);
@namespace.Children.Insert(index++, new RouteAttributeExtensionNode(template));
}
else
{
pageDirective.Diagnostics.Add(ComponentDiagnosticFactory.CreatePageDirective_MustSpecifyRoute(pageDirective.Source));
}
}
}
private static bool ComponentNamespaceMatchesFullyQualifiedName(RazorCodeDocument razorCodeDocument, StringSegment namespaceName)
{
var namespaceNode = (NamespaceDeclarationIntermediateNode)razorCodeDocument
.GetDocumentIntermediateNode()
.FindDescendantNodes <IntermediateNode>()
.First(n => n is NamespaceDeclarationIntermediateNode);
return(new StringSegment(namespaceNode.Content).Equals(namespaceName, StringComparison.Ordinal));
}
public StringWithQualityHeaderValue(StringSegment value)
{
HeaderUtilities.CheckValidToken(value, nameof(value));
_value = value;
}
public static bool TryParse(StringSegment input, out RangeHeaderValue parsedValue)
{
var index = 0;
return(Parser.TryParseValue(input, ref index, out parsedValue));
}
public static string Highlight(this StringSegment segment, string startHighlight = "[", string endHighlight = "]")
{
return(segment.SourceString
.Insert(segment.End, endHighlight)
.Insert(segment.Start, startHighlight));
}