WebAnswer GetStaticFile(WebRequest request)
{
string url = Uri.UnescapeDataString(request.DecodedUrl).TrimStart('/');
if (url == string.Empty)
{
url = "index.html";
}
else
{
url += request.Extension;
}
string file = FileSystem.Combine(StaticFilesPath, url);
if (!FileSystem.IsRelative(file, StaticFilesPath))
{
return(null);
}
if (!File.Exists(file))
{
return(null);
}
Trace.TraceInformation("Get static file {0}", url);
var answer = WebAnswer.Raw(
request,
WebMessage.Create(request.PlainUrl, $"<cyan>{url} <default>retrieved."),
File.ReadAllBytes(file),
MimeTypes.FromExtension(Path.GetExtension(file)));
return(answer);
}
/// <summary>Returns the result as HTML answer.</summary>
/// <returns></returns>
public WebAnswer ToAnswer(WebMessage message)
{
var sb = new StringBuilder();
sb.AppendLine("<!DOCTYPE html>");
sb.AppendLine($"<html><head><title>{WebUtility.HtmlEncode(message.Source)}</title>");
sb.Append(Header);
sb.AppendLine("</head><body>");
sb.AppendLine("<div class=\"container-fluid\">");
if (Breadcrump != null)
{
sb.AppendLine("<ol class=\"breadcrumb\">");
WebLink[] links = Breadcrump.ToArray();
int last = links.Length - 1;
for (int i = 0; i < links.Length; i++)
{
if (i != last)
{
sb.Append("<li class=\"breadcrumb-item\">");
}
else
{
sb.Append("<li class=\"breadcrumb-item active\">");
}
sb.Append(links[i]);
sb.Append("</li>");
}
sb.AppendLine("</ol>");
}
if (message.Error == WebError.None)
{
sb.AppendLine("<div class=\"alert alert-success\" role=\"alert\">");
}
else
{
sb.AppendLine("<div class=\"alert alert-danger\" role=\"alert\">");
}
sb.Append($"<strong>{(int)message.Code} {message.Code} {WebUtility.HtmlEncode(message.Source)}");
if (message.Error != WebError.None)
{
sb.Append($" ({message.Error})");
}
sb.Append("</strong><p>");
sb.AppendLine(WebUtility.HtmlEncode(message.Content));
sb.AppendLine("</p></div>");
sb.Append(Content);
sb.Append(Footer);
sb.AppendLine("</div>");
sb.AppendLine("</body></html>");
return(WebAnswer.Html(request, message, sb.ToString()));
}
private WebAnswer GetPlainAnswer()
{
using (var ms = new MemoryStream())
{
foreach (KeyValuePair <string, SerializerTable> t in tables)
{
SerializerTable table = t.Value;
ms.WriteUtf8($"[Table: {table.Name}]\n");
var writer = new CSVWriter(ms);
writer.SetLayout(table.Layout);
writer.WriteRows(table.Rows);
writer.Close();
ms.WriteUtf8($"#end table: {table.Name}\n\n");
}
return(WebAnswer.Plain(Request, lastMessage, ms.ToArray()));
}
}
WebAnswer GetXmlAnswer()
{
XmlSerializer.Flags flags = 0;
if (TransmitLayout)
{
flags |= XmlSerializer.Flags.WithLayout;
}
var xml = new XmlSerializer(Server.JsonVersion, flags);
foreach (KeyValuePair <string, SerializerTable> t in tables)
{
SerializerTable table = t.Value;
xml.Serialize(table.Name, table.Layout, table.Rows);
}
return(WebAnswer.Xml(Request, lastMessage, xml.ToString()));
}
WebAnswer GetJsonAnswer()
{
JsonSerializer.Flags flags = 0;
if (SkipMainObject)
{
flags |= JsonSerializer.Flags.SkipMainObject;
}
if (TransmitLayout)
{
flags |= JsonSerializer.Flags.WithLayout;
}
var json = new JsonSerializer(Server.JsonVersion, flags);
foreach (KeyValuePair <string, SerializerTable> t in tables)
{
SerializerTable table = t.Value;
json.Serialize(table.Name, table.Layout, table.Rows);
}
return(WebAnswer.Json(Request, lastMessage, json.ToString()));
}
/// <summary>Writes the answer.</summary>
/// <param name="answer">The answer.</param>
public void SendAnswer(WebAnswer answer)
{
Writer.WriteLine($"HTTP/1.1 {(int)answer.StatusCode} {answer.StatusCode}");
if (answer == null)
{
answer = WebAnswer.Empty;
}
answer.Headers["Date"] = DateTime.Now.ToString("R");
answer.Headers["Server"] = "CaveSystems WebServer";
answer.Headers["Connection"] = answer.CloseAfterAnswer ? "close" : "persistent";
if (!WebServer.DisableCompression && (WebServer.ForceCompression || answer.AllowCompression) && (answer.ContentData.Length > 128))
{
byte[] packed = answer.ContentData.Gzip();
if (packed.Length < answer.ContentData.Length)
{
answer.ContentData = packed;
answer.Headers["Content-Encoding"] = "gzip";
}
}
foreach (System.Collections.Generic.KeyValuePair <string, string> header in answer.Headers)
{
Writer.WriteLine(header.Key + ": " + header.Value);
}
Writer.WriteLine();
if (answer.ContentData != null)
{
Writer.Write(answer.ContentData);
}
Writer.Flush();
Trace.TraceInformation("{0}. Elapsed <cyan>{1}<default>.", answer, StopWatch.Elapsed.FormatTime());
if (answer.CloseAfterAnswer)
{
Close();
}
}
void HandleRequest(WebServerClient client, WebData data)
{
// add acl headers
if (Certificate != null)
{
data.Result.Headers["Strict-Transport-Security"] = "max-age=604800; includeSubDomains";
}
data.Result.Headers["Access-Control-Allow-Headers"] = "Session";
if (data.Method?.PageAttribute?.AuthType == WebServerAuthType.Basic)
{
data.Result.Headers["Access-Control-Allow-Credentials"] = "true";
data.Result.Headers["Access-Control-Allow-Headers"] += ", Authorization";
}
if (!data.Result.Headers.ContainsKey("Access-Control-Allow-Origin"))
{
data.Result.Headers["Access-Control-Allow-Origin"] = string.IsNullOrEmpty(data.Request.Origin) ? "*" : data.Request.Origin;
}
if (!data.Result.Headers.ContainsKey("Access-Control-Allow-Methods"))
{
data.Result.Headers["Access-Control-Allow-Methods"] = "POST, GET, OPTIONS";
}
if (data.Method?.PageAttribute?.AllowHeaders != null)
{
data.Result.Headers["Access-Control-Allow-Headers"] += ", " + data.Method.PageAttribute.AllowHeaders;
}
if (data.Request.Command == WebCommand.OPTIONS)
{
data.Result.AddMessage(data.Method, "Options transfered successfully.");
client.SendAnswer(data);
return;
}
data.Request.LoadPost(client);
if (data.Method == null)
{
Trace.TraceInformation("Static Request: {0}", data.Request);
if (StaticRequest != null)
{
var e = new WebPageEventArgs(data);
StaticRequest(this, e);
if (e.Handled)
{
client.SendAnswer(data);
return;
}
}
if (EnableTemplates && RunTemplate(data))
{
Trace.TraceInformation("Template: {0} {1}", data.Request, data.Result);
client.SendAnswer(data);
return;
}
// no method - send static file ?
WebAnswer staticFile = GetStaticFile(data.Request);
if (staticFile != null)
{
// file present, send answer
Trace.TraceInformation("Static file: {0} {1}", data.Request, staticFile);
SetStaticCacheTime(staticFile, StaticPathCacheTime);
client.SendAnswer(staticFile);
return;
}
// static path access -> set cache time
SetStaticCacheTime(data, StaticPathCacheTime);
// file not present, check special functions
if (EnableExplain && (data.Request.DecodedUrl.ToLower() == "/explain" || data.Request.DecodedUrl.ToLower() == "/functionlist"))
{
// special page (function list / explain)
explain.Explain(data);
}
else if (EnableFileListing)
{
// list files
GetStaticFileListing(data);
}
else
{
// no static -> error
data.Result.AddMessage(data.Request.PlainUrl, WebError.NotFound, $"The requested URL {data.Request.DecodedUrl} was not found on this server.");
}
client.SendAnswer(data);
return;
}
// invoke method
CallMethod(data);
// send answer
client.SendAnswer(data);
}
/// <summary>Builds the template.</summary>
/// <param name="data">The data.</param>
/// <returns>Returns true on success, false otherwise.</returns>
public bool Render(WebData data)
{
if (data.Server != server)
{
throw new ArgumentOutOfRangeException(nameof(data.Server));
}
{ // need reload ?
DateTime lastChanged = FileSystem.GetLastWriteTimeUtc(FileName);
if (lastChanged != LastChanged)
{
Reload();
}
}
// do auth and load user session (if any)
data.Result.SkipMainObject = true;
data.Result.TransmitLayout = false;
// call functions
IDictionary <string, string> templateParameters = data.Request.Parameters;
var tables = new Set <string>();
var parameterDescription = new List <WebTemplateParameter>();
for (int i = 0; i < functions.Length; i++)
{
Func function = functions[i];
parameterDescription.AddRange(function.ParameterDescriptions);
if (function.NeededParameters.Count > 0)
{
// foreach neededparameters, any parameter is not at tmeplate parameters -> continue
if (function.NeededParameters.Where(n => !templateParameters.ContainsKey(n)).Any())
{
continue;
}
}
var functionParameters = new Dictionary <string, string>();
foreach (System.Reflection.ParameterInfo methodParameter in function.Method.Parameters)
{
// lookup function parameter name from function section at template
if (!function.Parameters.TryGetValue(methodParameter.Name, out string templateParameterName))
{
continue;
}
// parameter name at template could be loaded
if (!templateParameters.TryGetValue(templateParameterName, out string parameterValue))
{
if (!methodParameter.IsOptional)
{
// no value given and is not optional
throw new WebServerException(WebError.InvalidParameters, $"Template error: Missing {methodParameter.Name} is not for function {function} is not set. Define {templateParameterName} at template call!");
}
continue;
}
functionParameters[methodParameter.Name] = parameterValue;
}
data.Request.Parameters = new ReadOnlyDictionary <string, string>(functionParameters);
// invoke method
data.Method = function.Method;
data.Server.CallMethod(data);
}
Stopwatch renderWatch = server.PerformanceChecks ? Stopwatch.StartNew() : null;
// replace content
byte[] result = staticData ?? BuildStaticData(content);
if (renderWatch != null)
{
Trace.TraceInformation("Template static data generation took {0}", renderWatch.Elapsed.FormatTime());
}
// render data
{
data.Result.Type = WebResultType.Json;
data.Result.AddStructs(parameterDescription);
WebAnswer answer = data.Result.ToAnswer();
result = result.ReplaceFirst(Tag, ScriptStart, answer.ContentData, ScriptEnd);
}
// set result
data.Result = null;
WebMessage message;
if (data.Method != null)
{
message = WebMessage.Create(data.Method, $"Template call <cyan>{data.Request}<default> succeeded.");
}
else
{
message = WebMessage.Create($"Static {data.Request.PlainUrl}", $"Template call <cyan>{data.Request}<default> succeeded.");
}
data.Answer = WebAnswer.Raw(data.Request, message, result, "text/html");
return(true);
}
