Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
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
2016-05-03 00:07:37 +02:00

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