/// <summary>
/// Processes the specified log level.
/// </summary>
/// <param name="context">The context.</param>
/// <returns></returns>
public void Execute(RuleContext context)
{
string inputUrl = context.CurrentUrl.GetComponents(UriComponents.PathAndQuery, UriFormat.UriEscaped);
string sqlCommand = Pattern.Replace(inputUrl, Substitution, context);
string substituedUrl;
using (MySqlConnection connection = new MySqlConnection(Properties.Settings.Default.DatabaseConnection))
using (MySqlCommand command = connection.CreateCommand())
{
command.CommandText = sqlCommand;
command.CommandType = CommandType.Text;
try
{
connection.Open();
substituedUrl = command.ExecuteScalar() as string;
}
finally
{
connection.Close();
}
}
context.SubstitutedUrl = new Uri(context.CurrentUrl, substituedUrl);
}
/// <summary>
/// Initializes a new instance of the <see cref="ConditionContext"/> class.
/// </summary>
/// <param name="index">The index.</param>
/// <param name="ruleContext">The rule context.</param>
/// <param name="condition">The condition.</param>
public ConditionContext(int index, RuleContext ruleContext, ICondition condition)
: base(ruleContext)
{
if (condition == null)
throw new ArgumentNullException("condition");
ConditionIndex = index;
LogCategory = "Condition " + index;
CurrentCondition = condition;
}
/// <summary>
/// Initializes a new instance of the <see cref="RuleContext"/> class.
/// </summary>
/// <param name="copy">The copy.</param>
internal RuleContext(RuleContext copy)
: base(copy)
{
RuleIndex = copy.RuleIndex;
LogCategory = copy.LogCategory;
_currentContent = copy._currentContent;
_substitutedContent = copy.SubstitutedContent;
CurrentUrl = copy.CurrentUrl;
_substitutedUrl = copy.SubstitutedUrl;
CurrentRule = copy.CurrentRule;
}
public string GetValue(string input, RuleContext context)
{
int startIndex = 1;
for (int i = 0; i < context.Conditions.Count; i++)
{
var cond = context.Conditions[i];
int groupCount = cond.Pattern.GetGroupCount(input);
ConditionContext condContext = new ConditionContext(i, context, cond);
if ((startIndex + groupCount) >= Index)
{
int varIndex = Math.Abs(startIndex - _index);
return cond.Pattern.GetValue(cond.Test.GetValue(condContext), varIndex, condContext);
}
startIndex += groupCount;
}
return null;
}
/// <summary>
///
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public virtual bool IsMatch(RuleContext context)
{
string testUrl = context.CurrentUrl.AbsolutePath;
return Pattern.IsMatch(testUrl);
}
/// <summary>
/// Returns a <see cref="T:System.String"/> that represents the current <see cref="T:System.Object"/>.
/// </summary>
/// <returns>
/// A <see cref="T:System.String"/> that represents the current <see cref="T:System.Object"/>.
/// </returns>
public string ToString(RuleContext context)
{
return Replace(ToString(false), context);
}
/// <summary>
/// Replaces the specified input for a rule variable.
/// </summary>
/// <param name="input">The input.</param>
/// <param name="replacement">The replacement.</param>
/// <param name="context">The context.</param>
/// <returns></returns>
public string Replace(string input, string replacement, RuleContext context)
{
if (context != null)
replacement = Variables.Replace(replacement, match => {
if (match.Groups["condvar"].Success)
{
var condVar = GetConditionVariable(match);
return condVar.GetValue(input, context);
}
else if (match.Groups["servervar"].Success)
{
var serverVar = GetServerVariable(match);
return serverVar.GetValue(input, context);
}
return match.Value;
});
return _pattern.Replace(input, replacement);
}
/// <summary>
/// Gets the value.
/// </summary>
/// <param name="input">The input.</param>
/// <param name="index">The index.</param>
/// <param name="context">The context.</param>
/// <returns>Returns the value of the pattern for the <paramref name="index"/></returns>
public string GetValue(string input, int index, RuleContext context)
{
return GetValue(input, index);
}
/// <summary>
/// Determines whether the specified input is match.
/// </summary>
/// <param name="input">The input.</param>
/// <param name="context">The context.</param>
/// <returns>
/// <see langword="true"/> if the specified input is match; otherwise, <see langword="false"/>.
/// </returns>
public bool IsMatch(string input, RuleContext context)
{
// if the input contains a rule or a condition placeholders that need to be
// replaced from the input URL it needs to be processed by the rule pattern
// before we can check if it is a match
if (input.IndexOfAny(new[] { '%', '$' }) >= 0)
input = Replace(input, context);
return IsMatch(input);
}
/// <summary>
///
/// </summary>
/// <param name="httpContext"></param>
/// <param name="content"></param>
/// <returns></returns>
public byte[] RunOutputRules(HttpContextBase httpContext, byte[] content)
{
var context = new RuleSetContext(this, content, httpContext);
byte[] currentContent = content;
if (!EngineEnabled)
Manager.LogIf(!EngineEnabled && LogLevel >= 9, "Rewrite Engine Is DISABLED", "OutRewrite");
if (_outputRules.Count > 0 && EngineEnabled)
{
Manager.LogIf(LogLevel >= 1, "**********************************************************************************");
//Manager.LogIf(LogLevel >= 9, "Input: " + currentContent, "OutRewrite");
var temporyFlags = (IRuleFlagProcessor)null;
bool skipNextChain = false;
byte[] initialContent = currentContent;
// process rules according to their settings
for (int i = 0; i < _outputRules.Count; i++)
{
var ruleContext = new RuleContext(i, context, currentContent, _outputRules[i]);
temporyFlags = _outputRules[i].Flags;
bool containsChain = RuleFlagsProcessor.HasChain(_outputRules[i].Flags);
bool previousContainsChain = RuleFlagsProcessor.HasChain(_outputRules[Math.Max(0, i - 1)].Flags);
// if the previous rule doesn't contain a chain flag then set the initial URL
// this will be used to reset a chain if one of the chain rules fail
if (!previousContainsChain)
initialContent = currentContent;
// skip if the current rule or the last rule has a chain flag
// and if the skip next chain is set
if (skipNextChain && (previousContainsChain || containsChain))
continue;
else
skipNextChain = false;
if (_outputRules[i].TryExecute(ruleContext))
{
var flagResponse = temporyFlags.Apply(ruleContext);
currentContent = ruleContext.SubstitutedContent;
i = ruleContext.RuleIndex ?? -1;
bool breakLoop = false;
// apply the flags to the rules, and only do special processing
// for the flag responses listed in the switch statement below
switch (flagResponse)
{
case RuleFlagProcessorResponse.ExitRuleSet:
return null;
case RuleFlagProcessorResponse.LastRule:
breakLoop = true;
break;
}
// break the loop because we have reached the last rule as indicated by a flag
if (breakLoop)
break;
}
else if (containsChain)
{
skipNextChain = true;
// reset the current URL back to the initial URL from the start of the chain
currentContent = initialContent;
}
else if (previousContainsChain)
{
// reset the current URL back to the initial URL from the start of the chain
currentContent = initialContent;
}
}
//Manager.LogIf(LogLevel >= 9, "Output: " + currentContent, "OutRewrite");
Manager.LogIf(LogLevel >= 1, "**********************************************************************************");
}
return currentContent;
}
/// <summary>
/// Runs the rules.
/// </summary>
/// <param name="httpContext">The HTTP context.</param>
/// <param name="url">The URL.</param>
/// <returns>
/// Returns a rewritten <see cref="System.Uri"/>, or a value of <see langword="null"/> if no rewriting was done to <paramref name="url"/>.
/// </returns>
public Uri RunRules(HttpContextBase httpContext, Uri url)
{
var context = new RuleSetContext(this, url, httpContext);
var currentUrl = url;
if (!EngineEnabled)
Manager.LogIf(!EngineEnabled && LogLevel >= 9, "Rewrite Engine Is DISABLED", "Rewrite");
if (_rules.Count > 0 && EngineEnabled)
{
Manager.LogIf(LogLevel >= 1, "**********************************************************************************");
Manager.LogIf(LogLevel >= 1, "Input: " + currentUrl, "Rewrite");
// check if max number of internal transfers have been exceeded
if (InternalTransferCount(httpContext) > MaxInternalTransfers)
{
string message = "Exceeded the max number of internal transfers.";
Manager.LogIf(LogLevel >= 1, message, "Error");
throw new HttpException(500, message);
}
var temporyFlags = (IRuleFlagProcessor)null;
var skipNextChain = false;
var initialUrl = currentUrl;
if (!String.IsNullOrEmpty(VirtualBase) && VirtualBase != "/")
currentUrl = RemoveBase(VirtualBase, currentUrl);
// process rules according to their settings
for (int i = 0; i < _rules.Count; i++)
{
var ruleContext = new RuleContext(i, context, currentUrl, _rules[i]);
temporyFlags = _rules[i].Flags;
// continue if this rule shouldn't be processed because it doesn't allow internal transfer requests
if (RuleFlagsProcessor.HasNotForInternalSubRequests(temporyFlags) && IsInternalTransfer(httpContext))
continue;
bool containsChain = RuleFlagsProcessor.HasChain(_rules[i].Flags);
bool previousContainsChain = RuleFlagsProcessor.HasChain(_rules[Math.Max(0, i - 1)].Flags);
// if the previous rule doesn't contain a chain flag then set the initial URL
// this will be used to reset a chain if one of the chain rules fail
if (!previousContainsChain)
initialUrl = currentUrl;
// skip if the current rule or the last rule has a chain flag
// and if the skip next chain is set
if (skipNextChain && (previousContainsChain || containsChain))
continue;
else
skipNextChain = false;
if (_rules[i].TryExecute(ruleContext))
{
var flagResponse = temporyFlags.Apply(ruleContext);
currentUrl = ruleContext.SubstitutedUrl;
i = ruleContext.RuleIndex ?? -1;
bool breakLoop = false;
// apply the flags to the rules, and only do special processing
// for the flag responses listed in the switch statement below
switch (flagResponse)
{
case RuleFlagProcessorResponse.ExitRuleSet:
return null;
case RuleFlagProcessorResponse.LastRule:
breakLoop = true;
break;
}
// break the loop because we have reached the last rule as indicated by a flag
if (breakLoop)
break;
}
else if (containsChain)
{
skipNextChain = true;
// reset the current URL back to the initial URL from the start of the chain
currentUrl = initialUrl;
}
else if (previousContainsChain)
{
// reset the current URL back to the initial URL from the start of the chain
currentUrl = initialUrl;
}
}
// if the scheme, host, and ports do not match on the request vs the rewrite a redirect needs to be performed instead of a rewrite
if (Uri.Compare(currentUrl, context.RequestedUrl, UriComponents.SchemeAndServer, UriFormat.SafeUnescaped, StringComparison.OrdinalIgnoreCase) != 0)
{
Manager.LogIf(LogLevel >= 1, "Output: 302 Redirect to " + currentUrl, "Rewrite");
Manager.Redirect(httpContext, "found", currentUrl);
}
if (!String.IsNullOrEmpty(VirtualBase) && VirtualBase != "/")
currentUrl = AddBase(VirtualBase, currentUrl);
Manager.LogIf(LogLevel >= 1, "Output: " + currentUrl, "Rewrite");
Manager.LogIf(LogLevel >= 1, "**********************************************************************************");
Manager.TryToAddXRewriteUrlHeader(httpContext);
Manager.TryToAddVanityHeader(httpContext);
}
// if the http request url matches for both the request and the rewrite no work was done so the url should be null
if (Uri.Compare(currentUrl, url, UriComponents.HttpRequestUrl, UriFormat.SafeUnescaped, StringComparison.OrdinalIgnoreCase) == 0)
currentUrl = null;
return currentUrl;
}