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
457 lines
17 KiB
C#
457 lines
17 KiB
C#
//------------------------------------------------------------
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//------------------------------------------------------------
|
|
#pragma warning disable 1634, 1691
|
|
|
|
namespace System.ServiceModel.Web
|
|
{
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Collections.ObjectModel;
|
|
using System.Globalization;
|
|
using System.Net;
|
|
using System.Net.Mime;
|
|
using System.Runtime;
|
|
using System.ServiceModel;
|
|
using System.ServiceModel.Channels;
|
|
using System.ServiceModel.Dispatcher;
|
|
|
|
public class IncomingWebRequestContext
|
|
{
|
|
static readonly string HttpGetMethod = "GET";
|
|
static readonly string HttpHeadMethod = "HEAD";
|
|
static readonly string HttpPutMethod = "PUT";
|
|
static readonly string HttpPostMethod = "POST";
|
|
static readonly string HttpDeleteMethod = "DELETE";
|
|
|
|
Collection<ContentType> cachedAcceptHeaderElements;
|
|
string acceptHeaderWhenHeaderElementsCached;
|
|
internal const string UriTemplateMatchResultsPropertyName = "UriTemplateMatchResults";
|
|
OperationContext operationContext;
|
|
|
|
internal IncomingWebRequestContext(OperationContext operationContext)
|
|
{
|
|
Fx.Assert(operationContext != null, "operationContext is null");
|
|
this.operationContext = operationContext;
|
|
}
|
|
|
|
public string Accept
|
|
{
|
|
get { return EnsureMessageProperty().Headers[HttpRequestHeader.Accept]; }
|
|
}
|
|
|
|
public long ContentLength
|
|
{
|
|
get { return long.Parse(this.EnsureMessageProperty().Headers[HttpRequestHeader.ContentLength], CultureInfo.InvariantCulture); }
|
|
}
|
|
|
|
public string ContentType
|
|
{
|
|
get { return this.EnsureMessageProperty().Headers[HttpRequestHeader.ContentType]; }
|
|
}
|
|
|
|
public IEnumerable<string> IfMatch
|
|
{
|
|
get
|
|
{
|
|
string ifMatchHeader = MessageProperty.Headers[HttpRequestHeader.IfMatch];
|
|
return (string.IsNullOrEmpty(ifMatchHeader)) ? null : Utility.QuoteAwareStringSplit(ifMatchHeader);
|
|
}
|
|
}
|
|
|
|
public IEnumerable<string> IfNoneMatch
|
|
{
|
|
get
|
|
{
|
|
string ifNoneMatchHeader = MessageProperty.Headers[HttpRequestHeader.IfNoneMatch];
|
|
return (string.IsNullOrEmpty(ifNoneMatchHeader)) ? null : Utility.QuoteAwareStringSplit(ifNoneMatchHeader);
|
|
}
|
|
}
|
|
|
|
public DateTime? IfModifiedSince
|
|
{
|
|
get
|
|
{
|
|
string dateTime = this.MessageProperty.Headers[HttpRequestHeader.IfModifiedSince];
|
|
if (!string.IsNullOrEmpty(dateTime))
|
|
{
|
|
DateTime parsedDateTime;
|
|
if (HttpDateParse.ParseHttpDate(dateTime, out parsedDateTime))
|
|
{
|
|
return parsedDateTime;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public DateTime? IfUnmodifiedSince
|
|
{
|
|
get
|
|
{
|
|
string dateTime = this.MessageProperty.Headers[HttpRequestHeader.IfUnmodifiedSince];
|
|
if (!string.IsNullOrEmpty(dateTime))
|
|
{
|
|
DateTime parsedDateTime;
|
|
if (HttpDateParse.ParseHttpDate(dateTime, out parsedDateTime))
|
|
{
|
|
return parsedDateTime;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public WebHeaderCollection Headers
|
|
{
|
|
get { return this.EnsureMessageProperty().Headers; }
|
|
}
|
|
|
|
public string Method
|
|
{
|
|
get { return this.EnsureMessageProperty().Method; }
|
|
}
|
|
|
|
public UriTemplateMatch UriTemplateMatch
|
|
{
|
|
get
|
|
{
|
|
if (this.operationContext.IncomingMessageProperties.ContainsKey(UriTemplateMatchResultsPropertyName))
|
|
{
|
|
return this.operationContext.IncomingMessageProperties[UriTemplateMatchResultsPropertyName] as UriTemplateMatch;
|
|
}
|
|
else
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
set
|
|
{
|
|
this.operationContext.IncomingMessageProperties[UriTemplateMatchResultsPropertyName] = value;
|
|
}
|
|
}
|
|
|
|
public string UserAgent
|
|
{
|
|
get { return this.EnsureMessageProperty().Headers[HttpRequestHeader.UserAgent]; }
|
|
}
|
|
|
|
HttpRequestMessageProperty MessageProperty
|
|
{
|
|
get
|
|
{
|
|
if (operationContext.IncomingMessageProperties == null)
|
|
{
|
|
return null;
|
|
}
|
|
if (!operationContext.IncomingMessageProperties.ContainsKey(HttpRequestMessageProperty.Name))
|
|
{
|
|
return null;
|
|
}
|
|
return operationContext.IncomingMessageProperties[HttpRequestMessageProperty.Name] as HttpRequestMessageProperty;
|
|
}
|
|
}
|
|
|
|
public void CheckConditionalRetrieve(string entityTag)
|
|
{
|
|
string validEtag = OutgoingWebResponseContext.GenerateValidEtagFromString(entityTag);
|
|
CheckConditionalRetrieveWithValidatedEtag(validEtag);
|
|
}
|
|
|
|
public void CheckConditionalRetrieve(int entityTag)
|
|
{
|
|
string validEtag = OutgoingWebResponseContext.GenerateValidEtag(entityTag);
|
|
CheckConditionalRetrieveWithValidatedEtag(validEtag);
|
|
}
|
|
|
|
public void CheckConditionalRetrieve(long entityTag)
|
|
{
|
|
string validEtag = OutgoingWebResponseContext.GenerateValidEtag(entityTag);
|
|
CheckConditionalRetrieveWithValidatedEtag(validEtag);
|
|
}
|
|
|
|
public void CheckConditionalRetrieve(Guid entityTag)
|
|
{
|
|
string validEtag = OutgoingWebResponseContext.GenerateValidEtag(entityTag);
|
|
CheckConditionalRetrieveWithValidatedEtag(validEtag);
|
|
}
|
|
|
|
public void CheckConditionalRetrieve(DateTime lastModified)
|
|
{
|
|
if (!string.Equals(this.Method, IncomingWebRequestContext.HttpGetMethod, StringComparison.OrdinalIgnoreCase) &&
|
|
!string.Equals(this.Method, IncomingWebRequestContext.HttpHeadMethod, StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(
|
|
SR2.GetString(SR2.ConditionalRetrieveGetAndHeadOnly, this.Method)));
|
|
}
|
|
|
|
DateTime? ifModifiedSince = this.IfModifiedSince;
|
|
if (ifModifiedSince.HasValue)
|
|
{
|
|
long ticksDifference = lastModified.ToUniversalTime().Ticks - ifModifiedSince.Value.ToUniversalTime().Ticks;
|
|
if (ticksDifference < TimeSpan.TicksPerSecond)
|
|
{
|
|
WebOperationContext.Current.OutgoingResponse.LastModified = lastModified;
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new WebFaultException(HttpStatusCode.NotModified));
|
|
}
|
|
}
|
|
}
|
|
|
|
public void CheckConditionalUpdate(string entityTag)
|
|
{
|
|
string validEtag = OutgoingWebResponseContext.GenerateValidEtagFromString(entityTag);
|
|
CheckConditionalUpdateWithValidatedEtag(validEtag);
|
|
}
|
|
|
|
public void CheckConditionalUpdate(int entityTag)
|
|
{
|
|
string validEtag = OutgoingWebResponseContext.GenerateValidEtag(entityTag);
|
|
CheckConditionalUpdateWithValidatedEtag(validEtag);
|
|
}
|
|
|
|
public void CheckConditionalUpdate(long entityTag)
|
|
{
|
|
string validEtag = OutgoingWebResponseContext.GenerateValidEtag(entityTag);
|
|
CheckConditionalUpdateWithValidatedEtag(validEtag);
|
|
}
|
|
|
|
public void CheckConditionalUpdate(Guid entityTag)
|
|
{
|
|
string validEtag = OutgoingWebResponseContext.GenerateValidEtag(entityTag);
|
|
CheckConditionalUpdateWithValidatedEtag(validEtag);
|
|
}
|
|
|
|
public Collection<ContentType> GetAcceptHeaderElements()
|
|
{
|
|
string acceptHeader = this.Accept;
|
|
if (cachedAcceptHeaderElements == null ||
|
|
(!string.Equals(acceptHeaderWhenHeaderElementsCached, acceptHeader, StringComparison.OrdinalIgnoreCase)))
|
|
{
|
|
if (string.IsNullOrEmpty(acceptHeader))
|
|
{
|
|
cachedAcceptHeaderElements = new Collection<ContentType>();
|
|
acceptHeaderWhenHeaderElementsCached = acceptHeader;
|
|
}
|
|
else
|
|
{
|
|
List<ContentType> contentTypeList = new List<ContentType>();
|
|
int offset = 0;
|
|
while (true)
|
|
{
|
|
string nextItem = Utility.QuoteAwareSubString(acceptHeader, ref offset);
|
|
if (nextItem == null)
|
|
{
|
|
break;
|
|
}
|
|
|
|
ContentType contentType = Utility.GetContentTypeOrNull(nextItem);
|
|
if (contentType != null)
|
|
{
|
|
contentTypeList.Add(contentType);
|
|
}
|
|
}
|
|
|
|
contentTypeList.Sort(new AcceptHeaderElementComparer());
|
|
cachedAcceptHeaderElements = new Collection<ContentType>(contentTypeList);
|
|
acceptHeaderWhenHeaderElementsCached = acceptHeader;
|
|
}
|
|
}
|
|
return cachedAcceptHeaderElements;
|
|
}
|
|
|
|
HttpRequestMessageProperty EnsureMessageProperty()
|
|
{
|
|
if (this.MessageProperty == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(
|
|
SR2.GetString(SR2.HttpContextNoIncomingMessageProperty, typeof(HttpRequestMessageProperty).Name)));
|
|
}
|
|
return this.MessageProperty;
|
|
}
|
|
|
|
|
|
void CheckConditionalRetrieveWithValidatedEtag(string entityTag)
|
|
{
|
|
if (!string.Equals(this.Method, IncomingWebRequestContext.HttpGetMethod, StringComparison.OrdinalIgnoreCase) &&
|
|
!string.Equals(this.Method, IncomingWebRequestContext.HttpHeadMethod, StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(
|
|
SR2.GetString(SR2.ConditionalRetrieveGetAndHeadOnly, this.Method)));
|
|
}
|
|
|
|
if (!string.IsNullOrEmpty(entityTag))
|
|
{
|
|
string entityTagHeader = this.Headers[HttpRequestHeader.IfNoneMatch];
|
|
if (!string.IsNullOrEmpty(entityTagHeader))
|
|
{
|
|
if (IsWildCardCharacter(entityTagHeader) ||
|
|
DoesHeaderContainEtag(entityTagHeader, entityTag))
|
|
{
|
|
// set response entityTag directly because it has already been validated
|
|
WebOperationContext.Current.OutgoingResponse.ETag = entityTag;
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new WebFaultException(HttpStatusCode.NotModified));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void CheckConditionalUpdateWithValidatedEtag(string entityTag)
|
|
{
|
|
bool isPutMethod = string.Equals(this.Method, IncomingWebRequestContext.HttpPutMethod, StringComparison.OrdinalIgnoreCase);
|
|
if (!isPutMethod &&
|
|
!string.Equals(this.Method, IncomingWebRequestContext.HttpPostMethod, StringComparison.OrdinalIgnoreCase) &&
|
|
!string.Equals(this.Method, IncomingWebRequestContext.HttpDeleteMethod, StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(
|
|
SR2.GetString(SR2.ConditionalUpdatePutPostAndDeleteOnly, this.Method)));
|
|
}
|
|
|
|
string headerOfInterest;
|
|
|
|
// if the current entityTag is null then the resource doesn't currently exist and the
|
|
// a PUT request should only succeed if If-None-Match equals '*'.
|
|
if (isPutMethod && string.IsNullOrEmpty(entityTag))
|
|
{
|
|
headerOfInterest = this.Headers[HttpRequestHeader.IfNoneMatch];
|
|
if (string.IsNullOrEmpty(headerOfInterest) ||
|
|
!IsWildCardCharacter(headerOfInterest))
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new WebFaultException(HttpStatusCode.PreconditionFailed));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// all remaining cases are with an If-Match header
|
|
headerOfInterest = this.Headers[HttpRequestHeader.IfMatch];
|
|
if (string.IsNullOrEmpty(headerOfInterest) ||
|
|
(!IsWildCardCharacter(headerOfInterest) &&
|
|
!DoesHeaderContainEtag(headerOfInterest, entityTag)))
|
|
{
|
|
// set response entityTag directly because it has already been validated
|
|
WebOperationContext.Current.OutgoingResponse.ETag = entityTag;
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new WebFaultException(HttpStatusCode.PreconditionFailed));
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
static bool DoesHeaderContainEtag(string header, string entityTag)
|
|
{
|
|
int offset = 0;
|
|
while (true)
|
|
{
|
|
string nextEntityTag = Utility.QuoteAwareSubString(header, ref offset);
|
|
if (nextEntityTag == null)
|
|
{
|
|
break;
|
|
}
|
|
if (string.Equals(nextEntityTag, entityTag, StringComparison.Ordinal))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
static bool IsWildCardCharacter(string header)
|
|
{
|
|
return (header.Trim() == "*");
|
|
}
|
|
}
|
|
|
|
class AcceptHeaderElementComparer : IComparer<ContentType>
|
|
{
|
|
static NumberStyles numberStyles = NumberStyles.AllowDecimalPoint;
|
|
|
|
public int Compare(ContentType x, ContentType y)
|
|
{
|
|
string[] xTypeSubType = x.MediaType.Split('/');
|
|
string[] yTypeSubType = y.MediaType.Split('/');
|
|
|
|
Fx.Assert(xTypeSubType.Length == 2, "The creation of the ContentType would have failed if there wasn't a type and subtype.");
|
|
Fx.Assert(yTypeSubType.Length == 2, "The creation of the ContentType would have failed if there wasn't a type and subtype.");
|
|
|
|
if (string.Equals(xTypeSubType[0], yTypeSubType[0], StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
if (string.Equals(xTypeSubType[1], yTypeSubType[1], StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
// need to check the number of parameters to determine which is more specific
|
|
bool xHasParam = HasParameters(x);
|
|
bool yHasParam = HasParameters(y);
|
|
if (xHasParam && !yHasParam)
|
|
{
|
|
return 1;
|
|
}
|
|
else if (!xHasParam && yHasParam)
|
|
{
|
|
return -1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (xTypeSubType[1][0] == '*' && xTypeSubType[1].Length == 1)
|
|
{
|
|
return 1;
|
|
}
|
|
if (yTypeSubType[1][0] == '*' && yTypeSubType[1].Length == 1)
|
|
{
|
|
return -1;
|
|
}
|
|
}
|
|
}
|
|
else if (xTypeSubType[0][0] == '*' && xTypeSubType[0].Length == 1)
|
|
{
|
|
return 1;
|
|
}
|
|
else if (yTypeSubType[0][0] == '*' && yTypeSubType[0].Length == 1)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
decimal qualityDifference = GetQualityFactor(x) - GetQualityFactor(y);
|
|
if (qualityDifference < 0)
|
|
{
|
|
return 1;
|
|
}
|
|
else if (qualityDifference > 0)
|
|
{
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
decimal GetQualityFactor(ContentType contentType)
|
|
{
|
|
decimal result;
|
|
foreach (string key in contentType.Parameters.Keys)
|
|
{
|
|
if (string.Equals("q", key, StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
if (decimal.TryParse(contentType.Parameters[key], numberStyles, CultureInfo.InvariantCulture, out result) &&
|
|
(result <= (decimal)1.0))
|
|
{
|
|
return result;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (decimal)1.0;
|
|
}
|
|
|
|
bool HasParameters(ContentType contentType)
|
|
{
|
|
int number = 0;
|
|
foreach (string param in contentType.Parameters.Keys)
|
|
{
|
|
if (!string.Equals("q", param, StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
number++;
|
|
}
|
|
}
|
|
|
|
return (number > 0);
|
|
}
|
|
}
|
|
}
|