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;
}
