public static string ReplaceVars(HtcHttpContext httpContext, string data)
{
data = data.Replace("$scheme", httpContext.Request.Scheme);
data = data.Replace("$uri", httpContext.Request.RequestPath);
data = data.Replace("$host", httpContext.Request.Host);
return(data);
}
public Task Invoke(HtcHttpContext httpContext)
{
foreach (string fileName in _files)
{
if (fileName.Equals("/$internal"))
{
foreach (string fileName2 in httpContext.Site.Indexes)
{
var path2 = httpContext.Request.Path.Add(fileName2);
string extension = Path.GetExtension(path2);
var fileInfo = httpContext.Site.FileProvider.GetFileInfo(path2);
if (fileInfo.Exists && httpContext.Site.FileExtensions.TryGetValue(extension, out var extensionProcessor))
{
return(extensionProcessor.OnHttpExtensionProcess(_next, httpContext, path2, extension));
}
}
}
var path = httpContext.Request.Path.Add(fileName);
var staticFileContext = new StaticFileContext(httpContext, httpContext.Site.FileProvider, path);
if (!staticFileContext.LookupFileInfo())
{
continue;
}
return(staticFileContext.ServeStaticFile(httpContext, _next));
}
return(_next(httpContext));
}
public void ExecutePageMessage(HtcHttpContext httpContext)
{
if (httpContext.Response.HasStarted)
{
return;
}
var fileContent = File.ReadAllText(_pageFileName, Encoding.UTF8);
fileContent = fileContent.Replace("{Request.Path}", httpContext.Request.Path);
fileContent = fileContent.Replace("{Request.Host}", httpContext.Request.Host);
fileContent = fileContent.Replace("{Request.PathBase}", httpContext.Request.PathBase);
fileContent = fileContent.Replace("{Request.Protocol}", httpContext.Request.Protocol);
fileContent = fileContent.Replace("{Request.QueryString}", httpContext.Request.QueryString);
fileContent = fileContent.Replace("{Request.RequestFilePath}", httpContext.Request.RequestFilePath);
fileContent = fileContent.Replace("{Request.RequestPath}", httpContext.Request.RequestPath);
fileContent = fileContent.Replace("{Request.Scheme}", httpContext.Request.Scheme);
fileContent = fileContent.Replace("{Request.TranslatedPath}", httpContext.Request.TranslatedPath);
fileContent = fileContent.Replace("{Request.IsHttps}", httpContext.Request.IsHttps.ToString());
fileContent = fileContent.Replace("{Request.Method}", httpContext.Request.Method.ToString());
fileContent = fileContent.Replace("{Connection.Id}", httpContext.Connection.Id);
fileContent = fileContent.Replace("{Connection.RemoteIpAddress}", httpContext.Connection.RemoteIpAddress.ToString());
fileContent = fileContent.Replace("{Connection.RemotePort}", httpContext.Connection.RemotePort.ToString());
httpContext.Response.StatusCode = StatusCode;
httpContext.Response.WriteAsync(fileContent).GetAwaiter().GetResult();
}
public async Task ProcessRequest(HttpContext httpContext)
{
#if DEBUG
var stopWatch = new Stopwatch();
stopWatch.Start();
#endif
var matchedSite = _sites.FirstOrDefault(site => site.Match(httpContext));
#if DEBUG
stopWatch.Stop();
Logger.LogDebug($"Router took {stopWatch.ElapsedMilliseconds}ms to match location.");
#endif
if (matchedSite == null)
{
}
else
{
#if DEBUG
stopWatch.Reset();
stopWatch.Start();
#endif
var htcContext = new HtcHttpContext(httpContext, matchedSite);
await matchedSite.ProcessRequest(htcContext);
#if DEBUG
stopWatch.Stop();
Logger.LogDebug($"Router took {stopWatch.ElapsedMilliseconds}ms to process request.");
#endif
}
}
private static Tuple <long, long> GetRange(HtcHttpContext httpContext, FileBuffer fileBuffer)
{
var rangeData = GetHeader(httpContext, "Range");
long startRange;
long endRange = -1;
if (rangeData != null)
{
var rangeHeader = rangeData.Replace("bytes=", "");
var range = rangeHeader.Split('-');
startRange = long.Parse(range[0]);
if (range[1].Trim().Length > 0)
{
long.TryParse(range[1], out endRange);
}
if (endRange == -1)
{
endRange = fileBuffer.Lenght;
}
}
else
{
startRange = 0;
endRange = fileBuffer.Lenght;
}
return(new Tuple <long, long>(startRange, endRange));
}
public void Execute(HtcHttpContext context)
{
foreach (var i in _indexes)
{
var index = HttpIoUtils.ReplaceVars(context, i);
if (index.Equals("$internal_indexes"))
{
foreach (var j in UrlMapper.IndexFiles)
{
var indexPath = Path.Combine(context.ServerInfo.RootPath, j[0].Equals('/') ? j.Remove(0, 1) : Path.Combine(context.Request.Path, j).Remove(0, 1));
if (!File.Exists(indexPath))
{
continue;
}
var extension = Path.GetExtension(indexPath);
context.Request.RequestFilePath = indexPath;
if (UrlMapper.ExtensionPlugins.TryGetValue(extension.ToLower(), out var plugin))
{
if (!plugin.OnHttpExtensionRequest(context, indexPath, extension.ToLower()))
{
continue;
}
context.ErrorMessageManager.SendError(context, 500);
return;
}
try {
HttpIoUtils.CallFile(context, indexPath);
} catch {
context.ErrorMessageManager.SendError(context, 500);
}
return;
}
}
else
{
var indexPath = Path.Combine(context.ServerInfo.RootPath, index[0].Equals('/') ? index.Remove(0, 1) : Path.Combine(context.Request.Path, index).Remove(0, 1));
if (!File.Exists(indexPath))
{
continue;
}
var extension = Path.GetExtension(indexPath);
context.Request.RequestFilePath = indexPath;
if (UrlMapper.ExtensionPlugins.TryGetValue(extension.ToLower(), out var plugin))
{
if (!plugin.OnHttpExtensionRequest(context, indexPath, extension.ToLower()))
{
continue;
}
context.ErrorMessageManager.SendError(context, 500);
return;
}
try {
HttpIoUtils.CallFile(context, indexPath);
} catch {
context.ErrorMessageManager.SendError(context, 500);
}
return;
}
}
}
public byte MatchRules(string request, HtcHttpContext context, out string newRequest)
{
if (_actionType == 1)
{
var remotePath = request.Equals("/") ? "/" : $"{Path.GetDirectoryName(request).Replace(@"\", @"/")}/".Replace(@"//", @"/");
if (_data.Equals(remotePath))
{
foreach (var rule in _rules)
{
var response = rule.MatchRule(request, context, out request);
if (response == 1)
{
newRequest = request;
return(0);
}
else if (response == 2)
{
context.Response.StatusCode = 302;
context.Response.Headers.Add("Location", request);
newRequest = request;
return(1);
}
else if (response == 3)
{
context.Response.StatusCode = 301;
context.Response.Headers.Add("Location", request);
newRequest = request;
return(1);
}
}
}
}
newRequest = request;
return(0);
}
public LuaContext(HtcHttpContext httpContext, string fileName)
{
_script = new Script();
_httpContext = httpContext;
_fileName = fileName;
_fileInfo = null;
}
public static void CallFile(HtcHttpContext httpContext, string requestPath)
{
using (var fileBuffer = new FileBuffer(requestPath, 2048)) {
var contentType = ContentType.DEFAULT.FromExtension(requestPath);
// 7 * 24 Hour * 60 Min * 60 Sec = 604800 Sec;
httpContext.Response.Headers.Add("Access-Control-Allow-Origin", "*");
httpContext.Response.Headers.Add("Date", DateTime.Now.ToString("r"));
//context.Response.Headers.Add("Last-Modified", File.GetLastWriteTime(requestPath).ToString("r"));
httpContext.Response.Headers.Add("Server", "HtcSharp");
//context.Response.Headers.Add("Cache-Control", "max-age=604800");
httpContext.Response.ContentType = contentType.ToValue();
httpContext.Response.StatusCode = 200;
var(startRange, endRange) = GetRange(httpContext, fileBuffer);
if (UseGzip(httpContext, fileBuffer.Lenght))
{
httpContext.Response.Headers.Add("Content-Encoding", "gzip");
using (var gzipStream = new GZipStream(httpContext.Response.OutputStream, CompressionMode.Compress, false)) {
fileBuffer.CopyToStream(gzipStream, startRange, endRange);
}
}
else
{
httpContext.Response.ContentLength = endRange - startRange;
fileBuffer.CopyToStream(httpContext.Response.OutputStream, startRange, endRange);
}
}
}
public Task Invoke(HtcHttpContext httpContext)
{
foreach ((string key, string value) in _headers)
{
httpContext.Response.Headers.Add(key, value);
}
return(_next(httpContext));
}
public void Execute(HtcHttpContext context)
{
foreach (var file in _files)
{
var tempPath = HttpIoUtils.ReplaceVars(context, file);
if (tempPath[0].Equals('='))
{
if (int.TryParse(tempPath.Remove(0, 1), out var statusCode))
{
context.ErrorMessageManager.SendError(context, statusCode);
return;
}
context.ErrorMessageManager.SendError(context, 500);
return;
}
if (tempPath[0].Equals('@'))
{
foreach (var location in _httpLocationManager.Locations)
{
if (!location.Key.Equals(tempPath, StringComparison.CurrentCultureIgnoreCase))
{
continue;
}
location.Execute(context);
return;
}
}
context.Request.TranslatedPath = Path.GetFullPath(Path.Combine(context.ServerInfo.RootPath, tempPath.Remove(0, 1)));
if (File.Exists(context.Request.TranslatedPath))
{
var extension = Path.GetExtension(context.Request.TranslatedPath);
if (UrlMapper.ExtensionPlugins.ContainsKey(extension.ToLower()))
{
if (UrlMapper.ExtensionPlugins[extension.ToLower()].OnHttpExtensionRequest(context, context.Request.TranslatedPath, extension.ToLower()))
{
context.ErrorMessageManager.SendError(context, 500);
}
}
else
{
try {
HttpIoUtils.CallFile(context, context.Request.TranslatedPath);
} catch {
context.ErrorMessageManager.SendError(context, 500);
}
}
}
else if (Directory.Exists(context.Request.TranslatedPath))
{
if (!context.Request.RequestPath.EndsWith('/'))
{
context.Response.Redirect(context.Request.RequestPath + "/");
}
//context.ErrorMessageManager.SendError(context, 404);
// Do indexer
}
}
}
public void Execute(HtcHttpContext context)
{
var match = _pattern.Match(context.Request.Path);
if (!match.Success)
{
return;
}
var newRequest = HttpIoUtils.ReplaceVars(context, _rewriteData);
for (var i = 0; i < match.Captures.Count; i++)
{
newRequest = newRequest.Replace($"${i + 1}", match.Captures[i].Value);
}
/*foreach (Match match in _pattern.Matches(context.Request.Path)) {
* newRequest = newRequest.Replace($"${match.Name}", match.Value);
* }*/
/*var rewriteQuery = _rewriteData.Split("?");
* request = rewriteQuery[0].Replace("$scheme", context.Request.Scheme);
* if (rewriteQuery.Length == 1) {
* request = _rewriteData;
* Logger.Info($"{request}");
* for (var p = 1; p < requestParts.Length; p++) {
* request = request.Replace($"${p}", requestParts[p]);
* }
* Logger.Info($"{request}");
* } else if (rewriteQuery.Length == 2) {
* var queryParts = rewriteQuery[1].Split("&");
* foreach (var query in queryParts) {
* var queryData = query.Split("=");
* var key = queryData[0];
* var value = queryData[1];
* for (var p = 1; p < requestParts.Length; p++) {
* value = value.Replace($"${p}", requestParts[p]);
* }
* context.Request.Query.Add(key, value);
* }
* }*/
/*if (_flag.Equals("last", StringComparison.CurrentCultureIgnoreCase)) {
* context.Request
* }
* if (_flag.Equals("break", StringComparison.CurrentCultureIgnoreCase)) {
*
* }*/
if (_flag.Equals("redirect", StringComparison.CurrentCultureIgnoreCase))
{
context.Response.StatusCode = 302;
context.Response.Headers.Add("Location", newRequest);
}
if (_flag.Equals("permanent", StringComparison.CurrentCultureIgnoreCase))
{
context.Response.StatusCode = 301;
context.Response.Headers.Add("Location", newRequest);
}
context.Request.RequestPath = newRequest;
}
protected virtual async Task ThrowException(HtcHttpContext httpContext, Exception exception)
{
Logger.LogError($"[{httpContext.Connection.Id}]", exception);
if (!httpContext.Response.HasStarted)
{
httpContext.Response.StatusCode = 500;
await httpContext.Response.WriteAsync($"[{httpContext.Connection.Id}] An internal failure occurred. Please try again later.");
}
}
public bool OnHttpExtensionRequest(HtcHttpContext httpContext, string filename, string extension)
{
if (extension != ".php")
{
return(true);
}
var response = PhpRequest.Request(httpContext, filename, 10000);
return(response);
}
public Task <IHttpObject> Parse(HtcHttpContext httpContext, Type objectType)
{
// Failure to deserialize is a known C# bug
// This is caused by the AssemblyLoadContext, there is no workaround for now, it is planned for .NET 6 Preview 2
// https://github.com/dotnet/runtime/issues/1388
// Possible solution: Use a custom XmlSerializer or external library?
var xmlSerializer = new XmlSerializer(objectType);
return(Task.FromResult((IHttpObject)xmlSerializer.Deserialize(httpContext.Request.Body)));
}
public void SendDefaultError(HtcHttpContext httpContext, int statusCode)
{
if (DefaultPages.ContainsKey(statusCode))
{
DefaultPages[statusCode].ExecutePageMessage(httpContext);
}
else
{
httpContext.Response.StatusCode = statusCode;
}
}
private static string GetHeader(HtcHttpContext httpContext, string name)
{
foreach (var key in httpContext.Request.Headers.Keys)
{
if (key.Equals(name, StringComparison.CurrentCultureIgnoreCase))
{
return(httpContext.Request.Headers[key]);
}
}
return(null);
}
internal bool Match(HtcHttpContext httpContext, string path)
{
if (_matchAnyDomain)
{
return(_routes.ContainsKey(path));
}
else
{
return(_domains.Contains(httpContext.Request.Host.Value) && _routes.ContainsKey(path));
}
}
protected override async Task ThrowHttpException(HtcHttpContext httpContext, HttpException httpException)
{
if (httpException is HttpDecodeDataException httpDecodeDataException)
{
foreach (var exception in httpDecodeDataException.InnerExceptions)
{
Logger.LogError(exception);
}
}
httpContext.Response.StatusCode = httpException.Status;
await httpContext.Response.WriteAsync(httpException.Message);
}
public async Task ProcessRequest(HtcHttpContext httpContext)
{
object[] parameterData;
if (RequireObject)
{
var exceptionList = new List <Exception>();
IHttpObject parsedHttpObject = null;
foreach (var parser in _parsers)
{
try {
parsedHttpObject = await parser.Parse(httpContext, _parameterType);
} catch (Exception ex) {
exceptionList.Add(ex);
}
if (parsedHttpObject == null)
{
continue;
}
}
if (parsedHttpObject == null)
{
throw new HttpDecodeDataException(exceptionList.ToArray());
}
if (!await parsedHttpObject.ValidateData(httpContext))
{
throw new HttpDataValidationException();
}
parameterData = new object[] { httpContext, parsedHttpObject };
}
else
{
parameterData = new object[] { httpContext };
}
var invokeReturn = _methodInfo.Invoke(_instance, parameterData);
if (invokeReturn is Task <object> taskReturn)
{
var data = await taskReturn;
try {
await JsonSerializer.SerializeAsync(httpContext.Response.Body, data);
} catch (Exception ex) {
throw new HttpEncodeDataException(ex);
}
}
else if (invokeReturn is Task task)
{
await task;
}
else
{
throw new HttpNullTaskException();
}
}
public static void ErrorScriptRuntimeException(HtcHttpContext httpContext, ScriptRuntimeException ex, string filepath)
{
if (ex.DecoratedMessage.Length <= 0)
{
httpContext.Response.OutputStream.Write(Encoding.UTF8.GetBytes(GenerateMessage(ex.Message, "Fatal Error:")));
}
else
{
var fileName = Path.GetFileName(filepath);
httpContext.Response.OutputStream.Write(Encoding.UTF8.GetBytes(GenerateMessage(ex.DecoratedMessage.Replace(filepath, fileName), "Fatal Error:")));
}
}
public static void ErrorScriptRuntimeException(HtcHttpContext httpContext, ScriptRuntimeException ex, string filepath)
{
if (ex.DecoratedMessage.Length == 0)
{
httpContext.Response.OutputStream.Write(Encoding.UTF8.GetBytes($"<br><strong style=\"color: #d50000; font-family: Arial, Helvetica, sans-serif;\">[Lua] {ex.Message}</strong><br>"));
}
else
{
var luaPath = ex.DecoratedMessage.Split(":(")[0];
var fileName = Path.GetFileName(filepath);
httpContext.Response.OutputStream.Write(Encoding.UTF8.GetBytes($"<br><strong style=\"color: #d50000; font-family: Arial, Helvetica, sans-serif;\">[Lua] {ex.DecoratedMessage.Replace(filepath, fileName)}</strong><br>"));
}
}
public Task Invoke(HtcHttpContext httpContext)
{
foreach (string replacePath in _paths)
{
string path = replacePath.Replace("$uri", httpContext.Request.Path.Value);
if (httpContext.Site.Pages.TryGetValue(path, out var page))
{
return(page.OnHttpPageRequest(_next, httpContext, path));
}
return(_next(httpContext));
}
return(_next(httpContext));
}
public async Task ProcessRequest(HtcHttpContext httpContext)
{
foreach (var location in _locations)
{
if (!location.Match(httpContext))
{
continue;
}
await location.ProcessRequest(httpContext);
break;
}
}
public async Task <string> GetReplaced(HtcHttpContext httpContext)
{
var dataBuilder = ShouldCache ? new StringBuilder(_cache) : new StringBuilder(await _streamReader.ReadToEndAsync());
dataBuilder.Replace("$Scheme", httpContext.Request.Scheme);
dataBuilder.Replace("$Path", httpContext.Request.Path.Value);
dataBuilder.Replace("$ContentType", httpContext.Request.ContentType);
dataBuilder.Replace("$Method", httpContext.Request.Method);
dataBuilder.Replace("$Host", httpContext.Request.Host.Value);
dataBuilder.Replace("$RemoteAddr", httpContext.Connection.RemoteIpAddress.ToString());
dataBuilder.Replace("$RemotePort", httpContext.Connection.RemotePort.ToString());
dataBuilder.Replace("$IsHttps", httpContext.Request.IsHttps.ToString());
return(dataBuilder.ToString());
}
public Task Invoke(HtcHttpContext httpContext)
{
foreach (string replaceName in _paths)
{
PathString fileName = replaceName.Replace("$uri", httpContext.Request.Path.Value);
var staticFileContext = new StaticFileContext(httpContext, httpContext.Site.FileProvider, fileName);
if (!staticFileContext.LookupFileInfo())
{
continue;
}
return(staticFileContext.ServeStaticFile(httpContext, _next));
}
return(_next(httpContext));
}
public Task Invoke(HtcHttpContext httpContext)
{
foreach (string replacePath in _paths)
{
string path = replacePath.Replace("$uri", httpContext.Request.Path.Value);
string extension = Path.GetExtension(path);
if (httpContext.Site.FileExtensions.TryGetValue(extension, out var extensionProcessor))
{
return(extensionProcessor.OnHttpExtensionProcess(_next, httpContext, path, extension));
}
return(_next(httpContext));
}
return(_next(httpContext));
}
public Task <string> GetReplaced(HtcHttpContext httpContext)
{
var dataBuilder = new StringBuilder(Template);
dataBuilder.Replace("$Scheme", httpContext.Request.Scheme);
dataBuilder.Replace("$Path", httpContext.Request.Path.Value);
dataBuilder.Replace("$ContentType", httpContext.Request.ContentType);
dataBuilder.Replace("$Method", httpContext.Request.Method);
dataBuilder.Replace("$Host", httpContext.Request.Host.Value);
dataBuilder.Replace("$RemoteAddr", httpContext.Connection.RemoteIpAddress.ToString());
dataBuilder.Replace("$RemotePort", httpContext.Connection.RemotePort.ToString());
dataBuilder.Replace("$IsHttps", httpContext.Request.IsHttps.ToString());
return(Task.FromResult(dataBuilder.ToString()));
}
public string GetErrorMessage(HtcHttpContext httpContext, int statusCode)
{
if (_overridePages.ContainsKey(statusCode))
{
return(_overridePages[statusCode].GetPageMessage(httpContext));
}
else if (DefaultPages.ContainsKey(statusCode))
{
return(DefaultPages[statusCode].GetPageMessage(httpContext));
}
else
{
return(null);
}
}
public Task Invoke(HtcHttpContext httpContext)
{
foreach (string replacePath in _paths)
{
string path = replacePath.Replace("$uri", httpContext.Request.Path.Value);
foreach (var mvc in httpContext.Site.Mvcs)
{
if (mvc.Match(httpContext, path))
{
return(mvc.OnHttpRequest(httpContext, path));
}
}
return(_next(httpContext));
}
return(_next(httpContext));
}
