예제 #1
0
    public override void OnActionExecuting(
        ActionExecutingContext Context)
    {
        HttpRequestBase  Request  = Context.HttpContext.Request;
        HttpResponseBase Response = Context.HttpContext.Response;

        if (!Request.IsLocal)
        {
            if (!Request.IsSecureConnection && this.ForceHttps)          //  http://domain.com OR http://www.domain.com
            {
                if (this.ForceWww && !Request.Url.Host.Contains("www.")) //  http://domain.com
                {
                    Response.RedirectPermanent(new Uri(Uri.UriSchemeHttps + "://www." + Request.Url.Host + Request.Url.AbsolutePath).AbsoluteUri, true);
                }
                else            //  http://www.domain.com
                {
                    Response.RedirectPermanent(new Uri(Uri.UriSchemeHttps + "://" + Request.Url.Host + Request.Url.AbsolutePath).AbsoluteUri, true);
                };
            }
            else
            {
                if (this.ForceWww && !Request.Url.Host.Contains("www."))        //  http://domain.com OR https://domain.com
                {
                    Response.RedirectPermanent(new Uri(Request.Url.Scheme + "://www." + Request.Url.Host + Request.Url.AbsolutePath).AbsoluteUri, true);
                }
                ;
            };
        }
        ;
    }
예제 #2
0
        /// <summary>
        /// Attempt to determine the file path to the requested markdown file
        /// the path could be part of the same Mater directory or could be a
        /// virtual directory mapped in IIS or Azure
        /// </summary>
        /// <param name="Response">ASP.NET Response object.</param>
        /// <param name="path">Web path used for finding the requested md file</param>
        /// <returns></returns>
        string GetMarkdownPath(HttpResponseBase Response, string path)
        {
            // Root, e.g. "/"
            if (null == path)
            {
                return(Server.MapPath("~/articles/index.md"));
            }

            // Directory, e.g. "/home/" attempts to find an index.md file
            if (path.EndsWith("/", StringComparison.InvariantCulture))
            {
                return(Server.MapPath("~/articles/" + path + "index.md"));
            }

            // Directory or file, e.g. "/home"
            if (System.IO.File.Exists(Server.MapPath("~/articles/" + path + "/index.md")))
            {
                // 301
                Response.RedirectPermanent("/" + path + "/", true);
            }
            else if (System.IO.File.Exists(Server.MapPath("~/articles/" + path + ".md")))
            {
                return(Server.MapPath("~/articles/" + path + ".md"));
            }

            throw new System.IO.FileNotFoundException("No directories or files found for " + path);
        }
        /// <summary>
        /// Enables processing of the result of an action method by a custom type that inherits from the <see cref="T:System.Web.Mvc.ActionResult"/> class.
        /// </summary>
        /// <param name="context">The context within which the result is executed.</param><exception cref="T:System.ArgumentNullException">The <paramref name="context"/> parameter is null.</exception>
        public override void ExecuteResult(ControllerContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }
            if (context.IsChildAction)
            {
                throw new InvalidOperationException(MvcResources.RedirectAction_CannotRedirectInChildAction);
            }
            string str = UrlHelper.GenerateUrl(this.RouteName, (string)null, (string)null, this.RouteValues, this.Routes, context.RequestContext, false);

            if (string.IsNullOrEmpty(str))
            {
                throw new InvalidOperationException(MvcResources.Common_NoRouteMatched);
            }
            context.Controller.TempData.Keep();
            if (this.Permanent)
            {
                HttpResponseBase response = context.HttpContext.Response;
                bool             flag     = false;
                string           url      = str;
                int num = flag ? 1 : 0;
                response.RedirectPermanent(url, num != 0);
            }
            else
            {
                HttpResponseBase response = context.HttpContext.Response;
                bool             flag     = false;
                string           url      = str;
                int num = flag ? 1 : 0;
                response.Redirect(url, num != 0);
            }
        }
예제 #4
0
        //TODO: This should only be called in one place total. And it needs to be tested.
        public static Entry GetEntryFromRequest(bool allowRedirectToEntryName, ISubtextContext context)
        {
            string slug = context.RequestContext.GetSlugFromRequest();

            if (!String.IsNullOrEmpty(slug))
            {
                return(GetEntry(slug, context));
            }

            int?id = context.RequestContext.GetIdFromRequest();

            if (id != null)
            {
                Entry entry = GetEntry(id.Value, context);
                if (entry == null)
                {
                    return(null);
                }

                //TODO: Violation of SRP here!
                //Second condition avoids infinite redirect loop. Should never happen.
                if (allowRedirectToEntryName && entry.HasEntryName && !entry.EntryName.IsNumeric())
                {
                    HttpResponseBase response = context.HttpContext.Response;
                    response.RedirectPermanent(context.UrlHelper.EntryUrl(entry).ToFullyQualifiedUrl(context.Blog).ToString());
                }
                return(entry);
            }

            return(null);
        }
    public override void ExecuteResult(ControllerContext context)
    {
        if (context == null)
        {
            throw new ArgumentNullException("context");
        }
        string url = UrlHelper.GenerateContentUrl(_url, context.HttpContext);

        context.Controller.TempData.Keep();
        HttpResponseBase response = context.HttpContext.Response;

        response.RedirectPermanent(url, endResponse: true);
    }
예제 #6
0
 /// <summary>
 ///
 /// </summary>
 /// <param name="response"></param>
 /// <param name="location"></param>
 public static void RedirectPermanentWithoutEncodingURL(this HttpResponseBase response, string location)
 {
     if (HttpContext.Current.Request.Browser.Browser.ToLower().Equals("ie") && (HttpContext.Current.Request.Browser.MajorVersion == 6))
     {
         response.RedirectPermanent(location);
     }
     else
     {
         response.Clear();
         response.StatusCode = 301;
         response.Status     = "301 Moved Permanently";
         response.AddHeader("Location", location);
         response.End();
     }
 }
예제 #7
0
        /// <summary>
        /// Fixes the request Url, if required. Returns a value indicating whether a redirect is necessary.
        /// </summary>
        public bool ValidateUrl()
        {
            HttpRequestBase  request  = context.Request;
            HttpResponseBase response = context.Response;

            // load balancers in production trick us into using the wrong port, we won't fall for that.
            Uri requestUrl = request.Url.WithPublicPort();

            string incoming = requestUrl.GetLeftPart(UriPartial.Path);
            string absolute = requestUrl.AbsolutePath;
            string decoded  = HttpUtility.UrlDecode(absolute);
            string redirect;

            if (absolute != decoded)
            {
                // encoded characters such as %7D result in issues, so we better leave them untouched.
                string host = requestUrl.GetLeftPart(UriPartial.Authority);
                redirect = host.ToLowerInvariant() + absolute;
            }
            else
            {
                redirect = incoming.ToLowerInvariant(); // our urls are always in lower case.
            }

            // remove www. from the beginning of the url.
            redirect = CompiledRegex.WwwSubdomain.Replace(redirect, Resources.Shared.Regex.WwwSubdomainReplacement);

            if (absolute.Length > 1 && absolute.EndsWith("/"))
            {
                // remove '/' from the end of the url unless this is the only character in the url.
                redirect = redirect.Substring(0, redirect.Length - 1);
            }
            if (redirect != incoming)
            {
                // append the query string to the redirect result.
                NameValueCollection query = request.QueryString;
                string queryString        = string.Empty;

                if (query.Count > 0)
                {
                    queryString = "?{0}".FormatWith(query.ToString());
                }
                response.RedirectPermanent(redirect + queryString);
                return(true);
            }
            return(false);
        }
 public override void RedirectPermanent(string url)
 {
     _response.RedirectPermanent(url);
 }