public static async Task<IMultipartCollection> ReadMultipartAsync(this HttpRequest request, CancellationToken cancellationToken) {
cancellationToken.ThrowIfCancellationRequested();
request.EnableRewind();
var parts = new MultipartCollection();
using(cancellationToken.Register(request.HttpContext.Abort)) {
var contentType = GetContentType(request);
var boundary = GetBoundary(contentType);
var multipartReader = new MultipartReader(boundary, request.Body);
var section = await multipartReader.ReadNextSectionAsync(cancellationToken);
while(section != null) {
var headers = new HeaderDictionary(section.Headers);
var contentDisposition = headers.GetContentDisposition();
await section.Body.DrainAsync(cancellationToken);
var part = new Multipart(request.Body, section.BaseStreamOffset.Value, section.Body.Length) {
Headers = headers
};
parts.Add(part);
section = await multipartReader.ReadNextSectionAsync(cancellationToken);
}
}
request.Body.Seek(0, SeekOrigin.Begin);
return parts;
}
internal static bool TryGetServiceMessage(this HttpRequestPacket request, out ServiceMessage message)
{
if (request == null) throw new ArgumentNullException("request");
message = new ServiceMessage();
//Build Request
IHttpRequestFeature req = message as IHttpRequestFeature;
Uri uri;
try
{
uri = request.BuildUri(null, null);
}
catch
{
message = null;
return false;
}
req.Path = uri.AbsolutePath;
req.Protocol = "HTTP/" + request.Version;
req.QueryString = uri.Query;
req.Method = request.Method;
req.Body = new MemoryStream(request.Content);
//Add Request Headers
{
var headers = new HeaderDictionary();
foreach (var hdr in request.Headers)
{
//NOTE: Client already folds Request Headers into RequestPacket, so there's no need to fold it again here.
headers.Add(hdr.Key, hdr.Value.ToArray());
}
req.Headers = headers;
}
//Create Response
IHttpResponseFeature resp = message as IHttpResponseFeature;
resp.StatusCode = 200;
//Add Response Headers
resp.Body = new MemoryStream();
{
var headers = new HeaderDictionary();
headers.Add("Server", HTTP_RESPONSE_SERVER);
resp.Headers = headers;
//TODO: Something to think about: Should host add Date response header.
//If so, shouldn't that be done at the time that the response is been transmitted
//In which case, the subscriber should be responsible for adding/overwriting that value.
//In any case, remember DateTime.UtcNow/Now is very slow, so use Environment.TickCount in addition to some
//other mechanism that limits the number of times, DateTime.UtcNow is polled.
}
return true;
}
public ResponseFeature()
{
Headers = new HeaderDictionary();
Body = new MemoryStream();
// 200 is the default status code all the way down to the host, so we set it
// here to be consistent with the rest of the hosts when writing tests.
StatusCode = 200;
}
private static HttpResponse GetResponseWithHeader(string headerName, string headerValue)
{
var headers = new HeaderDictionary();
if (headerValue != null)
{
headers.Add(headerName, headerValue);
}
return CreateResponse(headers);
}
public HttpRequestFeature()
{
Headers = new HeaderDictionary();
Body = Stream.Null;
Protocol = string.Empty;
Scheme = string.Empty;
Method = string.Empty;
PathBase = string.Empty;
Path = string.Empty;
QueryString = string.Empty;
}
public RequestFeature()
{
Body = Stream.Null;
Headers = new HeaderDictionary();
Method = "GET";
Path = "";
PathBase = "";
Protocol = "HTTP/1.1";
QueryString = "";
Scheme = "http";
}
public void DeleteCookieShouldSetDefaultPath()
{
var headers = new HeaderDictionary();
var cookies = new ResponseCookies(headers);
var testcookie = "TestCookie";
cookies.Delete(testcookie);
var cookieHeaderValues = headers[HeaderNames.SetCookie];
Assert.Equal(1, cookieHeaderValues.Count);
Assert.StartsWith(testcookie, cookieHeaderValues[0]);
Assert.Contains("path=/", cookieHeaderValues[0]);
Assert.Contains("expires=Thu, 01 Jan 1970 00:00:00 GMT", cookieHeaderValues[0]);
}
public void PropertiesAreAccessible()
{
var headers = new HeaderDictionary(
new Dictionary<string, StringValues>(StringComparer.OrdinalIgnoreCase)
{
{ "Header1", "Value1" }
});
Assert.Equal(1, headers.Count);
Assert.Equal<string>(new[] { "Header1" }, headers.Keys);
Assert.True(headers.ContainsKey("header1"));
Assert.False(headers.ContainsKey("header2"));
Assert.Equal("Value1", headers["header1"]);
Assert.Equal(new[] { "Value1" }, headers["header1"].ToArray());
}
public void NoParamsDeleteRemovesCookieCreatedByAdd()
{
var headers = new HeaderDictionary();
var cookies = new ResponseCookies(headers);
var testcookie = "TestCookie";
cookies.Append(testcookie, testcookie);
cookies.Delete(testcookie);
var cookieHeaderValues = headers[HeaderNames.SetCookie];
Assert.Equal(1, cookieHeaderValues.Count);
Assert.StartsWith(testcookie, cookieHeaderValues[0]);
Assert.Contains("path=/", cookieHeaderValues[0]);
Assert.Contains("expires=Thu, 01 Jan 1970 00:00:00 GMT", cookieHeaderValues[0]);
}
public void Host_GetsHostFromHeaders()
{
// Arrange
const string expected = "localhost:9001";
var headers = new HeaderDictionary()
{
{ "Host", expected },
};
var request = CreateRequest(headers);
// Act
var host = request.Host;
// Assert
Assert.Equal(expected, host.Value);
}
private static RouteJsController CreateController()
{
// Mock Response.Headers
var headers = new HeaderDictionary();
var response = new Mock<HttpResponse>();
response.Setup(x => x.Headers).Returns(headers);
var httpContext = new Mock<HttpContext>();
httpContext.Setup(x => x.Response).Returns(response.Object);
// Mock RouteJs
var routeJs = new Mock<IRouteJs>();
routeJs.Setup(x => x.GetJavaScript(true)).Returns("SampleDebug");
routeJs.Setup(x => x.GetJavaScript(false)).Returns("SampleProd");
return new RouteJsController(routeJs.Object)
{
ActionContext = new ActionContext {HttpContext = httpContext.Object}
};
}
public void writing_test()
{
// Arrange
var header = new HeaderDictionary();
var res = new Mock<HttpResponse>();
res.Setup(x => x.Cookies)
.Returns(new ResponseCookies(header));
var httpContext = new Mock<HttpContext>();
httpContext.Setup(x => x.Response)
.Returns(res.Object);
var accessor = new Mock<IHttpContextAccessor>();
accessor.Setup(x => x.HttpContext)
.Returns(httpContext.Object);
// Act
var cookie = new SmartCookies.SmartCookies(accessor.Object);
cookie["test"] = "1";
// Assert
Assert.Equal("Set-Cookie", header.Keys.First());
}
public void Host_DecodesPunyCode()
{
// Arrange
const string expected = "löcalhöst";
var headers = new HeaderDictionary()
{
{ "Host", "xn--lcalhst-90ae" },
};
var request = CreateRequest(headers);
// Act
var host = request.Host;
// Assert
Assert.Equal(expected, host.Value);
}
private static ActionContext GetActionContext(
MediaTypeHeaderValue contentType,
MemoryStream responseStream = null)
{
var request = new Mock<HttpRequest>();
var headers = new HeaderDictionary();
request.Setup(r => r.ContentType).Returns(contentType.ToString());
request.SetupGet(r => r.Headers).Returns(headers);
headers[HeaderNames.AcceptCharset] = contentType.Charset;
var response = new Mock<HttpResponse>();
response.SetupGet(f => f.Body).Returns(responseStream ?? new MemoryStream());
var httpContext = new Mock<HttpContext>();
httpContext.SetupGet(c => c.Request).Returns(request.Object);
httpContext.SetupGet(c => c.Response).Returns(response.Object);
return new ActionContext(httpContext.Object, routeData: null, actionDescriptor: null);
}
internal static bool TryGetServiceMessage (this HttpRequestPacket request, out ServiceMessage message)
{
if (request == null) throw new ArgumentNullException("request");
message = new ServiceMessage();
//Build Request
IHttpRequestFeature req = message as IHttpRequestFeature;
Uri uri;
try
{
uri = request.BuildUri(null, null);
}
catch
{
message = null;
return false;
}
req.Path = uri.AbsolutePath;
req.Protocol = "HTTP/" + request.Version;
req.QueryString = uri.Query;
req.Method = request.Method;
if (request.Content != null && request.Content.Length > 0)
{
message.CreateRequestBody(request.Content);
}
//Add Request Headers
{
var headers = new HeaderDictionary();
foreach (var hdr in request.Headers)
{
if (hdr.Key != null && hdr.Key.Trim().ToUpperInvariant() == "CONTENT-LENGTH") continue; // Content-length is calculated based on actual content.
//NOTE: Client already folds Request Headers into RequestPacket, so there's no need to fold it again here.
headers.Add(hdr.Key, hdr.Value.ToArray());
}
if (message.OriginalRequestBody != null)
{
headers.Add("Content-Length", request.Content.Length.ToString());
}
req.Headers = headers;
}
//Create Response
message.CreateResponseBody();
IHttpResponseFeature resp = message as IHttpResponseFeature;
resp.StatusCode = 200;
//Add Response Headers
{
var headers = new HeaderDictionary();
headers.Add("Server", HTTP_RESPONSE_SERVER_HEADER[0]);
resp.Headers = headers;
}
return true;
}
public HttpResponseFeature()
{
StatusCode = 200;
Headers = new HeaderDictionary();
Body = Stream.Null;
}
private static HttpContext GetHttpContext(string contentType)
{
var request = new Mock<HttpRequest>();
var headers = new HeaderDictionary();
headers["Accept-Charset"] = MediaTypeHeaderValue.Parse(contentType).Charset;
request.Setup(r => r.ContentType).Returns(contentType);
request.SetupGet(r => r.Headers).Returns(headers);
var response = new Mock<HttpResponse>();
response.SetupGet(f => f.Body).Returns(new MemoryStream());
var httpContext = new Mock<HttpContext>();
httpContext.SetupGet(c => c.Request).Returns(request.Object);
httpContext.SetupGet(c => c.Response).Returns(response.Object);
return httpContext.Object;
}
public async Task<IFormCollection> ReadFormAsync(CancellationToken cancellationToken)
{
if (Form != null)
{
return Form;
}
if (!HasFormContentType)
{
throw new InvalidOperationException("Incorrect Content-Type: " + _request.ContentType);
}
cancellationToken.ThrowIfCancellationRequested();
_request.EnableRewind();
IDictionary<string, StringValues> formFields = null;
var files = new FormFileCollection();
// Some of these code paths use StreamReader which does not support cancellation tokens.
using (cancellationToken.Register(_request.HttpContext.Abort))
{
var contentType = ContentType;
// Check the content-type
if (HasApplicationFormContentType(contentType))
{
var encoding = FilterEncoding(contentType.Encoding);
formFields = await FormReader.ReadFormAsync(_request.Body, encoding, cancellationToken);
}
else if (HasMultipartFormContentType(contentType))
{
var formAccumulator = new KeyValueAccumulator();
var boundary = GetBoundary(contentType);
var multipartReader = new MultipartReader(boundary, _request.Body);
var section = await multipartReader.ReadNextSectionAsync(cancellationToken);
while (section != null)
{
var headers = new HeaderDictionary(section.Headers);
ContentDispositionHeaderValue contentDisposition;
ContentDispositionHeaderValue.TryParse(headers[HeaderNames.ContentDisposition], out contentDisposition);
if (HasFileContentDisposition(contentDisposition))
{
// Find the end
await section.Body.DrainAsync(cancellationToken);
var file = new FormFile(_request.Body, section.BaseStreamOffset.Value, section.Body.Length)
{
Headers = headers,
};
files.Add(file);
}
else if (HasFormDataContentDisposition(contentDisposition))
{
// Content-Disposition: form-data; name="key"
//
// value
var key = HeaderUtilities.RemoveQuotes(contentDisposition.Name);
MediaTypeHeaderValue mediaType;
MediaTypeHeaderValue.TryParse(headers[HeaderNames.ContentType], out mediaType);
var encoding = FilterEncoding(mediaType?.Encoding);
using (var reader = new StreamReader(section.Body, encoding, detectEncodingFromByteOrderMarks: true, bufferSize: 1024, leaveOpen: true))
{
var value = await reader.ReadToEndAsync();
formAccumulator.Append(key, value);
}
}
else
{
System.Diagnostics.Debug.Assert(false, "Unrecognized content-disposition for this section: " + headers[HeaderNames.ContentDisposition]);
}
section = await multipartReader.ReadNextSectionAsync(cancellationToken);
}
formFields = formAccumulator.GetResults();
}
}
// Rewind so later readers don't have to.
_request.Body.Seek(0, SeekOrigin.Begin);
Form = new FormCollection(formFields, files);
return Form;
}
public void Host_EncodesPunyCode()
{
// Arrange
const string expected = "xn--lcalhst-90ae";
var headers = new HeaderDictionary();
var request = CreateRequest(headers);
// Act
request.Host = new HostString("löcalhöst");
// Assert
Assert.Equal(expected, headers["Host"][0]);
}
