public void ComprehendRequestHeaders()
{
string etag = _etag;
string[] ifMatch = _request.GetHeaderUnmodified("If-Match");
if (ifMatch != null)
{
_ifMatchState = PreconditionState.PreconditionFailed;
foreach (var segment in new HeaderSegmentCollection(ifMatch))
{
if (segment.Data.Equals(etag, StringComparison.Ordinal))
{
_ifMatchState = PreconditionState.ShouldProcess;
break;
}
}
}
string[] ifNoneMatch = _request.GetHeaderUnmodified("If-None-Match");
if (ifNoneMatch != null)
{
_ifNoneMatchState = PreconditionState.ShouldProcess;
foreach (var segment in new HeaderSegmentCollection(ifNoneMatch))
{
if (segment.Data.Equals(etag, StringComparison.Ordinal))
{
_ifNoneMatchState = PreconditionState.NotModified;
break;
}
}
}
string ifModifiedSince = _request.GetHeader("If-Modified-Since");
if (ifModifiedSince != null)
{
bool matches = string.Equals(ifModifiedSince, _lastModifiedString, StringComparison.Ordinal);
_ifModifiedSinceState = matches ? PreconditionState.NotModified : PreconditionState.ShouldProcess;
}
string ifUnmodifiedSince = _request.GetHeader("If-Unmodified-Since");
if (ifUnmodifiedSince != null)
{
bool matches = string.Equals(ifModifiedSince, _lastModifiedString, StringComparison.Ordinal);
_ifUnmodifiedSinceState = matches ? PreconditionState.ShouldProcess : PreconditionState.PreconditionFailed;
}
}
public Task Invoke(IDictionary <string, object> env)
{
var request = new OwinRequest(env);
var logger = _kernel.Get <ILogger>();
var requestHeaders = new StringBuilder();
foreach (var header in request.Headers)
{
requestHeaders.AppendLine(header.Key + " = " + request.GetHeader(header.Key));
}
Task task = _next(env);
var response = new OwinResponse(env);
var responseHeaders = new StringBuilder();
foreach (var header in response.Headers)
{
responseHeaders.AppendLine(header.Key + " = " + response.GetHeader(header.Key));
}
logger.Log("URI: " + request.Uri + " " + Environment.NewLine +
"Request Headers: \r\n " + requestHeaders.ToString() + Environment.NewLine +
"Response Headers: \r\n " + responseHeaders.ToString());
return(task);
}
/// <summary>
/// Inspects the environment and checks to see if this is a POST containing the HTML form fields in the login.html page.
/// </summary>
/// <param name="environment"></param>
/// <param name="formsAuthenticationProvider"></param>
public LoginContext(IDictionary <string, object> environment, FormsAuthenticationProvider formsAuthenticationProvider)
{
_environment = environment;
Request = new OwinRequest(environment);
Response = new OwinResponse(environment);
_formsAuthenticationProvider = formsAuthenticationProvider;
_responseStream = Response.Body;
var requestContentType = Request.GetHeader("Content-Type");
_isFormUrlEncodedPost = Request.Method == "POST" && !string.IsNullOrEmpty(requestContentType) && requestContentType.StartsWith("application/x-www-form-urlencoded");
if (_isFormUrlEncodedPost && Request.Body != null)
{
_formData = Request.ReadForm().Result;
var username = _formData["login_username"];
var password = _formData["login_password"];
var rememberMe = _formData["remember_me"] != null && _formData["remember_me"] == "yes";
if (!string.IsNullOrEmpty(username) && !string.IsNullOrEmpty(password))
{
environment["formsauthn.username"] = username;
environment["formsauthn.password"] = password;
environment["formsauthn.remember"] = rememberMe;
}
}
}
public Task Invoke(IDictionary <string, object> environment)
{
OwinRequest request = new OwinRequest(environment);
OwinResponse response = new OwinResponse(environment);
response.ContentType = "text/plain";
string responseText = request.GetHeader("breadcrumbs") + "\r\n"
+ "PathBase: " + request.PathBase + "\r\n"
+ "Path: " + request.Path + "\r\n";
return(response.WriteAsync(responseText));
}
public async Task Invoke(IDictionary <string, object> environment)
{
var request = new OwinRequest(environment);
Uri uri = request.Uri;
// Create a stream for the host and port so we can send the request
Stream stream = await _streamFactory.CreateStream(uri).ConfigureAwait(continueOnCapturedContext: false);
var requestWriter = new StreamWriter(stream);
// Request line
requestWriter.WriteHttpLine("{0} {1} {2}", request.Method, uri.PathAndQuery, request.Protocol);
// Write headers
foreach (var header in request.Headers)
{
requestWriter.WriteHttpLine("{0}: {1}", header.Key, request.GetHeader(header.Key));
}
// End headers
requestWriter.WriteHttpLine();
if (request.Body == null)
{
// End request
requestWriter.WriteHttpLine();
}
// Flush buffered content to the stream async
await requestWriter.FlushAsync().ConfigureAwait(continueOnCapturedContext: false);
if (request.Body != null)
{
// Copy the body to the request
await request.Body.CopyToAsync(stream).ConfigureAwait(continueOnCapturedContext: false);
}
var response = new OwinResponse(environment);
// Parse the response
HttpParser.ParseResponse(stream, (protocol, statusCode, reasonPhrase) =>
{
response.Protocol = protocol;
response.StatusCode = statusCode;
response.ReasonPhrase = reasonPhrase;
},
(key, value) => response.SetHeader(key, value));
// Set the body to the rest of the stream
response.Body = stream;
}
public Task Invoke(IDictionary <string, object> env)
{
var request = new OwinRequest(env);
// This header is set on app harbor since ssl is terminated at the load balancer
var scheme = request.GetHeader("X-Forwarded-Proto");
if (!String.IsNullOrEmpty(scheme))
{
env[OwinConstants.RequestScheme] = scheme;
}
return(_next(env));
}
public static IDictionary<string, string> GetCookies(OwinRequest request)
{
var cookies = request.Get<IDictionary<string, string>>("Owin.Types.Cookies#dictionary");
if (cookies == null)
{
cookies = new Dictionary<string, string>(StringComparer.Ordinal);
request.Set("Owin.Types.Cookies#dictionary", cookies);
}
var text = request.GetHeader("Cookie");
if (request.Get<string>("Owin.Types.Cookies#text") != text)
{
cookies.Clear();
ParseDelimited(text, SemicolonAndComma, AddCookieCallback, cookies);
request.Set("Owin.Types.Cookies#text", text);
}
return cookies;
}
public static IDictionary <string, string> GetCookies(OwinRequest request)
{
var cookies = request.Get <IDictionary <string, string> >("Owin.Types.Cookies#dictionary");
if (cookies == null)
{
cookies = new Dictionary <string, string>(StringComparer.Ordinal);
request.Set("Owin.Types.Cookies#dictionary", cookies);
}
var text = request.GetHeader("Cookie");
if (request.Get <string>("Owin.Types.Cookies#text") != text)
{
cookies.Clear();
ParseDelimited(text, SemicolonAndComma, AddCookieCallback, cookies);
request.Set("Owin.Types.Cookies#text", text);
}
return(cookies);
}
internal static bool IsPayloadHashPresent(this OwinRequest request)
{
string authorization = request.GetHeader(HawkConstants.AuthorizationHeaderName);
if (!String.IsNullOrWhiteSpace(authorization))
{
// TODO - Replace the following block with
// return ArtifactsContainer.IsPayloadHashPresent(parameter);
// once OWIN is part of tt.idm
string parameter = AuthenticationHeaderValue.Parse(authorization).Parameter;
string pattern = String.Format(@"({0})=""([^""\\]*)""\s*(?:,\s*|$)", "hash");
if (!String.IsNullOrWhiteSpace(parameter))
{
if (System.Text.RegularExpressions.Regex.IsMatch(parameter, pattern))
{
return(true);
}
}
}
return(false);
}
public OwinRequestMessage(OwinRequest request)
: base(request.Body, request.GetHeader(HawkConstants.ContentTypeHeaderName))
{
this.request = request;
}
private bool IsIE(IDictionary <string, object> environment)
{
OwinRequest request = new OwinRequest(environment);
return(request.GetHeader("User-Agent").Contains("MSIE"));
}
