/// <summary>
/// Handles the current request.
/// </summary>
/// <param name="context">The current context</param>
/// <param name="draft">Weather to view the draft</param>
/// <param name="args">Optional url arguments passed to the handler</param>
protected virtual void HandleRequest(HttpContext context, bool draft, params string[] args)
{
if (args != null && args.Length > 0) {
Permalink perm = Permalink.GetByName(args[0]) ;
if (perm != null) {
if (perm.Type == Permalink.PermalinkType.PAGE) {
Page page = Page.GetSingle(perm.ParentId, draft) ;
if (!String.IsNullOrEmpty(page.Controller)) {
context.RewritePath("~/templates/" + page.Controller + "/" + perm.Name +
(draft ? "?draft=true" : ""), false) ;
} else {
context.RewritePath("~/page/" + perm.Name + (draft ? "?draft=true" : "")) ;
}
} else {
context.RewritePath("~/post/" + perm.Name + (draft ? "?draft=true" : "")) ;
}
}
} else {
//
// Rewrite to current startpage
//
Page page = Page.GetStartpage() ;
if (!String.IsNullOrEmpty(page.Controller))
context.RewritePath("~/templates/" + page.Controller, false) ;
else context.RewritePath("~/page") ;
}
}
/// <summary>
/// Handles requests to the current startpage
/// </summary>
/// <param name="context">The current http context</param>
public void HandleStartpage(HttpContext context) {
var page = Page.GetStartpage();
if (!String.IsNullOrEmpty(page.Controller))
context.RewritePath("~/" + page.Controller + "?permalink=" + page.Permalink + FormatQuerystring(context), false);
else context.RewritePath("~/page?permalink=" + page.Permalink + FormatQuerystring(context), false);
}
/// <summary>
/// Handles requests to the given page.
/// </summary>
/// <param name="context">The current http context</param>
/// <param name="permalink">The permalink</param>
/// <param name="page">The page</param>
/// <param name="args">Optional route arguments</param>
public void HandlePage(HttpContext context, Permalink permalink, Page page, params string[] args) {
if (!String.IsNullOrEmpty(page.Controller)) {
context.RewritePath("~/" + page.Controller + "/" + args.Implode("/") + "?permalink=" + permalink.Name +
(page.IsDraft ? "&draft=true" : "") + FormatQuerystring(context), false);
} else {
context.RewritePath("~/page/" + args.Implode("/") + "?permalink=" + permalink.Name +
(page.IsDraft ? "&draft=true" : "") + FormatQuerystring(context), false);
}
}
IHttpHandler IHttpHandlerFactory.GetHandler(HttpContext context, string requestType, string url, string pathTranslated)
{
IHttpHandler handler = null;
if (context.Request.QueryString != null)
pathTranslated = getPathTranslatedFromSiteGeneratorGUI(url, pathTranslated);
// check if it is an .aspx page
if (".aspx" == Path.GetExtension(pathTranslated))
{
context.RewritePath(url, url, context.Request.QueryString.ToString());
handler = PageParser.GetCompiledPageInstance(url, pathTranslated, context);
}
else if (".asmx" == Path.GetExtension(pathTranslated).ToLower())
{
WebServiceHandlerFactory wshf = new WebServiceHandlerFactory();
handler = wshf.GetHandler(context, requestType, url, pathTranslated);
}
else
{
ProcessStaticContent(pathTranslated); // Process page and
HttpContext.Current.Response.End(); // end here
}
return handler;
}
/// <summary>
/// Rewrites the post.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="url">The URL string.</param>
public static void RewritePost(HttpContext context, string url)
{
int year, month, day;
var haveDate = ExtractDate(context, out year, out month, out day);
var slug = ExtractTitle(context, url);
// Allow for Year/Month only dates in URL (in this case, day == 0), as well as Year/Month/Day dates.
// first make sure the Year and Month match.
// if a day is also available, make sure the Day matches.
var post = Post.ApplicablePosts.Find(
p =>
(!haveDate || (p.DateCreated.Year == year && p.DateCreated.Month == month)) &&
((!haveDate || (day == 0 || p.DateCreated.Day == day)) &&
slug.Equals(Utils.RemoveIllegalCharacters(p.Slug), StringComparison.OrdinalIgnoreCase)));
if (post == null)
{
return;
}
var q = GetQueryString(context);
if (q.Contains("id=" + post.Id, StringComparison.OrdinalIgnoreCase))
q = string.Format("{0}post.aspx?{1}", Utils.ApplicationRelativeWebRoot, q);
else
q = string.Format("{0}post.aspx?id={1}{2}", Utils.ApplicationRelativeWebRoot, post.Id, q);
context.RewritePath(
url.Contains("/FEED/")
? string.Format("syndication.axd?post={0}{1}", post.Id, GetQueryString(context))
: q,
false);
}
public void ProcessRequest(HttpContext context)
{
HttpRequest req=context.Request;
HttpResponse res=context.Response;
string path = req.Path;
if(Path.GetExtension(path)==".aspx") context.RewritePath(path.Replace("/RAGS/","/"));
}
/// <summary>
/// Rewrite's a URL using <b>HttpContext.RewriteUrl()</b>.
/// </summary>
/// <param name="context">The HttpContext object to rewrite the URL to.</param>
/// <param name="sendToUrl">The URL to rewrite to.</param>
/// <param name="sendToUrlLessQString">Returns the value of sendToUrl stripped of the querystring.</param>
/// <param name="filePath">Returns the physical file path to the requested page.</param>
internal static void RewriteUrl(HttpContext context, string sendToUrl, out string sendToUrlLessQString, out string filePath)
{
// see if we need to add any extra querystring information
if (context.Request.QueryString.Count > 0)
{
if (sendToUrl.IndexOf('?') != -1)
sendToUrl += "&" + context.Request.QueryString.ToString();
else
sendToUrl += "?" + context.Request.QueryString.ToString();
}
// first strip the querystring, if any
string queryString = String.Empty;
sendToUrlLessQString = sendToUrl;
if (sendToUrl.IndexOf('?') > 0)
{
sendToUrlLessQString = sendToUrl.Substring(0, sendToUrl.IndexOf('?'));
queryString = sendToUrl.Substring(sendToUrl.IndexOf('?') + 1);
}
// grab the file's physical path
filePath = string.Empty;
filePath = context.Server.MapPath(sendToUrlLessQString);
// rewrite the path...
context.RewritePath(sendToUrlLessQString, String.Empty, queryString);
// NOTE! The above RewritePath() overload is only supported in the .NET Framework 1.1
// If you are using .NET Framework 1.0, use the below form instead:
// context.RewritePath(sendToUrl);
}
private static void HandleAjax(HttpContext context)
{
int dotasmx = context.Request.Path.IndexOf(".asmx");
string path = context.Request.Path.Substring(0, dotasmx + 5);
string pathInfo = context.Request.Path.Substring(dotasmx + 5);
context.RewritePath(path, pathInfo, context.Request.Url.Query);
}
public void CondRewrite(HttpContext ctx)
{
if ( RewriteNeeded ) {
Common.Log("ModCaseInsensitive: rewritting [ '{0}' -> '{1}' ]",
ctx.Request.RawUrl,
Url + PathInfo + QueryString
);
if ( PathInfo == String.Empty ) {
ctx.RewritePath( Url + QueryString );
}
else {
ctx.RewritePath( Url, PathInfo, QueryString );
}
}
else {
Common.Log("ModCaseInsensitive: not rewritting [ '{0}' ]", ctx.Request.RawUrl);
}
}
public override void SendImageToHttpResponse(HttpContext context, string cacheKey, string fileExtension)
{
// Instead of sending image directly to the response, just call RewritePath and let IIS
// handle the actual serving of the image.
string filePath = GetDiskCacheFilePath(context, cacheKey, fileExtension);
context.Items["FinalCachedFile"] = context.Server.MapPath(filePath);
context.RewritePath(filePath, false);
}
/// <summary>
/// Rewrites the specified HTTP context.
/// </summary>
/// <param name="httpContext">The HTTP context.</param>
public void Rewrite(HttpContext httpContext)
{
if (httpContext != null)
{
string outputUri = null;
if (RewriteToUri(httpContext.Request.RawUrl, out outputUri))
{
httpContext.RewritePath(outputUri);
}
}
}
private static void RewriteCategory(HttpContext context)
{
string title = ExtractTitle(context);
foreach (Category cat in Category.Categories)
{
string legalTitle = SupportUtilities.RemoveIllegalCharacters(cat.Title).ToLowerInvariant();
if (title.Equals(legalTitle, StringComparison.OrdinalIgnoreCase))
{
context.RewritePath(SupportUtilities.RelativeWebRoot + "Default.aspx?id=" + cat.Id.ToString() + GetQueryString(context), false);
break;
}
}
}
internal static void RewriteUrl(HttpContext context, string sendToUrl)
{
//first strip the querystring, if any
var queryString = string.Empty;
string sendToUrlLessQString = sendToUrl;
if ((sendToUrl.IndexOf("?", StringComparison.Ordinal) > 0))
{
sendToUrlLessQString = sendToUrl.Substring(0, sendToUrl.IndexOf("?", StringComparison.Ordinal));
queryString = sendToUrl.Substring(sendToUrl.IndexOf("?", StringComparison.Ordinal) + 1);
}
//rewrite the path..
context.RewritePath(sendToUrlLessQString, string.Empty, queryString);
//NOTE! The above RewritePath() overload is only supported in the .NET Framework 1.1
//If you are using .NET Framework 1.0, use the below form instead:
//context.RewritePath(sendToUrl);
}
/// <summary>
/// Rewrite's a URL using <b>HttpContext.RewriteUrl()</b>.
/// </summary>
/// <param name="context">The HttpContext object to rewrite the URL to.</param>
/// <param name="sendToUrl">The URL to rewrite to.</param>
/// <param name="sendToUrlLessQString">Returns the value of sendToUrl stripped of the querystring.</param>
/// <param name="filePath">Returns the physical file path to the requested page.</param>
internal static void RewriteUrl(HttpContext context, string sendToUrl, out string sendToUrlLessQString, out string filePath)
{
if (context.Request.QueryString.Count > 0)
if (sendToUrl.IndexOf('?') != -1)
sendToUrl += "&" + context.Request.QueryString.ToString();
else
sendToUrl += "?" + context.Request.QueryString.ToString();
string queryString = String.Empty;
sendToUrlLessQString = sendToUrl;
if (sendToUrl.IndexOf('?') > 0) {
sendToUrlLessQString = sendToUrl.Substring(0, sendToUrl.IndexOf('?'));
queryString = sendToUrl.Substring(sendToUrl.IndexOf('?') + 1);
}
filePath = context.Server.MapPath(sendToUrlLessQString);
context.RewritePath(sendToUrlLessQString, String.Empty, queryString);
}
internal static void UrlMappingRewritePath(HttpContext context) {
HttpRequest request = context.Request;
UrlMappingsSection urlMappings = RuntimeConfig.GetAppConfig().UrlMappings;
string path = request.Path;
string mappedUrl = null;
// First check path with query string (for legacy reasons)
string qs = request.QueryStringText;
if (!String.IsNullOrEmpty(qs)) {
mappedUrl = urlMappings.HttpResolveMapping(path + "?" + qs);
}
// Check Path if not found
if (mappedUrl == null)
mappedUrl = urlMappings.HttpResolveMapping(path);
if (!String.IsNullOrEmpty(mappedUrl))
context.RewritePath(mappedUrl, false);
}
internal static void UrlMappingRewritePath(HttpContext context)
{
HttpRequest request = context.Request;
UrlMappingsSection urlMappings = RuntimeConfig.GetAppConfig().UrlMappings;
string path = request.Path;
string str2 = null;
string queryStringText = request.QueryStringText;
if (!string.IsNullOrEmpty(queryStringText))
{
str2 = urlMappings.HttpResolveMapping(path + "?" + queryStringText);
}
if (str2 == null)
{
str2 = urlMappings.HttpResolveMapping(path);
}
if (!string.IsNullOrEmpty(str2))
{
context.RewritePath(str2, false);
}
}
internal static void UrlMappingRewritePath(HttpContext context)
{
HttpRequest request = context.Request;
UrlMappingsSection urlMappings = RuntimeConfig.GetAppConfig().UrlMappings;
string path = request.Path;
string str2 = null;
string queryStringText = request.QueryStringText;
if (!string.IsNullOrEmpty(queryStringText))
{
str2 = urlMappings.HttpResolveMapping(path + "?" + queryStringText);
}
if (str2 == null)
{
str2 = urlMappings.HttpResolveMapping(path);
}
if (!string.IsNullOrEmpty(str2))
{
context.RewritePath(str2, false);
}
}
internal static void RewriteUrl(HttpContext context, string sendToUrl, ref string sendToUrlLessQString, ref string filePath)
{
//first strip the querystring, if any
var queryString = string.Empty;
sendToUrlLessQString = sendToUrl;
if ((sendToUrl.IndexOf("?") > 0))
{
sendToUrlLessQString = sendToUrl.Substring(0, sendToUrl.IndexOf("?"));
queryString = sendToUrl.Substring(sendToUrl.IndexOf("?") + 1);
}
//grab the file's physical path
filePath = string.Empty;
filePath = context.Server.MapPath(sendToUrlLessQString);
//rewrite the path..
context.RewritePath(sendToUrlLessQString, string.Empty, queryString);
//NOTE! The above RewritePath() overload is only supported in the .NET Framework 1.1
//If you are using .NET Framework 1.0, use the below form instead:
//context.RewritePath(sendToUrl);
}
public static void RewriteUrl(HttpContext context, string sendToUrl, out string sendToUrlLessQString, out string filePath)
{
if (context.Request.QueryString.Count > 0)
{
if (sendToUrl.IndexOf('?') != -1)
{
sendToUrl = sendToUrl + "&" + context.Request.QueryString.ToString();
}
else
{
sendToUrl = sendToUrl + "?" + context.Request.QueryString.ToString();
}
}
string queryString = string.Empty;
sendToUrlLessQString = sendToUrl;
if (sendToUrl.IndexOf('?') > 0)
{
sendToUrlLessQString = sendToUrl.Substring(0, sendToUrl.IndexOf('?'));
queryString = sendToUrl.Substring(sendToUrl.IndexOf('?') + 1);
}
filePath = context.Server.MapPath(sendToUrlLessQString);
context.RewritePath(sendToUrlLessQString, string.Empty, queryString);
}
/// <summary>
/// Rewrites /blog.aspx path
/// </summary>
/// <param name="context">The HTTP context.</param>
/// <param name="url">The URL string.</param>
public static void RewriteBlog(HttpContext context, string url)
{
var path = string.Format("{0}default.aspx?blog=true{1}",
Utils.ApplicationRelativeWebRoot,
GetQueryString(context));
context.RewritePath(path, false);
}
/// <summary>
/// Posts for author
/// </summary>
/// <param name="context">The HTTP context.</param>
/// <param name="url">The URL string.</param>
public static void RewriteAuthor(HttpContext context, string url)
{
var author = UrlRules.ExtractTitle(context, url);
var path = string.Format("{0}default.aspx?name={1}{2}",
Utils.ApplicationRelativeWebRoot,
author,
GetQueryString(context));
context.RewritePath(path, false);
}
/// <summary>
/// Page with large calendar
/// </summary>
/// <param name="context">The HTTP context.</param>
/// <param name="url">The URL string.</param>
public static void RewriteCalendar(HttpContext context, string url)
{
// prevent fake URLs
// valid: "/calendar/"
// valid: "/calendar/default.aspx"
// invalid: "/fake-value/calendar/default.aspx"
// invalid: "/calendar/fake-value/default.aspx"
url = url.ToLower();
var validUrl = Utils.RelativeWebRoot.ToLower() + "calendar";
if (!url.StartsWith(validUrl))
throw new HttpException(404, "File not found");
if(url.Contains("default.aspx") && !url.Contains("calendar/default.aspx"))
throw new HttpException(404, "File not found");
context.RewritePath(string.Format("{0}default.aspx?calendar=show", Utils.ApplicationRelativeWebRoot), false);
}
/// <summary>
/// Rewrites the tag.
/// </summary>
/// <param name="context">The HTTP context.</param>
/// <param name="url">The URL string.</param>
public static void RewriteTag(HttpContext context, string url)
{
var tag = ExtractTitle(context, url);
if (url.Contains("/FEED/"))
{
tag = string.Format("syndication.axd?tag={0}{1}", tag, GetQueryString(context));
}
else
{
tag = string.Format("{0}default.aspx?tag=/{1}{2}", Utils.ApplicationRelativeWebRoot, tag, GetQueryString(context));
}
context.RewritePath(tag, false);
}
/// <summary>
/// Rewrites the category.
/// </summary>
/// <param name="context">The HTTP context.</param>
/// <param name="url">The URL string.</param>
public static void RewriteCategory(HttpContext context, string url)
{
var title = ExtractTitle(context, url);
foreach (var cat in from cat in Category.ApplicableCategories
let legalTitle = Utils.RemoveIllegalCharacters(cat.Title).ToLowerInvariant()
where title.Equals(legalTitle, StringComparison.OrdinalIgnoreCase)
select cat)
{
if (url.Contains("/FEED/"))
{
context.RewritePath(string.Format("syndication.axd?category={0}{1}", cat.Id, GetQueryString(context)), false);
}
else
{
context.RewritePath(
string.Format("{0}default.aspx?id={1}{2}", Utils.ApplicationRelativeWebRoot, cat.Id, GetQueryString(context)), false);
break;
}
}
}
/// <summary>
/// Generic routing to rewrite to a physical page, e.g. contact.aspx, archive.aspx, when RemoveExtensionsFromUrls is turned on.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="url">The URL string.</param>
/// <param name="relativePath">The relative path to the page including the physical page name, e.g. archive.aspx, folder/somepage.aspx</param>
private static void RewritePhysicalPageGeneric(HttpContext context, string url, string relativePath)
{
string query = GetQueryString(context);
if (query.Length > 0 && query.StartsWith("&"))
{
query = "?" + query.Substring(1);
}
context.RewritePath(string.Format("{0}{1}{2}", Utils.ApplicationRelativeWebRoot, relativePath, query), false);
}
internal static void RewriteUrl(HttpContext context, string sendToUrl, ref string sendToUrlLessQString, ref string filePath)
{
if (Host.DebugMode)
{
string debugMsg = "{0}, {1}";
context.Response.AppendHeader("X-OpenUrlRewriter-Debug", string.Format(debugMsg, context.Request.RawUrl, sendToUrl));
}
//System.Diagnostics.Debug.WriteLine(context.Request.RawUrl);
//first strip the querystring, if any
var queryString = string.Empty;
sendToUrlLessQString = sendToUrl;
if ((sendToUrl.IndexOf("?") > 0))
{
sendToUrlLessQString = sendToUrl.Substring(0, sendToUrl.IndexOf("?"));
queryString = sendToUrl.Substring(sendToUrl.IndexOf("?") + 1);
}
//grab the file's physical path
filePath = string.Empty;
filePath = context.Server.MapPath(sendToUrlLessQString);
//rewrite the path..
context.RewritePath(sendToUrlLessQString, string.Empty, queryString);
//NOTE! The above RewritePath() overload is only supported in the .NET Framework 1.1
//If you are using .NET Framework 1.0, use the below form instead:
//context.RewritePath(sendToUrl);
}
/// <summary>
/// Rewrites the path to point to the cached image.
/// </summary>
/// <param name="context">
/// The <see cref="HttpContext"/> encapsulating all information about the request.
/// </param>
public override void RewritePath(HttpContext context)
{
// The cached file is valid so just rewrite the path.
context.RewritePath(this.virtualCachedFilePath, false);
}
/// <summary>
/// See <see cref="System.Web.HttpContext"/> for a description.
/// </summary>
public void RewritePath(string path, bool rebaseClientPath)
{
_context.RewritePath(path, rebaseClientPath);
}
//url重定向
static bool ReWriteUrl(HttpContext context)
{
string path = context.Request.Path;
string filePath = UrlReWriteProvider.Instance().RewriteUrl(path, context.Request.Url.Query);
if (filePath != null)
{
string queryString = null;
int index = filePath.IndexOf('?');
if (index >= 0)
{
queryString = (index < (filePath.Length - 1)) ? filePath.Substring(index + 1) : string.Empty;
filePath = filePath.Substring(0, index);
}
context.RewritePath(filePath, null, queryString);
}
return (filePath != null);
}
/// <summary>
/// Rewrites the incoming image request to the actual handler
/// </summary>
/// <param name="context">the context</param>
/// <param name="url">the url string</param>
public static void RewriteImagePath(HttpContext context, string url)
{
var wr = url.Substring(0, url.IndexOf("/IMAGES/") + 7);
url = url.Replace(wr, "");
url = url.Substring(0, url.LastIndexOf(System.IO.Path.GetExtension(url)));
var npath = string.Format("{0}image.axd?picture={1}", Utils.ApplicationRelativeWebRoot, url);
context.RewritePath(npath);
}
public override void RewritePath(string path)
{
w.RewritePath(path);
}
/// <summary>
/// Rewrites the page.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="url">The URL string.</param>
public static void RewritePage(HttpContext context, string url)
{
var slug = ExtractTitle(context, url);
var page =
Page.Pages.Find(
p => slug.Equals(Utils.RemoveIllegalCharacters(p.Slug), StringComparison.OrdinalIgnoreCase));
if (page != null)
{
context.RewritePath(string.Format("{0}page.aspx?id={1}{2}", Utils.ApplicationRelativeWebRoot, page.Id, GetQueryString(context)), false);
}
}
/// <summary>
/// The rewrite default.
/// </summary>
/// <param name="context">
/// The context.
/// </param>
public static void RewriteDefault(HttpContext context)
{
var url = GetUrlWithQueryString(context);
var page = string.Format("&page={0}", context.Request.QueryString["page"]);
if (string.IsNullOrEmpty(context.Request.QueryString["page"]))
{
page = null;
}
if (YearMonthDayRegex.IsMatch(url))
{
var match = YearMonthDayRegex.Match(url);
var year = match.Groups[1].Value;
var month = match.Groups[2].Value;
var day = match.Groups[3].Value;
var date = string.Format("{0}-{1}-{2}", year, month, day);
url = string.Format("{0}default.aspx?date={1}{2}", Utils.ApplicationRelativeWebRoot, date, page);
}
else if (YearMonthRegex.IsMatch(url))
{
var match = YearMonthRegex.Match(url);
var year = match.Groups[1].Value;
var month = match.Groups[2].Value;
var path = string.Format("default.aspx?year={0}&month={1}", year, month);
url = Utils.ApplicationRelativeWebRoot + path + page;
}
else if (YearRegex.IsMatch(url))
{
var match = YearRegex.Match(url);
var year = match.Groups[1].Value;
var path = string.Format("default.aspx?year={0}", year);
url = Utils.ApplicationRelativeWebRoot + path + page;
}
else
{
string newUrl = url.Replace("Default.aspx", "default.aspx"); // fixes a casing oddity on Mono
int defaultStart = url.IndexOf("default.aspx", StringComparison.OrdinalIgnoreCase);
url = Utils.ApplicationRelativeWebRoot + url.Substring(defaultStart);
}
//if (string.IsNullOrEmpty(BlogConfig.FileExtension) && url.Contains("page="))
// url = url.Replace("default.aspx?", "");
context.RewritePath(url, false);
}
public override void RewritePath(string path)
{
_context.RewritePath(path);
}
private static void Handle404OrException(FriendlyUrlSettings settings, HttpContext context, Exception ex, UrlAction result, bool transfer, bool showDebug)
{
//handle Auto-Add Alias
if (result.Action == ActionType.Output404 && CanAutoAddPortalAlias())
{
//Need to determine if this is a real 404 or a possible new alias.
var portalId = Host.Host.HostPortalID;
if (portalId > Null.NullInteger)
{
if (string.IsNullOrEmpty(result.DomainName))
{
result.DomainName = Globals.GetDomainName(context.Request); //parse the domain name out of the request
}
//Get all the existing aliases
var aliases = PortalAliasController.Instance.GetPortalAliasesByPortalId(portalId).ToList();
bool autoaddAlias;
bool isPrimary = false;
if (!aliases.Any())
{
autoaddAlias = true;
isPrimary = true;
}
else
{
autoaddAlias = true;
foreach (var alias in aliases)
{
if (result.DomainName.ToLowerInvariant().IndexOf(alias.HTTPAlias, StringComparison.Ordinal) == 0
&& result.DomainName.Length >= alias.HTTPAlias.Length)
{
autoaddAlias = false;
break;
}
}
}
if (autoaddAlias)
{
var portalAliasInfo = new PortalAliasInfo
{
PortalID = portalId,
HTTPAlias = result.DomainName,
IsPrimary = isPrimary
};
PortalAliasController.Instance.AddPortalAlias(portalAliasInfo);
context.Response.Redirect(context.Request.Url.ToString(), true);
}
}
}
if (context != null)
{
HttpRequest request = context.Request;
HttpResponse response = context.Response;
HttpServerUtility server = context.Server;
const string errorPageHtmlHeader = @"<html><head><title>{0}</title></head><body>";
const string errorPageHtmlFooter = @"</body></html>";
var errorPageHtml = new StringWriter();
CustomErrorsSection ceSection = null;
//876 : security catch for custom error reading
try
{
ceSection = (CustomErrorsSection) WebConfigurationManager.GetSection("system.web/customErrors");
}
// ReSharper disable EmptyGeneralCatchClause
catch (Exception)
// ReSharper restore EmptyGeneralCatchClause
{
//on some medium trust environments, this will throw an exception for trying to read the custom Errors
//do nothing
}
/* 454 new 404/500 error handling routine */
bool useDNNTab = false;
int errTabId = -1;
string errUrl = null;
string status = "";
bool isPostback = false;
if (settings != null)
{
if (request.RequestType == "POST")
{
isPostback = true;
}
if (result != null && ex != null)
{
result.DebugMessages.Add("Exception: " + ex.Message);
result.DebugMessages.Add("Stack Trace: " + ex.StackTrace);
if (ex.InnerException != null)
{
result.DebugMessages.Add("Inner Ex : " + ex.InnerException.Message);
result.DebugMessages.Add("Stack Trace: " + ex.InnerException.StackTrace);
}
else
{
result.DebugMessages.Add("Inner Ex : null");
}
}
string errRH;
string errRV;
int statusCode;
if (result != null && result.Action != ActionType.Output404)
{
//output everything but 404 (usually 500)
if (settings.TabId500 > -1) //tabid specified for 500 error page, use that
{
useDNNTab = true;
errTabId = settings.TabId500;
}
errUrl = settings.Url500;
errRH = "X-UrlRewriter-500";
errRV = "500 Rewritten to {0} : {1}";
statusCode = 500;
status = "500 Internal Server Error";
}
else //output 404 error
{
if (settings.TabId404 > -1) //if the tabid is specified for a 404 page, then use that
{
useDNNTab = true;
errTabId = settings.TabId404;
}
if (!String.IsNullOrEmpty(settings.Regex404))
//with 404 errors, there's an option to catch certain urls and use an external url for extra processing.
{
try
{
//944 : check the original Url in case the requested Url has been rewritten before discovering it's a 404 error
string requestedUrl = request.Url.ToString();
if (result != null && string.IsNullOrEmpty(result.OriginalPath) == false)
{
requestedUrl = result.OriginalPath;
}
if (Regex.IsMatch(requestedUrl, settings.Regex404, RegexOptions.IgnoreCase | RegexOptions.CultureInvariant))
{
useDNNTab = false;
//if we have a match in the 404 regex value, then don't use the tabid
}
}
catch (Exception regexEx)
{
//.some type of exception : output in response header, and go back to using the tabid
response.AppendHeader("X-UrlRewriter-404Exception", regexEx.Message);
}
}
errUrl = settings.Url404;
errRH = "X-UrlRewriter-404";
errRV = "404 Rewritten to {0} : {1} : Reason {2}";
status = "404 Not Found";
statusCode = 404;
}
// check for 404 logging
if ((result == null || result.Action == ActionType.Output404))
{
//Log 404 errors to Event Log
UrlRewriterUtils.Log404(request, settings, result);
}
//912 : use unhandled 404 switch
string reason404 = null;
bool unhandled404 = true;
if (useDNNTab && errTabId > -1)
{
unhandled404 = false; //we're handling it here
TabInfo errTab = TabController.Instance.GetTab(errTabId, result.PortalId, true);
if (errTab != null)
{
bool redirect = false;
//ok, valid tabid. what we're going to do is to load up this tab via a rewrite of the url, and then change the output status
string reason = "Not Found";
if (result != null)
{
reason = result.Reason.ToString();
}
response.AppendHeader(errRH, string.Format(errRV, "DNN Tab",
errTab.TabName + "(Tabid:" + errTabId.ToString() + ")",
reason));
//show debug messages even if in debug mode
if (context != null && response != null && result != null && showDebug)
{
ShowDebugData(context, result.OriginalPath, result, null);
}
if (!isPostback)
{
response.ClearContent();
response.StatusCode = statusCode;
response.Status = status;
}
else
{
redirect = true;
//redirect postbacks as you can't postback successfully to a server.transfer
}
errUrl = Globals.glbDefaultPage + TabIndexController.CreateRewritePath(errTab.TabID, "");
//have to update the portal settings with the new tabid
PortalSettings ps = null;
if (context != null && context.Items != null)
{
if (context.Items.Contains("PortalSettings"))
{
ps = (PortalSettings) context.Items["PortalSettings"];
context.Items.Remove("PortalSettings"); //nix it from the context
}
}
if (ps != null && ps.PortalAlias != null)
{
ps = new PortalSettings(errTabId, ps.PortalAlias);
}
else
{
if (result.HttpAlias != null && result.PortalId > -1)
{
PortalAliasInfo pa = PortalAliasController.Instance.GetPortalAlias(result.HttpAlias, result.PortalId);
ps = new PortalSettings(errTabId, pa);
}
else
{
//912 : handle 404 when no valid portal can be identified
//results when iis is configured to handle portal alias, but
//DNN isn't. This always returns 404 because a multi-portal site
//can't just show the 404 page of the host site.
ArrayList portals = PortalController.Instance.GetPortals();
if (portals != null && portals.Count == 1)
{
//single portal install, load up portal settings for this portal
var singlePortal = (PortalInfo) portals[0];
//list of aliases from database
var aliases = PortalAliasController.Instance.GetPortalAliasesByPortalId(singlePortal.PortalID).ToList();
//list of aliases from Advanced Url settings
List<string> chosen = aliases.GetAliasesForPortalId(singlePortal.PortalID);
PortalAliasInfo useFor404 = null;
//go through all aliases and either get the first valid one, or the first
//as chosen in the advanced url management settings
foreach (var pa in aliases)
{
if (useFor404 == null)
{
useFor404 = pa; //first one by default
}
//matching?
if (chosen != null && chosen.Count > 0)
{
if (chosen.Contains(pa.HTTPAlias))
{
useFor404 = pa;
}
}
else
{
break; //no further checking
}
}
//now configure that as the portal settings
if (useFor404 != null)
{
//create portal settings context for identified portal alias in single portal install
ps = new PortalSettings(errTabId, useFor404);
}
}
else
{
reason404 = "Requested domain name is not configured as valid website";
unhandled404 = true;
}
}
}
if (ps != null)
{
//re-add the context items portal settings back in
context.Items.Add("PortalSettings", ps);
}
if (redirect)
{
errUrl = TestableGlobals.Instance.NavigateURL();
response.Redirect(errUrl, true); //redirect and end response.
//It will mean the user will have to postback again, but it will work the second time
}
else
{
if (transfer)
{
//execute a server transfer to the default.aspx?tabid=xx url
//767 : object not set error on extensionless 404 errors
if (context.User == null)
{
context.User = Thread.CurrentPrincipal;
}
response.TrySkipIisCustomErrors = true;
//881 : spoof the basePage object so that the client dependency framework
//is satisfied it's working with a page-based handler
IHttpHandler spoofPage = new CDefault();
context.Handler = spoofPage;
server.Transfer("~/" + errUrl, true);
}
else
{
context.RewritePath("~/Default.aspx", false);
response.TrySkipIisCustomErrors = true;
response.Status = "404 Not Found";
response.StatusCode = 404;
}
}
}
}
//912 : change to new if statement to handle cases where the TabId404 couldn't be handled correctly
if (unhandled404)
{
//proces the error on the external Url by rewriting to the external url
if (!String.IsNullOrEmpty(errUrl))
{
response.ClearContent();
response.TrySkipIisCustomErrors = true;
string reason = "Not Found";
if (result != null)
{
reason = result.Reason.ToString();
}
response.AppendHeader(errRH, string.Format(errRV, "Url", errUrl, reason));
if (reason404 != null)
{
response.AppendHeader("X-Url-Master-404-Data", reason404);
}
response.StatusCode = statusCode;
response.Status = status;
server.Transfer("~/" + errUrl, true);
}
else
{
errorPageHtml.Write(status + "<br>The requested Url does not return any valid content.");
if (reason404 != null)
{
errorPageHtml.Write(status + "<br>" + reason404);
}
errorPageHtml.Write("<div style='font-weight:bolder'>Administrators</div>");
errorPageHtml.Write("<div>Change this message by configuring a specific 404 Error Page or Url for this website.</div>");
//output a reason for the 404
string reason = "";
if (result != null)
{
reason = result.Reason.ToString();
}
if (!string.IsNullOrEmpty(errRH) && !string.IsNullOrEmpty(reason))
{
response.AppendHeader(errRH, reason);
}
response.StatusCode = statusCode;
response.Status = status;
}
}
}
else
{
//fallback output if not valid settings
if (result != null && result.Action == ActionType.Output404)
{
//don't restate the requested Url to prevent cross site scripting
errorPageHtml.Write("404 Not Found<br>The requested Url does not return any valid content.");
response.StatusCode = 404;
response.Status = "404 Not Found";
}
else
{
//error, especially if invalid result object
errorPageHtml.Write("500 Server Error<br><div style='font-weight:bolder'>An error occured during processing : if possible, check the event log of the server</div>");
response.StatusCode = 500;
response.Status = "500 Internal Server Error";
if (result != null)
{
result.Action = ActionType.Output500;
}
}
}
if (ex != null)
{
if (context != null)
{
if (context.Items.Contains("UrlRewrite:Exception") == false)
{
context.Items.Add("UrlRewrite:Exception", ex.Message);
context.Items.Add("UrlRewrite:StackTrace", ex.StackTrace);
}
}
if (ceSection != null && ceSection.Mode == CustomErrorsMode.Off)
{
errorPageHtml.Write(errorPageHtmlHeader);
errorPageHtml.Write("<div style='font-weight:bolder'>Exception:</div><div>" + ex.Message + "</div>");
errorPageHtml.Write("<div style='font-weight:bolder'>Stack Trace:</div><div>" + ex.StackTrace + "</div>");
errorPageHtml.Write("<div style='font-weight:bolder'>Administrators</div>");
errorPageHtml.Write("<div>You can see this exception because the customErrors attribute in the web.config is set to 'off'. Change this value to 'on' or 'RemoteOnly' to show Error Handling</div>");
try
{
if (errUrl != null && errUrl.StartsWith("~"))
{
errUrl = VirtualPathUtility.ToAbsolute(errUrl);
}
}
finally
{
if (errUrl != null)
{
errorPageHtml.Write("<div>The error handling would have shown this page : <a href='" + errUrl + "'>" + errUrl + "</a></div>");
}
else
{
errorPageHtml.Write("<div>The error handling could not determine the correct page to show.</div>");
}
}
}
}
string errorPageHtmlBody = errorPageHtml.ToString();
if (errorPageHtmlBody.Length > 0)
{
response.Write(errorPageHtmlHeader);
response.Write(errorPageHtmlBody);
response.Write(errorPageHtmlFooter);
}
if (ex != null)
{
UrlRewriterUtils.LogExceptionInRequest(ex, status, result);
}
}
}
/// <summary>
/// 通过实现 IHttpHandler 接口的自定义 HttpHandler 启用 HTTP Web 请求的处理。
/// </summary>
/// <param name="context">HttpContext 对象，它提供对用于为 HTTP 请求提供服务的内部服务器对象（如 Request、Response、Session 和 Server）的引用。</param>
public override void ProcessRequest(System.Web.HttpContext context)
{
base.ProcessRequest(context);
string path = context.Server.MapPath(this.RealPath);
if (System.IO.File.Exists(path))
{
switch (this.Config.Action)
{
case "none":
PageParser.GetCompiledPageInstance(this.RealPath, path, context).ProcessRequest(context);
break;
case "rewrite":
context.RewritePath(context.Request.Path, this.PathInfo, this.QueryString);
PageParser.GetCompiledPageInstance(this.RealPath, path, context).ProcessRequest(context);
break;
case "cache_static":
//一般静态文件缓存.
case "cache_static_news":
//新闻查看静态文件缓存
case "cache_static_pub":
//蒲点查看静态文件缓存
string filePath = context.Server.MapPath(this.FilePath);
FileInfo fileInfo = new FileInfo(filePath);
FileInfo fileInfoSource = new FileInfo(path);
bool toRebuild = false;
if (!fileInfo.Exists ||
(this.Config.TimeSpan.Ticks > 0 &&
fileInfo.LastWriteTime.Add(this.Config.TimeSpan) < DateTime.Now) ||
fileInfoSource.LastWriteTime > fileInfo.LastWriteTime)
{
toRebuild = true;
}
if (toRebuild)
{
context.RewritePath(context.Request.Path, this.PathInfo, this.QueryString);
switch (this.Config.Action)
{
case "cache_static_news":
#region 新闻查看静态文件缓存
/*long newsId = 0;
* if (context.Request.QueryString["newsId"] != null &&
* context.Request.QueryString["newsId"].Length != 0)
* {
* newsId = Convert.ToInt64(context.Request.QueryString["newsId"] , 10);
*
* }
* DataModel.News.News newsItem = null;
*
* if (context.Items[News.PageBaseNewsView.CONTEXT_KEY_NEWS] == null &&
* newsId > 0)
* {
* context.Items[News.PageBaseNewsView.CONTEXT_KEY_NEWS] = DAL.News.News.Get(newsId);
* }
*
* newsItem = context.Items[News.PageBaseNewsView.CONTEXT_KEY_NEWS] as DataModel.News.News;
*
* if (newsItem == null)
* {
* context.Response.Redirect(this.Error404Url , true);
* }
*
* if (newsItem != null &&
* newsItem.CheckState == DataModel.News.CheckState.Passed &&
* newsItem.IsView)
* {
* PageParser.GetCompiledPageInstance(this.RealPath , path , context).ProcessRequest(context);
*
* this.SetStaticFilter(context , filePath);
* return;
* }
* else
* {
* context.Response.Redirect(this.Error404Url , true);
* return;
* }*/
#endregion
case "cache_static":
default:
#region 一般静态文件缓存
PageParser.GetCompiledPageInstance(this.RealPath, path, context).ProcessRequest(context);
this.SetStaticFilter(context, filePath);
return;
#endregion
}
}
else
{
//直接调用静态文件
context.Response.WriteFile(filePath);
context.Response.End();
}
break;
}
}
else
{
context.Response.Redirect(this.Error404Url, true);
}
}
