public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value) { if (value is string s1) { var span = s1.AsSpan(); var s = span.Trim(); if (MemoryExtensions.Equals(s, SvgUnitCollection.None.AsSpan(), StringComparison.OrdinalIgnoreCase)) { return(new SvgUnitCollection { StringForEmptyValue = SvgUnitCollection.None }); } else if (MemoryExtensions.Equals(s, SvgUnitCollection.Inherit.AsSpan(), StringComparison.OrdinalIgnoreCase)) { return(new SvgUnitCollection { StringForEmptyValue = SvgUnitCollection.Inherit }); } return(SvgUnitCollectionConverter.Parse(span)); } return(base.ConvertFrom(context, culture, value)); }
public bool RepeatedSubstringPattern(string s) { if (s.Length <= 1) { return(false); } for (int len = 1; len <= s.Length / 2; len++) { if (s.Length % len == 0) { ReadOnlySpan <char> sample = s.AsSpan(0, len); for (int i = len; i < s.Length; i += len) { ReadOnlySpan <char> test = s.AsSpan(i, len); if (!MemoryExtensions.Equals(sample, test, StringComparison.Ordinal)) { goto next_length; } } return(true); next_length: ; } } return(false); }
public static bool AttributeNamesEqual(string attributeName1, string attributeName2) { ReadOnlySpan <char> name1 = attributeName1.EndsWith("Attribute") ? attributeName1.AsSpan(0, attributeName1.Length - 9) : attributeName1.AsSpan(); ReadOnlySpan <char> name2 = attributeName2.EndsWith("Attribute") ? attributeName2.AsSpan(0, attributeName2.Length - 9) : attributeName2.AsSpan(); return(MemoryExtensions.Equals(name1, name2, StringComparison.Ordinal)); }
public bool Find(ReadOnlySpan <char> key, out T val) { for (int i = 0; i < SlotsUsed; i++) { ref var e = ref Slots[i]; if (MemoryExtensions.Equals(e.Key, key, StringComparison.Ordinal)) { val = e.Value; return(true); } }
private static bool MatchHeader(HeaderMatchMode matchMode, string requestHeaderValue, string metadataHeaderValue, bool isCaseSensitive) { var comparison = isCaseSensitive ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase; return(matchMode switch { HeaderMatchMode.ExactHeader => MemoryExtensions.Equals(requestHeaderValue, metadataHeaderValue, comparison), HeaderMatchMode.HeaderPrefix => requestHeaderValue != null && metadataHeaderValue != null && MemoryExtensions.StartsWith(requestHeaderValue, metadataHeaderValue, comparison), _ => throw new NotImplementedException(matchMode.ToString()), });
public static StringsFolderLookupOverlay?TypicalFactory(string referenceModPath, StringsReadParameters?instructions, ModKey modKey) { var ret = new StringsFolderLookupOverlay(); var stringsFolderPath = instructions?.StringsFolderOverride; var dir = Path.GetDirectoryName(referenceModPath); if (stringsFolderPath == null) { stringsFolderPath = Path.Combine(dir, "Strings"); } if (stringsFolderPath.Value.Exists) { foreach (var file in stringsFolderPath.Value.Info.EnumerateFiles($"{modKey.Name}*{StringsUtility.StringsFileExtension}")) { if (!StringsUtility.TryRetrieveInfoFromString(file.Name, out var type, out var lang, out _)) { continue; } var dict = ret.Get(type); dict[lang] = new Lazy <IStringsLookup>(() => new StringsLookupOverlay(file.FullName, type), LazyThreadSafetyMode.ExecutionAndPublication); } } foreach (var bsaFile in Directory.EnumerateFiles(dir, "*.bsa")) { var bsaReader = BSAReader.Load(new AbsolutePath(bsaFile, skipValidation: true)); foreach (var item in bsaReader.Files) { if (!StringsUtility.TryRetrieveInfoFromString(Path.GetFileName(item.Path.ToString()), out var type, out var lang, out var modName)) { continue; } if (!MemoryExtensions.Equals(modKey.Name, modName, StringComparison.OrdinalIgnoreCase)) { continue; } var dict = ret.Get(type); if (dict.ContainsKey(lang)) { continue; } dict[lang] = new Lazy <IStringsLookup>(() => { byte[] bytes = new byte[item.Size]; using var stream = new MemoryStream(bytes); item.CopyDataTo(stream).AsTask().Wait(); return(new StringsLookupOverlay(bytes, type)); }, LazyThreadSafetyMode.ExecutionAndPublication); } } return(ret); }
/// <summary> /// Checks if two spans are equal in a case-insensitive manner. Utilizes <see cref="StringComparison.OrdinalIgnoreCase" />. /// </summary> /// <param name="text">The text.</param> /// <param name="otherText">The other text.</param> /// <returns><c>true</c> if strings are both null or both equal regardless of casing, <c>false</c> otherwise.</returns> public static bool EqualsCaseInvariant(this ReadOnlySpan <char> text, ReadOnlySpan <char> otherText) { if (text.IsEmpty && otherText.IsEmpty) { return(true); } if (text == otherText) { return(true); } return(MemoryExtensions.Equals(text, otherText, StringComparison.OrdinalIgnoreCase)); }
private IHeaderParser GetParser(Memory <char> name) { int count = HeaderFieldParsers.Count; for (int i = 0; i < count; i++) { var p = HeaderFieldParsers.ElementAt(i); if (MemoryExtensions.Equals(name.Span, p.Key.AsSpan(), StringComparison.OrdinalIgnoreCase)) { return(p.Value); } } return(DefaultHeaderFieldParser); }
bool IEqualityComparer.Equals(object?x, object?y) { ReadOnlySpan <char> left = x switch { string str => str, char[] chars => chars, _ => x?.ToString() }; ReadOnlySpan <char> right = y switch { string str => str, char[] chars => chars, _ => x?.ToString() }; return(MemoryExtensions.Equals(left, right, _comparison)); } int IEqualityComparer.GetHashCode(object obj) { ReadOnlySpan <char> span = obj switch { string str => str, char[] chars => chars, _ => obj?.ToString() }; return(string.GetHashCode(span, _comparison)); } int IComparer.Compare(object?x, object?y) { ReadOnlySpan <char> left = x switch { string str => str, char[] chars => chars, _ => x?.ToString() }; ReadOnlySpan <char> right = y switch { string str => str, char[] chars => chars, _ => x?.ToString() }; return(MemoryExtensions.CompareTo(left, right, _comparison)); } } }
private static bool MatchQueryParameter(QueryParameterMatchMode matchMode, string requestQueryParameterValue, string metadataQueryParameterValue, bool isCaseSensitive) { var comparison = isCaseSensitive ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase; return(matchMode switch { QueryParameterMatchMode.Exact => MemoryExtensions.Equals(requestQueryParameterValue, metadataQueryParameterValue, comparison), QueryParameterMatchMode.Prefix => requestQueryParameterValue != null && metadataQueryParameterValue != null && MemoryExtensions.StartsWith(requestQueryParameterValue, metadataQueryParameterValue, comparison), QueryParameterMatchMode.Contains => requestQueryParameterValue != null && metadataQueryParameterValue != null && MemoryExtensions.Contains(requestQueryParameterValue, metadataQueryParameterValue, comparison), QueryParameterMatchMode.NotContains => requestQueryParameterValue != null && metadataQueryParameterValue != null && !MemoryExtensions.Contains(requestQueryParameterValue, metadataQueryParameterValue, comparison), _ => throw new NotImplementedException(matchMode.ToString()), });
Tag ParseTag() { Expect(TokenType.LeftBracket); var tagName = Lex().Segment; if (MemoryExtensions.Equals(tagName.Span, _breakline.Span, StringComparison.OrdinalIgnoreCase)) { Expect(TokenType.RightBracket); return(KnownTags.Breakline); } Parameter parameter = null; if (_lookahead.Type == TokenType.ParameterValue) { parameter = new SimpleParameter(Lex().Segment); } Expect(TokenType.RightBracket); var child = ParseChild(); Expect(TokenType.LeftBracketWithSlash); var closingTagName = Lex().Segment; if (!MemoryExtensions.Equals(tagName.Span, closingTagName.Span, StringComparison.OrdinalIgnoreCase)) { throw new BBCodeParseException(); } Expect(TokenType.RightBracket); #if !NET462 return(new Tag(new string(tagName.Span), parameter, child)); #else return(new Tag(tagName.ToString(), parameter, child)); #endif }
public override void Solve(IOManager io) { var tests = io.ReadInt(); var one = "one".AsSpan(); var two = "two".AsSpan(); var twone = "twone".AsSpan(); for (int t = 0; t < tests; t++) { var s = io.ReadString().ToCharArray(); var toRemove = new Queue <int>(); for (int i = 0; i + 4 < s.Length; i++) { var span = s.AsSpan(i, 5); if (MemoryExtensions.Equals(span, twone, StringComparison.Ordinal)) { toRemove.Enqueue(i + 3); s[i + 2] = 'x'; } } for (int i = 0; i + 2 < s.Length; i++) { var span = s.AsSpan(i, 3); if (MemoryExtensions.Equals(span, one, StringComparison.Ordinal) || MemoryExtensions.Equals(span, two, StringComparison.Ordinal)) { toRemove.Enqueue(i + 2); } } io.WriteLine(toRemove.Count); io.WriteLine(toRemove, ' '); } }
public int StrStr(ReadOnlySpan <char> str, ReadOnlySpan <char> fragment) { if (str.Length < fragment.Length) { return(-1); } else if (fragment.Length == 0) { return(0); } int n_hash = Hash(fragment, 0, fragment.Length); int h_hash = 0; for (int i = 0; i <= str.Length - fragment.Length; i++) { if (i <= 0) { h_hash = Hash(str, 0, fragment.Length); } else { h_hash = Hash(h_hash, str[i - 1], str[i + fragment.Length - 1]); } if (n_hash == h_hash) { ReadOnlySpan <char> sample = str.Slice(i, fragment.Length); if (MemoryExtensions.Equals(sample, fragment, StringComparison.Ordinal)) { return(i); } } } return(-1); }
public Task ApplyAsync(HttpContext httpContext, CandidateSet candidates) { if (httpContext == null) { throw new ArgumentNullException(nameof(httpContext)); } if (candidates == null) { throw new ArgumentNullException(nameof(candidates)); } for (var i = 0; i < candidates.Count; i++) { if (!candidates.IsValidCandidate(i)) { continue; } var hosts = candidates[i].Endpoint.Metadata.GetMetadata <IngressHostMetadata>()?.Hosts; if (hosts == null || hosts.Count == 0) { // Can match any host. continue; } var matched = false; var(requestHost, requestPort) = GetHostAndPort(httpContext); for (var j = 0; j < hosts.Count; j++) { var host = hosts[j].AsSpan(); var port = ReadOnlySpan <char> .Empty; // Split into host and port var pivot = host.IndexOf(':'); if (pivot >= 0) { port = host.Slice(pivot + 1); host = host.Slice(0, pivot); } if (host == null || host.Equals(WildcardHost, StringComparison.OrdinalIgnoreCase)) { // Can match any host } else if ( host.StartsWith(WildcardPrefix) && // Note that we only slice of the `*`. We want to match the leading `.` also. MemoryExtensions.EndsWith(requestHost, host.Slice(WildcardHost.Length), StringComparison.OrdinalIgnoreCase)) { // Matches a suffix wildcard. } else if (MemoryExtensions.Equals(requestHost, host, StringComparison.OrdinalIgnoreCase)) { // Matches exactly } else { // If we get here then the host doesn't match. continue; } if (port.Equals(WildcardHost, StringComparison.OrdinalIgnoreCase)) { // Port is a wildcard, we allow any port. } else if (port.Length > 0 && (!int.TryParse(port, out var parsed) || parsed != requestPort)) { // If we get here then the port doesn't match. continue; } matched = true; break; } if (!matched) { candidates.SetValidity(i, false); } } return(Task.CompletedTask); }
public bool Equals(char[]?x, char[]?y) { return(MemoryExtensions.Equals(x, y, _comparison)); }
public bool Equals(string?x, string?y) { return(MemoryExtensions.Equals(x, y, _comparison)); }
public bool Equals(ReadOnlySpan <char> x, ReadOnlySpan <char> y) { return(MemoryExtensions.Equals(x, y, _comparison)); }
public static bool Equals(this ReadOnlySpan <char> span, string str, StringComparison comparisonType = StringComparison.Ordinal) => MemoryExtensions.Equals(span, str.AsSpan(), comparisonType);
public async Task ValidateAzureKeyCredentialGatewayModeUpdateAsync() { const int defaultStatusCode = 401; const int defaultSubStatusCode = 50000; const int authMisMatchStatusCode = 70000; string originalKey = CosmosClientTests.NewRamdonMasterKey(); string newKey = CosmosClientTests.NewRamdonResourceToken(); string currentKey = originalKey; Mock <IHttpHandler> mockHttpHandler = new Mock <IHttpHandler>(); mockHttpHandler.Setup(x => x.SendAsync( It.IsAny <HttpRequestMessage>(), It.IsAny <CancellationToken>())) .Returns((HttpRequestMessage request, CancellationToken cancellationToken) => { HttpResponseMessage responseMessage = new HttpResponseMessage((HttpStatusCode)defaultStatusCode); if (request.RequestUri != VmMetadataApiHandler.vmMetadataEndpointUrl) { bool authHeaderPresent = request.Headers.TryGetValues(Documents.HttpConstants.HttpHeaders.Authorization, out IEnumerable <string> authValues); Assert.IsTrue(authHeaderPresent); Assert.AreNotEqual(0, authValues.Count()); AuthorizationHelper.GetResourceTypeAndIdOrFullName(request.RequestUri, out _, out string resourceType, out string resourceIdValue); AuthorizationHelper.ParseAuthorizationToken(authValues.First(), out ReadOnlyMemory <char> authType, out ReadOnlyMemory <char> _, out ReadOnlyMemory <char> tokenFromAuthHeader); bool authValidated = false; if (MemoryExtensions.Equals(authType.Span, Documents.Constants.Properties.ResourceToken.AsSpan(), StringComparison.OrdinalIgnoreCase)) { authValidated = HttpUtility.UrlDecode(authValues.First()) == currentKey; } else { authValidated = AuthorizationHelper.CheckPayloadUsingKey( tokenFromAuthHeader, request.Method.Method, resourceIdValue, resourceType, request.Headers.Aggregate(new NameValueCollectionWrapper(), (c, kvp) => { c.Add(kvp.Key, kvp.Value); return(c); }), currentKey); } int subStatusCode = authValidated ? defaultSubStatusCode : authMisMatchStatusCode; responseMessage.Headers.Add(Documents.WFConstants.BackendHeaders.SubStatus, subStatusCode.ToString()); } return(Task.FromResult(responseMessage)); }); AzureKeyCredential masterKeyCredential = new AzureKeyCredential(originalKey); using (CosmosClient client = new CosmosClient( CosmosClientTests.AccountEndpoint, masterKeyCredential, new CosmosClientOptions() { HttpClientFactory = () => new HttpClient(new HttpHandlerHelper(mockHttpHandler.Object)), EnableClientTelemetry = false, })) { Container container = client.GetContainer(Guid.NewGuid().ToString(), Guid.NewGuid().ToString()); Func <int, int, Task> authValidation = async(int statusCode, int subStatusCode) => { try { await container.ReadItemAsync <ToDoActivity>(Guid.NewGuid().ToString(), new Cosmos.PartitionKey(Guid.NewGuid().ToString())); Assert.Fail("Expected client to throw a authentication exception"); } catch (CosmosException ex) { Assert.AreEqual(statusCode, (int)ex.StatusCode, ex.ToString()); Assert.AreEqual(subStatusCode, ex.SubStatusCode, ex.ToString()); } }; // Key(V1) await authValidation(defaultStatusCode, defaultSubStatusCode); // Update key(V2) and let the auth validation fail masterKeyCredential.Update(newKey); await authValidation(defaultStatusCode, authMisMatchStatusCode); // Updated Key(V2) and now lets succeed auth validation Interlocked.Exchange(ref currentKey, newKey); await authValidation(defaultStatusCode, defaultSubStatusCode); } }
public HttpMessageStartLine Parse(Memory <char> content) { var span = content.Span; var lineLength = span.IndexOf("\r\n".AsSpan()); var line = content.Slice(0, lineLength); span = line.Span; lineLength = span.Length; HttpMessageStartLine startLine = null; HttpMessageType messageType; if (MemoryExtensions.Equals(span.Slice(0, 4), "HTTP".AsSpan(), StringComparison.OrdinalIgnoreCase)) { messageType = HttpMessageType.Response; } else { messageType = HttpMessageType.Request; } if (messageType == HttpMessageType.Response) { int pointer = 0; Memory <char> msgProtocolVersion = default; Memory <char> msgCode = default; Memory <char> msgContent = default; for (int i = pointer; i < lineLength; i++) { if (span[i] == ' ') { msgProtocolVersion = content.Slice(pointer, i); pointer = i; break; } } for (int i = pointer; i < lineLength; i++) { if (span[i] != ' ') { pointer = i; break; } } for (int i = pointer; i < lineLength; i++) { if (span[i] == ' ') { msgCode = content.Slice(pointer, i - (pointer)); pointer = i; break; } } for (int i = pointer; i < lineLength; i++) { if (span[i] != ' ') { msgContent = content.Slice(i, lineLength - i); break; } } startLine = new HttpResponseStartLine(messageType, content.Slice(0, lineLength), msgProtocolVersion, msgCode, msgContent); } else { int pointer = 0; Memory <char> msgProtocolVersion = default; Memory <char> msgMethod = default; Memory <char> msgAddressee = default; for (int i = pointer; i < lineLength; i++) { if (span[i] == ' ') { msgMethod = content.Slice(0, i); pointer = i; break; } } for (int i = pointer; i < lineLength; i++) { if (span[i] != ' ') { pointer = i; break; } } for (int i = pointer; i < lineLength; i++) { if (span[i] == ' ') { msgAddressee = content.Slice(pointer, i - (pointer)); pointer = i; break; } } for (int i = pointer; i < lineLength; i++) { if (span[i] != ' ') { pointer = i; break; } } int end = lineLength; for (int i = pointer; i < lineLength; i++) { if (span[i] == ' ') { end = i - 1; } } msgProtocolVersion = content.Slice(pointer, end - pointer); startLine = new HttpRequestStartLine(messageType, content.Slice(0, lineLength), msgProtocolVersion, msgMethod, msgAddressee); } content = content.Slice(lineLength); return(startLine); }
// used in Compute public static void ParseAuthorizationToken( string authorizationTokenString, out ReadOnlyMemory <char> typeOutput, out ReadOnlyMemory <char> versionOutput, out ReadOnlyMemory <char> tokenOutput) { typeOutput = default; versionOutput = default; tokenOutput = default; if (string.IsNullOrEmpty(authorizationTokenString)) { DefaultTrace.TraceError("Auth token missing"); throw new UnauthorizedException(RMResources.MissingAuthHeader); } int authorizationTokenLength = authorizationTokenString.Length; authorizationTokenString = HttpUtility.UrlDecode(authorizationTokenString); // Format of the token being deciphered is // type=<master/resource/system>&ver=<version>&sig=<base64encodedstring> // Step 1. split the tokens into type/ver/token. // when parsing for the last token, I use , as a separator to skip any redundant authorization headers ReadOnlyMemory <char> authorizationToken = authorizationTokenString.AsMemory(); int typeSeparatorPosition = authorizationToken.Span.IndexOf('&'); if (typeSeparatorPosition == -1) { throw new UnauthorizedException(RMResources.InvalidAuthHeaderFormat); } ReadOnlyMemory <char> authType = authorizationToken.Slice(0, typeSeparatorPosition); authorizationToken = authorizationToken.Slice(typeSeparatorPosition + 1, authorizationToken.Length - typeSeparatorPosition - 1); int versionSepartorPosition = authorizationToken.Span.IndexOf('&'); if (versionSepartorPosition == -1) { throw new UnauthorizedException(RMResources.InvalidAuthHeaderFormat); } ReadOnlyMemory <char> version = authorizationToken.Slice(0, versionSepartorPosition); authorizationToken = authorizationToken.Slice(versionSepartorPosition + 1, authorizationToken.Length - versionSepartorPosition - 1); ReadOnlyMemory <char> token = authorizationToken; int tokenSeparatorPosition = authorizationToken.Span.IndexOf(','); if (tokenSeparatorPosition != -1) { token = authorizationToken.Slice(0, tokenSeparatorPosition); } // Step 2. For each token, split to get the right half of '=' // Additionally check for the left half to be the expected scheme type int typeKeyValueSepartorPosition = authType.Span.IndexOf('='); if (typeKeyValueSepartorPosition == -1 || !authType.Span.Slice(0, typeKeyValueSepartorPosition).SequenceEqual(Constants.Properties.AuthSchemaType.AsSpan()) || !authType.Span.Slice(0, typeKeyValueSepartorPosition).ToString().Equals(Constants.Properties.AuthSchemaType, StringComparison.OrdinalIgnoreCase)) { throw new UnauthorizedException(RMResources.InvalidAuthHeaderFormat); } ReadOnlyMemory <char> authTypeValue = authType.Slice(typeKeyValueSepartorPosition + 1); if (MemoryExtensions.Equals(authTypeValue.Span, Constants.Properties.AadToken.AsSpan(), StringComparison.OrdinalIgnoreCase)) { if (authorizationTokenLength > AuthorizationHelper.MaxAadAuthorizationHeaderSize) { DefaultTrace.TraceError($"Token of type [{authTypeValue.Span.ToString()}] was of size [{authorizationTokenLength}] while the max allowed size is [{AuthorizationHelper.MaxAadAuthorizationHeaderSize}]."); throw new UnauthorizedException(RMResources.InvalidAuthHeaderFormat, SubStatusCodes.InvalidAuthHeaderFormat); } } else if (MemoryExtensions.Equals(authTypeValue.Span, Constants.Properties.ResourceToken.AsSpan(), StringComparison.OrdinalIgnoreCase)) { if (authorizationTokenLength > AuthorizationHelper.MaxResourceTokenAuthorizationHeaderSize) { DefaultTrace.TraceError($"Token of type [{authTypeValue.Span.ToString()}] was of size [{authorizationTokenLength}] while the max allowed size is [{AuthorizationHelper.MaxResourceTokenAuthorizationHeaderSize}]."); throw new UnauthorizedException(RMResources.InvalidAuthHeaderFormat, SubStatusCodes.InvalidAuthHeaderFormat); } } else if (authorizationTokenLength > AuthorizationHelper.MaxAuthorizationHeaderSize) { DefaultTrace.TraceError($"Token of type [{authTypeValue.Span.ToString()}] was of size [{authorizationTokenLength}] while the max allowed size is [{AuthorizationHelper.MaxAuthorizationHeaderSize}]."); throw new UnauthorizedException(RMResources.InvalidAuthHeaderFormat, SubStatusCodes.InvalidAuthHeaderFormat); } int versionKeyValueSeparatorPosition = version.Span.IndexOf('='); if (versionKeyValueSeparatorPosition == -1 || !version.Span.Slice(0, versionKeyValueSeparatorPosition).SequenceEqual(Constants.Properties.AuthVersion.AsSpan()) || !version.Slice(0, versionKeyValueSeparatorPosition).ToString().Equals(Constants.Properties.AuthVersion, StringComparison.OrdinalIgnoreCase)) { throw new UnauthorizedException(RMResources.InvalidAuthHeaderFormat); } ReadOnlyMemory <char> versionValue = version.Slice(versionKeyValueSeparatorPosition + 1); int tokenKeyValueSeparatorPosition = token.Span.IndexOf('='); if (tokenKeyValueSeparatorPosition == -1 || !token.Slice(0, tokenKeyValueSeparatorPosition).Span.SequenceEqual(Constants.Properties.AuthSignature.AsSpan()) || !token.Slice(0, tokenKeyValueSeparatorPosition).ToString().Equals(Constants.Properties.AuthSignature, StringComparison.OrdinalIgnoreCase)) { throw new UnauthorizedException(RMResources.InvalidAuthHeaderFormat); } ReadOnlyMemory <char> tokenValue = token.Slice(tokenKeyValueSeparatorPosition + 1); if (authTypeValue.IsEmpty || versionValue.IsEmpty || tokenValue.IsEmpty) { throw new UnauthorizedException(RMResources.InvalidAuthHeaderFormat); } typeOutput = authTypeValue; versionOutput = versionValue; tokenOutput = tokenValue; }