public RequestInfo(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session)
{
Request = request;
Response = response;
Session = session;
BodyWriter = new BodyWriter(response, request);
}
public bool Process(IHttpRequest aRequest, IHttpResponse aResponse, HttpServer.Sessions.IHttpSession aSession)
{
if (aRequest.Uri.AbsolutePath.StartsWith("/hello"))
{
Host.Logger.WriteLine("Accept request for : {0}", aRequest.Uri.ToString());
StreamWriter writer = new StreamWriter(aResponse.Body);
writer.WriteLine("Hello dude..dude!");
writer.Flush();
aResponse.Send();
return(true);
}
return(false);
}
private void GetBackup(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session, BodyWriter bw)
{
HttpServer.HttpInput input = request.Method.ToUpper() == "POST" ? request.Form : request.QueryString;
var bk = Program.DataConnection.GetBackup(input["id"].Value);
if (bk == null)
{
ReportError(response, bw, "Invalid or missing backup id");
}
else
{
var scheduleId = Program.DataConnection.GetScheduleIDsFromTags(new string[] { "ID=" + bk.ID });
var schedule = scheduleId.Any() ? Program.DataConnection.GetSchedule(scheduleId.First()) : null;
var sourcenames = SpecialFolders.GetSourceNames(bk);
//TODO: Filter out the password in both settings and the target url
bw.OutputOK(new
{
success = true,
data = new {
Schedule = schedule,
Backup = bk,
DisplayNames = sourcenames
}
});
}
}
public static void HandleControlCGI(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session, BodyWriter bw, Type module)
{
var method = request.Method;
if (!string.IsNullOrWhiteSpace(request.Headers["X-HTTP-Method-Override"]))
{
method = request.Headers["X-HTTP-Method-Override"];
}
DoProcess(request, response, session, method, module.Name.ToLowerInvariant(), (String.Equals(request.Method, "POST", StringComparison.OrdinalIgnoreCase) ? request.Form : request.QueryString)["id"].Value);
}
public static void DoProcess(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session, string method, string module, string key)
{
using (var reqinfo = new RequestInfo(request, response, session))
DoProcess(reqinfo, method, module, key);
}
public bool Process(HttpServer.IHttpRequest aRequest, HttpServer.IHttpResponse aResponse, HttpServer.Sessions.IHttpSession aSession)
{
if (aRequest.Uri.AbsolutePath == "/user/bye/")
{
Host?.Logger.WriteLine($"Accept request for : {aRequest.Uri}");
var writer = new StreamWriter(aResponse.Body);
writer.WriteLine("<library><book>Eu e eu...</book></library>");
writer.Flush();
aResponse.Send();
return(true);
}
return(false);
}
public bool Process(IHttpRequest aRequest, IHttpResponse aResponse, HttpServer.Sessions.IHttpSession aSession)
{
return(true);
}
public void Execute(HttpServer.IHttpClientContext context, HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session)
{
if (!request.Param.Contains("number"))
{
return;
}
var call = _plugin.PluginManager.Core.CallManager.MakeCall(request.Param["number"].Value);
var content = TemplateTools.ProcessTemplate(
"Call.html",
new Dictionary <string, string>()
{
{ "number", call.Number }
});
response.Connection = HttpServer.ConnectionType.Close;
response.ContentType = "text/html";
response.ContentLength = content.Length;
response.AddHeader("Content-type", "text/html");
response.SendHeaders();
response.SendBody(content);
//response.Connection = HttpServer.ConnectionType.Close;
//response.Redirect(String.Format("/callstate?call_id={0}", call.SessionId));
//response.Send();
}
private void ReadLogData(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session, BodyWriter bw)
{
HttpServer.HttpInput input = request.Method.ToUpper() == "POST" ? request.Form : request.QueryString;
var backupid = input["id"].Value;
if (string.IsNullOrWhiteSpace(backupid))
{
List <Dictionary <string, object> > res = null;
Program.DataConnection.ExecuteWithCommand(x =>
{
res = DumpTable(x, "ErrorLog", "Timestamp", input["offset"].Value, input["pagesize"].Value);
});
bw.OutputOK(res);
}
else
{
var backup = Program.DataConnection.GetBackup(backupid);
if (backup == null)
{
ReportError(response, bw, "Invalid or missing backup id");
return;
}
using (var con = (System.Data.IDbConnection)Activator.CreateInstance(Duplicati.Library.SQLiteHelper.SQLiteLoader.SQLiteConnectionType))
{
con.ConnectionString = "Data Source=" + backup.DBPath;
con.Open();
using (var cmd = con.CreateCommand())
{
if (Duplicati.Library.Utility.Utility.ParseBool(input["remotelog"].Value, false))
{
var dt = DumpTable(cmd, "RemoteOperation", "ID", input["offset"].Value, input["pagesize"].Value);
// Unwrap raw data to a string
foreach (var n in dt)
{
try { n["Data"] = System.Text.Encoding.UTF8.GetString((byte[])n["Data"]); }
catch { }
}
bw.OutputOK(dt);
}
else
{
var dt = DumpTable(cmd, "LogData", "ID", input["offset"].Value, input["pagesize"].Value);
bw.OutputOK(dt);
}
}
}
}
}
public void Execute(HttpServer.IHttpClientContext context, HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session)
{
if (!request.Param.Contains("call_id"))
{
return;
}
var call = _plugin.PluginManager.Core.CallManager[Int32.Parse(request.Param["call_id"].Value)];
var content = TemplateTools.ProcessTemplate(
"CallState.html",
new Dictionary <string, string>()
{
{ "number", call.Number },
{ "state", ConvertState(call.State) }
});
response.Connection = HttpServer.ConnectionType.Close;
response.ContentType = "text/html";
response.ContentLength = content.Length;
response.AddHeader("Content-type", "text/html");
response.SendHeaders();
response.SendBody(content);
}
public override bool Process(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session)
{
HttpServer.HttpInput input = request.Method.ToUpper() == "POST" ? request.Form : request.QueryString;
var authcookie = request.Cookies[AUTH_COOKIE_NAME] ?? request.Cookies[Library.Utility.Uri.UrlEncode(AUTH_COOKIE_NAME)];
var authinput = input["auth-token"] ?? input[Library.Utility.Uri.UrlEncode("auth-token")];
var auth_token = authcookie == null || string.IsNullOrWhiteSpace(authcookie.Value) ? null : authcookie.Value;
if (authinput != null && !string.IsNullOrWhiteSpace(authinput.Value))
{
auth_token = input["auth-token"].Value;
}
if (request.Uri.AbsolutePath == "/logout.cgi")
{
if (!string.IsNullOrWhiteSpace(auth_token))
{
if (m_activeTokens.ContainsKey(auth_token))
{
m_activeTokens.Remove(auth_token);
}
}
response.Status = System.Net.HttpStatusCode.NoContent;
response.Reason = "OK";
return(true);
}
else if (request.Uri.AbsolutePath == "/login.cgi")
{
foreach (var k in (from n in m_activeNonces where DateTime.UtcNow > n.Value.Item1 select n.Key).ToList())
{
m_activeNonces.Remove(k);
}
if (input["get-nonce"] != null && !string.IsNullOrWhiteSpace(input["get-nonce"].Value))
{
if (m_activeNonces.Count > 50)
{
response.Status = System.Net.HttpStatusCode.ServiceUnavailable;
response.Reason = "Too many active login attempts";
return(true);
}
var buf = new byte[32];
var expires = DateTime.UtcNow.AddMinutes(10);
m_prng.GetBytes(buf);
var nonce = Convert.ToBase64String(buf);
var sha256 = System.Security.Cryptography.SHA256.Create();
sha256.TransformBlock(buf, 0, buf.Length, buf, 0);
buf = Convert.FromBase64String(Program.DataConnection.ApplicationSettings.WebserverPassword);
sha256.TransformFinalBlock(buf, 0, buf.Length);
var pwd = Convert.ToBase64String(sha256.Hash);
m_activeNonces.Add(nonce, new Tuple <DateTime, string>(expires, pwd));
response.Cookies.Add(new HttpServer.ResponseCookie(NONCE_COOKIE_NAME, nonce, expires));
using (var bw = new BodyWriter(response))
{
bw.OutputOK(new {
Status = "OK",
Nonce = nonce,
Salt = Program.DataConnection.ApplicationSettings.WebserverPasswordSalt
});
}
return(true);
}
else
{
if (input["password"] != null && !string.IsNullOrWhiteSpace(input["password"].Value))
{
var nonce_el = request.Cookies[NONCE_COOKIE_NAME] ?? request.Cookies[Library.Utility.Uri.UrlEncode(NONCE_COOKIE_NAME)];
var nonce = nonce_el == null || string.IsNullOrWhiteSpace(nonce_el.Value) ? "" : nonce_el.Value;
var urldecoded = nonce == null ? "" : Duplicati.Library.Utility.Uri.UrlDecode(nonce);
if (m_activeNonces.ContainsKey(urldecoded))
{
nonce = urldecoded;
}
if (!m_activeNonces.ContainsKey(nonce))
{
response.Status = System.Net.HttpStatusCode.Unauthorized;
response.Reason = "Unauthorized";
response.ContentType = "application/json";
return(true);
}
var pwd = m_activeNonces[nonce].Item2;
m_activeNonces.Remove(nonce);
if (pwd != input["password"].Value)
{
response.Status = System.Net.HttpStatusCode.Unauthorized;
response.Reason = "Unauthorized";
response.ContentType = "application/json";
return(true);
}
var buf = new byte[32];
var expires = DateTime.UtcNow.AddHours(1);
m_prng.GetBytes(buf);
var token = Duplicati.Library.Utility.Utility.Base64UrlEncode(buf);
while (token.Length > 0 && token.EndsWith("="))
{
token = token.Substring(0, token.Length - 1);
}
m_activeTokens.Add(token, expires);
response.Cookies.Add(new HttpServer.ResponseCookie(AUTH_COOKIE_NAME, token, expires));
using (var bw = new BodyWriter(response))
bw.OutputOK();
return(true);
}
}
}
if (string.IsNullOrWhiteSpace(Program.DataConnection.ApplicationSettings.WebserverPassword))
{
return(false);
}
foreach (var k in (from n in m_activeTokens where DateTime.UtcNow > n.Value select n.Key).ToList())
{
m_activeTokens.Remove(k);
}
// If we have a valid token, proceeed
if (!string.IsNullOrWhiteSpace(auth_token))
{
DateTime expires;
var found = m_activeTokens.TryGetValue(auth_token, out expires);
if (!found)
{
auth_token = Duplicati.Library.Utility.Uri.UrlDecode(auth_token);
found = m_activeTokens.TryGetValue(auth_token, out expires);
}
if (found && DateTime.UtcNow < expires)
{
expires = DateTime.UtcNow.AddHours(1);
m_activeTokens[auth_token] = expires;
response.Cookies.Add(new ResponseCookie(AUTH_COOKIE_NAME, auth_token, expires));
return(false);
}
}
if (request.Uri.AbsolutePath == "/" || request.Uri.AbsolutePath == "/index.html")
{
response.Redirect("/login.html");
return(true);
}
if (request.Uri.AbsolutePath == "/control.cgi")
{
response.Status = System.Net.HttpStatusCode.Unauthorized;
response.Reason = "Not logged in";
response.AddHeader("Location", "login.html");
return(true);
}
return(false);
}
public override bool Process(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session)
{
if (request.UriPath.StartsWith(Url))
{
string value = request.QueryString[UrlParameters.IsEnabled].Value;
Settings.ThumbnailOnly = value == "true";
string redirect = request.QueryString[UrlParameters.RedirectUrl].Value;
if (!string.IsNullOrWhiteSpace(redirect))
{
response.Redirect(redirect);
}
else
{
response.Redirect("/");
}
return(true);
}
return(false);
}
public override bool Process(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session)
{
var path = this.GetPath(request.Uri);
var html = System.IO.Path.Combine(path, "index.html");
var htm = System.IO.Path.Combine(path, "index.htm");
if (System.IO.Directory.Exists(path) && (System.IO.File.Exists(html) || System.IO.File.Exists(htm)))
{
if (!request.Uri.AbsolutePath.EndsWith("/", StringComparison.Ordinal))
{
response.Redirect(request.Uri.AbsolutePath + "/");
return(true);
}
response.Status = System.Net.HttpStatusCode.OK;
response.Reason = "OK";
response.ContentType = "text/html; charset=utf-8";
response.AddHeader("Cache-Control", "no-cache, no-store, must-revalidate, max-age=0");
using (var fs = System.IO.File.OpenRead(System.IO.File.Exists(html) ? html : htm))
{
response.ContentLength = fs.Length;
response.Body = fs;
response.Send();
}
return(true);
}
return(false);
}
/// <summary>
/// Processes the request
/// </summary>
/// <returns><c>true</c> if the request is handled <c>false</c> otherwise.</returns>
/// <param name="request">The request.</param>
/// <param name="response">The response.</param>
/// <param name="session">The session.</param>
public override bool Process(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session)
{
if (FULLY_DISABLED)
{
response.Status = System.Net.HttpStatusCode.ServiceUnavailable;
response.Reason = "The system is incorrectly configured";
return(true);
}
var limitedAccess =
request.Uri.AbsolutePath.StartsWith(RESTHandler.API_URI_PATH, StringComparison.OrdinalIgnoreCase)
||
request.Uri.AbsolutePath.StartsWith(AuthenticationHandler.LOGIN_SCRIPT_URI, StringComparison.OrdinalIgnoreCase)
||
request.Uri.AbsolutePath.StartsWith(AuthenticationHandler.LOGOUT_SCRIPT_URI, StringComparison.OrdinalIgnoreCase);
if (!limitedAccess)
{
return(false);
}
var tmpenv = new Dictionary <string, string>();
tmpenv["REMOTE_ADDR"] = request.RemoteEndPoint.Address.ToString();
tmpenv["REMOTE_PORT"] = request.RemoteEndPoint.Port.ToString();
if (!string.IsNullOrWhiteSpace(request.Headers["X-Real-IP"]))
{
tmpenv["REMOTE_ADDR"] = request.Headers["X-Real-IP"];
}
if (!string.IsNullOrWhiteSpace(request.Headers["X-Real-IP"]))
{
tmpenv["REMOTE_PORT"] = request.Headers["X-Real-Port"];
}
var loginid = request.Cookies["id"]?.Value;
if (!string.IsNullOrWhiteSpace(loginid))
{
tmpenv["HTTP_COOKIE"] = "id=" + loginid;
}
var xsrftoken = request.Headers["X-Syno-Token"];
if (string.IsNullOrWhiteSpace(xsrftoken))
{
xsrftoken = request.QueryString["SynoToken"]?.Value;
}
var cachestring = BuildCacheKey(tmpenv, xsrftoken);
DateTime cacheExpires;
if (m_logincache.TryGetValue(cachestring, out cacheExpires) && cacheExpires > DateTime.Now)
{
// We do not refresh the cache, as we need to ask the synology auth system periodically
return(false);
}
if (string.IsNullOrWhiteSpace(xsrftoken) && AUTO_XSRF)
{
var authre = new Regex(@"""SynoToken""\s?\:\s?""(?<token>[^""]+)""");
try
{
var resp = ShellExec(LOGIN_CGI, env: tmpenv).Result;
var m = authre.Match(resp);
if (m.Success)
{
xsrftoken = m.Groups["token"].Value;
}
else
{
throw new Exception("Unable to get XSRF token");
}
}
catch (Exception)
{
response.Status = System.Net.HttpStatusCode.InternalServerError;
response.Reason = "The system is incorrectly configured";
return(true);
}
}
if (!string.IsNullOrWhiteSpace(xsrftoken))
{
tmpenv["HTTP_X_SYNO_TOKEN"] = xsrftoken;
}
cachestring = BuildCacheKey(tmpenv, xsrftoken);
var username = GetEnvArg("SYNO_USERNAME");
if (string.IsNullOrWhiteSpace(username))
{
try
{
username = ShellExec(AUTH_CGI, shell: false, exitcode: 0, env: tmpenv).Result;
}
catch (Exception)
{
response.Status = System.Net.HttpStatusCode.InternalServerError;
response.Reason = "The system is incorrectly configured";
return(true);
}
}
if (string.IsNullOrWhiteSpace(username))
{
response.Status = System.Net.HttpStatusCode.Forbidden;
response.Reason = "Permission denied, not logged in";
return(true);
}
username = username.Trim();
if (ADMIN_ONLY)
{
var groups = GetEnvArg("SYNO_GROUP_IDS");
if (string.IsNullOrWhiteSpace(groups))
{
groups = ShellExec("id", "-G '" + username.Trim().Replace("'", "\\'") + "'", exitcode: 0).Result ?? string.Empty;
}
if (!groups.Split(new char[] { ' ' }).Contains("101"))
{
response.Status = System.Net.HttpStatusCode.Forbidden;
response.Reason = "Administrator login required";
return(true);
}
}
// We are now authenticated, add to cache
m_logincache[cachestring] = DateTime.Now + CACHE_TIMEOUT;
return(false);
}
/// <summary>
/// Process the received request
/// </summary>
/// <returns>A flag indicating if the request is handled.</returns>
/// <param name="request">The received request.</param>
/// <param name="response">The response object.</param>
/// <param name="session">The session state.</param>
public override bool Process(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session)
{
string[] h = null;
var hstring = Program.DataConnection.ApplicationSettings.AllowedHostnames;
if (!string.IsNullOrWhiteSpace(hstring))
{
h = m_lastSplitNames;
if (hstring != m_lastAllowed)
{
m_lastAllowed = hstring;
h = m_lastSplitNames = (hstring ?? string.Empty).Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
}
if (h == null || h.Length == 0)
{
h = null;
}
}
// For some reason, the web server strips out the host header
var host = request.Headers["Host"];
if (string.IsNullOrWhiteSpace(host))
{
host = request.Uri.Host;
}
// This should not happen
if (string.IsNullOrWhiteSpace(host))
{
response.Reason = "Invalid request, missing host header";
response.Status = System.Net.HttpStatusCode.Forbidden;
var msg = System.Text.Encoding.ASCII.GetBytes(response.Reason);
response.ContentType = "text/plain";
response.ContentLength = msg.Length;
response.Body.Write(msg, 0, msg.Length);
response.Send();
return(true);
}
// Check the hostnames we always allow
if (Array.IndexOf(DEFAULT_ALLOWED, host) >= 0)
{
return(false);
}
// Then the user specified ones
if (h != null && Array.IndexOf(h, host) >= 0)
{
return(false);
}
// Disable checks if we have an asterisk
if (h != null && Array.IndexOf(h, "*") >= 0)
{
return(false);
}
// Finally, check if we have a potential IP address
var v4 = IPV4.Match(host);
var v6 = IPV6.Match(host);
if ((v4.Success && v4.Length == host.Length) || (v6.Success && v6.Length == host.Length))
{
try
{
// Verify that the hostname is indeed a valid IP address
System.Net.IPAddress.Parse(host);
return(false);
}
catch
{ }
}
// Failed to find a valid header
response.Reason = $"The host header sent by the client is not allowed";
response.Status = System.Net.HttpStatusCode.Forbidden;
var txt = System.Text.Encoding.ASCII.GetBytes(response.Reason);
response.ContentType = "text/plain";
response.ContentLength = txt.Length;
response.Body.Write(txt, 0, txt.Length);
response.Send();
return(true);
}
public sealed override bool Process(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session)
{
if (request.UriPath == GetPageUrl())
{
StringBuilder sb = new StringBuilder(HtmlTemplates.ThreadFiltersPageTemplate);
IncludeCommonHtml(sb);
sb.Replace("{{inline-title}}", GetPageTitle());
sb.Replace("{{boards-list-html}}", ThreadServerModule.get_board_list(UrlParameters.Board));
sb.Replace("{{available-filters-list}}", get_available_filters());
sb.Replace("{{filters-list}}", GetThreadFiltersTableHtml());
WriteFinalHtmlResponse(response, sb.ToString());
return(true);
}
if (request.UriPath.StartsWith(GetPageUrl() + "/"))
{
string mode = request.QueryString["mode"].Value;
string board = request.QueryString[UrlParameters.Board].Value;
BoardWatcher bw;
switch (mode)
{
case "add":
{
if (Program.active_dumpers.ContainsKey(board))
{
bw = Program.active_dumpers[board];
}
else
{
bw = new BoardWatcher(board);
Program.active_dumpers.Add(board, bw);
}
string filter_type = request.QueryString["type"].Value;
string filter_exp = request.QueryString["exp"].Value;
if (string.IsNullOrEmpty(filter_exp) || string.IsNullOrEmpty(filter_type))
{
return(false);
}
else
{
ChanArchiver.Filters.IFilter f = get_filter(filter_type, filter_exp);
if (f != null)
{
bw.AddFilter(f);
bw.SaveFilters();
response.Redirect(GetPageUrl());
return(true);
}
else
{
return(false);
}
}
}
case "edit":
return(false);
case "delete":
{
if (Program.active_dumpers.ContainsKey(board))
{
string index = request.QueryString["i"].Value;
bw = Program.active_dumpers[board];
int inde = -1;
Int32.TryParse(index, out inde);
if (inde >= 0 && inde <= bw.WhitelistFilters.Length - 1)
{
bw.RemoveFilter(inde);
bw.SaveFilters();
response.Redirect(GetPageUrl());
return(true);
}
else
{
return(false);
}
}
else
{
return(false);
}
}
case "editnotes":
{
string fID = request.QueryString["filterindex"].Value;
string notes_text = request.QueryString["notestext"].Value;
if (string.IsNullOrEmpty(fID) || string.IsNullOrEmpty(board))
{
response.Redirect(GetPageUrl());
return(true);
}
else
{
if (Program.active_dumpers.ContainsKey(board))
{
bw = Program.active_dumpers[board];
int index = -1;
Int32.TryParse(fID, out index);
if (index >= 0 && index < bw.WhitelistFilters.Length)
{
Filters.IFilter fil = bw.WhitelistFilters[index];
fil.Notes = notes_text;
bw.SaveFilters();
response.Redirect(GetPageUrl());
return(true);
}
}
}
}
return(false);
default:
return(false);
}
}
return(false);
}
public override bool Process(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session)
{
if (!request.Uri.AbsolutePath.StartsWith("/capture"))
{
return(false);
}
HttpServerUtil.DebugPrintRequest(request);
HttpInputItem deviceIdParam = request.Param["id"];
CaptureDevice device;
CaptureDeviceHandler captureDevice;
// First, get the specified lowlevel capture device
if (deviceIdParam.Count == 1)
{
device = WasapiLoopbackCapture2.GetLoopbackCaptureDevices()[int.Parse(deviceIdParam.Value)];
}
else
{
device = WasapiLoopbackCapture2.GetDefaultLoopbackCaptureDevice();
}
// Then, get the capture device handler
if (captureDevices.ContainsKey(device))
{
captureDevice = captureDevices[device];
}
else
{
captureDevice = new CaptureDeviceHandler(device);
captureDevices.Add(device, captureDevice);
}
response.ContentLength = long.MaxValue;
response.ContentType = String.Format("audio/L16;rate={0};channels={1}",
captureDevice.WaveFormat.SampleRate,
captureDevice.WaveFormat.Channels);
response.AddHeader("TransferMode.DLNA.ORG", "Streaming");
response.AddHeader("Server", "UPnP/1.0 DLNADOC/1.50 LAB/1.0");
response.AddHeader("icy-name", "Local Audio Broadcast");
// create local output buffers
CircleBuffer captureBuffer = new CircleBuffer(BUFFER_SIZE);
byte[] buffer = new byte[BUFFER_SIZE];
byte[] emptiness100ms = new byte[captureDevice.WaveFormat.SampleRate / 10
* captureDevice.WaveFormat.Channels
* (captureDevice.WaveFormat.BitsPerSample / 8)];
// register buffer for being filled with loopback samples
captureDevice.Add(captureBuffer);
IDataSource data = captureBuffer;
EventHandler <TrackInfoChangedEventArgs> trackInfoHandler = null;
if (request.Headers["Icy-MetaData"] == "1")
{
ShoutcastMetadataEmbedder me = new ShoutcastMetadataEmbedder(
captureDevice.WaveFormat.SampleRate * 2, // 1 second interval
captureBuffer);
response.ProtocolVersion = "ICY";
response.AddHeader("icy-metaint", me.Interval + "");
data = me;
me.SetTrackInfo(trackInfoProvider.TrackInfo);
trackInfoHandler = new EventHandler <TrackInfoChangedEventArgs>(delegate(object sender, TrackInfoChangedEventArgs e) {
me.SetTrackInfo(e.TrackInfo);
});
trackInfoProvider.TrackInfoChanged += trackInfoHandler;
}
HttpServerUtil.DebugPrintResponse(response);
Socket socket = HttpServerUtil.GetNetworkSocket(response);
response.SendHeaders();
int bytesRead = 0;
while (socket.Connected)
{
Thread.Sleep(100);
while (captureBuffer.Empty)
{
//Thread.Sleep(200);
captureBuffer.Write(emptiness100ms, 0, emptiness100ms.Length);
}
lock (captureDevice.lockObject) {
bytesRead = data.Read(buffer, 0, buffer.Length);
}
//Console.WriteLine("buffer-{3} r {0} - {1} = {2}%", loopbackBuffer.FillLevel + bytesRead, bytesRead,
// (float)loopbackBuffer.FillLevel / loopbackBuffer.Length * 100, loopbackBuffer.GetHashCode());
response.SendBody(buffer, 0, bytesRead);
Console.WriteLine("sending {0} bytes = {1:0.00} secs", bytesRead, bytesRead /
(double)captureDevice.loopbackCapture.WaveFormat.AverageBytesPerSecond);
}
if (trackInfoHandler != null)
{
trackInfoProvider.TrackInfoChanged -= trackInfoHandler;
}
// remove local output buffer
captureDevice.Remove(captureBuffer);
Console.WriteLine("request processing finished");
return(true);
}
public override bool Process(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session)
{
if (!this.CanHandle(request.Uri))
{
return(false);
}
if (request.Uri.AbsolutePath.EndsWith("index.html", StringComparison.Ordinal) || request.Uri.AbsolutePath.EndsWith("index.htm", StringComparison.Ordinal))
{
response.AddHeader("Cache-Control", "no-cache, no-store, must-revalidate, max-age=0");
}
else
{
response.AddHeader("Cache-Control", "max-age=" + (60 * 60 * 24));
}
return(base.Process(request, response, session));
}
public override bool Process(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session)
{
System.Diagnostics.Trace.WriteLine(string.Format("Rejecting request for {0}", request.Uri));
return(false);
}
private void AddBackup(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session, BodyWriter bw)
{
var str = request.Form["data"].Value;
if (string.IsNullOrWhiteSpace(str))
{
ReportError(response, bw, "Missing backup object");
return;
}
AddOrUpdateBackupData data = null;
try
{
data = Serializer.Deserialize <AddOrUpdateBackupData>(new StringReader(str));
if (data.Backup == null)
{
ReportError(response, bw, "Data object had no backup entry");
return;
}
data.Backup.ID = null;
if (Duplicati.Library.Utility.Utility.ParseBool(request.Form["temporary"].Value, false))
{
Program.DataConnection.RegisterTemporaryBackup(data.Backup);
bw.OutputOK(new { status = "OK", ID = data.Backup.ID });
}
else
{
if (Library.Utility.Utility.ParseBool(request.Form["existing_db"].Value, false))
{
data.Backup.DBPath = Library.Main.DatabaseLocator.GetDatabasePath(data.Backup.TargetURL, null, false, false);
if (string.IsNullOrWhiteSpace(data.Backup.DBPath))
{
throw new Exception("Unable to find remote db path?");
}
}
lock (Program.DataConnection.m_lock)
{
if (Program.DataConnection.Backups.Where(x => x.Name.Equals(data.Backup.Name, StringComparison.InvariantCultureIgnoreCase)).Any())
{
ReportError(response, bw, "There already exists a backup with the name: " + data.Backup.Name);
return;
}
Program.DataConnection.AddOrUpdateBackupAndSchedule(data.Backup, data.Schedule);
}
bw.OutputOK(new { status = "OK", ID = data.Backup.ID });
}
}
catch (Exception ex)
{
if (data == null)
{
ReportError(response, bw, string.Format("Unable to parse backup or schedule object: {0}", ex.Message));
}
else
{
ReportError(response, bw, string.Format("Unable to save schedule or backup object: {0}", ex.Message));
}
}
}
public override bool Process(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session)
{
if (request.UriPath == Url || request.UriPath == (Url + "/"))
{
StringBuilder sb = new StringBuilder(HtmlTemplates.WatchJobsPageTemplate);
IncludeCommonHtml(sb);
sb.Replace("{{watched-threads-table}}", GetWatchedThreadsTableHtml());
sb.Replace("//{ai_items_js}", get_ai_items());
sb.Replace("//{board_names_js}", get_boards_names_js());
sb.Replace("{archives}", get_archives_html());
WriteFinalHtmlResponse(response, sb.ToString());
return(true);
}
return(false);
}
private void UpdateBackup(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session, BodyWriter bw)
{
string str = request.Form["data"].Value;
if (string.IsNullOrWhiteSpace(str))
{
ReportError(response, bw, "Missing backup object");
return;
}
AddOrUpdateBackupData data = null;
try
{
data = Serializer.Deserialize <AddOrUpdateBackupData>(new StringReader(str));
if (data.Backup == null)
{
ReportError(response, bw, "Data object had no backup entry");
return;
}
if (data.Backup.ID == null)
{
ReportError(response, bw, "Invalid or missing backup id");
return;
}
if (data.Backup.IsTemporary)
{
var backup = Program.DataConnection.GetBackup(data.Backup.ID);
if (backup.IsTemporary)
{
throw new InvalidDataException("External is temporary but internal is not?");
}
Program.DataConnection.UpdateTemporaryBackup(backup);
bw.OutputOK();
}
else
{
lock (Program.DataConnection.m_lock)
{
var backup = Program.DataConnection.GetBackup(data.Backup.ID);
if (backup == null)
{
ReportError(response, bw, "Invalid or missing backup id");
return;
}
if (Program.DataConnection.Backups.Where(x => x.Name.Equals(data.Backup.Name, StringComparison.InvariantCultureIgnoreCase) && x.ID != data.Backup.ID).Any())
{
ReportError(response, bw, "There already exists a backup with the name: " + data.Backup.Name);
return;
}
//TODO: Merge in real passwords where the placeholder is found
Program.DataConnection.AddOrUpdateBackupAndSchedule(data.Backup, data.Schedule);
}
bw.OutputOK();
}
}
catch (Exception ex)
{
if (data == null)
{
ReportError(response, bw, string.Format("Unable to parse backup or schedule object: {0}", ex.Message));
}
else
{
ReportError(response, bw, string.Format("Unable to save backup or schedule: {0}", ex.Message));
}
}
}
protected override void HandleRequest(HttpServer.IHttpClientContext context, HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session)
{
var handler = _handlerManager[request.Uri.LocalPath];
if (handler != null)
{
try
{
handler.Execute(context, request, response, session);
}
catch (Exception e)
{
Logger.LogWarn(e);
}
}
else
{
new FileHandler().Execute(context, request, response, session);
}
base.HandleRequest(context, request, response, session);
}
private void SearchBackupFiles(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session, BodyWriter bw)
{
HttpServer.HttpInput input = request.Method.ToUpper() == "POST" ? request.Form : request.QueryString;
var filter = (input["filter"].Value ?? "").Split(new string[] { System.IO.Path.PathSeparator.ToString() }, StringSplitOptions.RemoveEmptyEntries);
var timestring = input["time"].Value;
var allversion = Duplicati.Library.Utility.Utility.ParseBool(input["all-versions"].Value, false);
if (string.IsNullOrWhiteSpace(timestring) && !allversion)
{
ReportError(response, bw, "Invalid or missing time");
return;
}
var bk = Program.DataConnection.GetBackup(input["id"].Value);
if (bk == null)
{
ReportError(response, bw, "Invalid or missing backup id");
return;
}
var prefixonly = Duplicati.Library.Utility.Utility.ParseBool(input["prefix-only"].Value, false);
var foldercontents = Duplicati.Library.Utility.Utility.ParseBool(input["folder-contents"].Value, false);
var time = new DateTime();
if (!allversion)
{
time = Duplicati.Library.Utility.Timeparser.ParseTimeInterval(timestring, DateTime.Now);
}
var r = Runner.Run(Runner.CreateListTask(bk, filter, prefixonly, allversion, foldercontents, time), false) as Duplicati.Library.Interface.IListResults;
var result = new Dictionary <string, object>();
foreach (HttpServer.HttpInputItem n in input)
{
result[n.Name] = n.Value;
}
result["Filesets"] = r.Filesets;
result["Files"] = r.Files;
bw.OutputOK(result);
}
public override bool Process(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session)
{
HttpServer.HttpInput input = request.Method.ToUpper() == "POST" ? request.Form : request.QueryString;
var auth_token = FindAuthCookie(request);
var xsrf_token = FindXSRFToken(request);
if (!HasXSRFCookie(request))
{
var cookieAdded = AddXSRFTokenToRespone(response);
if (!cookieAdded)
{
response.Status = System.Net.HttpStatusCode.ServiceUnavailable;
response.Reason = "Too Many Concurrent Request, try again later";
return(true);
}
}
Tuple <DateTime, string> tmpTuple;
DateTime tmpDateTime;
if (LOGOUT_SCRIPT_URI.Equals(request.Uri.AbsolutePath, StringComparison.OrdinalIgnoreCase))
{
if (!string.IsNullOrWhiteSpace(auth_token))
{
// Remove the active auth token
m_activeTokens.TryRemove(auth_token, out tmpDateTime);
}
response.Status = System.Net.HttpStatusCode.NoContent;
response.Reason = "OK";
return(true);
}
else if (LOGIN_SCRIPT_URI.Equals(request.Uri.AbsolutePath, StringComparison.OrdinalIgnoreCase))
{
// Remove expired nonces
foreach (var k in (from n in m_activeNonces where DateTime.UtcNow > n.Value.Item1 select n.Key))
{
m_activeNonces.TryRemove(k, out tmpTuple);
}
if (input["get-nonce"] != null && !string.IsNullOrWhiteSpace(input["get-nonce"].Value))
{
if (m_activeNonces.Count > 50)
{
response.Status = System.Net.HttpStatusCode.ServiceUnavailable;
response.Reason = "Too many active login attempts";
return(true);
}
var password = Program.DataConnection.ApplicationSettings.WebserverPassword;
if (request.Headers[TRAYICONPASSWORDSOURCE_HEADER] == "database")
{
password = Program.DataConnection.ApplicationSettings.WebserverPasswordTrayIconHash;
}
var buf = new byte[32];
var expires = DateTime.UtcNow.AddMinutes(AUTH_TIMEOUT_MINUTES);
m_prng.GetBytes(buf);
var nonce = Convert.ToBase64String(buf);
var sha256 = System.Security.Cryptography.SHA256.Create();
sha256.TransformBlock(buf, 0, buf.Length, buf, 0);
buf = Convert.FromBase64String(password);
sha256.TransformFinalBlock(buf, 0, buf.Length);
var pwd = Convert.ToBase64String(sha256.Hash);
m_activeNonces.AddOrUpdate(nonce, key => new Tuple <DateTime, string>(expires, pwd), (key, existingValue) =>
{
// Simulate the original behavior => if the nonce, against all odds, is already used
// we throw an ArgumentException
throw new ArgumentException("An element with the same key already exists in the dictionary.");
});
response.Cookies.Add(new HttpServer.ResponseCookie(NONCE_COOKIE_NAME, nonce, expires));
using (var bw = new BodyWriter(response, request))
{
bw.OutputOK(new {
Status = "OK",
Nonce = nonce,
Salt = Program.DataConnection.ApplicationSettings.WebserverPasswordSalt
});
}
return(true);
}
else
{
if (input["password"] != null && !string.IsNullOrWhiteSpace(input["password"].Value))
{
var nonce_el = request.Cookies[NONCE_COOKIE_NAME] ?? request.Cookies[Library.Utility.Uri.UrlEncode(NONCE_COOKIE_NAME)];
var nonce = nonce_el == null || string.IsNullOrWhiteSpace(nonce_el.Value) ? "" : nonce_el.Value;
var urldecoded = nonce == null ? "" : Duplicati.Library.Utility.Uri.UrlDecode(nonce);
if (m_activeNonces.ContainsKey(urldecoded))
{
nonce = urldecoded;
}
if (!m_activeNonces.ContainsKey(nonce))
{
response.Status = System.Net.HttpStatusCode.Unauthorized;
response.Reason = "Unauthorized";
response.ContentType = "application/json";
return(true);
}
var pwd = m_activeNonces[nonce].Item2;
// Remove the nonce
m_activeNonces.TryRemove(nonce, out tmpTuple);
if (pwd != input["password"].Value)
{
response.Status = System.Net.HttpStatusCode.Unauthorized;
response.Reason = "Unauthorized";
response.ContentType = "application/json";
return(true);
}
var buf = new byte[32];
var expires = DateTime.UtcNow.AddHours(1);
m_prng.GetBytes(buf);
var token = Duplicati.Library.Utility.Utility.Base64UrlEncode(buf);
while (token.Length > 0 && token.EndsWith("=", StringComparison.Ordinal))
{
token = token.Substring(0, token.Length - 1);
}
m_activeTokens.AddOrUpdate(token, key => expires, (key, existingValue) =>
{
// Simulate the original behavior => if the token, against all odds, is already used
// we throw an ArgumentException
throw new ArgumentException("An element with the same key already exists in the dictionary.");
});
response.Cookies.Add(new HttpServer.ResponseCookie(AUTH_COOKIE_NAME, token, expires));
using (var bw = new BodyWriter(response, request))
bw.OutputOK();
return(true);
}
}
}
var limitedAccess =
request.Uri.AbsolutePath.StartsWith(RESTHandler.API_URI_PATH, StringComparison.OrdinalIgnoreCase)
;
// Override to allow the CAPTCHA call to go through
if (request.Uri.AbsolutePath.StartsWith(CAPTCHA_IMAGE_URI, StringComparison.OrdinalIgnoreCase) && request.Method == "GET")
{
limitedAccess = false;
}
if (limitedAccess)
{
if (xsrf_token != null && m_activexsrf.ContainsKey(xsrf_token))
{
var expires = DateTime.UtcNow.AddMinutes(XSRF_TIMEOUT_MINUTES);
m_activexsrf[xsrf_token] = expires;
response.Cookies.Add(new ResponseCookie(XSRF_COOKIE_NAME, xsrf_token, expires));
}
else
{
response.Status = System.Net.HttpStatusCode.BadRequest;
response.Reason = "Missing XSRF Token. Please reload the page";
return(true);
}
}
if (string.IsNullOrWhiteSpace(Program.DataConnection.ApplicationSettings.WebserverPassword))
{
return(false);
}
foreach (var k in (from n in m_activeTokens where DateTime.UtcNow > n.Value select n.Key))
{
m_activeTokens.TryRemove(k, out tmpDateTime);
}
// If we have a valid token, proceed
if (!string.IsNullOrWhiteSpace(auth_token))
{
DateTime expires;
var found = m_activeTokens.TryGetValue(auth_token, out expires);
if (!found)
{
auth_token = Duplicati.Library.Utility.Uri.UrlDecode(auth_token);
found = m_activeTokens.TryGetValue(auth_token, out expires);
}
if (found && DateTime.UtcNow < expires)
{
expires = DateTime.UtcNow.AddHours(1);
m_activeTokens[auth_token] = expires;
response.Cookies.Add(new ResponseCookie(AUTH_COOKIE_NAME, auth_token, expires));
return(false);
}
}
if ("/".Equals(request.Uri.AbsolutePath, StringComparison.OrdinalIgnoreCase) || "/index.html".Equals(request.Uri.AbsolutePath, StringComparison.OrdinalIgnoreCase))
{
response.Redirect("/login.html");
return(true);
}
if (limitedAccess)
{
response.Status = System.Net.HttpStatusCode.Unauthorized;
response.Reason = "Not logged in";
response.AddHeader("Location", "login.html");
return(true);
}
return(false);
}
public override bool Process(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session)
{
string command = request.UriPath;
if (command == "/settings")
{
StringBuilder page = new StringBuilder(Properties.Resources.settings_page);
//-------------------- General Settings --------------------------
if (Settings.AutoStartManuallyAddedThreads)
{
page.Replace("{gs0c}", Checked);
}
else
{
page.Replace("{gs0c}", "");
}
if (Settings.ThumbnailOnly)
{
page.Replace("{gs1c}", Checked);
}
else
{
page.Replace("{gs1c}", "");
}
if (Settings.EnableFileStats)
{
page.Replace("{gs2c}", Checked);
}
else
{
page.Replace("{gs2c}", "");
}
if (Settings.UseHttps)
{
page.Replace("{gs3c}", Checked);
}
else
{
page.Replace("{gs3c}", "");
}
if (Settings.RemoveThreadsWhenTheyEnterArchivedState)
{
page.Replace("{gs4c}", Checked);
}
else
{
page.Replace("{gs4c}", "");
}
if (Settings.SaveBannedFileThumbnail)
{
page.Replace("{gs5c}", Checked);
}
else
{
page.Replace("{gs5c}", "");
}
if (Settings.CacheAPIFilesInMemory)
{
page.Replace("{gs6c}", Checked);
}
else
{
page.Replace("{gs6c}", "");
}
//-------------------- Security Settings --------------------------
if (Settings.EnableAuthentication)
{
page.Replace("{ss0c}", Checked);
}
else
{
page.Replace("{ss0c}", "");
}
if (Settings.AllowGuestAccess)
{
page.Replace("{ss1c}", Checked);
}
else
{
page.Replace("{ss1c}", "");
}
page.Replace("{bauser}", string.IsNullOrEmpty(Settings.AuthUsername) ? "" : Settings.AuthUsername);
page.Replace("{bapass}", string.IsNullOrEmpty(Settings.AuthPassword) ? "" : Settings.AuthPassword);
//-------------------- FFMPEG Settings --------------------------
page.Replace("{ffpath}", Program.ffmpeg_path);
if (Settings.ConvertGifsToWebm)
{
page.Replace("{ff0c}", Checked);
}
else
{
page.Replace("{ff0c}", "");
}
if (Settings.ConvertWebmToMp4)
{
page.Replace("{ff1c}", Checked);
}
else
{
page.Replace("{ff1c}", "");
}
if (Settings.Convert_Webmgif_To_Target)
{
page.Replace("{ff2c}", Checked);
}
else
{
page.Replace("{ff2c}", "");
}
if (Settings.Convert_Webmgif_Target == Settings.X_Target.GIF)
{
page.Replace("{ff2s1o1c}", Selected);
page.Replace("{ff2s1o2c}", "");
}
else
{
page.Replace("{ff2s1o1c}", "");
page.Replace("{ff2s1o2c}", Selected);
}
if (Settings.Convert_Webmgif_only_devices)
{
page.Replace("{ff2s2o1c}", Selected);
page.Replace("{ff2s2o2c}", "");
}
else
{
page.Replace("{ff2s2o1c}", "");
page.Replace("{ff2s2o2c}", Selected);
}
//-------------------- File Queue Settings --------------------------
if (Settings.ListThumbsInQueue)
{
page.Replace("{fq0c}", Checked);
}
else
{
page.Replace("{fq0c}", "");
}
/*
* if (Settings.PrioritizeBumpLimit)
* {
* page.Replace("{fq1c}", Checked);
* }
* else
* {
* page.Replace("{fq1c}", "");
* }
*
* switch (Settings.FilePrioritizeMode)
* {
* case Settings.FilePrioritizeModeEnum.BoardSpeed:
* page.Replace("{fq2s1o1c}", "");
* page.Replace("{fq2s1o2c}", "");
* page.Replace("{fq2s1o3c}", Selected);
* break;
* case Settings.FilePrioritizeModeEnum.LargerFirst:
* page.Replace("{fq2s1o1c}", "");
* page.Replace("{fq2s1o2c}", Selected);
* page.Replace("{fq2s1o3c}", "");
* break;
* case Settings.FilePrioritizeModeEnum.SmallerFirst:
* page.Replace("{fq2s1o1c}", Selected);
* page.Replace("{fq2s1o2c}", "");
* page.Replace("{fq2s1o3c}", "");
* break;
* default:
* break;
* }
*/
if (Settings.AutoRemoveCompleteFiles)
{
page.Replace("{fq3c}", Checked);
}
else
{
page.Replace("{fq3c}", "");
}
response.Status = System.Net.HttpStatusCode.OK;
response.ContentType = "text/html";
byte[] data = Encoding.UTF8.GetBytes(page.ToString());
response.ContentLength = data.Length;
response.SendHeaders();
response.SendBody(data);
return(true);
}
if (command.StartsWith("/settings/"))
{
// -------------- General Settings ------------
Settings.AutoStartManuallyAddedThreads = request.QueryString["gs0"].Value == "1";
Settings.ThumbnailOnly = request.QueryString["gs1"].Value == "1";
Settings.EnableFileStats = request.QueryString["gs2"].Value == "1";
Settings.UseHttps = request.QueryString["gs3"].Value == "1";
Settings.RemoveThreadsWhenTheyEnterArchivedState = request.QueryString["gs4"].Value == "1";
Settings.SaveBannedFileThumbnail = request.QueryString["gs5"].Value == "1";
Settings.CacheAPIFilesInMemory = request.QueryString["gs6"].Value == "1";
if (Settings.EnableFileStats)
{
FileSystemStats.Init();
}
// -------------- Security Settings ------------
Settings.EnableAuthentication = request.QueryString["ss0"].Value == "1";
Settings.AllowGuestAccess = request.QueryString["ss1"].Value == "1";
Settings.AuthUsername = request.QueryString["ba_user"].Value;
Settings.AuthPassword = request.QueryString["ba_pass"].Value;
// -------------- FFMPEG Settings ------------
Settings.ConvertGifsToWebm = request.QueryString["ff0"].Value == "1";
Settings.ConvertWebmToMp4 = request.QueryString["ff1"].Value == "1";
Settings.Convert_Webmgif_To_Target = request.QueryString["ff2"].Value == "1";
if (request.QueryString["ff2s1"].Value == "gif")
{
Settings.Convert_Webmgif_Target = Settings.X_Target.GIF;
}
else
{
Settings.Convert_Webmgif_Target = Settings.X_Target.MP4;
}
Settings.Convert_Webmgif_only_devices = request.QueryString["ff2s2"].Value == "ff2s2o1";
// -------------- File Queue Settings ------------
Settings.ListThumbsInQueue = request.QueryString["fq0"].Value == "1";
/*
* Settings.PrioritizeBumpLimit = request.QueryString["fq1"].Value == "1";
*
* switch (request.QueryString["fq2s1"].Value)
* {
* case "fq2s1o1":
* Settings.FilePrioritizeMode = Settings.FilePrioritizeModeEnum.SmallerFirst;
* break;
* case "fq2s1o2":
* Settings.FilePrioritizeMode = Settings.FilePrioritizeModeEnum.LargerFirst;
* break;
* case "fq2s1o3":
* Settings.FilePrioritizeMode = Settings.FilePrioritizeModeEnum.BoardSpeed;
* break;
* default:
* Settings.FilePrioritizeMode = Settings.FilePrioritizeModeEnum.SmallerFirst;
* break;
* }*/
Settings.AutoRemoveCompleteFiles = request.QueryString["fq3"].Value == "1";
Settings.Save();
if (!Settings.EnableAuthentication)
{
session.Clear();
response.Cookies.Clear();
}
response.Redirect("/settings");
return(true);
}
return(false);
}
public override bool Process(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session)
{
if (!request.Uri.AbsolutePath.StartsWith(API_URI_PATH, StringComparison.OrdinalIgnoreCase))
{
return(false);
}
var module = request.Uri.Segments.Skip(API_URI_SEGMENTS).FirstOrDefault();
if (string.IsNullOrWhiteSpace(module))
{
module = "help";
}
module = module.Trim('/');
var key = string.Join("", request.Uri.Segments.Skip(API_URI_SEGMENTS + 1)).Trim('/');
var method = request.Method;
if (!string.IsNullOrWhiteSpace(request.Headers["X-HTTP-Method-Override"]))
{
method = request.Headers["X-HTTP-Method-Override"];
}
DoProcess(request, response, session, method, module, key);
return(true);
}
public void Execute(HttpServer.IHttpClientContext context, HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session)
{
var filePath = request.Uri.LocalPath;
// Prevent hacking
filePath = filePath.Replace('/', '\\');
filePath = filePath.Substring(filePath.LastIndexOf('\\'));
if (filePath[0] == '\\')
{
filePath = filePath.Substring(1);
}
response.Connection = HttpServer.ConnectionType.Close;
try
{
var content = TemplateTools.ReadResourceFile(filePath);
response.ContentType = GetMimeTypeByExtension(filePath);
response.ContentLength = content.Length;
response.SendHeaders();
response.SendBody(content);
}
catch
{
response.Reason = "HTTP/1.1 404 Not Found";
response.Send();
}
}
public override bool Process(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session)
{
if (request.UriPath.StartsWith(Url))
{
string day_number = request.QueryString[UrlParameters.DayNumber].Value;
int dayNumber = 0;
DateTime day = DateTime.Now;
if (Int32.TryParse(day_number, out dayNumber))
{
day = new DateTime(day.Year, 1, 1);
dayNumber--;
if (!DateTime.IsLeapYear(day.Year) && dayNumber == 365)
{
dayNumber--;
}
day = day.AddDays(dayNumber);
}
var sdata = NetworkUsageCounter.GetDayStats(day);
JsonArray ja = new JsonArray();
for (int i = 0; i < sdata.Length; i++)
{
double t = sdata[i].Value / 1024 / 1024;
JsonArray inner = new JsonArray();
inner.Add(sdata[i].Key);
inner.Add(Math.Round(t, 2, MidpointRounding.AwayFromZero));
ja.Add(inner);
}
WriteJsonResponse(response, ja.ToString());
return(true);
}
return(false);
}
public override bool Process(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session)
{
if (!request.Uri.AbsolutePath.StartsWith(path))
{
return(false);
}
HttpServerUtil.DebugPrintRequest(request);
Socket socket = HttpServerUtil.GetNetworkSocket(response);
//response.ContentLength = long.MaxValue;
response.ContentType = "audio/" + fileInfo.Extension.Substring(1);
response.AddHeader("TransferMode.DLNA.ORG", "Streaming");
response.AddHeader("Server", "UPnP/1.0 DLNADOC/1.50 LAB/1.0");
FileStream stream = fileInfo.OpenRead();
// create local output buffers
byte[] buffer = new byte[BUFFER_SIZE];
HttpServerUtil.DebugPrintResponse(response);
response.SendHeaders();
int bytesRead = 1;
while (socket.Connected && bytesRead > 0)
{
// file stream -> byte array buffer -> circlebuffer -> add metadata -> byte array buffer -> response stream
bytesRead = stream.Read(buffer, 0, buffer.Length);
response.SendBody(buffer, 0, bytesRead);
}
// remove local output buffer
stream.Close();
Console.WriteLine("request processing finished");
return(true);
}
