public HttpRequest()
{
Protocol = DEFAULT_HTTP_PROTOCOL;
GET = new HttpRequestParams();
POST = new HttpRequestParams();
FILES = new HttpFormFiles();
Headers = new HttpRequestHeaders();
Cookies = new HttpCookies();
}
/// <summary>
/// Send an HTTP request to the specified 'url'.
/// </summary>
/// <param name="url"></param>
/// <param name="method"></param>
/// <param name="headers"></param>
/// <param name="content"></param>
/// <param name="onError"></param>
/// <exception cref="HttpClientRequestException">Response did not return a success status code.</exception>
/// <returns></returns>
public virtual async Task <TModel> SendAsync <TModel>(string url, HttpMethod method, HttpRequestHeaders headers, HttpContent content = null, Func <HttpResponseMessage, bool> onError = null)
{
var response = await SendAsync(url, method, headers, content);
if (response.IsSuccessStatusCode)
{
return(await DeserializeAsync <TModel>(response));
}
// If the error handle is not provided, or if it returns false throw an error.
if (!(onError?.Invoke(response) ?? false))
{
var error = new HttpClientRequestException(response);
_logger.LogError(error, error.Message);
throw error;
}
return(default);
/// <summary>
/// Send an HTTP request to the specified 'uri'.
/// </summary>
/// <param name="uri"></param>
/// <param name="method"></param>
/// <param name="headers"></param>
/// <param name="content"></param>
/// <returns></returns>
public virtual async Task <HttpResponseMessage> SendAsync(Uri url, HttpMethod method, HttpRequestHeaders headers, HttpContent content = null)
{
return(await SendAsync(url.OriginalString, method, headers, content));
}
/// <summary>
/// Send an HTTP request to the specified 'url'.
/// </summary>
/// <param name="url"></param>
/// <param name="method"></param>
/// <param name="headers"></param>
/// <param name="content"></param>
/// <returns></returns>
public virtual Task <HttpResponseMessage> SendAsync(string url, HttpMethod method, HttpRequestHeaders headers, HttpContent content = null)
{
if (String.IsNullOrWhiteSpace(url))
{
throw new ArgumentException($"Argument '{nameof(url)}' must be a valid URL.");
}
return(this.SendInternalAsync(url, method, headers, content));
}
public void Headers_Invalid()
{
HttpRequestMessage message = new HttpRequestMessage();
HttpRequestHeaders headers = message.Headers;
try {
headers.Add("Allow", "");
Assert.Fail("#1");
} catch (InvalidOperationException) {
}
try {
headers.Add(null, "");
Assert.Fail("#2");
} catch (ArgumentException) {
}
try {
headers.Add("mm", null as IEnumerable <string>);
Assert.Fail("#2b");
} catch (ArgumentNullException) {
}
try {
headers.Add("accept", "audio");
Assert.Fail("#2c");
} catch (FormatException) {
}
Assert.IsFalse(headers.TryAddWithoutValidation("Allow", ""), "#3");;
Assert.IsFalse(headers.TryAddWithoutValidation(null, ""), "#4");
try {
headers.Contains(null);
Assert.Fail("#5");
} catch (ArgumentException) {
}
try {
headers.GetValues(null);
Assert.Fail("#6a");
} catch (ArgumentException) {
}
try {
headers.GetValues("bbbb");
Assert.Fail("#6b");
} catch (InvalidOperationException) {
}
try {
headers.Add("from", new[] { "*****@*****.**", "*****@*****.**" });
Assert.Fail("#7a");
} catch (FormatException) {
}
Assert.IsTrue(headers.TryAddWithoutValidation("from", "*****@*****.**"), "#7-0");
try {
headers.Add("from", "*****@*****.**");
Assert.Fail("#7b");
} catch (FormatException) {
}
}
public void Headers()
{
HttpRequestMessage message = new HttpRequestMessage();
HttpRequestHeaders headers = message.Headers;
headers.Accept.Add(new MediaTypeWithQualityHeaderValue("audio/x"));
headers.AcceptCharset.Add(new StringWithQualityHeaderValue("str-v", 0.002));
headers.AcceptEncoding.Add(new StringWithQualityHeaderValue("str-enc", 0.44));
headers.AcceptLanguage.Add(new StringWithQualityHeaderValue("str-lang", 0.41));
headers.Authorization = new AuthenticationHeaderValue("sh-aut", "par");
headers.CacheControl = new CacheControlHeaderValue()
{
MaxAge = TimeSpan.MaxValue
};
headers.Connection.Add("test-value");
headers.ConnectionClose = true;
headers.Date = new DateTimeOffset(DateTime.Today);
headers.Expect.Add(new NameValueWithParametersHeaderValue("en", "ev"));
headers.ExpectContinue = true;
headers.From = "*****@*****.**";
headers.Host = "host";
headers.IfMatch.Add(new EntityTagHeaderValue("\"tag\"", true));
headers.IfModifiedSince = new DateTimeOffset(DateTime.Today);
headers.IfNoneMatch.Add(new EntityTagHeaderValue("\"tag2\"", true));
headers.IfRange = new RangeConditionHeaderValue(new DateTimeOffset(DateTime.Today));
headers.IfUnmodifiedSince = new DateTimeOffset? (DateTimeOffset.Now);
headers.MaxForwards = 0x15b3;
headers.Pragma.Add(new NameValueHeaderValue("name", "value"));
headers.ProxyAuthorization = new AuthenticationHeaderValue("s", "p");
headers.Range = new RangeHeaderValue(5L, 30L);
headers.Referrer = new Uri("http://xamarin.com");
headers.TE.Add(new TransferCodingWithQualityHeaderValue("TE", 0.3));
headers.Trailer.Add("value");
headers.TransferEncoding.Add(new TransferCodingHeaderValue("tchv"));
headers.TransferEncodingChunked = true;
headers.Upgrade.Add(new ProductHeaderValue("prod", "ver"));
headers.UserAgent.Add(new ProductInfoHeaderValue("(comment)"));
headers.Via.Add(new ViaHeaderValue("protocol", "rec-by"));
headers.Warning.Add(new WarningHeaderValue(5, "agent", "\"txt\""));
try {
headers.Add("authorization", "");
Assert.Fail("Authorization");
} catch (FormatException) {
}
try {
headers.Add("connection", "extra ß ");
Assert.Fail("Date");
} catch (FormatException) {
}
try {
headers.Add("date", "");
Assert.Fail("Date");
} catch (FormatException) {
}
try {
headers.Add("from", "*****@*****.**");
Assert.Fail("From");
} catch (FormatException) {
}
try {
headers.Add("hOst", "host");
Assert.Fail("Host");
} catch (FormatException) {
}
try {
headers.Add("if-modified-since", "");
Assert.Fail("if-modified-since");
} catch (FormatException) {
}
try {
headers.Add("if-range", "");
Assert.Fail("if-range");
} catch (FormatException) {
}
try {
headers.Add("if-unmodified-since", "");
Assert.Fail("if-unmodified-since");
} catch (FormatException) {
}
try {
headers.Add("max-forwards", "");
Assert.Fail("max-forwards");
} catch (FormatException) {
}
try {
headers.Add("proxy-authorization", "");
Assert.Fail("proxy-authorization");
} catch (FormatException) {
}
try {
headers.Add("range", "");
} catch (FormatException) {
}
try {
headers.Add("referer", "");
Assert.Fail("referer");
} catch (FormatException) {
}
try {
headers.Add("pragma", "nocache,RequestID=1,g=");
Assert.Fail("pragma");
} catch (FormatException) {
}
headers.Add("accept", "audio/y");
headers.Add("accept-charset", "achs");
headers.Add("accept-encoding", "aenc");
headers.Add("accept-language", "alan");
headers.Add("expect", "exp");
headers.Add("if-match", "\"v\"");
headers.Add("if-none-match", "\"v2\"");
headers.Add("TE", "0.8");
headers.Add("trailer", "value2");
headers.Add("transfer-encoding", "ttt");
headers.Add("upgrade", "uuu");
headers.Add("user-agent", "uaua");
headers.Add("via", "prot v");
headers.Add("warning", "4 ww \"t\"");
headers.Add("pragma", "nocache,R=1,g");
Assert.IsTrue(headers.Accept.SequenceEqual(
new[] {
new MediaTypeWithQualityHeaderValue("audio/x"),
new MediaTypeWithQualityHeaderValue("audio/y")
}
));
Assert.IsTrue(headers.AcceptCharset.SequenceEqual(
new[] {
new StringWithQualityHeaderValue("str-v", 0.002),
new StringWithQualityHeaderValue("achs")
}
));
Assert.IsTrue(headers.AcceptEncoding.SequenceEqual(
new[] {
new StringWithQualityHeaderValue("str-enc", 0.44),
new StringWithQualityHeaderValue("aenc")
}
));
Assert.IsTrue(headers.AcceptLanguage.SequenceEqual(
new[] {
new StringWithQualityHeaderValue("str-lang", 0.41),
new StringWithQualityHeaderValue("alan")
}
));
Assert.AreEqual(new AuthenticationHeaderValue("sh-aut", "par"), headers.Authorization);
var cch = new CacheControlHeaderValue()
{
MaxAge = TimeSpan.MaxValue,
};
Assert.AreEqual(cch, headers.CacheControl);
Assert.IsTrue(headers.Connection.SequenceEqual(
new string[] { "test-value", "close" }));
Assert.AreEqual(headers.Date, new DateTimeOffset(DateTime.Today));
Assert.IsTrue(headers.Expect.SequenceEqual(
new [] {
new NameValueWithParametersHeaderValue("en", "ev"),
new NameValueWithParametersHeaderValue("100-continue"),
new NameValueWithParametersHeaderValue("exp")
}));
Assert.AreEqual(headers.From, "*****@*****.**");
Assert.IsTrue(headers.IfMatch.SequenceEqual(
new EntityTagHeaderValue[] {
new EntityTagHeaderValue("\"tag\"", true),
new EntityTagHeaderValue("\"v\"", false)
}
));
Assert.AreEqual(headers.IfModifiedSince, new DateTimeOffset(DateTime.Today));
Assert.IsTrue(headers.IfNoneMatch.SequenceEqual(new EntityTagHeaderValue[] { new EntityTagHeaderValue("\"tag2\"", true), new EntityTagHeaderValue("\"v2\"", false) }));
Assert.AreEqual(new DateTimeOffset(DateTime.Today), headers.IfRange.Date);
Assert.AreEqual(headers.MaxForwards, 0x15b3);
Assert.AreEqual("p", headers.ProxyAuthorization.Parameter);
Assert.AreEqual("s", headers.ProxyAuthorization.Scheme);
Assert.AreEqual(5, headers.Range.Ranges.First().From);
Assert.AreEqual(30, headers.Range.Ranges.First().To);
Assert.AreEqual("bytes", headers.Range.Unit);
Assert.AreEqual(headers.Referrer, new Uri("http://xamarin.com"));
Assert.IsTrue(headers.TE.SequenceEqual(new TransferCodingWithQualityHeaderValue[] { new TransferCodingWithQualityHeaderValue("TE", 0.3), new TransferCodingWithQualityHeaderValue("0.8") }), "29");
Assert.IsTrue(headers.Trailer.SequenceEqual(
new string[] {
"value", "value2"
}), "30");
Assert.IsTrue(headers.TransferEncoding.SequenceEqual(
new[] {
new TransferCodingHeaderValue("tchv"),
new TransferCodingHeaderValue("chunked"),
new TransferCodingHeaderValue("ttt")
}
));
Assert.IsTrue(headers.Upgrade.SequenceEqual(
new[] {
new ProductHeaderValue("prod", "ver"),
new ProductHeaderValue("uuu")
}
));
Assert.IsTrue(headers.UserAgent.SequenceEqual(
new[] {
new ProductInfoHeaderValue("(comment)"),
new ProductInfoHeaderValue("uaua", null)
}
));
Assert.IsTrue(headers.Via.SequenceEqual(
new[] {
new ViaHeaderValue("protocol", "rec-by"),
new ViaHeaderValue("prot", "v")
}
));
Assert.IsTrue(headers.Warning.SequenceEqual(
new[] {
new WarningHeaderValue(5, "agent", "\"txt\""),
new WarningHeaderValue(4, "ww", "\"t\"")
}
));
Assert.IsTrue(headers.Pragma.SequenceEqual(
new[] {
new NameValueHeaderValue("name", "value"),
new NameValueHeaderValue("nocache", null),
new NameValueHeaderValue("R", "1"),
new NameValueHeaderValue("g", null)
}
));
}
public static string ValueFor(this IEnumerable <Header> headers, HttpRequestHeader header)
{
return(headers.ValueFor(HttpRequestHeaders.HeaderNameFor(header)));
}
private void PostProcessRequestHttpHeadersCallback(HttpRequestMessage Request, HttpRequestHeaders DefaultRequestHeaders)
{
this.DebugMsg("PreProcessHeadRequestHeadersCallback Called");
}
public static void SetBearerAuthentication(this HttpRequestHeaders headers, string token)
{
headers.Authorization = new AuthenticationHeaderValue("Bearer", token);
}
public static void SetBasicAuthentication(this HttpRequestHeaders headers, string username, string password)
{
var bytes = Encoding.UTF8.GetBytes($"{username}:{password}");
headers.Authorization = new AuthenticationHeaderValue("Basic", Convert.ToBase64String(bytes));
}
private static void AddRequestHeaders(HttpWebRequest request, HttpRequestHeaders headers)
{
foreach (var header in headers)
{
switch (header.Key.ToLowerInvariant())
{
case "accept":
request.Accept = headers.Accept.ToString();
break;
case "connection":
request.Connection = headers.Connection.ToString();
break;
case "date":
// .NET 3.5 does not expose a property for setting this reserved header
goto default;
case "expect":
request.Expect = headers.Expect.ToString();
break;
case "host":
// .NET 3.5 does not expose a property for setting this reserved header
goto default;
case "if-modified-since":
request.IfModifiedSince = headers.IfModifiedSince.Value.UtcDateTime;
break;
case "range":
foreach (var range in headers.Range.Ranges)
{
checked
{
if (!string.IsNullOrEmpty(headers.Range.Unit))
{
if (range.To.HasValue)
{
request.AddRange(headers.Range.Unit, (int)range.From.Value, (int)range.To.Value);
}
else
{
request.AddRange(headers.Range.Unit, (int)range.From.Value);
}
}
else
{
if (range.To.HasValue)
{
request.AddRange((int)range.From.Value, (int)range.To.Value);
}
else
{
request.AddRange((int)range.From.Value);
}
}
}
}
break;
case "referer":
request.Referer = headers.Referrer.OriginalString;
break;
case "transfer-encoding":
request.TransferEncoding = headers.TransferEncoding.ToString();
break;
case "user-agent":
request.UserAgent = headers.UserAgent.ToString();
break;
default:
foreach (var value in header.Value)
{
request.Headers.Add(header.Key, value);
}
break;
}
}
}
UpdateCardholderAsync(object query, PropertyBag body, string newSafeKey = null, string safeKey = null, Paging paging = null, HttpRequestHeaders headers = null)
{
QueryDef qd = new QueryDef(query, body);
string path = "/cardholders";
if (headers == null)
{
headers = new HttpRequestMessage().Headers;
}
AddNewSafeKeyHeader(headers, newSafeKey);
return(await ApiMultiPutDelAsync <Cardholder>(path, null, qd, HttpMethod.Put, body, null, paging, headers));
}
CreateCardholderAsync(PropertyBag body, string safeKey = null, string financialInstitution = null, HttpRequestHeaders headers = null)
{
if (headers == null)
{
headers = new HttpRequestMessage().Headers;
}
AddSafeKeyHeader(headers, safeKey);
if (financialInstitution != null)
{
headers.Add("x-cardsavr-financial-institution", financialInstitution);
}
return(await ApiPostAsync <Cardholder>("/cardholders", body, null, headers));
}
internal void AddHeaders(HttpRequestHeaders headers)
{
foreach (var header in headers) {
TryAddWithoutValidation (header.Key, header.Value);
}
}
/// <returns>
/// The first value is the canonical request, the second value is the signed headers.
/// </returns>
public static async Task <(string, string)> BuildAsync(
HttpRequestMessage request,
HttpRequestHeaders defaultHeaders)
{
var builder = new StringBuilder();
// The HTTP request method (GET, PUT, POST, etc.), followed by a newline character
builder.Append($"{request.Method}\n");
// Add the canonical URI parameter, followed by a newline character. The canonical URI
// is the URI-encoded version of the absolute path component of the URI, which is
// everything in the URI from the HTTP host to the question mark character ("?") that
// begins the query string parameters (if any).
//
// Normalize URI paths according to <see href="https://tools.ietf.org/html/rfc3986">RFC
// 3986</see>. Remove redundant and relative path components. Each path segment must be
// URI-encoded twice (
// <see href="https://docs.aws.amazon.com/AmazonS3/latest/API/sigv4-query-string-auth.html">
// except for Amazon S3 which only gets URI-encoded once</see>).
var pathSegments = request.RequestUri.AbsolutePath
.Replace("//", "/")
.Split('/')
.Select(pathSegment => AWSSDKUtils.UrlEncode(pathSegment, false));
builder.Append($"{string.Join("/", pathSegments)}\n");
// Add the canonical query string, followed by a newline character. If the request does
// not include a query string, use an empty string (essentially, a blank line).
//
// To construct the canonical query string, complete the following steps:
//
// a. Sort the parameter names by character code point in ascending order. Parameters
// with duplicate names should be sorted by value. For example, a parameter name
// that begins with the uppercase letter F precedes a parameter name that begins
// with a lowercase letter b.
// b. URI-encode each parameter name and value according to the following rules:
// - Do not URI-encode any of the unreserved characters that RFC 3986 defines: A-Z,
// a-z, 0-9, hyphen ( - ), underscore ( _ ), period ( . ), and tilde ( ~ ).
// - Percent-encode all other characters with %XY, where X and Y are hexadecimal
// characters (0-9 and uppercase A-F). For example, the space character must be
// encoded as %20 (not using '+', as some encoding schemes do) and extended UTF-8
// characters must be in the form %XY%ZA%BC.
// c. Build the canonical query string by starting with the first parameter name in the
// sorted list.
// d. For each parameter, append the URI-encoded parameter name, followed by the equals
// sign character (=), followed by the URI-encoded parameter value. Use an empty
// string for parameters that have no value.
// e. Append the ampersand character (&) after each parameter value, except for the
// last value in the list.
var parameters = SortQueryParameters(request.RequestUri.Query)
.SelectMany(
parameter => parameter.Value.Select(
parameterValue => $"{AWSSDKUtils.UrlEncode(parameter.Key, false)}={AWSSDKUtils.UrlEncode(parameterValue, false)}"));
builder.Append($"{string.Join("&", parameters)}\n");
// Add the canonical headers, followed by a newline character. The canonical headers
// consist of a list of all the HTTP headers that you are including with the signed
// request.
//
// To create the canonical headers list, convert all header names to lowercase and
// remove leading spaces and trailing spaces. Convert sequential spaces in the header
// value to a single space.
//
// Build the canonical headers list by sorting the (lowercase) headers by character
// code and then iterating through the header names. Construct each header according to
// the following rules:
//
// - Append the lowercase header name followed by a colon.
// - Append a comma-separated list of values for that header. Do not sort the values in
// headers that have multiple values.
// PLEASE NOTE: Microsoft has chosen to separate the header values with ", ", not ","
// as defined by the Canonical Request algorithm.
// - Append a new line ('\n').
var sortedHeaders = SortHeaders(request.Headers, defaultHeaders);
foreach (var header in sortedHeaders)
{
builder.Append($"{header.Key}:{string.Join(HeaderValueSeparator, header.Value)}\n");
}
builder.Append('\n');
// Add the signed headers, followed by a newline character. This value is the list of
// headers that you included in the canonical headers. By adding this list of headers,
// you tell AWS which headers in the request are part of the signing process and which
// ones AWS can ignore (for example, any additional headers added by a proxy) for
// purposes of validating the request.
//
// To create the signed headers list, convert all header names to lowercase, sort them
// by character code, and use a semicolon to separate the header names.
//
// Build the signed headers list by iterating through the collection of header names,
// sorted by lowercase character code. For each header name except the last, append a
// semicolon (';') to the header name to separate it from the following header name.
var signedHeaders = string.Join(";", sortedHeaders.Keys);
builder.Append($"{signedHeaders}\n");
// Use a hash (digest) function like SHA256 to create a hashed value from the payload
// in the body of the HTTP or HTTPS request.
//
// If the payload is empty, use an empty string as the input to the hash function.
var requestPayload = request.Content != null
? await request.Content.ReadAsByteArrayAsync()
: new byte[0];
var hash = AWS4Signer.ComputeHash(requestPayload);
var hex = AWSSDKUtils.ToHex(hash, true);
builder.Append(hex);
return(builder.ToString(), signedHeaders);
}
/// <summary>
/// A default constructor that initialises all fields to their defaults.
/// </summary>
internal HttpRequest()
{
Headers = new HttpRequestHeaders();
}
public HttpRequestHeaders AddSubscriptionHeader(HttpRequestHeaders headers)
{
headers.Add(_azureSettings.OcpApimSubscriptionKeyHeader, _azureSettings.ApiKey);
return(headers);
}
public async Task CopyToAsyncDoesNotCopyBlocks()
{
var writeCount = 0;
var writeTcs = new TaskCompletionSource <(byte[], int, int)>(TaskCreationOptions.RunContinuationsAsynchronously);
var mockDestination = new Mock <Stream>()
{
CallBase = true
};
mockDestination
.Setup(m => m.WriteAsync(It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>(), CancellationToken.None))
.Callback((byte[] buffer, int offset, int count, CancellationToken cancellationToken) =>
{
writeTcs.SetResult((buffer, offset, count));
writeCount++;
})
.Returns(Task.CompletedTask);
using (var memoryPool = KestrelMemoryPool.Create())
{
var options = new PipeOptions(pool: memoryPool, readerScheduler: PipeScheduler.Inline, writerScheduler: PipeScheduler.Inline, useSynchronizationContext: false);
var pair = DuplexPipe.CreateConnectionPair(options, options);
var transport = pair.Transport;
var application = pair.Application;
var http1ConnectionContext = new Http1ConnectionContext
{
ServiceContext = new TestServiceContext(),
ConnectionFeatures = new FeatureCollection(),
Application = application,
Transport = transport,
MemoryPool = memoryPool,
TimeoutControl = Mock.Of <ITimeoutControl>()
};
var http1Connection = new Http1Connection(http1ConnectionContext)
{
HasStartedConsumingRequestBody = true
};
var headers = new HttpRequestHeaders {
HeaderContentLength = "12"
};
var body = Http1MessageBody.For(HttpVersion.Http11, headers, http1Connection);
var copyToAsyncTask = body.CopyToAsync(mockDestination.Object);
var bytes = Encoding.ASCII.GetBytes("Hello ");
var buffer = http1Connection.RequestBodyPipe.Writer.GetMemory(2048);
ArraySegment <byte> segment;
Assert.True(MemoryMarshal.TryGetArray(buffer, out segment));
Buffer.BlockCopy(bytes, 0, segment.Array, segment.Offset, bytes.Length);
http1Connection.RequestBodyPipe.Writer.Advance(bytes.Length);
await http1Connection.RequestBodyPipe.Writer.FlushAsync();
// Verify the block passed to Stream.WriteAsync() is the same one incoming data was written into.
Assert.Equal((segment.Array, segment.Offset, bytes.Length), await writeTcs.Task);
// Verify the again when GetMemory returns the tail space of the same block.
writeTcs = new TaskCompletionSource <(byte[], int, int)>(TaskCreationOptions.RunContinuationsAsynchronously);
bytes = Encoding.ASCII.GetBytes("World!");
buffer = http1Connection.RequestBodyPipe.Writer.GetMemory(2048);
Assert.True(MemoryMarshal.TryGetArray(buffer, out segment));
Buffer.BlockCopy(bytes, 0, segment.Array, segment.Offset, bytes.Length);
http1Connection.RequestBodyPipe.Writer.Advance(bytes.Length);
await http1Connection.RequestBodyPipe.Writer.FlushAsync();
Assert.Equal((segment.Array, segment.Offset, bytes.Length), await writeTcs.Task);
http1Connection.RequestBodyPipe.Writer.Complete();
await copyToAsyncTask;
Assert.Equal(2, writeCount);
// Don't call body.StopAsync() because PumpAsync() was never called.
http1Connection.RequestBodyPipe.Reader.Complete();
}
}
private static Dictionary <string, StringValues> CopyWithoutContentHeaders(HttpRequestHeaders sourceHeaders)
{
return(sourceHeaders.Where(h => !h.Key.ToLowerInvariant().StartsWith("content-"))
.ToDictionary(v => v.Key, v => new StringValues(v.Value.ToArray())));
}
private static void SetRequestHeaders(HttpWebRequest webRequest, HttpRequestMessage request)
{
WebHeaderCollection webRequestHeaders = webRequest.Headers;
HttpRequestHeaders headers = request.Headers;
// Most headers are just added directly to HWR's internal headers collection. But there are some exceptions
// requiring different handling.
// The following bool vars are used to skip string comparison when not required: E.g. if the 'Host' header
// was not set, we don't need to compare every header in the collection with 'Host' to make sure we don't
// add it to HWR's header collection.
bool isHostSet = headers.Contains(HttpKnownHeaderNames.Host);
bool isExpectSet = headers.Contains(HttpKnownHeaderNames.Expect);
bool isTransferEncodingSet = headers.Contains(HttpKnownHeaderNames.TransferEncoding);
bool isConnectionSet = headers.Contains(HttpKnownHeaderNames.Connection);
if (isHostSet)
{
string host = headers.Host;
if (host != null)
{
webRequest.Host = host;
}
}
// The following headers (Expect, Transfer-Encoding, Connection) have both a collection property and a
// bool property indicating a special value. Internally (in HttpHeaders) we don't distinguish between
// "special" values and other values. So we must make sure that we add all but the special value to HWR.
// E.g. the 'Transfer-Encoding: chunked' value must be set using HWR.SendChunked, whereas all other values
// can be added to the 'Transfer-Encoding'.
if (isExpectSet)
{
string expectHeader = headers.Expect.GetHeaderStringWithoutSpecial();
// Was at least one non-special value set?
if (!String.IsNullOrEmpty(expectHeader) || !headers.Expect.IsSpecialValueSet)
{
webRequestHeaders.AddInternal(HttpKnownHeaderNames.Expect, expectHeader);
}
}
if (isTransferEncodingSet)
{
string transferEncodingHeader = headers.TransferEncoding.GetHeaderStringWithoutSpecial();
// Was at least one non-special value set?
if (!String.IsNullOrEmpty(transferEncodingHeader) || !headers.TransferEncoding.IsSpecialValueSet)
{
webRequestHeaders.AddInternal(HttpKnownHeaderNames.TransferEncoding, transferEncodingHeader);
}
}
if (isConnectionSet)
{
string connectionHeader = headers.Connection.GetHeaderStringWithoutSpecial();
// Was at least one non-special value set?
if (!String.IsNullOrEmpty(connectionHeader) || !headers.Connection.IsSpecialValueSet)
{
webRequestHeaders.AddInternal(HttpKnownHeaderNames.Connection, connectionHeader);
}
}
foreach (var header in request.Headers.GetHeaderStrings())
{
string headerName = header.Key;
if ((isHostSet && AreEqual(HttpKnownHeaderNames.Host, headerName)) ||
(isExpectSet && AreEqual(HttpKnownHeaderNames.Expect, headerName)) ||
(isTransferEncodingSet && AreEqual(HttpKnownHeaderNames.TransferEncoding, headerName)) ||
(isConnectionSet && AreEqual(HttpKnownHeaderNames.Connection, headerName)))
{
continue; // Header was already added.
}
// Use AddInternal() to skip validation.
webRequestHeaders.AddInternal(header.Key, header.Value);
}
}
public HeaderValueProvider(HttpRequestHeaders headers)
{
_headers = headers;
}
public void Header_BaseImplementation()
{
HttpRequestMessage message = new HttpRequestMessage();
HttpRequestHeaders headers = message.Headers;
headers.Add("a", "a-value");
headers.Add("b", new List <string> {
"v1", "v2"
});
headers.Add("c", null as string);
headers.Add("d", new string[0]);
Assert.IsTrue(headers.TryAddWithoutValidation("accept", "audio"), "#0");
Assert.IsFalse(headers.Contains("nn"), "#1a");
Assert.IsTrue(headers.Contains("b"), "#1b");
var values = headers.GetValues("b").ToList();
Assert.AreEqual("v1", values[0], "#2a");
Assert.AreEqual("v2", values[1], "#2b");
Assert.IsFalse(headers.Remove("p"), "#3a");
Assert.IsTrue(headers.Remove("b"), "#3b");
Assert.IsFalse(headers.Contains("b"), "#3b-c");
IEnumerable <string> values2;
Assert.IsTrue(headers.TryGetValues("c", out values2));
values = values2.ToList();
Assert.AreEqual("", values[0], "#4a");
int counter = 0;
foreach (var i in headers)
{
++counter;
}
Assert.AreEqual(3, counter, "#5");
headers.Clear();
headers.Accept.Add(new MediaTypeWithQualityHeaderValue("audio/x"));
Assert.IsTrue(headers.TryAddWithoutValidation("accept", "audio"), "#55");
values = headers.GetValues("accept").ToList();
Assert.AreEqual(2, values.Count, "#6");
Assert.AreEqual("audio/x", values[0], "#6a");
Assert.AreEqual("audio", values[1], "#6b");
Assert.AreEqual(1, headers.Accept.Count, "#6c");
headers.Clear();
Assert.IsTrue(headers.TryAddWithoutValidation("from", new[] { "*****@*****.**", "*****@*****.**" }), "#70");
values = headers.GetValues("from").ToList();
Assert.AreEqual(2, values.Count, "#7");
Assert.AreEqual("*****@*****.**", values[0], "#7a");
Assert.AreEqual("*****@*****.**", values[1], "#7b");
Assert.AreEqual("*****@*****.**", headers.From, "#7c");
headers.Clear();
Assert.IsTrue(headers.TryAddWithoutValidation("Date", "wrong date"), "#8-0");
var value = headers.Date;
Assert.IsNull(headers.Date, "#8");
}
public void Headers_MultiValues()
{
HttpRequestMessage message = new HttpRequestMessage();
HttpRequestHeaders headers = message.Headers;
headers.Add("Accept", "application/vnd.citrix.requesttokenresponse+xml, application/vnd.citrix.requesttokenchoices+xml");
headers.Add("Accept-Charset", "aa ;Q=0,bb;Q=1");
headers.Add("Expect", "x=1; v, y=5");
headers.Add("If-Match", "\"a\",*, \"b\",*");
headers.Add("user-Agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_8_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/29.0.1547.62 Safari/537.36");
Assert.AreEqual(2, headers.Accept.Count, "#1a");
Assert.IsTrue(headers.Accept.SequenceEqual(
new[] {
new MediaTypeWithQualityHeaderValue("application/vnd.citrix.requesttokenresponse+xml"),
new MediaTypeWithQualityHeaderValue("application/vnd.citrix.requesttokenchoices+xml"),
}
), "#1b");
Assert.AreEqual(2, headers.AcceptCharset.Count, "#2a");
Assert.IsTrue(headers.AcceptCharset.SequenceEqual(
new[] {
new StringWithQualityHeaderValue("aa", 0),
new StringWithQualityHeaderValue("bb", 1),
}
), "#2b");
Assert.AreEqual(2, headers.Expect.Count, "#3a");
var expect_expected = new[] {
new NameValueWithParametersHeaderValue("x", "1")
{
},
new NameValueWithParametersHeaderValue("y", "5"),
};
expect_expected [0].Parameters.Add(new NameValueHeaderValue("v"));
Assert.IsTrue(headers.Expect.SequenceEqual(
expect_expected
), "#3b");
Assert.AreEqual(4, headers.IfMatch.Count, "#4a");
Assert.IsTrue(headers.IfMatch.SequenceEqual(
new[] {
new EntityTagHeaderValue("\"a\""),
EntityTagHeaderValue.Any,
new EntityTagHeaderValue("\"b\""),
EntityTagHeaderValue.Any
}
), "#4b");
Assert.AreEqual(6, headers.UserAgent.Count, "#10a");
Assert.IsTrue(headers.UserAgent.SequenceEqual(
new[] {
new ProductInfoHeaderValue("Mozilla", "5.0"),
new ProductInfoHeaderValue("(Macintosh; Intel Mac OS X 10_8_4)"),
new ProductInfoHeaderValue("AppleWebKit", "537.36"),
new ProductInfoHeaderValue("(KHTML, like Gecko)"),
new ProductInfoHeaderValue("Chrome", "29.0.1547.62"),
new ProductInfoHeaderValue("Safari", "537.36")
}
), "#10b");
}
private static void GoogleTraceContextEmitter(HttpRequestHeaders headers, string traceId, ulong?spanId, bool?shouldTrace) => // To mimic incoming requests with the Google trace header. headers.Add(TraceHeaderContext.TraceHeader, TraceHeaderContext.Create(traceId, spanId, shouldTrace).ToString());
public void GetServiceHeader(HttpRequestHeaders headers)
{
}
/// <summary>
/// Send an HTTP request to the specified 'uri'.
/// </summary>
/// <param name="uri"></param>
/// <param name="method"></param>
/// <param name="headers"></param>
/// <param name="data"></param>
/// <returns></returns>
public virtual async Task <HttpResponseMessage> SendJsonAsync <T>(Uri url, HttpMethod method, HttpRequestHeaders headers, T data = null)
where T : class
{
return(await SendJsonAsync(url.OriginalString, method, headers, data));
}
private void AddDefaultRequestHeaders(HttpRequestHeaders headers)
{
headers.Add("Accept", "application/json");
}
/// <summary>
/// Send an HTTP request to the specified 'url'.
/// </summary>
/// <param name="url"></param>
/// <param name="method"></param>
/// <param name="headers"></param>
/// <param name="data"></param>
/// <param name="onError"></param>
/// <exception cref="HttpClientRequestException">Response did not return a success status code.</exception>
/// <returns></returns>
public virtual async Task <TModel> SendJsonAsync <TModel, T>(string url, HttpMethod method, HttpRequestHeaders headers, T data = null, Func <HttpResponseMessage, bool> onError = null)
where T : class
{
if (data != null)
{
var json = JsonSerializer.Serialize(data, _serializeOptions);
using var content = new StringContent(json, Encoding.UTF8, "application/json");
return(await SendAsync <TModel>(url, method, headers, content, onError));
}
else
{
return(await SendAsync <TModel>(url, method, headers, null, onError));
}
}
/** -------------------------------------------------------------------- **/
private void PostProcessRequestHttpHeadersCallback(HttpRequestMessage Request, HttpRequestHeaders DefaultRequestHeaders)
{
}
public static SortedDictionary <string, List <string> > SortHeaders(
HttpRequestHeaders headers,
HttpRequestHeaders defaultHeaders)
{
var sortedHeaders = new SortedDictionary <string, List <string> >(StringComparer.Ordinal);
string FormatHeaderName(string headerName)
{
return(headerName.ToLowerInvariant());
}
void AddHeader(KeyValuePair <string, IEnumerable <string> > header)
{
var headerName = FormatHeaderName(header.Key);
// Create header if it doesn't already exist
if (!sortedHeaders.TryGetValue(headerName, out var headerValues))
{
headerValues = new List <string>();
sortedHeaders.Add(headerName, headerValues);
}
// Remove leading and trailing header value spaces, and convert sequential spaces
// into a single space
headerValues.AddRange(header.Value.Select(headerValue => headerValue.Trim().NormalizeWhiteSpace()));
}
void AddDefaultDotnetHeaders()
{
foreach (var defaultHeader in defaultHeaders)
{
// On .NET Framework or .NET Core we only add header values if they're not
// already added on the message. Note that we don't merge collections: If both
// the default headers and the message have set some values for a certain
// header, then we don't try to merge the values.
if (!sortedHeaders.ContainsKey(FormatHeaderName(defaultHeader.Key)))
{
AddHeader(defaultHeader);
}
}
}
void AddDefaultMonoHeaders()
{
foreach (var defaultHeader in defaultHeaders)
{
// On Mono we add header values indifferent of whether the header already exists
AddHeader(defaultHeader);
}
}
// Add headers
foreach (var header in headers)
{
AddHeader(header);
}
// Add default headers
if (defaultHeaders != null)
{
if (EnvironmentProbe.IsMono)
{
AddDefaultMonoHeaders();
}
else
{
AddDefaultDotnetHeaders();
}
}
return(sortedHeaders);
}
private bool RequestIdInHeaders(RequestId.RequestId requestId, HttpRequestHeaders headers)
{
IEnumerable <string> value;
return(headers.TryGetValues(requestId.RequestIdKey, out value));
}
public HeaderHandler(HttpRequestHeaders headers)
{
_headers = headers;
}
private bool ShouldAddRequestId(RequestId.RequestId requestId, HttpRequestHeaders headers)
{
return(!string.IsNullOrEmpty(requestId?.RequestIdKey) &&
!string.IsNullOrEmpty(requestId.RequestIdValue) &&
!RequestIdInHeaders(requestId, headers));
}
