string EP_show_reason(IHttpRequestResponse req)
{
string result = "";
string prefix = "url=";
try
{
string reason = "No url found";
if (!string.IsNullOrEmpty(req.QueryString))
{
int startIndex = req.QueryString.IndexOf(prefix);
if (startIndex > -1)
{
Uri url = new Uri(System.Net.WebUtility.UrlDecode(req.QueryString.Substring(startIndex + prefix.Length)));
isBlockedFullFlow(url, out reason);
}
}
result = AndroidApp.Properties.Resources.BlockedPage.Replace("{0}", reasonToHTML(reason));
}
catch (Exception ex)
{
result = stringHTML(ex.ToString(), "Error");
AndroidBridge.e(TAG, ex.ToString());
}
return(result);
}
string EP_echo(IHttpRequestResponse req)
{
string result = "";
try
{
string headers = "";
foreach (var key in req.Headers.Keys)
{
headers += $"{key}: {req.Headers[key]}\r\n";
}
string sentBody = readReqBodyAsString(req);
result =
AndroidApp.Properties.Resources.Echo
.Replace("{0}", headers)
.Replace("{1}", sentBody)
.Replace("{2}", req.Method)
.Replace("{3}", req.Path)
;
}
catch (Exception ex)
{
result = stringHTML(ex.ToString(), "Error");
AndroidBridge.e(TAG, ex.ToString());
}
return(result);
}
async Task SendResponseAsync(IHttpRequestResponse request, HttpSender httpSender)
{
try
{
if (request.RequestType == RequestType.TCP)
{
string path = request.Path;
string responseContentType = ContentHTML;
string responseBody = $"<html>\r\n<body>Unknown Path:\r\n{path}</body>\r\n</html>";
if (path.StartsWith("/echo"))
{
responseContentType = ContentHTML;
responseBody = EP_echo(request);
}
else if (path.StartsWith("/history"))
{
responseContentType = ContentHTML;
responseBody = EP_domainHistory(request);
}
else if (path.StartsWith("/check"))
{
responseContentType = ContentJSON;
responseBody = EP_checkDomain(request);
}
else if (path.StartsWith("/reason"))
{
responseContentType = ContentHTML;
responseBody = EP_show_reason(request);
}
var response = new HttpResponse
{
StatusCode = (int)HttpStatusCode.OK,
ResponseReason = HttpStatusCode.OK.ToString(),
Headers = new Dictionary <string, string>
{
{ "Date", DateTime.UtcNow.ToString("r") },
{ "Content-Type", responseContentType },
{ "Connection", "close" }
},
Body = new MemoryStream(Encoding.UTF8.GetBytes(responseBody))
};
AndroidBridge.d(TAG, "[RESP-SEND] \"" + request.Path + "\" IP: " + ipString(request.RemoteIpEndPoint));
await httpSender.SendTcpResponseAsync(request, response).ConfigureAwait(false);
request.TcpClient.Close(); // Force close!
AndroidBridge.d(TAG, "[END] \"" + request.Path + "\" IP: " + ipString(request.RemoteIpEndPoint));
}
}
catch (Exception ex)
{
AndroidBridge.e(TAG, ex.ToString());
}
}
public void CancelDownload(DownloadOperation operation)
{
Profiler.BeginSample(string.Format("CancelDownload {0}", operation.ID));
AndroidBridge.CallStatic("cancelDownload", Context, operation.ID);
Profiler.EndSample();
}
public AndroidBridgeManager(int baudrate)
{
bridgeGameObject = new GameObject();
bridgeGameObject.name = "AndroidBridge";
bridgeComponent = bridgeGameObject.AddComponent <AndroidBridge>();
bridge = (AndroidBridge)bridgeComponent;
bridge.InputChanged += OnInputChanged;
bridge.ConnectionChanged += OnConnectionChanged;
bridge.Setup(baudrate);
}
public static void AppendLinePublic(string relativePath, string line)
{
try
{
File.AppendAllLines(AndroidBridge.GetAbsulotePath(relativePath, isPublic: true), new[] { line });
}
catch (Exception ex)
{
AndroidBridge.e(TAG, ex);
}
}
protected override void OnCreate(Bundle savedInstanceState)
{
base.OnCreate(savedInstanceState);
_impl = new AndroidBridge(this);
MonoSAMGame.StaticBridge = _impl;
var g = new MainGame();
SetContentView(g.Services.GetService <View>());
g.Run();
}
public void StopFlow()
{
if (AndroidBridge.isForegroundServiceUp())
{
AndroidBridge.StopForgroundService();
}
else
{
AndroidBridge.ToastIt("Service already stopped");
}
}
private async void BtnSet_Clicked(object sender, EventArgs e)
{
await FilterUtils.TimeLock.onlyUnlockedAsync(async() =>
{
DateTime PickedDate;
PickedDate = datePicker1.Date;
PickedDate = PickedDate.Add(timePicker1.Time - PickedDate.TimeOfDay);
string result = FilterUtils.TimeLock.TrySetLockDate(PickedDate);
AndroidBridge.ToastIt(result);
await Application.Current.MainPage.Navigation.PopAsync();
});
}
public void Stop()
{
try
{
AndroidBridge.d(TAG, "Closing server");
cancellationTokenSource?.Cancel();
myServerInstance?.Dispose();
myListener?.Stop();
}
catch (Exception ex)
{
AndroidBridge.e(TAG, ex.ToString());
}
}
public DownloadOperation StartDownload(BackgroundDownloadOptions options)
{
try
{
var id = AndroidBridge.CallStatic <long>("download", Context, options.URL, options.DestinationPath, options.Title, options.Description);
return(new AndroidDownloadOperation(this, options, id));
}
catch (Exception e)
{
Debug.LogException(e);
}
return(null);
}
string EP_domainHistory(IHttpRequestResponse req)
{
string result = "";
try
{
string body = String.Join("<br />", domainHistory);
result = stringHTML(body: body);
}
catch (Exception ex)
{
AndroidBridge.e(TAG, ex.ToString());
}
return(result);
}
public static TaskResult SetPassword(string newPass)
{
TaskResult result = TaskResult.Fail("Init");
try
{
newPass = get256Hash(newPass);
File.WriteAllText(Filenames.MASTER_PASSWORD.getAppPrivate(), newPass);
result = TaskResult.Success("Master password saved");
}
catch (Exception ex)
{
AndroidBridge.e(TAG, ex);
result = TaskResult.Fail(ex.ToString());
}
return(result);
}
public static string ReadAssetAsString(Context ctx, string tag, string asset_name)
{
string result = "";
try
{
using (Stream s = ctx.Assets.Open(asset_name))
{
StreamReader reader = new StreamReader(s);
result = reader.ReadToEnd();
}
}
catch (Exception ex)
{
AndroidBridge.e(tag, ex);
}
return(result);
}
string stringHTML(string body = "", string title = "")
{
string result = "";
try
{
result =
AndroidApp.Properties.Resources.EmptyHTML
.Replace("{title}", title)
.Replace("{body}", body)
;
}
catch (Exception ex)
{
AndroidBridge.e(TAG, ex.ToString());
}
return(result);
}
public static async Task onlyUnlockedAsync(Func <Task> callback)
{
try
{
var isLocked = TimeLock.isLocked();
if (isLocked)
{
AndroidBridge.ToastIt(isLocked.eventReason);
}
else
{
await callback();
}
}
catch (Exception ex)
{
AndroidBridge.e(TAG, ex);
}
}
string readReqBodyAsString(IHttpRequestResponse req)
{
string result = "";
try
{
if (req.Body != null && req.Body.Length > 0)
{
StreamReader reader = new StreamReader(req.Body);
req.Body.Position = 0;
result = reader.ReadToEnd();
}
}
catch (Exception ex)
{
AndroidBridge.e(TAG, ex.ToString());
}
return(result);
}
public static string domainCategoryResult(bool block)
{
string result = "";
try
{
int myCategory = block ? Category_Blocked : Category_Allowed;
var jsonObject = new JObject();
jsonObject["categories"] = new JArray(new[] { new JValue(myCategory) });
jsonObject["resultCode"] = new JValue(0);
result = jsonObject.ToString();
}
catch (Exception ex)
{
AndroidBridge.e(TAG, ex.ToString());
}
return(result);
}
public static TaskResult ComparePass(string checkPass)
{
TaskResult result = TaskResult.Fail("Init");
try
{
checkPass = get256Hash(checkPass);
string currentPass = File.ReadAllText(Filenames.MASTER_PASSWORD.getAppPrivate());
bool arePasswordHashSame = checkPass.Equals(currentPass);
result = new TaskResult();
result.success = arePasswordHashSame;
result.eventReason = "Are password same? " + arePasswordHashSame;
}
catch (Exception ex)
{
AndroidBridge.e(TAG, ex);
result = TaskResult.Fail(ex.ToString());
}
return(result);
}
public void Start(int port)
{
try
{
myListener = new TcpListener(IPAddress.Loopback, port)
{
ExclusiveAddressUse = false
};
var httpSender = new HttpSender();
cancellationTokenSource = new CancellationTokenSource();
myServerInstance = myListener.ToHttpListenerObservable(cancellationTokenSource.Token)
.Do(r =>
{
AndroidBridge.d(TAG, "[START] \"" + r.Path + "\" IP: " + ipString(r.RemoteIpEndPoint));
})
// Send reply to browser
.Select(r => Observable.FromAsync(() => SendResponseAsync(r, httpSender)))
.Concat()
.Subscribe(r =>
{
//Console.WriteLine("Reply sent.");
},
ex =>
{
AndroidBridge.e(TAG, ex.ToString());
},
() =>
{
AndroidBridge.d(TAG, "Server completed");
});
}
catch (Exception ex)
{
AndroidBridge.e(TAG, ex.ToString());
}
}
string EP_checkDomain(IHttpRequestResponse req)
{
string result = "";
try
{
var reqJSON = readReqBodyAsString(req);
string domain = SpinResultHelper.getDomainName(reqJSON).Trim(new char[] { ' ', '"' });
domainHistory.Add(domain);
string reason = "";
bool block = isBlockedFullFlow(new Uri(domain), out reason);
if (block)
{
try
{
File.AppendAllLines(Filenames.BLOCK_LOG.getAppPublic(), new[] {
string.Format("[{0}] {1} {2}", DateTime.Now, domain, reason)
});
}
catch (Exception ex)
{
AndroidBridge.e(TAG, ex);
}
}
result = SpinResultHelper.domainCategoryResult(block);
}
catch (Exception ex)
{
result = "{\"error\":\"0\"}".Replace("0", ex.ToString());
AndroidBridge.e(TAG, ex.ToString());
}
return(result);
}
public static string getDomainName(string jsonBody)
{
string result = "";
try
{
var jsonObject = JObject.Parse(jsonBody);
var version = jsonObject["v"].ToString();
if (version == "1")
{
var domainName = jsonObject["domainName"];
result = domainName.ToString();
}
else
{
throw new Exception("Unknown Version of domain request");
}
}
catch (Exception ex)
{
AndroidBridge.e(TAG, ex.ToString());
}
return(result);
}
private static string ForceLockDate(DateTime date)
{
string result = "";
try
{
string unlockPath = Filenames.LOCK_DATE.getAppPrivate();
AndroidBridge.d(TAG, "(*) Locking until '" + date.ToString() + "'");
if (File.Exists(unlockPath))
{
File.Delete(unlockPath);
}
File.WriteAllText(unlockPath, date.ToString());
result = "Sucess! Locked to " + date.ToString();
}
catch (Exception ex)
{
AndroidBridge.e(TAG, ex);
result = ex.ToString();
}
return(result);
}
public void StartFlow()
{
try
{
// Reload policies:
FilteringObjects.httpPolicy.reloadPolicy(File.ReadAllText(Filenames.HTTP_POLICY.getAppPrivate()));
FilteringObjects.timePolicy.reloadPolicy(File.ReadAllText(Filenames.TIME_POLICY.getAppPrivate()));
if (!AndroidBridge.isForegroundServiceUp())
{
AndroidBridge.OnForgroundServiceStart = () =>
{
AndroidBridge.d(TAG, "Starting filtering flow");
myHTTPServer.StartHttpServer();
StartPeriodicTasks();
};
AndroidBridge.OnForgroundServiceStop = () =>
{
AndroidBridge.d(TAG, "Stopping filtering flow");
StopPeriodicTasks();
myHTTPServer.StopHTTPServer();
};
AndroidBridge.StartForgroundService();
}
else
{
AndroidBridge.ToastIt("Service already up!");
}
}
catch (Exception ex)
{
AndroidBridge.e(TAG, ex);
}
}
public void scheduleRepeated()
{
TimeSpan WIFI_PERIOD = (FilteringObjects.isFiltering && FilteringObjects.isInWifiBlockZone) ?
WIFI_PERIOD_BLOCKED : WIFI_PERIOD_ALLOWED;
int taskID = AndroidBridge.scheduleJob(WIFI_PERIOD, WIFI_PERIOD + TimeSpan.FromSeconds(10), null,
(finishFunc) => {
if (AndroidBridge.isForegroundServiceUp())
{
AndroidBridge.StartWifiScanning();
scheduleRepeated();
}
finishFunc(false);
},
() => AndroidBridge.isForegroundServiceUp(),
null,
() => false
);
if (taskID < 0)
{
AndroidBridge.e(TAG, "Failed to schedule job.");
}
}
public string getAppPrivate()
{
return(AndroidBridge.GetAbsulotePath(_relative, false));
}
public void StopPeriodicTasks()
{
AndroidBridge.stopAllJobs();
}
public DownloadStatus GetStatus(long id)
{
return((DownloadStatus)AndroidBridge.CallStatic <int>("getDownloadStatus", Context, id));
}
public float GetProgress(long id)
{
return(AndroidBridge.CallStatic <float>("getDownloadProgress", Context, id));
}
public DownloadOperation GetDownloadOperation(string url)
{
var id = AndroidBridge.CallStatic <long> ("getDownloadOperation", Context, url);
return((id == -1) ? null : new AndroidDownloadOperation(this, new BackgroundDownloadOptions(url), id));
}
