public void When_matcher_is_asked_to_return_a_request_handler_that_is_set_up_that_handler_is_returned() { const string testResponse = "test-response"; var routeHandlers = new Dictionary <RouteBase, Func <OwinRequest, object> > { { new RegexRoute("foo/"), r => { return(testResponse); } } }; var matcher = new RouteMatcher(routeHandlers); var request = OwinRequest.Create(); request.Path = "foo/"; Assert.That(matcher.HasMatch(request), Is.True); var handler = matcher.GetMatch(request); Assert.That(handler(request).ToString(), Is.EqualTo(testResponse)); }
private static OwinRequest Create(Action <OwinRequest> setup) { var request = OwinRequest.Create(); setup(request); return(request); }
/// <summary> /// Reads and parses the request body as a form. /// </summary> /// <returns>The parsed form data.</returns> internal static IFormCollection ReadForm(this OwinRequest request) { var form = request.Get <IFormCollection>("Microsoft.Owin.Form#collection"); if (form == null) { request.Body.Seek(0, SeekOrigin.Begin); string text; // Don't close, it prevents re-winding. using (var reader = new StreamReader(request.Body, Encoding.UTF8, detectEncodingFromByteOrderMarks: true, bufferSize: 4 * 1024, leaveOpen: true)) { text = reader.ReadToEnd(); } // re-wind for the next caller request.Body.Seek(0, SeekOrigin.Begin); form = OwinHelpers.GetForm(text); request.Set("Microsoft.Owin.Form#collection", form); } return(form); }
public RequestHandler(IDictionary <string, object> owinEnvironment) { Console.WriteLine("RequestHandler ctor"); OwinRequest req = new OwinRequest(owinEnvironment); Console.WriteLine(req.Uri.AbsoluteUri); }
/// <summary> /// Extracts the username and password from a basic Authorize header. Returns false if the header /// is missing or badly formatted. /// </summary> /// <param name="request"></param> /// <param name="userName"></param> /// <param name="password"></param> /// <returns></returns> private bool ExtractCredentials(OwinRequest request, ref string userName, ref string password) { var result = false; var authorizationMime64 = request.Headers["Authorization"] ?? ""; if (authorizationMime64 != "") { const string basicScheme = "Basic "; if (authorizationMime64.StartsWith(basicScheme, StringComparison.OrdinalIgnoreCase)) { var usernamePassword = authorizationMime64.Substring(basicScheme.Length).Trim(); var authorizationBytes = Convert.FromBase64String(usernamePassword); var authorization = Encoding.UTF8.GetString(authorizationBytes); var separatorPosn = authorization.IndexOf(':'); if (separatorPosn != -1) { userName = authorization.Substring(0, separatorPosn); password = authorization.Substring(separatorPosn + 1); result = userName.Length > 0; } } } return(result); }
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); }
public void ShouldFailOnInvalidAuthFormat() { var logger = new Logger(); var builder = new AppBuilderFactory().Create(); builder.SetLoggerFactory(new LoggerFactory(logger)); var request = OwinRequest.Create(); request.Set <Action <Action <object>, object> >("server.OnSendingHeaders", RegisterForOnSendingHeaders); request.Method = "get"; request.SetUri(new Uri("http://example.com:8080/resource/4?filter=a")); request.SetHeader("Authorization", new string[] { "Hawk " + "" }); var response = new OwinResponse(request); var middleware = new HawkAuthenticationMiddleware( new AppFuncTransition((env) => { response.StatusCode = 401; return(Task.FromResult <object>(null)); }), builder, new HawkAuthenticationOptions { Credentials = GetCredential } ); middleware.Invoke(request, response); Assert.AreEqual(401, response.StatusCode); Assert.AreEqual("Invalid header format", logger.Messages[0]); }
public void ReadFromStreamTwice() { var stream = new MemoryStream(); var writer = new StreamWriter(stream); writer.Write(OriginalFormsString); writer.Flush(); stream.Seek(0, SeekOrigin.Begin); IOwinRequest request = new OwinRequest(); request.Body = stream; IFormCollection form = request.ReadFormAsync().Result; Assert.Equal("v1", form.Get("q1")); Assert.Equal("v2,b", form.Get("Q2")); Assert.Equal("v3,v4", form.Get("q3")); Assert.Null(form.Get("q4")); Assert.Equal("v5,v5", form.Get("Q5")); form = request.ReadFormAsync().Result; Assert.Equal("v1", form.Get("q1")); Assert.Equal("v2,b", form.Get("Q2")); Assert.Equal("v3,v4", form.Get("q3")); Assert.Null(form.Get("q4")); Assert.Equal("v5,v5", form.Get("Q5")); }
public static Task Invoke(IOwinContext context, Func <IOwinContext, Task> next) { var request = new OwinRequest(context.Environment); var segments = request.Uri.Segments; var raw = String.Join(null, segments); var matches = from builder in _builders from key in builder.RoutesKeys let matcher = new Regex(String.Format("^/{0}/{1}/?$", builder.Prefix, ToRegex(key))) let match = matcher.Match(raw) where match.Success let groups = match .Groups .Cast <Group>() .Index() let @params = (from g in groups select new KeyValuePair <string, string>( matcher.GroupNameFromNumber(g.Key), g.Value.Value)) select new { Params = @params.Skip(1).ToDictionary(k => k.Key, v => v.Value), Route = builder.Routes[key] }; var invocation = matches.FirstOrDefault(); return(invocation != null ? invocation.Route.Invoke(context.Environment, invocation.Params) : next(context)); }
public Task Invoke(IDictionary <string, object> environment) { OwinRequest request = new OwinRequest(environment); request.AddHeader("breadcrumbs", _breadcrumb); return(_next(environment)); }
public ServerRequest(IDictionary <string, object> environment) { _request = new OwinRequest(environment); // Cache user because AspNetWebSocket.CloseOutputAsync clears it. We need it during Hub.OnDisconnected _user = _request.User; }
public Task Invoke(IDictionary <string, object> env) { try { var request = new OwinRequest(env); var path = request.Path.ToString(); logger.Info("execute action: {0};", path); IListenerHandler handler; if (handlers.TryGetValue(path, out handler)) { //var message = string.Format("handler for url '{0}' is not found", localPath); return(handler.ProcessRequest(request)); } } catch (Exception ex) { var tcs = new TaskCompletionSource <object>(); tcs.SetException(ex); logger.ErrorException("", ex); return(tcs.Task); } return(next(env)); }
public static string GetForwardedScheme(OwinRequest request) { var headers = request.Headers; var forwardedSsl = GetHeader(headers, "X-Forwarded-Ssl"); if (forwardedSsl != null && string.Equals(forwardedSsl, "on", StringComparison.OrdinalIgnoreCase)) { return "https"; } var forwardedScheme = GetHeader(headers, "X-Forwarded-Scheme"); if (!string.IsNullOrWhiteSpace(forwardedScheme)) { return forwardedScheme; } var forwardedProto = GetHeaderSplit(headers, "X-Forwarded-Proto"); if (forwardedProto != null) { forwardedScheme = forwardedProto.FirstOrDefault(); if (!string.IsNullOrWhiteSpace(forwardedScheme)) { return forwardedScheme; } } return request.Scheme; }
public void ShouldSkipAuthOnWrongAuthScheme() { var builder = new AppBuilderFactory().Create(); var request = OwinRequest.Create(); request.Set <Action <Action <object>, object> >("server.OnSendingHeaders", RegisterForOnSendingHeaders); request.Method = "get"; request.SetUri(new Uri("http://example.com:8080/resource/4?filter=a")); request.SetHeader("Authorization", new string[] { "Basic " }); var response = new OwinResponse(request); var middleware = new HawkAuthenticationMiddleware( new AppFuncTransition((env) => { response.StatusCode = 200; return(Task.FromResult <object>(null)); }), builder, new HawkAuthenticationOptions { Credentials = GetCredential } ); middleware.Invoke(request, response); Assert.IsNotNull(response); Assert.AreEqual(200, response.StatusCode); }
public override async Task Invoke(IOwinContext context) { IRequest owinRequest = new OwinRequest(context.Request.Query, await context.Request.ReadFormAsync()); IResponseRenderer responseRenderer = new OwinResponseRenderer(context); _runningApplication.Handle(owinRequest, responseRenderer); }
private RaygunIdentifierMessage GetRaygunIdentifierForNancyContext(OwinRequest request) { var context = request.Get <NancyContext>("nancy.NancyContext"); if (context == null || context.CurrentUser == null) { return(null); } var user = context.CurrentUser as UserIdentity; if (user == null) { return(null); } var userId = user.UserId.ToString("D"); return(new RaygunIdentifierMessage(user.UserName) { Email = string.Format("{0}@raygunio.test", user.UserName), FirstName = "robbie", FullName = "robbie the robot", IsAnonymous = false, UUID = userId }); }
private static async Task ExecuteAsync( IDictionary <string, object> environment, IDictionary <string, string> keys, OwinRequest request, AsyncHttpRequestHandler handler) { var response = new OwinResponse(environment); var executor = (Func <Task <object> >)(async() => { var form = from w in request.HasForm() ? (IEnumerable <KeyValuePair <string, string[]> >)(await request.ReadFormAsync().ConfigureAwait(false)) : EmptyForm select w != null ? w[0] : null; return(await handler.Executor( environment, keys, form.ToDictionary())); }); var result = await executor().ConfigureAwait(false); if (result != null) { await response.WriteAsync(JsonConvert.SerializeObject(result)).ConfigureAwait(false); } response.StatusCode = handler.StatusCodeGenerator != null ? handler.StatusCodeGenerator(result) : (int)HttpStatusCode.OK; }
public static string GetForwardedScheme(OwinRequest request) { var headers = request.Headers; var forwardedSsl = GetHeader(headers, "X-Forwarded-Ssl"); if (forwardedSsl != null && string.Equals(forwardedSsl, "on", StringComparison.OrdinalIgnoreCase)) { return("https"); } var forwardedScheme = GetHeader(headers, "X-Forwarded-Scheme"); if (!string.IsNullOrWhiteSpace(forwardedScheme)) { return(forwardedScheme); } var forwardedProto = GetHeaderSplit(headers, "X-Forwarded-Proto"); if (forwardedProto != null) { forwardedScheme = forwardedProto.FirstOrDefault(); if (!string.IsNullOrWhiteSpace(forwardedScheme)) { return(forwardedScheme); } } return(request.Scheme); }
public Task Invoke(IDictionary <string, object> env) { var request = new OwinRequest(env); var response = new OwinResponse(env); if (request.Uri.Scheme.Equals("https", StringComparison.OrdinalIgnoreCase)) { return(_next(env)); } var builder = new UriBuilder(request.Uri) { Scheme = "https" }; if (request.Uri.IsDefaultPort) { builder.Port = -1; } response.Headers.Set("Location", builder.ToString()); response.StatusCode = (int)HttpStatusCode.Found; return(TaskHelper.Empty); }
private RequestInstance BuildRequest(Action <OwinRequest> configure) { OwinRequest request = OwinRequest.Create(); configure(request); return(new RequestInstance(request.Dictionary, _app)); }
public void CreateEnvironment() { var creator = typeof(Http11ProtocolOwinAdapter).GetMethod("CreateOwinEnvironment", BindingFlags.NonPublic | BindingFlags.Static); const string method = "GET", scheme = "https", host = "localhost:80", pathBase = "", path = "/test.txt", queryString = "xunit"; var requestHeaders = new Dictionary <string, string[]> { { "Host", new[] { host } } }; var environment = (Dictionary <string, object>)creator.Invoke(null, new object[] { method, scheme, pathBase, path, requestHeaders, queryString, null }); var owinRequest = new OwinRequest(environment); Assert.Equal(owinRequest.Method, method); Assert.Equal(owinRequest.Scheme, scheme); Assert.Equal(owinRequest.PathBase.Value, pathBase); Assert.Equal(owinRequest.Path.Value, path); Assert.Equal(owinRequest.Body.Length, 0); Assert.Equal(owinRequest.Headers.ContainsKey("Host"), true); Assert.Equal(owinRequest.Headers["Host"], host); Assert.Equal(owinRequest.QueryString.Value, queryString); Assert.Equal(owinRequest.CallCancelled.IsCancellationRequested, false); var owinResponse = new OwinResponse(environment); Assert.Equal(owinResponse.Headers.Count, 0); Assert.Equal(owinResponse.Body.Length, 0); Assert.Equal(owinResponse.StatusCode, StatusCode.Code200Ok); }
private RequestInstance BuildRequest(Action <IOwinRequest> configure) { IOwinRequest request = new OwinRequest(); configure(request); return(new RequestInstance(request.Environment, _app)); }
private IEncoding SelectCompression(IDictionary <string, object> environment) { var request = new OwinRequest(environment); var bestAccept = new Accept { Encoding = "identity", Quality = 0 }; IEncoding bestEncoding = null; IList <string> acceptEncoding = request.Headers.GetValues("accept-encoding"); if (acceptEncoding != null) { foreach (var segment in acceptEncoding) { Accept accept = Parse(segment); if (accept.Quality == 0 || accept.Quality < bestAccept.Quality) { continue; } IEncoding compression = _options.EncodingProvider.GetCompression(accept.Encoding); if (compression == null) { continue; } bestAccept = accept; bestEncoding = compression; if (accept.Quality == 1000) { break; } } } return(bestEncoding); }
public override Task ProcessRequest(HostContext context) { string alterWhen = "____Never____"; int statusCode = 200; if (!String.IsNullOrEmpty(context.Request.QueryString["alterWhen"])) { alterWhen = context.Request.QueryString["alterWhen"]; } if (!String.IsNullOrEmpty(context.Request.QueryString["statusCode"])) { statusCode = Int32.Parse(context.Request.QueryString["statusCode"]); } var owinRequest = new OwinRequest(context.Environment); if (owinRequest.Path.Value.Contains("/" + alterWhen)) { var response = new OwinResponse(context.Environment); // Alter status code response.StatusCode = statusCode; using (var sw = new StreamWriter(response.Body)) { sw.WriteLine("Hello world"); sw.Flush(); } return(TaskAsyncHelper.Empty); } return(base.ProcessRequest(context)); }
public void CallingMethodInvokesDelegate() { var res = new OwinResponse(OwinRequest.Create()); res.CanSendFile.ShouldBe(false); string aa = null; long bb = 0; long? cc = null; CancellationToken dd = CancellationToken.None; var cts = new CancellationTokenSource(); res.SendFileAsyncDelegate = (a, b, c, d) => { aa = a; bb = b; cc = c; dd = d; return(null); }; res.SendFileAsync("one", 2, 3, cts.Token); aa.ShouldBe("one"); bb.ShouldBe(2); cc.ShouldBe(3); dd.ShouldBe(cts.Token); res.SendFileAsync("four"); aa.ShouldBe("four"); bb.ShouldBe(0); cc.ShouldBe(null); dd.ShouldBe(CancellationToken.None); }
public void When_request_user_is_not_defined_should_get_null() { var environment = new Dictionary <string, object>(); var owinRequest = new OwinRequest(environment); owinRequest.User.Should().BeNull(); }
public void ShouldFailOnUnknownAuthAttribute() { var logger = new Logger(); var builder = new AppBuilderFactory().Create(); builder.SetLoggerFactory(new LoggerFactory(logger)); var request = OwinRequest.Create(); request.Set <Action <Action <object>, object> >("server.OnSendingHeaders", RegisterForOnSendingHeaders); request.Method = "get"; request.SetUri(new Uri("http://example.com:8080/resource/4?filter=a")); request.SetHeader("Authorization", new string[] { "Hawk " + "id = \"123\", ts = \"1353788437\", nonce = \"1353788437\", x = \"3\", mac = \"/qwS4UjfVWMcUyW6EEgUH4jlr7T/wuKe3dKijvTvSos=\", ext = \"hello\"" }); var response = new OwinResponse(request); var middleware = new HawkAuthenticationMiddleware( new AppFuncTransition((env) => { response.StatusCode = 401; return(Task.FromResult <object>(null)); }), builder, new HawkAuthenticationOptions { Credentials = GetCredential } ); middleware.Invoke(request, response); Assert.AreEqual(401, response.StatusCode); Assert.AreEqual("Unknown attributes", logger.Messages[0]); }
public static RaygunRequestMessage Build(OwinEnvironment environment) { var request = new OwinRequest(environment); // ToDo: limit querystring, form, and header values to 256 characters var message = new RaygunRequestMessage(); message.HostName = request.Host.Value; message.Url = request.Uri.AbsolutePath; message.HttpMethod = request.Method; message.IPAddress = request.RemoteIpAddress; // ToDo: bring this up to par with the official client // ToDo: filter querystring values message.QueryString = request.Query.ToDictionary(_ => _.Key, _ => string.Join(", ", _.Value)); // ToDo: filter form values (add 'password' by default?) message.Form = request.ReadForm().ToDictionary(_ => _.Key, _ => string.Join(", ", _.Value)); // ToDo: filter headers message.Headers = request.Headers.ToDictionary(_ => _.Key, _ => string.Join(", ", _.Value)); message.Headers.Remove("Cookie"); message.Cookies = GetCookies(request.Cookies); if (request.ContentType != "text/html" && request.ContentType != "application/x-www-form-urlencoded" && request.Method != "GET") { var text = request.BodyAsString(); message.RawData = text.Substring(0, Math.Min(4096, text.Length)); } message.Data = GetData(request).Where(_ => _.Value != null).ToDictionary(_ => _.Key, _ => _.Value); return(message); }
private static IEnumerable <KeyValuePair <string, object> > GetData(OwinRequest request) { #region OWIN v1.0.0 - 3.2.3. Other Data yield return(new KeyValuePair <string, object>(OwinConstants.OwinVersion, request.Get <string>(OwinConstants.OwinVersion))); #endregion #region OWIN v1.0.0 - 3.2.1. Request Data yield return(new KeyValuePair <string, object>(OwinConstants.RequestProtocol, request.Get <string>(OwinConstants.RequestProtocol))); #endregion #region OWIN Key Guidelines and Common Keys - 6. Common Keys var capabilities = request.Get <IDictionary <string, object> >(OwinConstants.CommonKeys.Capabilities); if (capabilities != null) { foreach (var capability in capabilities) { yield return(capability); } } #endregion yield return(new KeyValuePair <string, object>("host.AppName", request.Get <string>("host.AppName"))); yield return(new KeyValuePair <string, object>("host.AppMode", request.Get <string>("host.AppMode"))); yield return(new KeyValuePair <string, object>("integratedpipeline.CurrentStage", request.Get <string>("integratedpipeline.CurrentStage"))); }
public Task Invoke(IDictionary <string, object> env) { var request = new OwinRequest(env); var response = new OwinResponse(env); if (!request.Uri.Scheme.Equals("https", StringComparison.OrdinalIgnoreCase)) { var builder = new UriBuilder(request.Uri); builder.Scheme = "https"; if (request.Uri.IsDefaultPort) { builder.Port = -1; } response.SetHeader("Location", builder.ToString()); response.StatusCode = 302; return(TaskAsyncHelper.Empty); } else { return(_next(env)); } }
private static AppFunc EnableAuthentication(AppFunc app, string password) { return(DigestAuthentication.Enable( app, (env) => { var request = new OwinRequest(env); if (request.CanAccept) { return false; } if (!request.Path.StartsWith("/backgrounds/")) { return true; } if (request.Path.EndsWith("/list") || request.Path.EndsWith("/listall")) { return true; } return false; // all other requests to /backgrounds/ without /list(all) }, "WordsLive", (user) => (user == "WordsLive" ? new DigestAuthentication.UserPassword { Password = password } : (DigestAuthentication.UserPassword?)null) )); }
public void ItStronglyTypesOwinKeys() { var headers = new Dictionary<string, string[]>(StringComparer.InvariantCultureIgnoreCase) { {"alpha", new []{"beta", "gamma"}} }; var body = new MemoryStream(new byte[] { 65, 66, 67, 68 }); var cts = new CancellationTokenSource(); var env = new Dictionary<string, object>(StringComparer.Ordinal) { {"owin.RequestScheme", "http"}, {"owin.RequestMethod", "ONE"}, {"owin.RequestPathBase", "/two"}, {"owin.RequestPath", "/three"}, {"owin.RequestQueryString", "four=five"}, {"owin.RequestProtocol", "HTTP/1.0"}, {"owin.RequestHeaders", headers}, {"owin.RequestBody", body}, {"owin.Version", "1.0"}, {"owin.CallCancelled", cts.Token}, }; var req = new OwinRequest(env); req.Scheme.ShouldBe("http"); req.Method.ShouldBe("ONE"); req.PathBase.ShouldBe("/two"); req.Path.ShouldBe("/three"); req.QueryString.ShouldBe("four=five"); req.Protocol.ShouldBe("HTTP/1.0"); req.Headers.ShouldBeSameAs(headers); req.Body.ShouldBeSameAs(body); req.OwinVersion.ShouldBe("1.0"); req.CallCancelled.ShouldBe(cts.Token); }
public static Uri GetUri(OwinRequest request) { var queryString = request.QueryString; return string.IsNullOrWhiteSpace(queryString) ? new Uri(request.Scheme + "://" + GetHost(request) + request.PathBase + request.Path) : new Uri(request.Scheme + "://" + GetHost(request) + request.PathBase + request.Path + "?" + queryString); }
private ICompressedStorage GetStorageOnce(IDictionary<string, object> environment) { ICompressedStorage storage = _options.CompressedStorageProvider.Create(); var onAppDisposing = new OwinRequest(environment).Get<CancellationToken>("host.OnAppDisposing"); if (onAppDisposing != CancellationToken.None) { onAppDisposing.Register(storage.Dispose); } return storage; }
public static string GetHost(OwinRequest request) { var headers = request.Headers; var host = GetHeader(headers, "Host"); if (!string.IsNullOrWhiteSpace(host)) { return host; } var localIpAddress = request.LocalIpAddress ?? "localhost"; var localPort = request.LocalPort; return string.IsNullOrWhiteSpace(localPort) ? localIpAddress : (localIpAddress + ":" + localPort); }
public void ParseQuery() { IDictionary<string, object> environment = new Dictionary<string, object>(); environment["owin.RequestQueryString"] = OriginalQueryString; IOwinRequest request = new OwinRequest(environment); Assert.Equal(OriginalQueryString, request.QueryString.Value); IReadableStringCollection query = request.Query; Assert.Equal("v1", query.Get("q1")); Assert.Equal("v2,b", query.Get("Q2")); Assert.Equal("v3,v4", query.Get("q3")); Assert.Null(query.Get("q4")); Assert.Equal("v5,v5", query.Get("Q5")); }
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.Headers.Get("X-Forwarded-Proto"); if (!String.IsNullOrEmpty(scheme)) { request.Scheme = scheme; } return _next(env); }
public void ParseForm() { IDictionary<string, object> environment = new Dictionary<string, object>(); environment["owin.RequestBody"] = new MemoryStream(Encoding.ASCII.GetBytes(OriginalFormsString)); IOwinRequest request = new OwinRequest(environment); IFormCollection form = request.ReadFormAsync().Result; Assert.Equal("v1", form.Get("q1")); Assert.Equal("v2,b", form.Get("Q2")); Assert.Equal("v3,v4", form.Get("q3")); Assert.Null(form.Get("q4")); Assert.Equal("v5,v5", form.Get("Q5")); }
public async Task Invoke(IDictionary<string, object> env) { object value; if (env.TryGetValue("server.User", out value)) { var windowsPrincipal = value as WindowsPrincipal; if (windowsPrincipal != null && windowsPrincipal.Identity.IsAuthenticated) { await _next(env); var request = new OwinRequest(env); var response = new OwinResponse(env); if (response.StatusCode == 401) { // We're going no add the identifier claim var nameClaim = windowsPrincipal.FindFirst(ClaimTypes.Name); // This is the domain name string name = nameClaim.Value; // If the name is something like DOMAIN\username then // grab the name part var parts = name.Split(new[] { '\\' }, 2); string shortName = parts.Length == 1 ? parts[0] : parts[parts.Length - 1]; // REVIEW: Do we want to preserve the other claims? // Normalize the claims here var claims = new List<Claim>(); claims.Add(new Claim(ClaimTypes.NameIdentifier, name)); claims.Add(new Claim(ClaimTypes.Name, shortName)); claims.Add(new Claim(ClaimTypes.AuthenticationMethod, "Windows")); var identity = new ClaimsIdentity(claims, Constants.JabbRAuthType); response.Authentication.SignIn(identity); response.StatusCode = 302; response.Headers.Set("Location", request.PathBase + request.Path); } return; } } await _next(env); }
public void ReadFromStream() { var stream = new MemoryStream(); var writer = new StreamWriter(stream); writer.Write(OriginalFormsString); writer.Flush(); stream.Seek(0, SeekOrigin.Begin); IOwinRequest request = new OwinRequest(); request.Body = stream; IFormCollection form = request.ReadFormAsync().Result; Assert.Equal("v1", form.Get("q1")); Assert.Equal("v2,b", form.Get("Q2")); Assert.Equal("v3,v4", form.Get("q3")); Assert.Null(form.Get("q4")); Assert.Equal("v5,v5", form.Get("Q5")); }
public static string GetMethodOverride(OwinRequest request) { var method = request.Method; if (!string.Equals("POST", method, StringComparison.OrdinalIgnoreCase)) { // override has no effect on POST return method; } var methodOverride = GetHeader(request.Headers, "X-Http-Method-Override"); if (string.IsNullOrEmpty(methodOverride)) { return method; } return methodOverride; }
/// <summary> /// Limits the number of concurrent requests that can be handled used by the subsequent stages in the owin pipeline. /// </summary> /// <param name="getMaxConcurrentRequests"> /// A delegate to retrieve the maximum number of concurrent requests. Allows you /// to supply different values at runtime. Use 0 or a negative number to specify unlimited number of concurrent /// requests. /// </param> /// <param name="loggerName">(Optional) The name of the logger log messages are written to.</param> /// <returns>An OWIN middleware delegate.</returns> /// <exception cref="System.ArgumentNullException">getMaxConcurrentRequests</exception> public static MidFunc MaxConcurrentRequests( Func<RequestContext, int> getMaxConcurrentRequests, string loggerName = null) { getMaxConcurrentRequests.MustNotNull("getMaxConcurrentRequests"); loggerName = string.IsNullOrWhiteSpace(loggerName) ? "LimitsMiddleware.MaxConcurrentRequests" : loggerName; var logger = LogProvider.GetLogger(loggerName); var concurrentRequestCounter = 0; return next => async env => { var owinRequest = new OwinRequest(env); var limitsRequestContext = new RequestContext(owinRequest); int maxConcurrentRequests = getMaxConcurrentRequests(limitsRequestContext); if (maxConcurrentRequests <= 0) { maxConcurrentRequests = int.MaxValue; } try { int concurrentRequests = Interlocked.Increment(ref concurrentRequestCounter); logger.Debug("Concurrent request {0}/{1}.".FormatWith(concurrentRequests, maxConcurrentRequests)); if (concurrentRequests > maxConcurrentRequests) { logger.Info("Limit ({0}). Request rejected." .FormatWith(maxConcurrentRequests, concurrentRequests)); var response = new OwinContext(env).Response; response.StatusCode = 503; response.ReasonPhrase = "Service Unavailable"; response.Write(response.ReasonPhrase); return; } await next(env); } finally { int concurrentRequests = Interlocked.Decrement(ref concurrentRequestCounter); logger.Debug("Concurrent request {0}/{1}.".FormatWith(concurrentRequests, maxConcurrentRequests)); } }; }
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 string GetForwardedHost(OwinRequest request) { var headers = request.Headers; var forwardedHost = GetHeaderSplit(headers, "X-Forwarded-Host"); if (forwardedHost != null) { return forwardedHost.Last(); } var host = GetHeader(headers, "Host"); if (!string.IsNullOrWhiteSpace(host)) { return host; } var localIpAddress = request.LocalIpAddress ?? "localhost"; var localPort = request.LocalPort; return string.IsNullOrWhiteSpace(localPort) ? localIpAddress : (localIpAddress + ":" + localPort); }
protected async Task BaseInitialize(AuthenticationOptions options, OwinRequest request, OwinResponse response) { _baseOptions = options; Request = request; Response = response; Helper = new SecurityHelper(request); RequestPathBase = Request.PathBase; _registration = Request.RegisterAuthenticationHandler(this); Request.OnSendingHeaders(state => ((AuthenticationHandler)state).ApplyResponse().Wait(), this); await InitializeCore(); if (BaseOptions.AuthenticationMode == AuthenticationMode.Active) { AuthenticationTicket ticket = await Authenticate(); if (ticket != null && ticket.Identity != null) { Helper.AddUserIdentity(ticket.Identity); } } }
public async Task Invoke(IDictionary<string, object> env) { var req = new OwinRequest(env); string file; if (!_router.TryGet(req.Path, out file)) { await _next(env); } var resp = new OwinResponse(req) { ContentType = "text/html" }; if (!File.Exists(file)) { resp.StatusCode = 404; await resp.WriteAsync("File not found"); } using (var fs = new FileStream(file, FileMode.Open, FileAccess.Read, FileShare.Read)) { await fs.CopyToAsync(resp.Body); } }
public static OwinRequest ApplyForwardedUri(OwinRequest request) { return ApplyForwardedHost(ApplyForwardedScheme(request)); }
private IOwinRequest CreateRequest(string url) { var uriBuilder = new UriBuilder(url); var request = new OwinRequest(); request.Path = PathString.FromUriComponent(uriBuilder.Uri); request.PathBase = PathString.Empty; request.Scheme = uriBuilder.Scheme; request.QueryString = QueryString.FromUriComponent(uriBuilder.Uri); return request; }
private RequestInstance BuildRequest(Action<IOwinRequest> configure) { IOwinRequest request = new OwinRequest(); configure(request); return new RequestInstance(request.Environment, _app); }
public static OwinRequest ApplyForwardedHost(OwinRequest request) { request.Host = GetForwardedHost(request); return request; }
public static OwinRequest ApplyForwardedScheme(OwinRequest request) { request.Scheme = GetForwardedScheme(request); return request; }
public static OwinRequest ApplyMethodOverride(OwinRequest request) { request.Method = GetMethodOverride(request); return request; }
/// <summary> /// Helper code used when implementing authentication middleware /// </summary> /// <param name="environment"></param> public SecurityHelper(IDictionary<string, object> environment) { _request = new OwinRequest(environment); _response = new OwinResponse(environment); }
/// <summary> /// Helper code used when implementing authentication middleware /// </summary> /// <param name="request"></param> public SecurityHelper(OwinRequest request) { _request = request; _response = new OwinResponse(request); }
private IEncoding SelectCompression(IDictionary<string, object> environment) { var request = new OwinRequest(environment); var bestAccept = new Accept { Encoding = "identity", Quality = 0 }; IEncoding bestEncoding = null; IList<string> acceptEncoding = request.Headers.GetValues("accept-encoding"); if (acceptEncoding != null) { foreach (var segment in acceptEncoding) { Accept accept = Parse(segment); if (accept.Quality == 0 || accept.Quality < bestAccept.Quality) { continue; } IEncoding compression = _options.EncodingProvider.GetCompression(accept.Encoding); if (compression == null) { continue; } bestAccept = accept; bestEncoding = compression; if (accept.Quality == 1000) { break; } } } return bestEncoding; }
public AuthenticationManager(OwinRequest request) { _request = request; _response = new OwinResponse(request); }
public void SettersModifyEnvironment() { var headers = new Dictionary<string, string[]>(StringComparer.InvariantCultureIgnoreCase) { { "alpha", new[] { "beta", "gamma" } } }; var body = new MemoryStream(new byte[] { 65, 66, 67, 68 }); var cts = new CancellationTokenSource(); var env = new Dictionary<string, object>(StringComparer.Ordinal); var req = new OwinRequest(env) { Scheme = "http", Method = "ONE", PathBase = "/two", Path = "/three", QueryString = "four=five", Protocol = "HTTP/1.0", Headers = headers, Body = body, OwinVersion = "1.0", CallCancelled = cts.Token }; env["owin.RequestScheme"].ShouldBe("http"); env["owin.RequestMethod"].ShouldBe("ONE"); env["owin.RequestPathBase"].ShouldBe("/two"); env["owin.RequestPath"].ShouldBe("/three"); env["owin.RequestQueryString"].ShouldBe("four=five"); env["owin.RequestProtocol"].ShouldBe("HTTP/1.0"); env["owin.RequestHeaders"].ShouldBe(headers); env["owin.RequestBody"].ShouldBe(body); env["owin.Version"].ShouldBe("1.0"); env["owin.CallCancelled"].ShouldBe(cts.Token); }
public OwinResponse(OwinRequest request) { _dictionary = request.Dictionary; }
private async Task OnHandler3(OwinRequest request, OwinResponse response, Func<Task> next) { await next(); }
public override Task Invoke(OwinRequest request, OwinResponse response) { return _next(request.Environment); }