private void CheckForAuthFailure(object sender, EventArgs e)
        {
            var app = sender as HttpApplication;
            var response = new HttpResponseWrapper(app.Response);
            var request = new HttpRequestWrapper(app.Request);
            var context = new HttpContextWrapper(app.Context);

            CheckForAuthFailure(request, response, context);
        }
Example #2
1
        public void ProcessRequest(HttpContext context)
        {
            int attachmentID = Convert.ToInt32(context.Request.Params["AttachmentID"]);

            HttpRequestBase request = new HttpRequestWrapper(context.Request);
            HttpResponseBase response = new HttpResponseWrapper(context.Response);

            var uow = ObjectFactory.GetInstance<IUnitOfWork>();
            var attachment = uow.AttachmentRepository.GetQuery().FirstOrDefault(e => e.Id == attachmentID);

            CreateFileResponse(response, attachment);
        }
		public void Init(HttpApplication context)
		{
			context.BeginRequest += (sender, e) =>
			{
				try
				{
					var application = sender as HttpApplication;
					if (application != null)
					{
						var request = application.Request;
						var response = application.Response;

						if (request != null && response != null)
						{
							var wrappedRequest = new HttpRequestWrapper(request);
							var wrappedResponse = new HttpResponseWrapper(response);

							ResolveDuplicateCookies(wrappedRequest, wrappedResponse);
							Restore(wrappedRequest, wrappedResponse);
						}
					}
				}
				catch
				{
				}
			};
		}
 public void Init(HttpApplication application)
 {
     application.BeginRequest += delegate
     {
         var response = new HttpResponseWrapper(application.Context.Response);
         
         response.Filter = new InsertionFilter(response, application.Context.Request.ApplicationPath.TrimEnd('/'));
     };
 }
 public AccountController(
  HttpContextWrapper httpContext,
  HttpResponseWrapper httpResponse)
 {
     _context = httpContext;
      _response = httpResponse;
      _authenticationManager = _context.GetOwinContext().Authentication;
      _userManager =
     _context.GetOwinContext().GetUserManager<ApplicationUserManager>();
 }
        /// <summary>
        /// Handles the PreSendRquestHeaders event of the context control.
        /// </summary>
        void HasSecureAccess(object sender, EventArgs e)
        {
            var httpApplication = (HttpApplication)sender;
            var response = new HttpResponseWrapper(httpApplication.Response);
            var request = new HttpRequestWrapper(httpApplication.Request);
            var context = new HttpContextWrapper(httpApplication.Context);

            if (true.Equals(context.Items["RequestWasNotAuthorized"]) && request.IsAjaxRequest())
            {
                response.StatusCode = 401;
                response.ClearContent();
            }
        }
Example #7
0
		public override async Task ProcessRequestAsync(HttpContext context)
		{
			context.ThrowIfNull("context");

			var request = new HttpRequestWrapper(context.Request);
			var response = new HttpResponseWrapper(context.Response);

			if (_antiCsrfCookieManager != null && _antiCsrfNonceValidator != null && _antiCsrfResponseGenerator != null)
			{
				if (!String.IsNullOrEmpty(context.Request.ContentType))
				{
					try
					{
						var contentType = new ContentType(context.Request.ContentType);

						if (String.Equals(contentType.MediaType, "application/x-www-form-urlencoded", StringComparison.OrdinalIgnoreCase) || String.Equals(contentType.MediaType, "multipart/form-data", StringComparison.OrdinalIgnoreCase))
						{
							ValidationResult validationResult = await _antiCsrfNonceValidator.ValidateAsync(request);
							ResponseResult responseResult = await _antiCsrfResponseGenerator.GetResponseAsync(validationResult);

							if (responseResult.ResultType == ResponseResultType.ResponseGenerated)
							{
								await ProcessResponseAsync(context, responseResult.Response, null);
								return;
							}
						}
					}
					catch (FormatException)
					{
					}
				}

				await _antiCsrfCookieManager.ConfigureCookieAsync(request, response);
			}
			{
				IEnumerable<RouteMatchResult> routeMatchResults = await GetRouteMatchResultsAsync(request);
				IEnumerable<Task<ResponseGenerators.ResponseResult>> responseResultTasks = _responseGenerators.Select(arg => arg.GetResponseAsync(new HttpContextWrapper(context), routeMatchResults));

				foreach (Task<ResponseGenerators.ResponseResult> responseResultTask in responseResultTasks)
				{
					ResponseGenerators.ResponseResult responseResult = await responseResultTask;

					if (responseResult.ResultType == ResponseGenerators.ResponseResultType.ResponseGenerated)
					{
						await ProcessResponseAsync(context, await responseResult.Response, responseResult.CacheKey);
						return;
					}
				}
			}
		}
Example #8
0
        public void ProcessRequest(HttpContext context)
        {
            context.ThrowIfNull("context");

            var request = new HttpRequestWrapper(context.Request);
            var response = new HttpResponseWrapper(context.Response);
            // ReSharper disable ImplicitlyCapturedClosure
            RouteMatchResult[] routeMatchResults = _routes.Select(arg => new RouteMatchResult(arg, arg.MatchesRequest(request))).ToArray();
            // ReSharper restore ImplicitlyCapturedClosure
            ResponseResult responseResult = _responseGenerators
                .Select(arg => arg.GetResponse(request, routeMatchResults))
                .FirstOrDefault(arg => arg.ResultType != ResponseResultType.ResponseNotGenerated);

            if (responseResult == null)
            {
                throw new ApplicationException("No response was generated.");
            }

            ProcessResponse(request, response, responseResult.Response, responseResult.CacheKey);
        }
        public static void PerformCoreLogin(OCM.API.Common.Model.User userDetails)
        {
            string permissions = (userDetails.Permissions != null ? userDetails.Permissions : "");
            var session = System.Web.HttpContext.Current.Session;
            var response = new HttpResponseWrapper(System.Web.HttpContext.Current.Response);

            UpdateCookie(response, "IdentityProvider", userDetails.IdentityProvider);
            UpdateCookie(response, "Identifier", userDetails.Identifier);
            UpdateCookie(response, "Username", userDetails.Username);
            UpdateCookie(response, "OCMSessionToken", userDetails.CurrentSessionToken);
            UpdateCookie(response, "AccessPermissions", permissions);

            session["IdentityProvider"] = userDetails.IdentityProvider;
            session["Identifier"] = userDetails.Identifier;
            session["Username"] = userDetails.Username;
            session["UserID"] = userDetails.ID;

            if (UserManager.IsUserAdministrator(userDetails))
            {
                session["IsAdministrator"] = true;
            }
        }
Example #10
0
        void context_BeginRequest(object sender, EventArgs e)
        {
            var request = new HttpRequestWrapper(HttpContext.Current.Request);

            if (request.HttpMethod.ToLowerInvariant() != "get")
            {
                return;
            }

            if (HasUpperCaseLetters(request.RawUrl))
            {
                RedirectToLowerCaseVersion(request.RawUrl, new HttpResponseWrapper(HttpContext.Current.Response));
                return;
            }

            if (_redirects.Any(x => x.Match(request)))
            {
                UrlRedirect redirect = _redirects.First(x => x.Match(request));
                var response = new HttpResponseWrapper(HttpContext.Current.Response);
                redirect.Redirect(request, response);
                return;
            }
        }
Example #11
0
        public static void Refresh(IServerResponse msg = null, HttpResponseBase response = null)
        {
            if (response == null)
                response = new HttpResponseWrapper(HttpContext.Current.Response);

            StringBuilder sb = new StringBuilder();
            sb.Append("<script type='text/javascript'> ");
            sb.Append("if(window.postMessage) { if(window.opener != null) { window.opener.postMessage('{\"event\":\"reload\"");
            if (msg != null)
                sb.AppendFormat(", \"msg\": {{ \"Status\": \"{0}\", \"Message\": \"{1}\" }}", (int)msg.Status, msg.Message);
            sb.Append("}', '*'); }");
            sb.Append("else if(window.parent != null) { window.parent.postMessage('{\"event\":\"reload\"");
            if (msg != null)
                sb.AppendFormat(", \"msg\": {{ \"Status\": \"{0}\", \"Message\": \"{1}\" }}", (int)msg.Status, msg.Message);
            sb.Append("}', '*'); }");
            sb.Append("else { window.top.postMessage('{\"event\":\"reload\"");
            if (msg != null)
                sb.AppendFormat(", \"msg\": {{ \"Status\": \"{0}\", \"Message\": \"{1}\" }}", (int)msg.Status, msg.Message);
            sb.Append("}', '*'); }");
            sb.Append("} else { if(window.opener != null) { ");
            if (msg != null)
                sb.AppendFormat("window.localStorage.setItem(\"alert\", '{{ \"Status\": \"{0}\", \"Message\": \"{1}\" }}');", (int)msg.Status, msg.Message);
            sb.Append("window.opener.location.reload(); }");
            sb.Append("else if(window.parent != null) { ");
            if (msg != null)
                sb.AppendFormat("window.localStorage.setItem(\"alert\", '{{ \"Status\": \"{0}\", \"Message\": \"{1}\" }}');", (int)msg.Status, msg.Message);
            sb.Append("window.parent.location.reload(); }");
            sb.Append("else { ");
            if (msg != null)
                sb.AppendFormat("window.localStorage.setItem(\"alert\", '{{ \"Status\": \"{0}\", \"Message\": \"{1}\" }}');", (int)msg.Status, msg.Message);
            sb.Append("window.top.location.reload(); }");
            sb.Append("} </script>");

            response.Write(sb.ToString());
            response.End();
        }
		public void ApplyHeadersToResponse() {
			var headers = new WebHeaderCollection();
			headers[HttpResponseHeader.ContentType] = "application/binary";

			var response = new HttpResponseWrapper(new HttpResponse(new StringWriter()));
			MessagingUtilities.ApplyHeadersToResponse(headers, response);

			Assert.AreEqual(headers[HttpResponseHeader.ContentType], response.ContentType);
		}
 public HttpContextSimulator(HttpContext httpContext) : base(httpContext)
 {
     _request = new HttpRequestSimulator(httpContext.Request);
     _response = new HttpResponseWrapper(httpContext.Response);
     _session = new HttpSessionStateSimulator();
 }
        private void HandleGetRequest( HttpContext context, Func<IResult,IResult> resultWrapper )
        {
            var request = new HttpRequestWrapper( context.Request );
            var response = new HttpResponseWrapper( context.Response );

            var absolutePath = HttpUtility.UrlDecode( request.Url.AbsolutePath );
            var originalFormat = FormatInfoProvider.ResolveFromExtension( Path.GetExtension( absolutePath ) );

            if ( originalFormat == null )
            {
                ServeIllegalExtensionResult( response );
                return;
            }

            IMediaTransformer mediaTransformer;
            var transformMedia = MediaTransformerFactory.TryCreateTransformer( request, originalFormat, FormatInfoProvider, out mediaTransformer );
            var outputFormat = transformMedia ? mediaTransformer.OutputFormat : originalFormat;

            IResult result;
            if ( TryGetResult( request, outputFormat, transformMedia, mediaTransformer, out result ) )
            {
                result = resultWrapper( result );
                ResultHandler.HandleResult( result, outputFormat, request, response );
                result.Dispose();
            }
            else
            {
                ServeNotFoundResult( response );
            }
        }
		public override async Task ProcessRequestAsync(HttpContext context)
		{
			context.ThrowIfNull("context");

			var contextWrapper = new HttpContextWrapper(context);
			var requestWrapper = new HttpRequestWrapper(context.Request);
			var responseWrapper = new HttpResponseWrapper(context.Response);
			ExceptionDispatchInfo exceptionDispatchInfo = null;

			try
			{
				foreach (IRequestValidator requestValidator in _requestValidators)
				{
					ValidateResult validateResult = await requestValidator.Validate(requestWrapper, responseWrapper);

					if (validateResult.ResultType == ValidateResultType.RequestValidated)
					{
						continue;
					}

					await ProcessResponseAsync(context, validateResult.Response, null);
					return;
				}

				IEnumerable<RouteMatchResult> routeMatchResults = _routes.Select(arg => new RouteMatchResult(arg, arg.MatchesRequest(requestWrapper)));
				IEnumerable<Task<ResponseResult>> responseResultTasks = _responseGenerators.Select(arg => arg.GetResponseAsync(contextWrapper, routeMatchResults));

				foreach (Task<ResponseResult> responseResultTask in responseResultTasks)
				{
					ResponseResult responseResult = await responseResultTask;

					if (responseResult.ResultType != ResponseResultType.ResponseGenerated)
					{
						continue;
					}

					await ProcessResponseAsync(context, await responseResult.Response, responseResult.CacheKey);
					return;
				}
			}
			catch (Exception exception)
			{
				exceptionDispatchInfo = ExceptionDispatchInfo.Capture(exception);
			}

			if (exceptionDispatchInfo != null)
			{
				foreach (IErrorHandler errorHandler in _errorHandlers)
				{
					if ((await errorHandler.HandleAsync(contextWrapper, exceptionDispatchInfo.SourceException)).ResultType != HandleResultType.Handled)
					{
						continue;
					}

					exceptionDispatchInfo = null;
					break;
				}
			}
			if (exceptionDispatchInfo != null)
			{
				exceptionDispatchInfo.Throw();
			}
		}
Example #16
0
 /// <summary>
 /// does the initial redirect
 /// </summary>
 /// <param name="sReturnUrl">takes the url for google to return to</param>
 /// <param name="oResponse">takes the response object</param>
 public void Redirect(HttpResponseWrapper oResponse)
 {
     String sAuthUrl = "https://accounts.google.com/o/oauth2/auth?redirect_uri={0}&client_id={1}&scope=https://www.googleapis.com/auth/userinfo.profile&response_type=code&max_auth_age=0";
     String sRedirectToGoogle = String.Format(sAuthUrl, this.sRedirect, this.sKey);
     oResponse.Redirect(sRedirectToGoogle);
 }