//-------------------
// Run this thread to make sure connections are always being handled for inbound requests
private async Task ListenerUpdate(string prefixURL, int numListenerThreads, CancellationToken token)
{
List <Task> listenerTasks = new List <Task>(numListenerThreads);
// Create a local cancellation token source which goes away at the end of this function/task
try
{
// Turn on the webserver
while (token.IsCancellationRequested == false)
{
// Populate the task set in a non-concurrent dictionary
while (listenerTasks.Count < numListenerThreads)
{
Task t = Task <HttpListenerContext> .Run(() => { return(_listener?.GetContextAsync()); }, token).ContinueWith(HandleConnection, token, TaskContinuationOptions.OnlyOnRanToCompletion, TaskScheduler.Current);
listenerTasks.Add(t);
_logger?.Invoke("WebSocketServer.ListenerUpdate - adding listener", 2);
}
using (Task finished = await Task.WhenAny(listenerTasks).ConfigureAwait(false)) // when a connection listener task is completed, terminate it
{
listenerTasks.Remove(finished);
_logger?.Invoke("WebSocketServer.ListenerUpdate - listener handled", 2);
}
}
}
catch (OperationCanceledException) // if the token is cancelled, we pop to here
{
}
catch (Exception e)
{
_logger?.Invoke($"WebSocketServer.ListenerUpdate - caught unexpected exception {e.Message}", 0);
}
finally
{
_logger?.Invoke("WebSocketServer.ListenerUpdate - disposing listener tasks", 1);
for (int i = 0; i < listenerTasks.Count; i++)
{
try
{
await listenerTasks[i]; // this should throw an OperationCanceledException
}
catch (OperationCanceledException)
{
// expected
}
catch (Exception e)
{
_logger?.Invoke($"WebSocketServer.ListenerUpdate - disposing listener tasks caught unexpected exception {e.Message}", 0);
}
listenerTasks[i].Dispose();
}
listenerTasks.Clear();
_logger?.Invoke("WebSocketServer.ListenerUpdate - listener tasks dead", 1);
}
}
private static async Task HandleRequests()
{
if (IsHandlingRequests)
{
return;
}
IsHandlingRequests = true;
try {
while (IsListening)
{
Task <HttpListenerContext> task = HttpListener?.GetContextAsync();
if (task == null)
{
return;
}
HttpListenerContext context;
try {
context = await task.ConfigureAwait(false);
} catch (HttpListenerException e) {
// If HttpListener is null then we're stopping HttpListener, so this exception is expected, ignore it
if (HttpListener == null)
{
return;
}
// Otherwise this is an error, and HttpListener can dispose itself in this situation, so don't keep it around
HttpListener = null;
ASF.ArchiLogger.LogGenericException(e);
return;
}
Utilities.StartBackgroundFunction(() => HandleRequest(context), false);
}
} finally {
IsHandlingRequests = false;
}
}
public static async Task SimpleRequest_Succeeds()
{
string url = UrlPrefix.CreateLocal();
const string expectedResponse = "hello from HttpListener";
using (HttpListener listener = new HttpListener())
{
listener.Prefixes.Add(url);
listener.Start();
var serverContextTask = listener.GetContextAsync();
using (HttpClient client = new HttpClient())
{
var clientTask = client.GetStringAsync(url);
var serverContext = await serverContextTask;
using (var response = serverContext.Response)
{
var responseBuffer = Encoding.UTF8.GetBytes(expectedResponse);
response.ContentLength64 = responseBuffer.Length;
using (var output = response.OutputStream)
{
await output.WriteAsync(responseBuffer, 0, responseBuffer.Length);
}
}
var clientString = await clientTask;
Assert.Equal(expectedResponse, clientString);
}
listener.Stop();
}
}
// Keep on handling requests
public static async Task HandleIncomingConnections()
{
while (true)
{
// Will wait here until we hear from a connection
HttpListenerContext ctx = await listener.GetContextAsync();
// Peel out the requests and response objects
HttpListenerRequest req = ctx.Request;
HttpListenerResponse resp = ctx.Response;
int status = 200;
string statusDescription = "OK";
string json = "";
Error[] errors = new Error[1];
if (req.Url.AbsolutePath == "/" + type)
{
//OK
if (req.HttpMethod == "GET")
{ //Return sessionid
try
{
//Create new payment session
Session session = new Session(Double.Parse(req.QueryString["amount"]),
req.QueryString["purpose"]);
json = JsonConvert.SerializeObject(new Data(type,
session.sessionId.ToString()));
}
catch (Exception e)
{
//Error: amount or purpose is not exists
errors[0] = new Error(400, "Amount or purpose is missing!", 6);
json = JsonConvert.SerializeObject(errors);
status = 400;
statusDescription = "Bad Request";
Console.WriteLine(e);
}
}
else if (req.HttpMethod == "POST")
{ //Make payment
try
{
//Read request body
dynamic request = JsonConvert.DeserializeObject(
ReadInputStream(req.InputStream));
if (request.type == type)
{
Session session = Session.Find(Guid.Parse((string)request.id));
if (session != null)
{
Card card = new Card((string)request.attributes.number, (int)request.attributes.CVVCVC,
(int)request.attributes.year, (int)request.attributes.mounth,
(string)request.attributes.URL);
//Сheck the data is full
if (card.number.Length >= 4 && card.CVVCVC >= 100 && card.CVVCVC <= 999 &&
card.mounth >= 1 && card.year >= 0 && card.URL != "")
{
//Check the card number in Luna algorithm
if (SimpleLuna(card.number))
{
//Payment successful
json = JsonConvert.SerializeObject(new Data(type,
session.sessionId.ToString()));
//Send http-notice
HttpNotice(card.URL, session.sessionId, session.purpose,
card.number, session.amount);
}
else
{
//Error: the card number is not correct
errors[0] = new Error(400, "The card number is not correct!", 1);
json = JsonConvert.SerializeObject(errors);
status = 400;
statusDescription = "Bad Request";
}
}
else
{
//Error: the card data is not correct
errors[0] = new Error(400, "The card data is not correct!", 2);
json = JsonConvert.SerializeObject(errors);
status = 400;
statusDescription = "Bad Request";
}
//Delete used session
Session.list.Remove(session);
}
else
{
//Error: dead session
errors[0] = new Error(400, "Dead session!", 3);
json = JsonConvert.SerializeObject(errors);
status = 400;
statusDescription = "Bad Request";
}
}
else
{
//Error: unknown request type
errors[0] = new Error(400, "Unknown request type!", 4);
json = JsonConvert.SerializeObject(errors);
status = 400;
statusDescription = "Bad Request";
}
}
catch (Exception e)
{
if (e.GetType().Name == "UriFormatException")
{
errors[0] = new Error(400, "Invalid URL!", 4);
json = JsonConvert.SerializeObject(errors);
status = 400;
statusDescription = "Bad Request";
}
else if (e.GetType().Name == "FormatException")
{
errors[0] = new Error(400, "Bad Request", 7);
json = JsonConvert.SerializeObject(errors);
status = 400;
statusDescription = "Bad Request";
}
else
{
//Error: 500 - Internal Server Error
status = 500;
statusDescription = "Internal Server Error";
Console.WriteLine(e);
}
}
}
else
{
//Error: unknown method
errors[0] = new Error(400, "Unknown method!", 5);
json = JsonConvert.SerializeObject(errors);
status = 400;
statusDescription = "Bad Request";
}
}
else
{
//Error: resource not found
status = 404;
statusDescription = "Not Found";
}
byte[] data = Encoding.UTF8.GetBytes(json);
resp.StatusCode = status;
resp.StatusDescription = statusDescription;
resp.ContentType = "application/vnd.api+json";
resp.ContentEncoding = Encoding.UTF8;
resp.ContentLength64 = data.LongLength;
// Write out to the response stream (asynchronously), then close it
await resp.OutputStream.WriteAsync(data, 0, data.Length);
resp.Close();
}
}
static async Task Main(string[] args)
{
var users = new List<User>();
using var listener = new HttpListener();
listener.Prefixes.Add("http://localhost:80/");
listener.Start();
const string GIVE = "GIVE";
const string ADD = "ADD";
const string UPDATE = "UPDATE";
const string REMOVE = "REMOVE";
using var contextDb = new ContextDb();
Console.WriteLine("Готов к работе");
while (true)
{
users.Clear();
users = contextDb.Users.Where(u => u.IsDeleted == false).ToList();
using var context = await listener.GetContextAsync();
var request = context.Request;
IncomeUri = request.RawUrl;
var response = context.Response;
//using var stream = client.GetStream();
//var resultText = string.Empty;
//var buffer = new byte[1024];
//stream.Read(buffer, 0, buffer.Length);
////resultText += Encoding.UTF8.GetString(buffer).TrimEnd('\0');
//var response = JsonConvert.DeserializeObject<Response>(resultText);
if (response.Path == "user")
{
if (response.Action == GIVE)
{
StringBuilder stringBuilder = ParseSpecialType(users);
var answer = Encoding.UTF8.GetBytes(stringBuilder.ToString());
stream.Write(answer, 0, answer.Length);
Console.WriteLine($"[{DateTime.Now}]\tОтправка таблицы с пользователями...");
}
else if (response.Action == ADD)
{
var user = new User()
{
Name = response.Value,
};
contextDb.Users.Add(user);
contextDb.SaveChanges();
Console.WriteLine($"[{DateTime.Now}]\tДобавления пользователя {user.Id} - {user.Name}...");
}
else if (response.Action == UPDATE)
{
try
{
var user = users.FirstOrDefault(x => x.Id == int.Parse(response.Value));
var oldName = user.Name;
user.Name = response.NewData;
contextDb.Update(user);
contextDb.SaveChanges();
Console.WriteLine($"[{DateTime.Now}]\tОбновление пользователя {user.Id} - {oldName} на {user.Id} - {response.NewData}...");
}
catch
{
var error = "Вы ввели неверный ID";
var answer = Encoding.UTF8.GetBytes(error);
stream.Write(answer, 0, answer.Length);
}
}
else if (response.Action == REMOVE)
{
try
{
var user = contextDb.Users.FirstOrDefault(x => x.Id == int.Parse(response.Value));
user.IsDeleted = true;
contextDb.Update(user);
contextDb.SaveChanges();
Console.WriteLine($"[{DateTime.Now}]\tУдаление пользователя {user.Id} - {user.Name}...");
}
catch
{
var error = "Вы ввели неверный ID";
var answer = Encoding.UTF8.GetBytes(error);
stream.Write(answer, 0, answer.Length);
}
}
}
try
{
switch (context.Request.Url.AbsolutePath)
{
case "/users/give/":
if (context.Request.HttpMethod == POST)
{
}
break;
case "/users/add/":
if (context.Request.HttpMethod == ADD)
{
try
{
using var body = context.Request.InputStream;
using var reader = new StreamReader(body, context.Request.ContentEncoding);
var json = reader.ReadToEnd();
var user = JsonConvert.DeserializeObject<User>(json);
var userDb = contextDb.Users.FirstOrDefault(x => x.Name == user.Name);
if (userDb == null)
{
await contextDb.Users.AddAsync(user);
await contextDb.SaveChangesAsync();
Console.WriteLine($"[{DateTime.Now}]\tДобавления пользователя {user.Id} - {user.Name}...");
response.StatusCode = (int)HttpStatusCode.Created;
}
else
{
response.StatusCode = (int)HttpStatusCode.Forbidden;
}
}
catch (Exception exception)
{
response.StatusCode = (int)HttpStatusCode.Forbidden;
//var exceptionJson = JsonConvert.SerializeObject<Exception>(exception);
}
}
break;
case "/users/update":
if (context.Request.HttpMethod == POST)
{
try
{
using var body = context.Request.InputStream;
using var reader = new StreamReader(body, context.Request.ContentEncoding);
var json = reader.ReadToEnd();
var user = JsonConvert.DeserializeObject<User>(json);
var user = contextDb.Users.FirstOrDefault(x => x.Id == int.Parse(user.Id));
contextDb.Update(user);
await contextDb.SaveChangesAsync();
response.StatusCode = (int)HttpStatusCode.OK;
}
catch
{
response.StatusCode = (int)HttpStatusCode.NotFound;
}
}
break;
case "/users/delete":
if (context.Request.HttpMethod == POST)
{
}
break;
default:
response.StatusCode = (int)HttpStatusCode.BadRequest;
break;
}
}
catch (Exception exception)
{
response.StatusCode = (int)HttpStatusCode.InternalServerError;
response.ContentType = "application/json";
var buffer = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(exception));
response.ContentLength64 = buffer.Length;
response.OutputStream.Write(buffer, 0, buffer.Length);
}
response.Close();
}
}
/// <summary>
///
/// </summary>
/// <param name="uriPrefixes"></param>
/// <returns></returns>
public Task Run(params string[] uriPrefixes)
{
Error = null;
// Establish a host-handler context:
_hostContext = new HostContext(this, _handler);
_listener.IgnoreWriteExceptions = true;
if (uriPrefixes.Length == 0)
{
TraceLog.WriteError("Http start listenning url is null");
}
// Add the server bindings:
foreach (var prefix in uriPrefixes)
{
_listener.Prefixes.Add(prefix.EndsWith("/") ? prefix : prefix + "/");
}
return(Task.Run(async() =>
{
// Configure the handler:
if (_configValues != null)
{
var config = _handler as IConfigurationTrait;
if (config != null)
{
var task = config.Configure(_hostContext, _configValues);
if (task != null)
{
if (!await task)
{
return;
}
}
}
}
// Initialize the handler:
var init = _handler as IInitializationTrait;
if (init != null)
{
var task = init.Initialize(_hostContext);
if (task != null)
{
if (!await task)
{
return;
}
}
}
try
{
// Start the HTTP listener:
_listener.Start();
}
catch (HttpListenerException hlex)
{
Error = hlex;
TraceLog.WriteError("Http start listenning error:{0}", hlex);
return;
}
// Accept connections:
// Higher values mean more connections can be maintained yet at a much slower average response time; fewer connections will be rejected.
// Lower values mean less connections can be maintained yet at a much faster average response time; more connections will be rejected.
var sem = new Semaphore(_accepts, _accepts);
while (true)
{
sem.WaitOne();
#pragma warning disable 4014
_listener.GetContextAsync().ContinueWith(async(t) =>
{
try
{
sem.Release();
var ctx = await t;
await ProcessListenerContext(ctx, this);
return;
}
catch (Exception ex)
{
TraceLog.WriteError("Http request unknow error:{0}", ex);
}
});
#pragma warning restore 4014
}
}));
}
private async void BrowserLoginForm_Load(object sender, EventArgs e)
{
//webBrowser1.Navigate(new Uri(tenantUrl));
// Generates state and PKCE values.
string state = randomDataBase64url(32);
string code_verifier = randomDataBase64url(32);
string code_challenge = base64urlencodeNoPadding(sha256(code_verifier));
// Creates an HttpListener to listen for requests on that redirect URI.
var http = new HttpListener();
http.Prefixes.Add(redirectURI);
http.Start();
// Creates the OAuth 2.0 authorization request.
string params_endpoint = "?client_id=" + clientID +
"&scope=openid email phone address groups profile" +
"&response_type=code" +
"&response_mode=query" +
"&nonce=" + "nonceStatic" +
"&redirect_uri=" + redirectURI +
"&state=" + state +
"&sessionToken=" + "session_no_needed";
string authorizationRequest = tenantUrl + "/oauth2/v1/authorize" + params_endpoint;
// Sending request to the browser.
//System.Diagnostics.Process.Start(authorizationRequest);
webBrowser1.ScriptErrorsSuppressed = true;
webBrowser1.Navigate(new Uri(authorizationRequest));
// Waits for the OAuth authorization response.
var context = await http.GetContextAsync();
// Bring focus back to the app.
this.Activate();
// Sends an HTTP response to the browser.
var response = context.Response;
string responseString = string.Format("<html><head><meta http-equiv='refresh' content='10;url=https://okta.com'></head><body>Please return to the okta app.</body></html>");
var buffer = System.Text.Encoding.UTF8.GetBytes(responseString);
response.ContentLength64 = buffer.Length;
var responseOutput = response.OutputStream;
System.Threading.Tasks.Task responseTask = responseOutput.WriteAsync(buffer, 0, buffer.Length).ContinueWith((task) =>
{
responseOutput.Close();
http.Stop();
Console.WriteLine("HTTP server stopped.");
});
// Checks for errors.
if (context.Request.QueryString.Get("error") != null)
{
//output(String.Format("OAuth authorization error: {0}.", context.Request.QueryString.Get("error")));
return;
}
if (context.Request.QueryString.Get("code") == null ||
context.Request.QueryString.Get("state") == null)
{
//output("Malformed authorization response. " + context.Request.QueryString);
return;
}
// extracts the code
var code = context.Request.QueryString.Get("code");
var incoming_state = context.Request.QueryString.Get("state");
// Compares the receieved state to the expected value, to ensure that
// this app made the request which resulted in authorization.
if (incoming_state != state)
{
//output(String.Format("Received request with invalid state ({0})", incoming_state));
return;
}
//output("Authorization code: " + code);
// Starts the code exchange at the Token Endpoint.
getAccessToken(code, code_verifier, redirectURI);
}
public static async Task HandleIncomingConnections()
{
bool runServer = true;
// While a user hasn't visited the `shutdown` url, keep on handling requests
while (runServer)
{
// Will wait here until we hear from a connection
HttpListenerContext ctx = await listener.GetContextAsync();
// Peel out the requests and response objects
HttpListenerRequest req = ctx.Request;
HttpListenerResponse resp = ctx.Response;
// Print out some info about the request
Console.WriteLine("Request #: {0}", ++requestCount);
Console.WriteLine(req.Url.ToString());
Console.WriteLine(req.HttpMethod);
Console.WriteLine(req.UserHostName);
Console.WriteLine(req.UserAgent);
Console.WriteLine();
var pageData = "";
// If `shutdown` url requested w/ POST, then shutdown the server after serving the page
if ((req.HttpMethod == "GET"))
{
switch (req.Url.AbsolutePath)
{
case "/kick":
{
if (req.QueryString.Get("player") != "")
{
var player = playerManager.getPlayer(req.QueryString.Get("player"));
if (player != null)
{
player.Kick("ai lua muie");
pageData = $"Playerul {player.Name} a fost dat afara";
}
else
{
pageData = $"Playerul nu este online.";
}
}
break;
}
case "/send":
{
if (req.QueryString.Get("msg") != "")
{
NAPI.Chat.SendChatMessageToAll("SERVER: " + req.QueryString.Get("msg"));
}
break;
}
case "/playerList":
{
foreach (var item in NAPI.Pools.GetAllPlayers())
{
pageData += $"Name: {item.Name} IP Address: {item.Address} Position {NAPI.Util.ToJson(item.Position)}";
}
}
break;
}
}
// Make sure we don't increment the page views counter if `favicon.ico` is requested
if (req.Url.AbsolutePath != "/favicon.ico")
{
pageViews += 1;
}
// Write the response info
string disableSubmit = !runServer ? "disabled" : "";
byte[] data = Encoding.UTF8.GetBytes(pageData);
resp.ContentType = "text/html";
resp.ContentEncoding = Encoding.UTF8;
resp.ContentLength64 = data.LongLength;
// Write out to the response stream (asynchronously), then close it
await resp.OutputStream.WriteAsync(data, 0, data.Length);
resp.Close();
}
}
private async Task AcceptConnections(CancellationToken cancelToken)
{
try
{
while (true)
{
if (cancelToken.IsCancellationRequested)
{
break;
}
if (!_Listener.IsListening)
{
Task.Delay(100).Wait();
continue;
}
HttpListenerContext ctx = await _Listener.GetContextAsync().ConfigureAwait(false);
string ip = ctx.Request.RemoteEndPoint.Address.ToString();
int port = ctx.Request.RemoteEndPoint.Port;
string ipPort = ip + ":" + port;
lock (_PermittedIpsLock)
{
if (PermittedIpAddresses != null &&
PermittedIpAddresses.Count > 0 &&
!PermittedIpAddresses.Contains(ip))
{
Logger?.Invoke(_Header + "rejecting " + ipPort + " (not permitted)");
ctx.Response.StatusCode = 401;
ctx.Response.Close();
continue;
}
}
if (!ctx.Request.IsWebSocketRequest)
{
if (HttpHandler == null)
{
Logger?.Invoke(_Header + "non-websocket request rejected from " + ipPort);
ctx.Response.StatusCode = 400;
ctx.Response.Close();
}
else
{
Logger?.Invoke(_Header + "non-websocket request from " + ipPort + " HTTP-forwarded: " + ctx.Request.HttpMethod.ToString() + " " + ctx.Request.RawUrl);
HttpHandler.Invoke(ctx);
}
continue;
}
else
{
/*
* HttpListenerRequest req = ctx.Request;
* Console.WriteLine(Environment.NewLine + req.HttpMethod.ToString() + " " + req.RawUrl);
* if (req.Headers != null && req.Headers.Count > 0)
* {
* Console.WriteLine("Headers:");
* var items = req.Headers.AllKeys.SelectMany(req.Headers.GetValues, (k, v) => new { key = k, value = v });
* foreach (var item in items)
* {
* Console.WriteLine(" {0}: {1}", item.key, item.value);
* }
* }
*/
}
await Task.Run(() =>
{
Logger?.Invoke(_Header + "starting data receiver for " + ipPort);
CancellationTokenSource tokenSource = new CancellationTokenSource();
CancellationToken token = tokenSource.Token;
Task.Run(async() =>
{
WebSocketContext wsContext = await ctx.AcceptWebSocketAsync(subProtocol: null);
WebSocket ws = wsContext.WebSocket;
ClientMetadata md = new ClientMetadata(ctx, ws, wsContext, tokenSource);
_Clients.TryAdd(md.IpPort, md);
ClientConnected?.Invoke(this, new ClientConnectedEventArgs(md.IpPort, ctx.Request));
await Task.Run(() => DataReceiver(md), token);
}, token);
}, _Token).ConfigureAwait(false);
}
}
/*
* catch (HttpListenerException)
* {
* // thrown when disposed
* }
*/
catch (TaskCanceledException)
{
// thrown when disposed
}
catch (OperationCanceledException)
{
// thrown when disposed
}
catch (ObjectDisposedException)
{
// thrown when disposed
}
catch (Exception e)
{
Logger?.Invoke(_Header + "listener exception:" + Environment.NewLine + e.ToString());
}
finally
{
ServerStopped?.Invoke(this, EventArgs.Empty);
}
}
public static async Task <string> GetRefreshToken(string clientId, string clientSecret, string appName, GoogleScopes googleScope)
{
// Generates state and PKCE values.
var state = RandomDataBase64Url(32);
var codeVerifier = RandomDataBase64Url(32);
var codeChallenge = Base64UrlencodeNoPadding(Sha256(codeVerifier));
const string CodeChallengeMethod = "S256";
// Creates a redirect URI using an available port on the loopback address.
var redirectUri = $"http://{IPAddress.Loopback}:{GetRandomUnusedPort()}/";
// Creates an HttpListener to listen for requests on that redirect URI.
var http = new HttpListener();
http.Prefixes.Add(redirectUri);
http.Start();
var scope = GoogleScopes[googleScope];
// Creates the OAuth 2.0 authorization request.
var authorizationRequest =
$"{AuthorizationEndpoint}?response_type=code" +
$"&scope=openid%20{scope}" +
$"&redirect_uri={System.Uri.EscapeDataString(redirectUri)}" +
$"&client_id={clientId}" +
$"&state={state}" +
$"&code_challenge={codeChallenge}" +
$"&code_challenge_method={CodeChallengeMethod}";
// Opens request in the browser.
System.Diagnostics.Process.Start(authorizationRequest);
// Waits for the OAuth authorization response.
var context = await http.GetContextAsync();
// Sends an HTTP response to the browser.
var response = context.Response;
var responseString = $"<html><head><meta http-equiv=\'refresh\' content=\'10;url=https://google.com\'></head><body>Please return to the {appName}.</body></html>";
var buffer = System.Text.Encoding.UTF8.GetBytes(responseString);
response.ContentLength64 = buffer.Length;
var responseOutput = response.OutputStream;
await responseOutput.WriteAsync(buffer, 0, buffer.Length).ContinueWith((task) =>
{
responseOutput.Close();
http.Stop();
});
// Checks for errors.
if (context.Request.QueryString.Get("error") != null)
{
throw new GoogleException($"OAuth authorization error: {context.Request.QueryString.Get("error")}.");
}
if (context.Request.QueryString.Get("code") == null ||
context.Request.QueryString.Get("state") == null)
{
throw new GoogleException("Malformed authorization response. " + context.Request.QueryString);
}
// extracts the code
var code = context.Request.QueryString.Get("code");
var incomingState = context.Request.QueryString.Get("state");
// Compares the receieved state to the expected value, to ensure that
// this app made the request which resulted in authorization.
if (incomingState != state)
{
throw new GoogleException($"Received request with invalid state ({incomingState})");
}
// Starts the code exchange at the Token Endpoint.
return(await PerformCodeExchange(clientId, clientSecret, code, codeVerifier, redirectUri));
}
internal async Task Start()
{
string fullPrefix = "/" + prefix + "/";
using (HttpListener listener = new HttpListener())
{
listener.Prefixes.Add("http://localhost:" + port + "/" + prefix + "/");
listener.Start();
int requestId = 0;
while (true)
{
HttpListenerContext context = await listener.GetContextAsync();
HttpListenerRequest request = context.Request;
if (!request.Url.AbsolutePath.StartsWith(fullPrefix))
{
Console.WriteLine("Unexpected request for " + request.Url);
await WriteErrorResponse(context, HttpStatusCode.NotFound, "Unknown url");
continue;
}
requestId++;
string relativePath = request.Url.AbsolutePath.Substring(fullPrefix.Length);
if (relativePath == "quit")
{
using (HttpListenerResponse response = context.Response)
{
response.StatusCode = (int)HttpStatusCode.OK;
response.ContentType = "text/plain";
await WriteResponseBody(response, "Shutting down");
}
break;
}
string[] parts = relativePath.Split('/');
if (parts.Length != 2)
{
Console.WriteLine("Expected target/method relative path; was " + relativePath);
await WriteErrorResponse(context, HttpStatusCode.BadRequest, "Bad path");
continue;
}
object target;
if (!targets.TryGetValue(parts[0], out target))
{
Console.WriteLine("Unknown target for " + request.Url);
await WriteErrorResponse(context, HttpStatusCode.NotFound, "Unknown target");
continue;
}
// TODO: Make this cleaner. Possibly use a linked list?
Task task = HandleRequestAsync(context, target, parts[1], requestId);
outstandingRequests[requestId] = task;
int thisRequestId = requestId;
#pragma warning disable 4014
task.ContinueWith(t => outstandingRequests.TryRemove(thisRequestId, out task));
#pragma warning restore
}
Console.WriteLine("Shutting down... waiting for {0} outstanding requests", outstandingRequests.Count);
await Task.WhenAll(outstandingRequests.Values);
listener.Stop();
}
}
async Task HandleHttpRequestAsync (Action<HttpListenerRequest, HttpListenerResponse> handler)
{
var ctx = await listener.GetContextAsync ();
handler (ctx.Request, ctx.Response);
ctx.Response.Close ();
}
public static async Task <string> GetAuthorizationCodeFromBrower(this MicrosoftAuthenticator authenticator, bool activateMainWindow = false)
{
string url = "https://login.live.com/oauth20_authorize.srf" +
$"?client_id={authenticator.ClientId}" +
"&response_type=code" +
$"&redirect_uri={authenticator.RedirectUri}" +
"&scope=XboxLive.signin%20offline_access" +
"&prompt=select_account";
var httpListener = new HttpListener();
httpListener.Prefixes.Add($"{authenticator.RedirectUri.TrimEnd('/')}/");
httpListener.Start();
using var process = new Process()
{
StartInfo = new ProcessStartInfo
{
UseShellExecute = false,
CreateNoWindow = true,
RedirectStandardInput = true,
FileName = "cmd"
},
};
process.Start();
process.StandardInput.WriteLine($"start \"\" \"{url}\"");
process.StandardInput.WriteLine("exit");
process.WaitForExit();
string code;
var res = await httpListener.GetContextAsync();
using (var stream = res.Response.OutputStream)
{
code = res.Request.Url.ToString().Split('=')[1];
if (code.Contains("error"))
{
stream.Write(Encoding.Default.GetBytes("Login Failed ! Please Back to Launcher to Retry"));
}
else
{
stream.Write(Encoding.Default.GetBytes("Login Successfully ! Please Back to Launcher to Check"));
}
stream.Flush();
await Task.Delay(1000);
}
httpListener.Stop();
httpListener.Close();
if (activateMainWindow)
{
NativeWin32MethodExtend.SetForegroundWindow(Process.GetCurrentProcess().MainWindowHandle);
}
if (code.Contains("error"))
{
return(res.Request.Url.ToString().Replace(authenticator.RedirectUri, ""));
}
return(code);
}
private async Task StartServer()
{
//serv = serv??new HttpListener();
var selectedIP = _ips.ElementAt(comboIPs.SelectedIndex).Item2;
var url = string.Format("http://{0}:{1}", selectedIP, numPort.Value.ToString());
txtURL.Text = url;
serv.Prefixes.Clear();
serv.Prefixes.Add("http://localhost:" + numPort.Value.ToString() + "/");
//serv.Prefixes.Add("http://*:" + numPort.Value.ToString() + "/"); // Uncomment this to Allow Public IP Over Internet. [Commented for Security Reasons.]
serv.Prefixes.Add(url + "/");
serv.Start();
Log("Server Started Successfuly!");
Log("Private Network URL : " + url);
Log("Localhost URL : " + "http://localhost:" + numPort.Value.ToString() + "/");
while (isWorking)
{
var ctx = await serv.GetContextAsync();
//Screenshot();
var resPath = ctx.Request.Url.LocalPath;
if (resPath == "/") // Route The Root Dir to the Index Page
{
resPath += "index.html";
}
var page = Application.StartupPath + "/WebServer" + resPath;
if (OnceTranslation.Checked)
{
page = Application.StartupPath + "/OtherWebserver" + resPath;
}
else if (!OnceTranslation.Checked)
{
page = Application.StartupPath + "/WebServer" + resPath;
}
bool fileExist;
lock (locker)
fileExist = File.Exists(page);
if (!fileExist)
{
var errorPage = Encoding.UTF8.GetBytes("<h1 style=\"color:red\">Error 404 , File Not Found </h1><hr><a href=\".\\\">Back to Home</a>");
ctx.Response.ContentType = "text/html";
ctx.Response.StatusCode = 404;
try
{
await ctx.Response.OutputStream.WriteAsync(errorPage, 0, errorPage.Length);
}
catch (Exception ex)
{
}
ctx.Response.Close();
continue;
}
if (isPrivateTask)
{
if (!ctx.Request.Headers.AllKeys.Contains("Authorization"))
{
ctx.Response.StatusCode = 401;
ctx.Response.AddHeader("WWW-Authenticate", "Basic realm=Screen Task Authentication : ");
ctx.Response.Close();
continue;
}
else
{
var auth1 = ctx.Request.Headers["Authorization"];
auth1 = auth1.Remove(0, 6); // Remove "Basic " From The Header Value
auth1 = Encoding.UTF8.GetString(Convert.FromBase64String(auth1));
var auth2 = string.Format("{0}:{1}", txtUser.Text, txtPassword.Text);
if (auth1 != auth2)
{
// MessageBox.Show(auth1+"\r\n"+auth2);
Log(string.Format("Bad Login from {0} using {1}", ctx.Request.RemoteEndPoint.Address.ToString(), auth1));
var errorPage = Encoding.UTF8.GetBytes("<h1 style=\"color:red\">Not Authorized !!! </h1><hr><a href=\"./\">Back to Home</a>");
ctx.Response.ContentType = "text/html";
ctx.Response.StatusCode = 401;
ctx.Response.AddHeader("WWW-Authenticate", "Basic realm=Screen Task Authentication : ");
try
{
await ctx.Response.OutputStream.WriteAsync(errorPage, 0, errorPage.Length);
}
catch (Exception ex)
{
}
ctx.Response.Close();
continue;
}
}
}
//Everything OK! ??? Then Read The File From HDD as Bytes and Send it to the Client
byte[] filedata;
// Required for One-Time Access of the file {Reader\Writer Problem in OS}
rwl.AcquireReaderLock(Timeout.Infinite);
filedata = File.ReadAllBytes(page);
rwl.ReleaseReaderLock();
var fileinfo = new FileInfo(page);
if (fileinfo.Extension == ".css") // important for IE -> Content-Type must be defiend for CSS files unless will ignored !!!
{
ctx.Response.ContentType = "text/css";
}
else if (fileinfo.Extension == ".html" || fileinfo.Extension == ".htm")
{
ctx.Response.ContentType = "text/html"; // Important For Chrome Otherwise will display the HTML as plain text.
}
ctx.Response.StatusCode = 200;
try
{
await ctx.Response.OutputStream.WriteAsync(filedata, 0, filedata.Length);
}
catch (Exception ex)
{
/*
* Do Nothing !!! this is the Only Effective Solution for this Exception :
* the specified network name is no longer available
*/
}
ctx.Response.Close();
}
}
private static async Task <Dictionary <string, string> > getAccessCodeAsync()
{
// Generates state and PKCE values.
string state = randomDataBase64url(32);
string code_verifier = randomDataBase64url(32);
string code_challenge = base64urlencodeNoPadding(sha256(code_verifier));
const string code_challenge_method = "S256";
// Creates a redirect URI using an available port on the loopback address.
string redirectURI = string.Format("http://{0}:{1}/", IPAddress.Loopback, GetRandomUnusedPort());
// Creates the OAuth 2.0 authorization request.
string authorizationRequest = string.Format("{0}?response_type=code&scope={1}&redirect_uri={2}&client_id={3}&state={4}&code_challenge={5}&code_challenge_method={6}",
AUTH_ENDPOINT,
System.Uri.EscapeDataString(SCOPE),
System.Uri.EscapeDataString(redirectURI),
CLIENT_ID,
state,
code_challenge,
code_challenge_method);
// Opens request in the browser.
System.Diagnostics.Process.Start(authorizationRequest);
// Creates an HttpListener to listen for requests on that redirect URI.
var http = new HttpListener();
http.Prefixes.Add(redirectURI);
http.Start();
// Waits for the OAuth authorization response.
var context = await http.GetContextAsync();
// Sends an HTTP response to the browser.
var response = context.Response;
string responseString = string.Format("<html><head></head><body>Authentication Successful. You may close the browser.</body></html>");
var buffer = System.Text.Encoding.UTF8.GetBytes(responseString);
response.ContentLength64 = buffer.Length;
var responseOutput = response.OutputStream;
Task responseTask = responseOutput.WriteAsync(buffer, 0, buffer.Length).ContinueWith((task) =>
{
responseOutput.Close();
http.Stop();
LOG.Info("HTTP server stopped.");
});
// Checks for errors.
if (context.Request.QueryString.Get("error") != null)
{
throw new System.Exception(context.Request.QueryString.Get("error"));
}
if (context.Request.QueryString.Get("code") == null ||
context.Request.QueryString.Get("state") == null)
{
throw new System.Exception("Malformed authorization response. " + context.Request.QueryString);
}
// extracts the code
var code = context.Request.QueryString.Get("code");
var incoming_state = context.Request.QueryString.Get("state");
// Compares the receieved state to the expected value, to ensure that
// this app made the request which resulted in authorization.
if (incoming_state != state)
{
throw new System.Exception(System.String.Format("Received request with invalid state ({0})", incoming_state));
}
return(PerformCodeExchange(code, code_verifier, redirectURI).Result);
}
public static async Task HandleIncomingConnections()
{
bool runServer = true;
// While a user hasn't visited the `shutdown` url, keep on handling requests
while (runServer)
{
// Will wait here until we hear from a connection
HttpListenerContext ctx = await listener.GetContextAsync();
// Peel out the requests and response objects
HttpListenerRequest req = ctx.Request;
HttpListenerResponse resp = ctx.Response;
// Set default Response values
var responseCode = 200;
var responseMessage = "OK";
// Print out some info about the request
Console.WriteLine(req.Url.ToString());
Console.WriteLine(req.HttpMethod);
Console.WriteLine(req.UserHostName);
Console.WriteLine(req.UserAgent);
// If `shutdown` url requested w/ POST, then shutdown the server after serving the page
if ((req.HttpMethod == "POST") && (req.Url.AbsolutePath == "/shutdown"))
{
Console.WriteLine("Shutdown requested");
runServer = false;
}
var guid = req.Url.AbsolutePath.Replace("/hangman/", "");
if (req.HttpMethod == "POST" && Guid.TryParse(guid, out var gameId))
{
Console.WriteLine("Hangman initialized");
var bodyStream = new StreamReader(req.InputStream);
var bodyText = bodyStream.ReadToEnd();
//send StartGame Command
Console.WriteLine(bodyText);
dynamic body = JsonConvert.DeserializeObject(bodyText);
Console.WriteLine(body.command);
const int DEFAULTPORT = 1113;
var settings = ConnectionSettings.Create();
var conn = EventStoreConnection.Create(settings, new IPEndPoint(IPAddress.Loopback, DEFAULTPORT));
conn.ConnectAsync().Wait();
var cmdHandler = new HangmanCommandHandler(new EventStoreRepository(conn, "HangmanBackend.Domain.Game"));
try
{
switch (body.command.ToString())
{
case "StartGame":
cmdHandler.handleStartGame(new StartGame(gameId, new Guid(), "word",
DifficultySetting.EASY));
break;
case "GuessLetter":
cmdHandler.handleGuessLetter(new GuessLetter(gameId, (char)body.letter),
(int)body.version);
break;
case "GuessWord":
cmdHandler.handleGuessWord(new GuessWord(gameId, body.word.ToString()),
(int)body.version);
break;
default:
Console.WriteLine("Command not found");
break;
}
}
catch (System.AggregateException ex)
{
responseCode = 400;
responseMessage = $"Game already exists! Cannot start same game twice: {ex.Message}";
Console.WriteLine(responseMessage);
}
catch (DomainException ex)
{
responseCode = 400;
responseMessage = $"Domain Error: {ex.Message}";
Console.WriteLine(responseMessage);
}
}
// Write the response info
string disableSubmit = !runServer ? "disabled" : "";
byte[] data = Encoding.UTF8.GetBytes(String.Format(pageData, responseMessage, disableSubmit));
resp.ContentType = "text/html";
resp.ContentEncoding = Encoding.UTF8;
resp.ContentLength64 = data.LongLength;
resp.StatusCode = responseCode;
// Write out to the response stream (asynchronously), then close it
await resp.OutputStream.WriteAsync(data, 0, data.Length);
resp.Close();
}
}
public async void StartRedditAuthentication()
{
//Randomize state and change url to port you want.
ConfigureStateAndRedirectUri();
OpenBrowserForRedditAuth(headers);
var result = await StartListeningForResponse();
var uriData = result.GetHeadersFromUriData();
if (uriData == null)
{
return;
}
if (uriData.Contains("error"))
{
Debug.LogError(uriData["error"]);
}
AccessToken = uriData["access_token"];
if (this.GetComponent <RedditManager>() != null)
{
GetComponent <RedditManager>().InitReddit();
}
async Task <string> StartListeningForResponse()
{
HttpListener listener = new HttpListener();
listener.Prefixes.Add($"http://localhost:{listeningPort}/");
listener.Start();
//Hard code file
string responseString = Resources.Load <TextAsset>("magic_redirect_fragment_to_data").text;
byte[] htmlWeb = Encoding.UTF8.GetBytes(responseString);
string text;
while (true)
{
var context = await listener.GetContextAsync().ConfigureAwait(false);
try {
HttpListenerRequest request = context.Request;
HttpListenerResponse response = context.Response;
response.ContentLength64 = htmlWeb.Length;
Stream output = response.OutputStream;
output.Write(htmlWeb, 0, htmlWeb.Length);
output.Close();
// URl with /# symbol (fragment part of URI that not send to http) will be redirect using html code just to get fragments part.
// http://localhost:21345/?%2F=#access_token=214252035530-umX7LjfFWPvK7g82F0FaxrgE69k&token_type=bearer&state=6cc0633b-dda7-4f06-9408-0ae5a129fb04&expires_in=3600&scope=edit+history+identity+modposts+mysubreddits+read+save+submit
if (request.RawUrl.Contains("access_token"))
{
//Debug.Log(request.RawUrl);
// Meaning we have a full url : http://localhost:21345/?access_token=token & stuff
//RawURL look like: /access_token=214252035530-GKCNDtDglx8_3vYakCPcLYed0Pw&token_type=bearer&state=2a7e89b8-2aad-488a-b59b-97702a94f859&expires_in=3600&scope=edit+history+identity+modposts+mysubreddits+read+save+submit
text = request.RawUrl.Replace("/", ""); // Remove 1st character
break;
}
}
catch (Exception ex) { Debug.LogError(ex); }
}
listener.Stop();
listener.Close();
return(text);
}
}
async Task HTTPList()
{
while (true)
{
var context = await http.GetContextAsync();
switch (context.Request.RawUrl)
{
case "/device":
if (context.Request.HttpMethod == "GET")
{
context.Response.StatusCode = 200;
context.Response.ContentType = "application/json";
context.Response.AddHeader("Charset", "UTF-8");
StreamWriter write = new StreamWriter(context.Response.OutputStream);
await write.WriteAsync(JsonConvert.SerializeObject(Device.devices.Values.ToArray()));
write.Close();
context.Response.Close();
}
else if (context.Request.HttpMethod == "POST")
{
try
{
StreamReader reader = new StreamReader(context.Request.InputStream);
var device = JsonConvert.DeserializeObject <IdStatusDevice>(await reader.ReadToEndAsync());
reader.Close();
if (string.IsNullOrWhiteSpace(device.id) || device.status == null || device.status.Length == 0)
{
context.Response.StatusCode = 400;
context.Response.Close();
break;
}
if (!Device.devices.TryGetValue(device.id, out var currentDevice))
{
context.Response.StatusCode = 400;
context.Response.Close();
break;
}
currentDevice[0] = bool.Parse(device.status[0].ToString());
if (currentDevice.statusData.Length > 1 && device.status.Length > 1)
{
currentDevice[1] = device.status[1];
}
context.Response.StatusCode = 200;
context.Response.Close();
}
catch (InvalidCastException)
{
context.Response.StatusCode = 400;
context.Response.Close();
break;
}
catch (FormatException)
{
context.Response.StatusCode = 400;
context.Response.Close();
break;
}
}
break;
}
}
}
private static async Task DispatchHttpRequestsAsync(HttpListener httpListener, CancellationToken cancellationToken, int maxThreadCount = Int32.MaxValue)
{
// Create a request handler factory that uses basic authentication
var requestHandlerFactory = new WebDavMailRu.CloudStore.Mailru.RequestHandlerFactory();
// Create WebDAV dispatcher
var homeFolder = new MailruStore();
var webDavDispatcher = new WebDavDispatcher(homeFolder, requestHandlerFactory);
try
{
using (var sem = new SemaphoreSlim(maxThreadCount))
{
var semclo = sem;
while (!cancellationToken.IsCancellationRequested)
{
var httpListenerContext = await httpListener.GetContextAsync().ConfigureAwait(false);
if (httpListenerContext == null)
{
break;
}
//if (httpListenerContext.Request.IsAuthenticated)
// httpContext = new HttpBasicContext(httpListenerContext, i => i.Name == webdavUsername && i.Password == webdavPassword);
//else httpContext = new HttpContext(httpListenerContext);
HttpListenerBasicIdentity identity = (HttpListenerBasicIdentity)httpListenerContext.User.Identity;
IHttpContext httpContext = new HttpBasicContext(httpListenerContext, i => i.Name == identity.Name && i.Password == identity.Password);
await semclo.WaitAsync(cancellationToken);
// ReSharper disable once UnusedVariable
Task tsk = Task
.Run(async() =>
{
try
{
await webDavDispatcher.DispatchRequestAsync(httpContext);
}
catch (Exception ex)
{
Logger.Error("Exception", ex);
}
}, cancellationToken)
.ContinueWith(t => semclo.Release(), cancellationToken);
}
}
}
catch (HttpListenerException excListener)
{
if (excListener.ErrorCode != ERROR_OPERATION_ABORTED)
{
throw;
}
}
catch (Exception e)
{
Logger.Error("Global exception", e);
}
}
/// <summary>
/// Await connections.
/// </summary>
private async void StartConnectionListener(HttpListener listener)
{
ResponsePacket resp = null;
// Wait for a connection. Return to caller while we wait.
HttpListenerContext context = await listener.GetContextAsync();
Session session = sessionManager.GetSession(context.Request.RemoteEndPoint);
OnRequest.IfNotNull(r => r(session, context));
// Release the semaphore so that another listener can be immediately started up.
sem.Release();
Log(context.Request);
HttpListenerRequest request = context.Request;
try
{
string path = request.RawUrl.LeftOf("?"); // Only the path, not any of the parameters
string verb = request.HttpMethod; // get, post, delete, etc.
string parms = request.RawUrl.RightOf("?"); // Params on the URL itself follow the URL and are separated by a ?
Dictionary <string, object> kvParams = GetKeyValues(parms); // Extract into key-value entries.
string data = new StreamReader(context.Request.InputStream, context.Request.ContentEncoding).ReadToEnd();
// GetKeyValues(data, kvParams);
kvParams["Data"] = data;
Log(kvParams);
if (!VerifyCsrf(session, verb, kvParams))
{
Console.WriteLine("CSRF did not match. Terminating connection.");
context.Response.OutputStream.Close();
}
else
{
resp = router.Route(session, verb, path, kvParams);
// Update session last connection after getting the response, as the router itself validates session expiration only on pages requiring authentication.
session.UpdateLastConnectionTime();
if (resp.Error != ServerError.OK)
{
resp.Redirect = OnError(resp.Error);
}
// TODO: Nested exception: is this best?
try
{
Respond(request, context.Response, resp);
}
catch (Exception reallyBadException)
{
// The response failed!
// TODO: We need to put in some decent logging!
Console.WriteLine(reallyBadException.Message);
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Console.WriteLine(ex.StackTrace);
resp = new ResponsePacket()
{
Redirect = OnError(ServerError.ServerError)
};
}
}
private async Task ServerTask()
{
while (_httpListener != null && _httpListener.IsListening)
{
_lastRequestTime = DateTime.Now;
var server = await _httpListener.GetContextAsync();
var path = server.Request.Url.LocalPath;
if (_debugMode)
{
Log(path);
}
var key = path.Replace(_challengePrefix, "").ToLower();
if (key == _controlKey.ToLower())
{
server.Response.StatusCode = (int)HttpStatusCode.OK;
server.Response.ContentType = "text/plain";
using (var stream = new StreamWriter(server.Response.OutputStream))
{
stream.Write("Stopping");
stream.Flush();
stream.Close();
}
server.Response.Close();
Stop();
return;
}
if (key == _checkKey.ToLower())
{
if (_debugMode)
{
Log("Check key sent. OK.");
}
server.Response.StatusCode = (int)HttpStatusCode.OK;
server.Response.ContentType = "text/plain";
using (var stream = new StreamWriter(server.Response.OutputStream))
{
stream.Write("OK");
stream.Flush();
stream.Close();
}
}
else
{
if (key.Length > 8 && !_challengeResponses.ContainsKey(key))
{
// if challenge response not in our cache, fetch from local API
try
{
_maxServiceLookups--;
var apiUrl = $"{_baseUri}managedcertificates/currentchallenges/";
if (_debugMode)
{
Log($"Key {key} not found: Refreshing challenges.. {apiUrl}");
}
var response = await _apiClient.GetAsync(apiUrl);
if (response.IsSuccessStatusCode)
{
var json = await response.Content.ReadAsStringAsync();
if (_debugMode)
{
Log(json);
}
var list = Newtonsoft.Json.JsonConvert.DeserializeObject <List <SimpleAuthorizationChallengeItem> >(json);
_challengeResponses = new Dictionary <string, string>();
list.ForEach(i => _challengeResponses.Add(i.Key.ToLower(), i.Value));
}
else
{
Log("Failed to refresh current challenges");
}
}
catch (Exception exp)
{
Log(exp.ToString());
}
}
if (_challengeResponses.ContainsKey(key))
{
var value = _challengeResponses[key];
if (value != null)
{
// System.Console.Out.WriteLine(value);
server.Response.StatusCode = (int)HttpStatusCode.OK;
server.Response.ContentType = "text/plain";
using (var stream = new StreamWriter(server.Response.OutputStream))
{
stream.Write(value);
stream.Flush();
stream.Close();
}
Log($"Responded with Key: {key} Value:{value}");
}
else
{
server.Response.StatusCode = (int)HttpStatusCode.NotFound;
Log($"Requested key not found: {key}");
}
}
else
{
server.Response.StatusCode = 404;
}
}
server.Response.Close();
if (_debugMode)
{
Log("End request.");
}
if (_maxServiceLookups == 0)
{
// give up trying to resolve challenges, we have been queried too many times for
// challenge responses we don't know about
Stop();
if (_debugMode)
{
Log("Max lookups failed.");
}
}
}
}
internal static async Task <Result> GetToken(
string clientId,
string clientSecret,
string state,
string redirectUri,
string htmlResponseToShowInBrowser)
{
// Creates an HttpListener to listen for requests on that redirect URI.
var http = new HttpListener();
http.Prefixes.Add(redirectUri);
Debug("Listening on " + redirectUri);
http.Start();
// Creates the OAuth 2.0 authorization request.
RequestIdentity.Request(clientId, state, redirectUri);
// Waits for the OAuth authorization response.
var context = await http.GetContextAsync();
// Brings the Console to Focus.
ConsoleHack.BringConsoleToFront();
// Sends an HTTP response to the browser.
var response = context.Response;
var buffer = System.Text.Encoding.UTF8.GetBytes(htmlResponseToShowInBrowser);
response.ContentLength64 = buffer.Length;
var responseOutput = response.OutputStream;
Task responseTask = responseOutput.WriteAsync(
buffer, 0, buffer.Length).ContinueWith((task) =>
{
responseOutput.Close();
http.Stop();
Debug("HTTP server stopped.");
});
// Checks for errors.
if (context.Request.QueryString.Get("error") != null)
{
return(new Result()
{
Token = null,
Error = string.Format("OAuth authorization error: {0}.",
context.Request.QueryString.Get("error"))
});
}
if (context.Request.QueryString.Get("code") == null ||
context.Request.QueryString.Get("state") == null)
{
return(new Result()
{
Token = null,
Error = "Malformed authorization response. " + context.Request.QueryString
});
}
// extracts the code
var code = context.Request.QueryString.Get("code");
var incoming_state = context.Request.QueryString.Get("state");
// Compares the receieved state to the expected value, to ensure that
// this app made the request which resulted in authorization.
if (incoming_state != state)
{
return(new Result()
{
Token = null,
Error = string.Format(
"Received request with invalid state ({0})", incoming_state)
});
}
Debug("Authorization code: " + code);
return(new Result()
{
Token = await RequestToken.Get(clientId, clientSecret, code, redirectUri, state),
Error = null
});
}
private async Task AcceptConnections(CancellationToken token)
{
try
{
#region Process-Requests
while (_HttpListener.IsListening)
{
if (_RequestCount >= _Settings.IO.MaxRequests)
{
await Task.Delay(100, token).ConfigureAwait(false);
continue;
}
HttpListenerContext listenerCtx = await _HttpListener.GetContextAsync().ConfigureAwait(false);
Interlocked.Increment(ref _RequestCount);
HttpContext ctx = null;
Task unawaited = Task.Run(async() =>
{
DateTime startTime = DateTime.Now;
try
{
#region Build-Context
Events.HandleConnectionReceived(this, new ConnectionEventArgs(
listenerCtx.Request.RemoteEndPoint.Address.ToString(),
listenerCtx.Request.RemoteEndPoint.Port));
ctx = new HttpContext(listenerCtx, _Settings, Events);
Events.HandleRequestReceived(this, new RequestEventArgs(ctx));
if (_Settings.Debug.Requests)
{
Events.Logger?.Invoke(
_Header + ctx.Request.Source.IpAddress + ":" + ctx.Request.Source.Port + " " +
ctx.Request.Method.ToString() + " " + ctx.Request.Url.RawWithoutQuery);
}
Statistics.IncrementRequestCounter(ctx.Request.Method);
Statistics.IncrementReceivedPayloadBytes(ctx.Request.ContentLength);
#endregion
#region Check-Access-Control
if (!_Settings.AccessControl.Permit(ctx.Request.Source.IpAddress))
{
Events.HandleRequestDenied(this, new RequestEventArgs(ctx));
if (_Settings.Debug.AccessControl)
{
Events.Logger?.Invoke(_Header + ctx.Request.Source.IpAddress + ":" + ctx.Request.Source.Port + " denied due to access control");
}
listenerCtx.Response.StatusCode = 403;
listenerCtx.Response.Close();
return;
}
#endregion
#region Process-Preflight-Requests
if (ctx.Request.Method == HttpMethod.OPTIONS)
{
if (_Routes.Preflight != null)
{
if (_Settings.Debug.Routing)
{
Events.Logger?.Invoke(
_Header + "preflight route for " + ctx.Request.Source.IpAddress + ":" + ctx.Request.Source.Port + " " +
ctx.Request.Method.ToString() + " " + ctx.Request.Url.RawWithoutQuery);
}
await _Routes.Preflight(ctx).ConfigureAwait(false);
return;
}
}
#endregion
#region Pre-Routing-Handler
bool terminate = false;
if (_Routes.PreRouting != null)
{
terminate = await _Routes.PreRouting(ctx).ConfigureAwait(false);
if (terminate)
{
if (_Settings.Debug.Routing)
{
Events.Logger?.Invoke(
_Header + "prerouting terminated connection for " + ctx.Request.Source.IpAddress + ":" + ctx.Request.Source.Port + " " +
ctx.Request.Method.ToString() + " " + ctx.Request.Url.RawWithoutQuery);
}
return;
}
}
#endregion
#region Content-Routes
if (ctx.Request.Method == HttpMethod.GET || ctx.Request.Method == HttpMethod.HEAD)
{
ContentRoute cr = null;
if (_Routes.Content.Match(ctx.Request.Url.RawWithoutQuery, out cr))
{
if (_Settings.Debug.Routing)
{
Events.Logger?.Invoke(
_Header + "content route for " + ctx.Request.Source.IpAddress + ":" + ctx.Request.Source.Port + " " +
ctx.Request.Method.ToString() + " " + ctx.Request.Url.RawWithoutQuery);
}
ctx.RouteType = RouteTypeEnum.Content;
ctx.Route = cr;
await _Routes.ContentHandler.Process(ctx, token).ConfigureAwait(false);
return;
}
}
#endregion
#region Static-Routes
StaticRoute sr = null;
Func <HttpContext, Task> handler = _Routes.Static.Match(ctx.Request.Method, ctx.Request.Url.RawWithoutQuery, out sr);
if (handler != null)
{
if (_Settings.Debug.Routing)
{
Events.Logger?.Invoke(
_Header + "static route for " + ctx.Request.Source.IpAddress + ":" + ctx.Request.Source.Port + " " +
ctx.Request.Method.ToString() + " " + ctx.Request.Url.RawWithoutQuery);
}
ctx.RouteType = RouteTypeEnum.Static;
ctx.Route = sr;
await handler(ctx).ConfigureAwait(false);
return;
}
#endregion
#region Parameter-Routes
ParameterRoute pr = null;
Dictionary <string, string> parameters = null;
handler = _Routes.Parameter.Match(ctx.Request.Method, ctx.Request.Url.RawWithoutQuery, out parameters, out pr);
if (handler != null)
{
ctx.Request.Url.Parameters = new Dictionary <string, string>(parameters);
if (_Settings.Debug.Routing)
{
Events.Logger?.Invoke(
_Header + "parameter route for " + ctx.Request.Source.IpAddress + ":" + ctx.Request.Source.Port + " " +
ctx.Request.Method.ToString() + " " + ctx.Request.Url.RawWithoutQuery);
}
ctx.RouteType = RouteTypeEnum.Parameter;
ctx.Route = pr;
await handler(ctx).ConfigureAwait(false);
return;
}
#endregion
#region Dynamic-Routes
DynamicRoute dr = null;
handler = _Routes.Dynamic.Match(ctx.Request.Method, ctx.Request.Url.RawWithoutQuery, out dr);
if (handler != null)
{
if (_Settings.Debug.Routing)
{
Events.Logger?.Invoke(
_Header + "dynamic route for " + ctx.Request.Source.IpAddress + ":" + ctx.Request.Source.Port + " " +
ctx.Request.Method.ToString() + " " + ctx.Request.Url.RawWithoutQuery);
}
ctx.RouteType = RouteTypeEnum.Dynamic;
ctx.Route = dr;
await handler(ctx).ConfigureAwait(false);
return;
}
#endregion
#region Default-Route
if (_Routes.Default != null)
{
if (_Settings.Debug.Routing)
{
Events.Logger?.Invoke(
_Header + "default route for " + ctx.Request.Source.IpAddress + ":" + ctx.Request.Source.Port + " " +
ctx.Request.Method.ToString() + " " + ctx.Request.Url.RawWithoutQuery);
}
ctx.RouteType = RouteTypeEnum.Default;
await _Routes.Default(ctx).ConfigureAwait(false);
return;
}
else
{
if (_Settings.Debug.Routing)
{
Events.Logger?.Invoke(
_Header + "default route not found for " + ctx.Request.Source.IpAddress + ":" + ctx.Request.Source.Port + " " +
ctx.Request.Method.ToString() + " " + ctx.Request.Url.RawWithoutQuery);
}
ctx.Response.StatusCode = 404;
ctx.Response.ContentType = Pages.Default404Page.ContentType;
await ctx.Response.Send(Pages.Default404Page.Content).ConfigureAwait(false);
return;
}
#endregion
}
catch (Exception eInner)
{
ctx.Response.StatusCode = 500;
ctx.Response.ContentType = Pages.Default500Page.ContentType;
await ctx.Response.Send(Pages.Default500Page.Content).ConfigureAwait(false);
Events.HandleExceptionEncountered(this, new ExceptionEventArgs(ctx, eInner));
}
finally
{
Interlocked.Decrement(ref _RequestCount);
if (ctx != null && ctx.Response != null && ctx.Response.ResponseSent)
{
Events.HandleResponseSent(this, new ResponseEventArgs(ctx, TotalMsFrom(startTime)));
Statistics.IncrementSentPayloadBytes(ctx.Response.ContentLength);
}
}
}, token);
}
#endregion
}
catch (TaskCanceledException)
{
}
catch (OperationCanceledException)
{
}
catch (HttpListenerException)
{
}
catch (Exception e)
{
Events.HandleExceptionEncountered(this, new ExceptionEventArgs(null, e));
}
finally
{
Events.HandleServerStopped(this, EventArgs.Empty);
}
}
internal static async void Start()
{
string Prefix = "http://localhost:8080/";
string AuthenticationType = "none";
if (!HttpListener.IsSupported)
{
throw new NotSupportedException(
"Server is not supported.");
}
if (httplistener.IsListening)
{
return;
}
try
{
if (Helpers.Xml.AppConfigQuery(ApplicationSettings.ApplicationStructure.HttpAuthenticationPath).Count > 0)
{
Prefix = "http://" + Helpers.Xml.AppConfigQuery(
ApplicationSettings.ApplicationStructure.HttpHostNamePath)
.Item(0).InnerText + ":" +
Helpers.Xml.AppConfigQuery(
ApplicationSettings.ApplicationStructure.HttpPortPath)
.Item(0).InnerText + "/";
}
if (Helpers.Xml.AppConfigQuery(ApplicationSettings.ApplicationStructure.HttpAuthenticationPath).Count > 0)
{
AuthenticationType = Helpers.Xml.AppConfigQuery(
ApplicationSettings.ApplicationStructure.HttpAuthenticationPath)
.Item(0).InnerText;
}
}
catch (NullReferenceException e)
{
Logger.Instance.Append("obj [ Server.Web.Start <Exception> ]: NullReferenceException [ " + e.Message + " ]");
return;
}
httplistener.Prefixes.Clear();
httplistener.Prefixes.Add(Prefix);
httplistener.AuthenticationSchemes = AuthenticationType.ToLower() == "basic" ?
httplistener.AuthenticationSchemes = AuthenticationSchemes.Basic :
httplistener.AuthenticationSchemes = AuthenticationSchemes.Anonymous;
httplistener.IgnoreWriteExceptions = true;
httplistener.Start();
while (httplistener.IsListening)
{
try
{
var ctx = await httplistener.GetContextAsync();
Task.Run(() => ProcessRequestAsync(ctx));
}
catch (HttpListenerException e)
{
Logger.Instance.Append("obj [ Server.Web.Start <Exception> ]: HttpListenerException [ " + e.Message + " ]");
//Restart();
}
catch (InvalidOperationException)
{
//FileSystem.Log.Append("obj [ Server.Web.Start <Exception> ]: InvalidOperationException [ " + e.Message + " ]");
//Restart();
}
catch (Exception e)
{
Logger.Instance.Append("obj [ Server.Web.Start <Exception> ]: Generic [ " + e.Message + " ]");
//Restart();
}
}
}
public async Task <IHttpListenerContext> GetContextAsync()
{
return(new HttpListenerContextWrapper(await inner.GetContextAsync()));
}
/// <summary>
/// Loguje użytkownika przez konto Google (OAuth 2)
/// </summary>
private async Task AuthenticateWithGoogle()
{
// Generates state and PKCE values.
string state = RandomDataBase64url(32);
string code_verifier = RandomDataBase64url(32);
string code_challenge = Base64urlencodeNoPadding(Sha256(code_verifier));
const string code_challenge_method = "S256";
// Creates a redirect URI using an available port on the loopback address.
string redirectURI = "http://localhost:8080/";
// Creates an HttpListener to listen for requests on that redirect URI.
using (HttpListener http = new HttpListener())
{
http.Prefixes.Add(redirectURI);
http.Start();
// Creates the OAuth 2.0 authorization request.
string authorizationRequest = string.Format(CultureInfo.InvariantCulture, "{0}?response_type=code&scope=profile%20profile&redirect_uri={1}&client_id={2}&state={3}&code_challenge={4}&code_challenge_method={5}&access_type=offline&approval_prompt=force",
authorizationEndpoint,
System.Uri.EscapeDataString(redirectURI),
clientID,
state,
code_challenge,
code_challenge_method);
// Opens request in the browser.
Process.Start(new ProcessStartInfo(authorizationRequest)
{
UseShellExecute = true
});
// Waits for the OAuth authorization response.
HttpListenerContext context = await http.GetContextAsync().ConfigureAwait(false);
// Sends an HTTP response to the browser.
HttpListenerResponse response = context.Response;
string responseString = string.Format(CultureInfo.InvariantCulture, "<html><head><meta http-equiv='refresh' content='10;url=https://google.com'></head><body>Please return to the app.</body></html>");
byte[] buffer = Encoding.UTF8.GetBytes(responseString);
response.ContentLength64 = buffer.Length;
Stream responseOutput = response.OutputStream;
Task responseTask = responseOutput.WriteAsync(buffer, 0, buffer.Length).ContinueWith((task) =>
{
responseOutput.Close();
http.Stop();
});
// Checks for errors.
if (context.Request.QueryString.Get("error") != null)
{
return;
}
if (context.Request.QueryString.Get("code") == null ||
context.Request.QueryString.Get("state") == null)
{
return;
}
// extracts the code
string code = context.Request.QueryString.Get("code");
string incoming_state = context.Request.QueryString.Get("state");
// Compares the receieved state to the expected value, to ensure that
// this app made the request which resulted in authorization.
if (incoming_state != state)
{
return;
}
// Starts the code exchange at the Token Endpoint.
await PerformCodeExchange(code, code_verifier, redirectURI).ConfigureAwait(false);
return;
}
}
private async Task StartServer()
{
var selectedIP = _ips.ElementAt(cIPs.SelectedIndex).Item2;
var url = string.Format("http://{0}:{1}", selectedIP, numPort.Value.ToString());
txtURL.Text = url;
serv.Prefixes.Clear();
serv.Prefixes.Add("http://localhost:" + numPort.Value.ToString() + "/");
serv.Prefixes.Add(url + "/");
serv.Start();
Log("Server Started Successfuly!");
Log("Private Network URL : " + url);
Log("Localhost URL : " + "http://localhost:" + numPort.Value.ToString() + "/");
while (isWorking)
{
var ctx = await serv.GetContextAsync();
// 统计用户数量
if ((DateTime.Now.Second + 11) % 20 == 0)
{
usersum.Clear();
}
if (ctx.Request.RemoteEndPoint != null)
{
string ipAddress = ctx.Request.RemoteEndPoint.Address.ToString();
if (!usersum.Contains(ipAddress))
{
usersum.Add(ipAddress);
}
}
sumlog.Text = "当前在线用户数：" + usersum.Count() + "\r\n";
sumlog.Text += "IP分别为：" + "\r\n";
for (int i = 0; i < usersum.Count(); i++)
{
sumlog.Text += usersum[i] + "\r\n";
}
/* // 检测dsm安全性
* if (!DSMSecurity.isSecurity())
* {
* Log("检测到有加密文档打开，停止服务!");
* btnStartServer.Tag = "start";
* btnStartServer.Text = "Start Server";
* isWorking = false;
* isTakingScreenshots = false;
*
* }*/
//Screenshot();
var resPath = ctx.Request.Url.LocalPath;
if (resPath == "/")
{
resPath += "index.html";
}
var page = Application.StartupPath + "/WebServer" + resPath;
bool fileExist;
lock (locker)
fileExist = File.Exists(page);
if (!fileExist)
{
var errorPage = Encoding.UTF8.GetBytes("<h1 style=\"color:red\">Error 404 , File Not Found </h1><hr><a href=\".\\\">Back to Home</a>");
ctx.Response.ContentType = "text/html";
ctx.Response.StatusCode = 404;
try
{
await ctx.Response.OutputStream.WriteAsync(errorPage, 0, errorPage.Length);
}
catch (Exception ex)
{
}
ctx.Response.Close();
continue;
}
if (isPrivateTask)
{
if (!ctx.Request.Headers.AllKeys.Contains("Authorization"))
{
ctx.Response.StatusCode = 401;
ctx.Response.AddHeader("WWW-Authenticate", "Basic realm=Screen Task Authentication : ");
ctx.Response.Close();
continue;
}
else
{
var auth1 = ctx.Request.Headers["Authorization"];
auth1 = auth1.Remove(0, 6); // Remove "Basic " From The Header Value
auth1 = Encoding.UTF8.GetString(Convert.FromBase64String(auth1));
var auth2 = string.Format("{0}:{1}", txtUser.Text, txtPassword.Text);
if (auth1 != auth2)
{
// MessageBox.Show(auth1+"\r\n"+auth2);
Log(string.Format("Bad Login from {0} using {1}", ctx.Request.RemoteEndPoint.Address.ToString(), auth1));
var errorPage = Encoding.UTF8.GetBytes("<h1 style=\"color:red\">Not Authorized !!! </h1><hr><a href=\"./\">Back to Home</a>");
ctx.Response.ContentType = "text/html";
ctx.Response.StatusCode = 401;
ctx.Response.AddHeader("WWW-Authenticate", "Basic realm=Screen Task Authentication : ");
try
{
await ctx.Response.OutputStream.WriteAsync(errorPage, 0, errorPage.Length);
}
catch (Exception ex)
{
}
ctx.Response.Close();
continue;
}
}
}
byte[] filedata;
rwl.AcquireReaderLock(Timeout.Infinite);
filedata = File.ReadAllBytes(page);
rwl.ReleaseReaderLock();
var fileinfo = new FileInfo(page);
if (fileinfo.Extension == ".css") // important for IE -> Content-Type must be defiend for CSS files unless will ignored !!!
{
ctx.Response.ContentType = "text/css";
}
else if (fileinfo.Extension == ".html" || fileinfo.Extension == ".htm")
{
ctx.Response.ContentType = "text/html"; // Important For Chrome Otherwise will display the HTML as plain text.
}
ctx.Response.StatusCode = 200;
try
{
await ctx.Response.OutputStream.WriteAsync(filedata, 0, filedata.Length);
}
catch (Exception ex)
{
}
ctx.Response.Close();
}
}
protected override Task StartServer(CancellationToken cancel)
{
// This will ensure that any failures to start are nicely thrown from StartServerAsync.
_httpListener.Start();
// Kick off the actual processing to a new thread and return a Task for the processing thread.
return(Task.Factory.StartNew(delegate
{
try
{
while (!cancel.IsCancellationRequested)
{
// There is no way to give a CancellationToken to GCA() so, we need to hack around it a bit.
var getContext = _httpListener.GetContextAsync();
getContext.Wait(cancel);
var context = getContext.Result;
// Kick the request off to a background thread for processing.
_ = Task.Factory.StartNew(async delegate
{
var request = context.Request;
var response = context.Response;
try
{
try
{
// We first touch the response.OutputStream only in the callback because touching
// it means we can no longer send headers (the status code).
var serializer = new TextSerializer(delegate
{
response.ContentType = PrometheusConstants.ExporterContentType;
response.StatusCode = 200;
return response.OutputStream;
});
await _registry.CollectAndSerializeAsync(serializer, cancel);
response.OutputStream.Dispose();
}
catch (ScrapeFailedException ex)
{
// This can only happen before anything is written to the stream, so it
// should still be safe to update the status code and report an error.
response.StatusCode = 503;
if (!string.IsNullOrWhiteSpace(ex.Message))
{
using (var writer = new StreamWriter(response.OutputStream))
writer.Write(ex.Message);
}
}
}
catch (Exception ex) when(!(ex is OperationCanceledException))
{
if (!_httpListener.IsListening)
{
return; // We were shut down.
}
Trace.WriteLine(string.Format("Error in MetricsServer: {0}", ex));
try
{
response.StatusCode = 500;
}
catch
{
// Might be too late in request processing to set response code, so just ignore.
}
}
finally
{
response.Close();
}
}, TaskCreationOptions.LongRunning);
}
}
finally
{
_httpListener.Stop();
// This should prevent any currently processed requests from finishing.
_httpListener.Close();
}
}, TaskCreationOptions.LongRunning));
}
private async void runServerSession()
{
while (server.IsListening)
{
try
{
Task <HttpListenerContext> getContext = server.GetContextAsync();
getContext.Wait();
pingedStudio = true;
HttpListenerContext context = getContext.Result;
HttpListenerRequest request = context.Request;
HttpListenerResponse response = context.Response;
string query = request.Headers.Get("Query");
Console.WriteLine("Received Query {0}", query);
if (query != null)
{
if (query == "GetStringList")
{
Console.Beep();
while (!stringListReady)
{
await Task.Delay(100);
}
string file = string.Join("\n", stringList);
Stream outStream = response.OutputStream;
byte[] buffer = Encoding.ASCII.GetBytes(file);
outStream.Write(buffer, 0, buffer.Length);
windowState = 5;
}
else if (query == "PingProgress")
{
windowState = 0;
string s_processed = request.Headers.Get("Count");
if (s_processed != null)
{
int.TryParse(s_processed, out processed);
}
}
else if (query == "SendFVariables")
{
string fvarChunk = request.Headers.Get("FVariables");
if (fvarChunk != null)
{
foreach (string fvar in fvarChunk.Split(';'))
{
fvars.Add(fvar);
}
}
}
else if (query == "Finished")
{
finished = true;
editor.receiveFVariableScan(fvars);
}
}
response.Close();
}
catch {}
}
}
public Task StartAsync(string hostName, int listenPort)
{
if (Status == HttpAsyncHostStatus.Uninitialised)
{
throw new InvalidOperationException("Host is in an invalid state. Initialization may have failed.");
}
if (_listener != null)
{
throw new InvalidOperationException("Host has already been started.");
}
SetStatus(HttpAsyncHostStatus.Starting);
// Establish a host-handler context:
//_hostContext = new HostContext(this, _handler);
_listener = new HttpListener
{
IgnoreWriteExceptions = true
};
_listener.Prefixes.Add(string.Format("http://{0}:{1}/", hostName, listenPort));
return(Task.Run(() =>
{
// Configure the handler:
//if (_configValues != null)
//{
// var config = _handler as IConfigurationTrait;
// if (config != null)
// {
// var task = config.Configure(_hostContext, _configValues);
// if (task != null)
// if (!await task) return;
// }
//}
// Initialize the handler:
//var init = _handler as IInitializationTrait;
//if (init != null)
//{
// var task = init.Initialize(_hostContext);
// if (task != null)
// if (!await task) return;
//}
try
{
_stop = false;
// Start the HTTP listener:
_listener.Start();
}
catch (HttpListenerException ex)
{
Console.Error.WriteLine(ex.Message);
return;
}
// Accept connections:
// Higher values mean more connections can be maintained yet at a much slower average response time; fewer connections will be rejected.
// Lower values mean less connections can be maintained yet at a much faster average response time; more connections will be rejected.
var semaphore = new Semaphore(_accepts, _accepts);
SetStatus(HttpAsyncHostStatus.Running);
while (!_stop)
{
semaphore.WaitOne();
#pragma warning disable 4014
_listener?.GetContextAsync().ContinueWith(async(t) =>
{
string errMessage;
try
{
semaphore.Release();
var context = await t;
await ProcessListenerContext(context, this);
return;
}
catch (Exception ex)
{
errMessage = ex.ToString();
}
await Console.Error.WriteLineAsync(errMessage);
});
#pragma warning restore 4014
}
SetStatus(HttpAsyncHostStatus.Initialised);
}));
}
async Task StartServerAsync(HttpListener listener, CancellationToken cancellationToken = default(CancellationToken))
{
var actionMap = new Dictionary <Tuple <string, Regex>, Action <HttpListenerRequest, HttpListenerResponse> >()
{
{ Tuple.Create("GET", new Regex($@"^{RelativeUrlRoot}api/v1/gameObjects/list$")), (req, res) => {
res.ContentType = "application/json";
var responseData = new ResponseObjects()
{
objects = new List <Object>()
};
foreach (GameObject obj in UnityEngine.Resources.FindObjectsOfTypeAll(typeof(GameObject)))
{
AppendSceneObject(responseData.objects, obj);
}
var responseJson = Encoding.ASCII.GetBytes(JsonUtility.ToJson(responseData));
res.OutputStream.Write(responseJson, 0, responseJson.Length);
res.Close();
} },
{ Tuple.Create("PUT", new Regex($@"^{RelativeUrlRoot}api/v1/gameObjects/transforms$")), (req, res) => {
res.ContentType = "application/json";
if (!req.HasEntityBody)
{
res.StatusCode = 400;
res.Close();
return;
}
var request = JsonUtility.FromJson <RequestPutObjectTransform>(ReadRequestBody(req));
if (request == null)
{
res.StatusCode = 400;
res.Close();
return;
}
var responseData = new ResponseObjects()
{
objects = new List <Object>()
};
var objects = (IEnumerable <GameObject>)UnityEngine.Resources.FindObjectsOfTypeAll(typeof(GameObject));
foreach (var t in request.transforms)
{
var obj = objects.FirstOrDefault(o => o.GetInstanceID() == t.instanceId);
if (obj == null)
{
continue;
}
AssignTransform(obj.transform, t);
if (!responseData.objects.Any(p => p.instanceId == t.instanceId))
{
AppendSceneObject(responseData.objects, obj);
}
}
var responseJson = Encoding.ASCII.GetBytes(JsonUtility.ToJson(responseData));
res.OutputStream.Write(responseJson, 0, responseJson.Length);
res.Close();
} },
{ Tuple.Create("GET", new Regex($@"^{RelativeUrlRoot}")), (req, res) => {
string relativePath = req.RawUrl.Remove(req.RawUrl.IndexOf(RelativeUrlRoot), RelativeUrlRoot.Length);
if (relativePath.Contains(".."))
{
res.StatusCode = 404;
res.Close();
}
if (relativePath == "")
{
relativePath = "index.html";
}
string zipFilePath = Path.Combine(Application.streamingAssetsPath, ZipFileName);
byte[] content = GetBytesFromZip(zipFilePath, relativePath);
if (content == null)
{
res.StatusCode = 404;
res.Close();
return;
}
string contentType;
if (!ExtensionContentTypeDict.TryGetValue(Path.GetExtension(relativePath), out contentType))
{
contentType = ExtensionContentTypeDict[".html"];
}
res.ContentType = contentType;
res.OutputStream.Write(content, 0, content.Length);
res.Close();
} },
};
listener.Start();
while (true)
{
var context = await listener.GetContextAsync();
cancellationToken.ThrowIfCancellationRequested();
var req = context.Request;
var res = context.Response;
var action = actionMap.FirstOrDefault(a => a.Key.Item1 == req.HttpMethod && a.Key.Item2.IsMatch(req.RawUrl));
if (action.Value == null)
{
res.StatusCode = 404;
res.Close();
continue;
}
action.Value(req, res);
}
}
