public static IUrlHelper GetStaticUrlHelper(this IWebHost host, Uri baseUri)
{
HttpContext httpContext = new DefaultHttpContext()
{
RequestServices = host.Services,
Request =
{
Scheme = baseUri.Scheme,
Host = HostString.FromUriComponent(baseUri),
PathBase = PathString.FromUriComponent(baseUri),
},
};
var captured = host.Services.GetRequiredService <Capture>();
var actionContext = new ActionContext
{
HttpContext = httpContext,
RouteData = new RouteData {
Routers = { captured.Router }
},
ActionDescriptor = new ActionDescriptor(),
};
return(new UrlHelper(actionContext));
}
public async Task When_the_project_is_valid_is_should_return_a_CreatedResult_with_the_new_project_id()
{
var projectManagerService = new Mock <IProjectManagerService>();
projectManagerService.Setup(pms => pms.Handle(It.IsAny <CreateProjectCommand>()))
.Returns(Task.FromResult(CommandResult.Success(Guid.Parse("11111111-1111-1111-1111-111111111111"))));
var subject = new ProjectsController(
projectManagerService.Object,
Mock.Of <IProjectRepository>(),
Mock.Of <ILogger <ProjectsController> >());
subject.ControllerContext = new ControllerContext
{
HttpContext = new DefaultHttpContext()
};
subject.ControllerContext.HttpContext.Request.Scheme = "http";
subject.ControllerContext.HttpContext.Request.Host = HostString.FromUriComponent("localhost:5000");
subject.ControllerContext.HttpContext.Request.Path = "/";
var result =
Assert.IsType <CreatedResult>(
await subject.CreateProject(new CreateProjectDto("Valid project", "Desc", "VP", "Kanban")));
Assert.EndsWith("/11111111-1111-1111-1111-111111111111", result.Location);
}
public void VerifyFromUriComponentUri(string input, string expected)
{
Uri uri = new Uri("http://" + input);
HostString host = HostString.FromUriComponent(uri);
Assert.Equal(expected, host.Value, StringComparer.Ordinal);
}
/// <inheritdoc />
public IAndHttpRequestBuilder WithLocation(Uri location)
{
Uri uri;
if (location.IsAbsoluteUri)
{
uri = new Uri(location.OriginalString, UriKind.Absolute);
}
else
{
uri = new Uri(new Uri("http://localhost"), location);
}
if (location.IsAbsoluteUri)
{
this
.WithHost(HostString.FromUriComponent(uri))
.WithScheme(uri.Scheme);
}
return(this
.WithPathBase(PathString.FromUriComponent(uri))
.WithPath(PathString.FromUriComponent(uri.AbsolutePath))
.WithQueryString(QueryString.FromUriComponent(uri.Query)));
}
public void StandardRequests()
{
HttpContext context = new DefaultHttpContext();
context.Response.Body = new MemoryStream();
Uri uri = new Uri("http://localhost/info/StandardRequestTest");
context.Request.Scheme = "http";
context.Request.Host = HostString.FromUriComponent(uri);
context.Request.Path = PathString.FromUriComponent(uri);
context.Request.Method = "GET";
object expected = new { Message = "OK" };
API.GET("/info/{firstParam}", x => expected, x => x.Parameters.firstParam == "StandardRequestTest");
var processed = API.Resolve(context).Result;
context.Response.Body.Seek(0, SeekOrigin.Begin);
var response = DeserializeFromStream(context.Response.Body);
Assert.IsTrue(JsonConvert.SerializeObject(expected) == JsonConvert.SerializeObject(response));
}
public void OnAuthorization_RedirectsToHttpsEndpoint_ForCustomSslPort(
string url,
int?sslPort,
string expectedUrl)
{
// Arrange
var options = Options.Create(new MvcOptions());
var uri = new Uri(url);
var requestContext = new DefaultHttpContext();
requestContext.RequestServices = CreateServices(sslPort);
requestContext.Request.Scheme = "http";
requestContext.Request.Method = "GET";
requestContext.Request.Host = HostString.FromUriComponent(uri);
requestContext.Request.Path = PathString.FromUriComponent(uri);
requestContext.Request.QueryString = QueryString.FromUriComponent(uri);
var authContext = CreateAuthorizationContext(requestContext);
var attr = new RequireHttpsAttribute();
// Act
attr.OnAuthorization(authContext);
// Assert
Assert.NotNull(authContext.Result);
var result = Assert.IsType <RedirectResult>(authContext.Result);
Assert.Equal(expectedUrl, result.Url);
}
public async Task Office_Create_ReturnsCreated()
{
var request = new Mock <HttpRequest>();
request.Setup(x => x.Scheme).Returns("https");
request.Setup(x => x.Host).Returns(HostString.FromUriComponent("localhost:8000"));
var httpContext = Mock.Of <HttpContext>(_ =>
_.Request == request.Object
);
var controllerContext = new ControllerContext()
{
HttpContext = httpContext,
};
_controller.ControllerContext = controllerContext;
var response = await _controller.Create(new CreateOfficeRequest { Name = "New Office" });
var result = response as CreatedResult;
var resultValue = result.Value as OfficeResponse;
Assert.That(result.StatusCode, Is.EqualTo(201));
Assert.That(resultValue.Name, Is.EqualTo("New Office"));
Assert.That(resultValue.Id, Is.Not.Null);
}
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
app.UseStaticFiles();
app.Use(async(context, next) =>
{
context.Request.Host = HostString.FromUriComponent(new Uri("http://localhost:54660/"));
await next.Invoke();
});
//var options = new ForwardedHeadersOptions
//{
// ForwardedHeaders = ForwardedHeaders.XForwardedFor | ForwardedHeaders.XForwardedProto | ForwardedHeaders.XForwardedHost,
// ForwardLimit = 1
//};
//options.KnownNetworks.Clear();
//options.KnownProxies.Clear();
//app.UseForwardedHeaders(options);
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
app.UseExceptionHandler("/Home/Error");
}
app.UseAuthentication();
app.UseMvc(routes =>
{
routes.MapRoute(
name: "default",
template: "MvcClient/{controller=Home}/{action=index}/{id?}");
});
}
/// <summary>
/// Creates, configures, sends, and returns a <see cref="HttpContext"/>. This completes as soon as the response is started.
/// </summary>
/// <returns></returns>
public async Task <HttpContext> SendAsync(Action <HttpContext> configureContext, CancellationToken cancellationToken = default)
{
if (configureContext == null)
{
throw new ArgumentNullException(nameof(configureContext));
}
var builder = new HttpContextBuilder(_application);
builder.Configure(context =>
{
var request = context.Request;
request.Scheme = BaseAddress.Scheme;
request.Host = HostString.FromUriComponent(BaseAddress);
if (BaseAddress.IsDefaultPort)
{
request.Host = new HostString(request.Host.Host);
}
var pathBase = PathString.FromUriComponent(BaseAddress);
if (pathBase.HasValue && pathBase.Value.EndsWith("/"))
{
pathBase = new PathString(pathBase.Value.Substring(0, pathBase.Value.Length - 1));
}
request.PathBase = pathBase;
});
builder.Configure(configureContext);
return(await builder.SendAsync(cancellationToken).ConfigureAwait(false));
}
/// <summary>
/// Returns the origin in unicode, and not in punycode (if we have a unicode hostname)
/// </summary>
public static string GetUnicodeOrigin(this IServerUrls urls)
{
var split = urls.Origin.Split(new[] { "://" }, StringSplitOptions.RemoveEmptyEntries);
var scheme = split.First();
var host = HostString.FromUriComponent(split.Last()).Value;
return(scheme + "://" + host);
}
public override void Process(TagHelperContext context, TagHelperOutput output)
{
base.Process(context, output);
if (context.AllAttributes.TryGetAttribute("href", out var attribute))
{
var content = attribute.Value switch
{
string value => value,
HtmlString htmlString => htmlString.Value,
_ => null
};
if (content != null)
{
if (content.StartsWith("//", StringComparison.OrdinalIgnoreCase))
{
content = ViewContext.HttpContext.Request.Scheme + ":" + content;
}
// ignore same site
if (!content.Contains("://", StringComparison.OrdinalIgnoreCase))
{
return;
}
// ignore same site
if (Uri.TryCreate(content, UriKind.Absolute, out var uri))
{
var host = HostString.FromUriComponent(uri);
if (host == ViewContext.HttpContext.Request.Host)
{
return;
}
}
}
}
if (context.AllAttributes.TryGetAttribute("rel", out attribute))
{
var content = attribute.Value switch
{
string value => value,
HtmlString htmlString => htmlString.Value,
_ => null
};
if (content != null && !content.Contains("noopener", StringComparison.OrdinalIgnoreCase))
{
output.Attributes.SetAttribute("rel", content + " noopener");
}
}
else
{
output.Attributes.Add("rel", "noopener");
}
}
}
public UriHelper(Uri uri)
{
Scheme = uri.Scheme;
Host = HostString.FromUriComponent(uri);
// Assume nothing is being put in PathBase
Path = PathString.FromUriComponent(uri);
Query = QueryString.FromUriComponent(uri);
Fragment = FragmentString.FromUriComponent(uri);
}
/// <summary>
/// Builds the HTTP context.
/// </summary>
/// <param name="routeEndpoint">The route endpoint.</param>
/// <param name="requestInfo">The request information.</param>
/// <param name="routeValues">The route values.</param>
/// <returns>The HTTP context to invoke a request delegate with</returns>
private HttpContext BuildHttpContext(RouteEndpoint routeEndpoint, RequestInfo requestInfo, RouteValueDictionary routeValues)
{
DefaultHttpContext httpContext = new DefaultHttpContext();
httpContext.Features.Set <IEndpointFeature>(new HttpContextFeatures.EndpointFeature(routeEndpoint));
httpContext.Features.Set <IRoutingFeature>(new HttpContextFeatures.RoutingFeature(routeValues));
httpContext.RequestServices = _serviceProvider;
if (_httpContextAccessor.HttpContext != null)
{
httpContext.User = _httpContextAccessor.HttpContext.User;
}
string[] relativeUriComponents = requestInfo.RelativeUri.Split(QuerySeparator);
Uri requestUri = new UriBuilder(_batchRequestOptions.RequestHost)
{
Path = relativeUriComponents[0],
Query = relativeUriComponents.Length > 1 ? relativeUriComponents[1] : string.Empty,
}.Uri;
httpContext.Request.Scheme = requestUri.Scheme;
httpContext.Request.Host = HostString.FromUriComponent(requestUri);
httpContext.Request.Path = PathString.FromUriComponent(requestUri);
httpContext.Request.QueryString = QueryString.FromUriComponent(requestUri);
httpContext.Request.Query = new QueryCollection(QueryHelpers.ParseQuery(requestUri.Query));
httpContext.Request.ContentType = requestInfo.ContentType;
httpContext.Request.Method = requestInfo.Method.ToUpper();
httpContext.Request.Protocol = _batchRequestOptions.DefaultProtocol;
httpContext.Request.IsHttps = httpContext.Request.Scheme == Uri.UriSchemeHttps;
httpContext.Response.Body = new MemoryStream();
if (!string.IsNullOrEmpty(requestInfo.Body))
{
byte[] bodyData;
if (requestInfo.Base64Encoded)
{
try
{
bodyData = Convert.FromBase64String(requestInfo.Body);
}
catch (FormatException)
{
throw new Base64FormatException()
{
Base64 = requestInfo.Body
};
}
}
else
{
bodyData = Encoding.UTF8.GetBytes(requestInfo.Body);
}
httpContext.Request.Body = new MemoryStream(bodyData);
}
return(httpContext);
}
public async Task <WebSocket> ConnectAsync(Uri uri, CancellationToken cancellationToken)
{
WebSocketFeature webSocketFeature = null;
var contextBuilder = new HttpContextBuilder(_application, AllowSynchronousIO, PreserveExecutionContext);
contextBuilder.Configure(context =>
{
var request = context.Request;
var scheme = uri.Scheme;
scheme = (scheme == "ws") ? "http" : scheme;
scheme = (scheme == "wss") ? "https" : scheme;
request.Scheme = scheme;
if (!request.Host.HasValue)
{
request.Host = uri.IsDefaultPort
? new HostString(HostString.FromUriComponent(uri).Host)
: HostString.FromUriComponent(uri);
}
request.Path = PathString.FromUriComponent(uri);
request.PathBase = PathString.Empty;
if (request.Path.StartsWithSegments(_pathBase, out var remainder))
{
request.Path = remainder;
request.PathBase = _pathBase;
}
request.QueryString = QueryString.FromUriComponent(uri);
request.Headers.Add(HeaderNames.Connection, new string[] { "Upgrade" });
request.Headers.Add(HeaderNames.Upgrade, new string[] { "websocket" });
request.Headers.Add(HeaderNames.SecWebSocketVersion, new string[] { "13" });
request.Headers.Add(HeaderNames.SecWebSocketKey, new string[] { CreateRequestKey() });
if (SubProtocols.Any())
{
request.Headers.Add(HeaderNames.SecWebSocketProtocol, SubProtocols.ToArray());
}
request.Body = Stream.Null;
// WebSocket
webSocketFeature = new WebSocketFeature(context);
context.Features.Set <IHttpWebSocketFeature>(webSocketFeature);
ConfigureRequest?.Invoke(context.Request);
});
var httpContext = await contextBuilder.SendAsync(cancellationToken);
if (httpContext.Response.StatusCode != StatusCodes.Status101SwitchingProtocols)
{
throw new InvalidOperationException("Incomplete handshake, status code: " + httpContext.Response.StatusCode);
}
if (webSocketFeature.ClientWebSocket == null)
{
throw new InvalidOperationException("Incomplete handshake");
}
return(webSocketFeature.ClientWebSocket);
}
public void CreateInstances()
{
_httpContext = new DefaultHttpContext();
_httpContext.Request.Scheme = "http";
_httpContext.Request.Host = HostString.FromUriComponent("unit test");
_httpContext.Request.QueryString = QueryString.Create("querystring", "param");
_httpContext.Response.Body = new MemoryStream();
}
private async Task <HttpRequest> GetRequest(HttpContext context, HttpRequestMessage request)
{
var requestContent = request.Content ?? new StreamContent(Stream.Null);
var body = await requestContent.ReadAsStreamAsync();
PathString pathBase = new PathString("");
var req = context.Request;
req.Protocol = "HTTP/" + request.Version.ToString(fieldCount: 2);
req.Method = request.Method.ToString();
req.Scheme = request.RequestUri.Scheme;
foreach (var header in request.Headers)
{
req.Headers.Append(header.Key, header.Value.ToArray());
}
if (req.Host == null || !req.Host.HasValue)
{
// If Host wasn't explicitly set as a header, let's infer it from the Uri
req.Host = HostString.FromUriComponent(request.RequestUri);
if (request.RequestUri.IsDefaultPort)
{
req.Host = new HostString(req.Host.Host);
}
}
req.Path = PathString.FromUriComponent(request.RequestUri);
req.PathBase = PathString.Empty;
if (req.Path.StartsWithSegments(pathBase, out var remainder))
{
req.Path = remainder;
req.PathBase = pathBase;
}
req.QueryString = QueryString.FromUriComponent(request.RequestUri);
if (requestContent != null)
{
foreach (var header in requestContent.Headers)
{
req.Headers.Append(header.Key, header.Value.ToArray());
}
}
if (body.CanSeek)
{
// This body may have been consumed before, rewind it.
body.Seek(0, SeekOrigin.Begin);
}
req.Body = body;
return(req);
}
public static ProxyOptions GetProxyOptions(this IConfigurationSection config)
{
// Host & AppendQuery properties will not bind correctly
// due to objects being ctor sealed
var proxyOptions = config.Get <ProxyOptions>();
proxyOptions.Host = HostString.FromUriComponent(config["Host"]);
proxyOptions.AppendQuery = QueryString.FromUriComponent(config["AppendQuery"]);
return(proxyOptions);
}
/// <summary>
/// Adds X-Forwarded-* headers to the upstream websocket request
/// with an additional PathBase parameter.
/// </summary>
public static void AddXForwardedHeaders(this WebSocketClientOptions options)
{
var protocol = options.HttpContext.Request.Scheme;
var @for = options.HttpContext.Connection.RemoteIpAddress;
var host = options.HttpContext.Request.Headers[HeaderNames.Host];
var hostString = HostString.FromUriComponent(host);
var pathBase = options.HttpContext.Request.PathBase.Value;
options.AddXForwardedHeaders(@for, hostString, protocol, pathBase);
}
public void DeleteViewResultWithViewModel()
{
//Won't work, due to it use global Session["ShoppingCartSession"]
// Arrange
ShoppingCart shoppingCart = new ShoppingCart()
{
ProductId = 1,
Unit = 1
};
List <ShoppingCart> shoppingCartList = new List <ShoppingCart>();
var mockLogger = new Mock <ILogger <HomeController> >();
var mockCateRepo = new Mock <ICategoryRepository>();
var mockProdRepo = new Mock <IProductRepository>();
var session = new MockHttpSession();
Mock <HttpContext> mockHttpContext = new Mock <HttpContext>();
MockHttpSession mockSession = new MockHttpSession();
mockSession["ShoppingCartSession"] = new List <ShoppingCart> {
shoppingCart
};
var request = new Mock <HttpRequest>();
request.Setup(x => x.Scheme).Returns("http");
request.Setup(x => x.Host).Returns(HostString.FromUriComponent("http://localhost:44331"));
request.Setup(x => x.PathBase).Returns(PathString.FromUriComponent("/home"));
var httpContext = Moq.Mock.Of <HttpContext>(_ =>
_.Request == request.Object
);
//Controller needs a controller context
var controllerContext = new ControllerContext()
{
HttpContext = httpContext,
};
//assign context to controller
var controller = new HomeController(mockLogger.Object, mockProdRepo.Object, mockCateRepo.Object)
{
ControllerContext = controllerContext,
};
//Action
//var result = controller.RemoveFromCart(1);
//
//var viewResult = Assert.IsType<ViewResult>(result);
//Assert.Null(viewResult);
//Assert.Null(viewResult.ViewData.Model);
//Assert.IsType<ShoppingCart>(viewResult.ViewData.Model);
}
public static IOwinRequest SetUrl(this IOwinRequest self, string url)
{
Uri uri = new Uri(url);
self.Scheme = uri.Scheme;
self.Host = HostString.FromUriComponent(uri);
self.PathBase = new PathString("");
self.QueryString = QueryString.FromUriComponent(uri);
self.Path = PathString.FromUriComponent(uri);
return(self);
}
public static IOwinRequest CreateRequest(string url)
{
var uriBuilder = new UriBuilder(url);
var request = new OwinRequest();
request.Host = HostString.FromUriComponent(uriBuilder.Uri);
request.Path = PathString.FromUriComponent(uriBuilder.Uri);
request.PathBase = PathString.Empty;
request.Scheme = uriBuilder.Scheme;
request.QueryString = QueryString.FromUriComponent(uriBuilder.Uri);
return(request);
}
public async Task Csp_UpgradeInsecureRequestsConformantUa_RedirectsToHttps()
{
const string path = "/CspUpgradeInsecureRequests";
var expectedLocationUri = UriHelper.BuildAbsolute("https", HostString.FromUriComponent("localhost"), PathString.FromUriComponent(path));
_httpClient.DefaultRequestHeaders.Add("Upgrade-Insecure-Requests", "1");
var response = await _httpClient.GetAsync(path);
Assert.Equal(HttpStatusCode.RedirectKeepVerb, response.StatusCode);
Assert.Equal("Upgrade-Insecure-Requests", response.Headers.Vary.Single());
Assert.Equal(expectedLocationUri, response.Headers.Location.AbsoluteUri);
}
public static ForwardContext ApplyXForwardedHeaders(this ForwardContext forwardContext)
{
var headers = forwardContext.UpstreamRequest.Headers;
var protocol = forwardContext.HttpContext.Request.Scheme;
var @for = forwardContext.HttpContext.Connection.RemoteIpAddress;
var host = forwardContext.HttpContext.Request.Headers["Host"];
var hostString = HostString.FromUriComponent(host);
var pathBase = forwardContext.HttpContext.Request.PathBase.Value;
headers.ApplyXForwardedHeaders(@for, hostString, protocol, pathBase);
return(forwardContext);
}
/// <summary>
/// Seperates the given absolute URI string into components. Assumes no PathBase.
/// </summary>
/// <param name="uri">A string representation of the uri.</param>
/// <param name="scheme">http, https, etc.</param>
/// <param name="host">The host portion of the uri normally included in the Host header. This may include the port.</param>
/// <param name="path">The portion of the request path that identifies the requested resource.</param>
/// <param name="query">The query, if any.</param>
/// <param name="fragment">The fragment, if any.</param>
public static void FromAbsolute(
string uri,
out string scheme,
out HostString host,
out PathString path,
out QueryString query,
out FragmentString fragment)
{
if (uri == null)
{
throw new ArgumentNullException(nameof(uri));
}
// Satisfy the out parameters
path = new PathString();
query = new QueryString();
fragment = new FragmentString();
var startIndex = uri.IndexOf(SchemeDelimiter);
if (startIndex < 0)
{
throw new FormatException("No scheme delimiter in uri.");
}
scheme = uri.Substring(0, startIndex);
// PERF: Calculate the end of the scheme for next IndexOf
startIndex += SchemeDelimiter.Length;
var searchIndex = -1;
var limit = uri.Length;
if ((searchIndex = uri.IndexOf(Pound, startIndex)) >= 0 && searchIndex < limit)
{
fragment = FragmentString.FromUriComponent(uri.Substring(searchIndex));
limit = searchIndex;
}
if ((searchIndex = uri.IndexOf(QuestionMark, startIndex)) >= 0 && searchIndex < limit)
{
query = QueryString.FromUriComponent(uri.Substring(searchIndex, limit - searchIndex));
limit = searchIndex;
}
if ((searchIndex = uri.IndexOf(ForwardSlash, startIndex)) >= 0 && searchIndex < limit)
{
path = PathString.FromUriComponent(uri.Substring(searchIndex, limit - searchIndex));
limit = searchIndex;
}
host = HostString.FromUriComponent(uri.Substring(startIndex, limit - startIndex));
}
public void GlobalSetup()
{
_serviceProvider = new ServiceCollection()
.AddLogging()
.AddOpenTracingCoreServices(builder =>
{
builder.AddAspNetCore();
builder.AddBenchmarkTracer(Mode);
})
.BuildServiceProvider();
var diagnosticManager = _serviceProvider.GetRequiredService <DiagnosticManager>();
diagnosticManager.Start();
// Request
_httpContext = new DefaultHttpContext();
var request = _httpContext.Request;
Uri requestUri = new Uri("http://www.example.com/foo");
request.Protocol = "HTTP/1.1";
request.Method = HttpMethods.Get;
request.Scheme = requestUri.Scheme;
request.Host = HostString.FromUriComponent(requestUri);
if (requestUri.IsDefaultPort)
{
request.Host = new HostString(request.Host.Host);
}
request.PathBase = PathString.Empty;
request.Path = PathString.FromUriComponent(requestUri);
request.QueryString = QueryString.FromUriComponent(requestUri);
// Hosting Application
var diagnosticSource = new DiagnosticListener("Microsoft.AspNetCore");
_features = new FeatureCollection();
_features.Set <IHttpRequestFeature>(new HttpRequestFeature());
var httpContextFactory = Substitute.For <IHttpContextFactory>();
httpContextFactory.Create(_features).Returns(_httpContext);
_hostingApplication = new HostingApplication(
ctx => Task.FromResult(0),
_serviceProvider.GetRequiredService <ILogger <RequestDiagnosticsBenchmark> >(),
diagnosticSource,
httpContextFactory);
}
public Task Invoke(HttpContext context)
{
if ((_options.ForwardedOptions & ForwardedHeaders.XForwardedFor) != 0)
{
var xForwardedForHeaderValue = context.Request.Headers.GetCommaSeparatedValues(XForwardedForHeaderName);
if (xForwardedForHeaderValue != null && xForwardedForHeaderValue.Length > 0)
{
IPAddress ipFromHeader;
if (IPAddress.TryParse(xForwardedForHeaderValue[0], out ipFromHeader))
{
var remoteIPString = context.Connection.RemoteIpAddress?.ToString();
if (!string.IsNullOrEmpty(remoteIPString))
{
context.Request.Headers[XOriginalIPName] = remoteIPString;
}
context.Connection.RemoteIpAddress = ipFromHeader;
}
}
}
if ((_options.ForwardedOptions & ForwardedHeaders.XForwardedHost) != 0)
{
var xForwardHostHeaderValue = context.Request.Headers[XForwardedHostHeaderName];
if (!string.IsNullOrEmpty(xForwardHostHeaderValue))
{
var hostString = context.Request.Host.ToString();
if (!string.IsNullOrEmpty(hostString))
{
context.Request.Headers[XOriginalHostName] = hostString;
}
context.Request.Host = HostString.FromUriComponent(xForwardHostHeaderValue);
}
}
if ((_options.ForwardedOptions & ForwardedHeaders.XForwardedProto) != 0)
{
var xForwardProtoHeaderValue = context.Request.Headers[XForwardedProtoHeaderName];
if (!string.IsNullOrEmpty(xForwardProtoHeaderValue))
{
if (!string.IsNullOrEmpty(context.Request.Scheme))
{
context.Request.Headers[XOriginalProtoName] = context.Request.Scheme;
}
context.Request.Scheme = xForwardProtoHeaderValue;
}
}
return(_next(context));
}
public UpstreamHost(
string uri,
uint weight = 1)
{
if (string.IsNullOrWhiteSpace(uri))
{
throw new ArgumentException("Value cannot be null or whitespace.", nameof(uri));
}
var upstreamUri = new Uri(uri);
Scheme = upstreamUri.Scheme;
Host = HostString.FromUriComponent(upstreamUri);
PathBase = PathString.FromUriComponent(upstreamUri);
Weight = weight;
}
/// <summary>
/// Generates a string from the given absolute or relative Uri that is appropriately encoded for use in
/// HTTP headers. Note that a unicode host name will be encoded as punycode.
/// </summary>
/// <param name="uri"></param>
/// <returns></returns>
public static string Encode(Uri uri)
{
if (uri.IsAbsoluteUri)
{
return(Encode(
scheme: uri.Scheme,
host: HostString.FromUriComponent(uri),
pathBase: PathString.FromUriComponent(uri),
query: QueryString.FromUriComponent(uri),
fragment: FragmentString.FromUriComponent(uri)));
}
else
{
return(uri.GetComponents(UriComponents.SerializationInfoString, UriFormat.UriEscaped));
}
}
private void SetRequest()
{
var request = _httpContext.Request;
Uri requestUri = new Uri("http://www.example.com/foo");
request.Protocol = "HTTP/1.1";
request.Method = HttpMethods.Get;
request.Scheme = requestUri.Scheme;
request.Host = HostString.FromUriComponent(requestUri);
if (requestUri.IsDefaultPort)
{
request.Host = new HostString(request.Host.Host);
}
request.PathBase = PathString.Empty;
request.Path = PathString.FromUriComponent(requestUri);
request.QueryString = QueryString.FromUriComponent(requestUri);
}
public void GetUrlFromFeatureConfiguration_NoFeatureSpecified_ResultsInDefaultUrl()
{
// Arrange
var httpContext = new DefaultHttpContext();
var randomurl = "http://" + Guid.NewGuid();
target.featuresRoot = new Microsoft.Azure.IoTSolutions.ReverseProxy.Models.Config.FeaturesRoot
{
DefaultHost = new Microsoft.Azure.IoTSolutions.ReverseProxy.Models.Config.FeaturesConfig
{
Features = new Dictionary <string, Feature>
{
{
FeaturesManager.DEFAULTFEATURE, new Feature
{
Name = FeaturesManager.DEFAULTFEATURE,
Urls = new StringNode
{
Children = new Dictionary <string, StringNode>
{
{
FeaturesManager.DEFAULTURLKEY, new StringNode
{
Children = new Dictionary <string, StringNode>(),
Value = randomurl
}
}
}
}
}
}
}
},
Hostnames = new Dictionary <string, FeaturesConfig>()
};
httpContext.Request.Scheme = "http";
httpContext.Request.Host = HostString.FromUriComponent(Guid.NewGuid().ToString());
// Act
var result = target.GetUrlFromFeatureConfiguration(null, httpContext.Request);
// Assert
Assert.Equal(randomurl, result?.toUrl);
}