mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
Adding reference source for System.Data System.Data.DataSetExtensions System.Data.Entity System.Data.Entity.Design System.Data.Linq System.Data.SqlXml System.ServiceModel System.ServiceModel.Activation System.ServiceModel.Activities System.ServiceModel.Channels System.ServiceModel.Discovery System.ServiceModel.Internals System.ServiceModel.Routing System.ServiceModel.WasHosting System.ServiceModel.Web System.Web System.Web.ApplicationServices System.Web.DynamicData System.Web.Entity System.Web.Entity.Design System.Web.Extensions System.Web.Mobile System.Web.Routing System.Web.Services System.Xml System.Xml.Linq
340 lines
15 KiB
C#
340 lines
15 KiB
C#
namespace System.Web.Routing {
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.Globalization;
|
|
using System.Linq;
|
|
|
|
internal static class RouteParser {
|
|
private static string GetLiteral(string segmentLiteral) {
|
|
// Scan for errant single { and } and convert double {{ to { and double }} to }
|
|
|
|
// First we eliminate all escaped braces and then check if any other braces are remaining
|
|
string newLiteral = segmentLiteral.Replace("{{", "").Replace("}}", "");
|
|
if (newLiteral.Contains("{") || newLiteral.Contains("}")) {
|
|
return null;
|
|
}
|
|
|
|
// If it's a valid format, we unescape the braces
|
|
return segmentLiteral.Replace("{{", "{").Replace("}}", "}");
|
|
}
|
|
|
|
private static int IndexOfFirstOpenParameter(string segment, int startIndex) {
|
|
// Find the first unescaped open brace
|
|
while (true) {
|
|
startIndex = segment.IndexOf('{', startIndex);
|
|
if (startIndex == -1) {
|
|
// If there are no more open braces, stop
|
|
return -1;
|
|
}
|
|
if ((startIndex + 1 == segment.Length) ||
|
|
((startIndex + 1 < segment.Length) && (segment[startIndex + 1] != '{'))) {
|
|
// If we found an open brace that is followed by a non-open brace, it's
|
|
// a parameter delimiter.
|
|
// It's also a delimiter if the open brace is the last character - though
|
|
// it ends up being being called out as invalid later on.
|
|
return startIndex;
|
|
}
|
|
// Increment by two since we want to skip both the open brace that
|
|
// we're on as well as the subsequent character since we know for
|
|
// sure that it is part of an escape sequence.
|
|
startIndex += 2;
|
|
}
|
|
}
|
|
|
|
internal static bool IsSeparator(string s) {
|
|
return String.Equals(s, "/", StringComparison.Ordinal);
|
|
}
|
|
|
|
private static bool IsValidParameterName(string parameterName) {
|
|
if (parameterName.Length == 0) {
|
|
return false;
|
|
}
|
|
|
|
for (int i = 0; i < parameterName.Length; i++) {
|
|
char c = parameterName[i];
|
|
if (c == '/' || c == '{' || c == '}') {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
internal static bool IsInvalidRouteUrl(string routeUrl) {
|
|
return (routeUrl.StartsWith("~", StringComparison.Ordinal) ||
|
|
routeUrl.StartsWith("/", StringComparison.Ordinal) ||
|
|
(routeUrl.IndexOf('?') != -1));
|
|
}
|
|
|
|
public static ParsedRoute Parse(string routeUrl) {
|
|
if (routeUrl == null) {
|
|
routeUrl = String.Empty;
|
|
}
|
|
|
|
if (IsInvalidRouteUrl(routeUrl)) {
|
|
throw new ArgumentException(SR.GetString(SR.Route_InvalidRouteUrl), "routeUrl");
|
|
}
|
|
|
|
IList<string> urlParts = SplitUrlToPathSegmentStrings(routeUrl);
|
|
Exception ex = ValidateUrlParts(urlParts);
|
|
if (ex != null) {
|
|
throw ex;
|
|
}
|
|
|
|
IList<PathSegment> pathSegments = SplitUrlToPathSegments(urlParts);
|
|
|
|
Debug.Assert(urlParts.Count == pathSegments.Count, "The number of string segments should be the same as the number of path segments");
|
|
|
|
return new ParsedRoute(pathSegments);
|
|
}
|
|
|
|
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA2208:InstantiateArgumentExceptionsCorrectly",
|
|
Justification = "The exceptions are just constructed here, but they are thrown from a method that does have those parameter names.")]
|
|
private static IList<PathSubsegment> ParseUrlSegment(string segment, out Exception exception) {
|
|
int startIndex = 0;
|
|
|
|
List<PathSubsegment> pathSubsegments = new List<PathSubsegment>();
|
|
|
|
while (startIndex < segment.Length) {
|
|
int nextParameterStart = IndexOfFirstOpenParameter(segment, startIndex);
|
|
if (nextParameterStart == -1) {
|
|
// If there are no more parameters in the segment, capture the remainder as a literal and stop
|
|
string lastLiteralPart = GetLiteral(segment.Substring(startIndex));
|
|
if (lastLiteralPart == null) {
|
|
exception = new ArgumentException(
|
|
String.Format(
|
|
CultureInfo.CurrentUICulture,
|
|
SR.GetString(SR.Route_MismatchedParameter),
|
|
segment
|
|
),
|
|
"routeUrl");
|
|
return null;
|
|
}
|
|
if (lastLiteralPart.Length > 0) {
|
|
pathSubsegments.Add(new LiteralSubsegment(lastLiteralPart));
|
|
}
|
|
break;
|
|
}
|
|
|
|
int nextParameterEnd = segment.IndexOf('}', nextParameterStart + 1);
|
|
if (nextParameterEnd == -1) {
|
|
exception = new ArgumentException(
|
|
String.Format(
|
|
CultureInfo.CurrentUICulture,
|
|
SR.GetString(SR.Route_MismatchedParameter),
|
|
segment
|
|
),
|
|
"routeUrl");
|
|
return null;
|
|
}
|
|
|
|
string literalPart = GetLiteral(segment.Substring(startIndex, nextParameterStart - startIndex));
|
|
if (literalPart == null) {
|
|
exception = new ArgumentException(
|
|
String.Format(
|
|
CultureInfo.CurrentUICulture,
|
|
SR.GetString(SR.Route_MismatchedParameter),
|
|
segment
|
|
),
|
|
"routeUrl");
|
|
return null;
|
|
}
|
|
if (literalPart.Length > 0) {
|
|
pathSubsegments.Add(new LiteralSubsegment(literalPart));
|
|
}
|
|
|
|
string parameterName = segment.Substring(nextParameterStart + 1, nextParameterEnd - nextParameterStart - 1);
|
|
pathSubsegments.Add(new ParameterSubsegment(parameterName));
|
|
|
|
startIndex = nextParameterEnd + 1;
|
|
}
|
|
|
|
exception = null;
|
|
return pathSubsegments;
|
|
}
|
|
|
|
private static IList<PathSegment> SplitUrlToPathSegments(IList<string> urlParts) {
|
|
List<PathSegment> pathSegments = new List<PathSegment>();
|
|
|
|
foreach (string pathSegment in urlParts) {
|
|
bool isCurrentPartSeparator = IsSeparator(pathSegment);
|
|
if (isCurrentPartSeparator) {
|
|
pathSegments.Add(new SeparatorPathSegment());
|
|
}
|
|
else {
|
|
Exception exception;
|
|
IList<PathSubsegment> subsegments = ParseUrlSegment(pathSegment, out exception);
|
|
Debug.Assert(exception == null, "This only gets called after the path has been validated, so there should never be an exception here");
|
|
pathSegments.Add(new ContentPathSegment(subsegments));
|
|
}
|
|
}
|
|
return pathSegments;
|
|
}
|
|
|
|
internal static IList<string> SplitUrlToPathSegmentStrings(string url) {
|
|
List<string> parts = new List<string>();
|
|
|
|
if (String.IsNullOrEmpty(url)) {
|
|
return parts;
|
|
}
|
|
|
|
int currentIndex = 0;
|
|
|
|
// Split the incoming URL into individual parts
|
|
while (currentIndex < url.Length) {
|
|
int indexOfNextSeparator = url.IndexOf('/', currentIndex);
|
|
if (indexOfNextSeparator == -1) {
|
|
// If there are no more separators, the rest of the string is the last part
|
|
string finalPart = url.Substring(currentIndex);
|
|
if (finalPart.Length > 0) {
|
|
parts.Add(finalPart);
|
|
}
|
|
break;
|
|
}
|
|
|
|
string nextPart = url.Substring(currentIndex, indexOfNextSeparator - currentIndex);
|
|
if (nextPart.Length > 0) {
|
|
parts.Add(nextPart);
|
|
}
|
|
Debug.Assert(url[indexOfNextSeparator] == '/', "The separator char itself should always be a '/'.");
|
|
parts.Add("/");
|
|
currentIndex = indexOfNextSeparator + 1;
|
|
}
|
|
|
|
return parts;
|
|
}
|
|
|
|
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA2208:InstantiateArgumentExceptionsCorrectly",
|
|
Justification = "The exceptions are just constructed here, but they are thrown from a method that does have those parameter names.")]
|
|
private static Exception ValidateUrlParts(IList<string> pathSegments) {
|
|
Debug.Assert(pathSegments != null, "The value should always come from SplitUrl(), and that function should never return null.");
|
|
|
|
HashSet<string> usedParameterNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
|
|
bool? isPreviousPartSeparator = null;
|
|
|
|
bool foundCatchAllParameter = false;
|
|
|
|
foreach (string pathSegment in pathSegments) {
|
|
if (foundCatchAllParameter) {
|
|
// If we ever start an iteration of the loop and we've already found a
|
|
// catchall parameter then we have an invalid URL format.
|
|
return new ArgumentException(
|
|
String.Format(
|
|
CultureInfo.CurrentCulture,
|
|
SR.GetString(SR.Route_CatchAllMustBeLast)
|
|
),
|
|
"routeUrl");
|
|
}
|
|
|
|
bool isCurrentPartSeparator;
|
|
if (isPreviousPartSeparator == null) {
|
|
// Prime the loop with the first value
|
|
isPreviousPartSeparator = IsSeparator(pathSegment);
|
|
isCurrentPartSeparator = isPreviousPartSeparator.Value;
|
|
}
|
|
else {
|
|
isCurrentPartSeparator = IsSeparator(pathSegment);
|
|
|
|
// If both the previous part and the current part are separators, it's invalid
|
|
if (isCurrentPartSeparator && isPreviousPartSeparator.Value) {
|
|
return new ArgumentException(SR.GetString(SR.Route_CannotHaveConsecutiveSeparators), "routeUrl");
|
|
}
|
|
Debug.Assert(isCurrentPartSeparator != isPreviousPartSeparator.Value, "This assert should only happen if both the current and previous parts are non-separators. This should never happen because consecutive non-separators are always parsed as a single part.");
|
|
isPreviousPartSeparator = isCurrentPartSeparator;
|
|
}
|
|
|
|
// If it's not a separator, parse the segment for parameters and validate it
|
|
if (!isCurrentPartSeparator) {
|
|
Exception exception;
|
|
IList<PathSubsegment> subsegments = ParseUrlSegment(pathSegment, out exception);
|
|
if (exception != null) {
|
|
return exception;
|
|
}
|
|
exception = ValidateUrlSegment(subsegments, usedParameterNames, pathSegment);
|
|
if (exception != null) {
|
|
return exception;
|
|
}
|
|
|
|
foundCatchAllParameter = subsegments.Any<PathSubsegment>(seg => (seg is ParameterSubsegment) && (((ParameterSubsegment)seg).IsCatchAll));
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA2208:InstantiateArgumentExceptionsCorrectly",
|
|
Justification = "The exceptions are just constructed here, but they are thrown from a method that does have those parameter names.")]
|
|
private static Exception ValidateUrlSegment(IList<PathSubsegment> pathSubsegments, HashSet<string> usedParameterNames, string pathSegment) {
|
|
bool segmentContainsCatchAll = false;
|
|
|
|
Type previousSegmentType = null;
|
|
|
|
foreach (PathSubsegment subsegment in pathSubsegments) {
|
|
if (previousSegmentType != null) {
|
|
if (previousSegmentType == subsegment.GetType()) {
|
|
return new ArgumentException(
|
|
String.Format(
|
|
CultureInfo.CurrentCulture,
|
|
SR.GetString(SR.Route_CannotHaveConsecutiveParameters)
|
|
),
|
|
"routeUrl");
|
|
}
|
|
}
|
|
previousSegmentType = subsegment.GetType();
|
|
|
|
LiteralSubsegment literalSubsegment = subsegment as LiteralSubsegment;
|
|
if (literalSubsegment != null) {
|
|
// Nothing to validate for literals - everything is valid
|
|
}
|
|
else {
|
|
ParameterSubsegment parameterSubsegment = subsegment as ParameterSubsegment;
|
|
if (parameterSubsegment != null) {
|
|
string parameterName = parameterSubsegment.ParameterName;
|
|
|
|
if (parameterSubsegment.IsCatchAll) {
|
|
segmentContainsCatchAll = true;
|
|
}
|
|
|
|
// Check for valid characters in the parameter name
|
|
if (!IsValidParameterName(parameterName)) {
|
|
return new ArgumentException(
|
|
String.Format(
|
|
CultureInfo.CurrentUICulture,
|
|
SR.GetString(SR.Route_InvalidParameterName),
|
|
parameterName
|
|
),
|
|
"routeUrl");
|
|
}
|
|
|
|
if (usedParameterNames.Contains(parameterName)) {
|
|
return new ArgumentException(
|
|
String.Format(
|
|
CultureInfo.CurrentUICulture,
|
|
SR.GetString(SR.Route_RepeatedParameter),
|
|
parameterName
|
|
),
|
|
"routeUrl");
|
|
}
|
|
else {
|
|
usedParameterNames.Add(parameterName);
|
|
}
|
|
}
|
|
else {
|
|
Debug.Fail("Invalid path subsegment type");
|
|
}
|
|
}
|
|
}
|
|
|
|
if (segmentContainsCatchAll && (pathSubsegments.Count != 1)) {
|
|
return new ArgumentException(
|
|
String.Format(
|
|
CultureInfo.CurrentCulture,
|
|
SR.GetString(SR.Route_CannotHaveCatchAllInMultiSegment)
|
|
),
|
|
"routeUrl");
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|
|
}
|