public bool OnBeforeBrowse(IWebBrowser browserControl, IBrowser browser, IFrame frame, IRequest request, bool isRedirect)
{
if (request.Url.StartsWith("https://auth.iagd.dreamcrash.org/token/"))
{
var token = ExtractToken(request.Url);
OnAuthentication?.Invoke(browser, new AuthResultEvent {
Token = token
});
return(true);
}
else if (request.Url.StartsWith("transfer://single/"))
{
TransferSingleRequested?.Invoke(this, new ItemTransferEvent {
Request = request.Url.Replace("transfer://single/", "")
});
return(true);
}
else if (request.Url.StartsWith("transfer://all/"))
{
TransferAllRequested?.Invoke(this, new ItemTransferEvent {
Request = request.Url.Replace("transfer://all/", "")
});
return(true);
}
else if (!request.Url.Contains("grimdawn.dreamcrash") && (request.Url.StartsWith("http://") || request.Url.StartsWith("https://")))
{
System.Diagnostics.Process.Start(request.Url);
return(true);
}
return(false);
}
/// <summary>
/// Navigation/redirect request hook.
/// This ensures that only whitelisted URLs can be opened inside IA.
/// Any URL not whitelisted will be opened using the system default browser instead.
/// </summary>
/// <param name="chromiumWebBrowser"></param>
/// <param name="browser"></param>
/// <param name="frame"></param>
/// <param name="request"></param>
/// <param name="userGesture"></param>
/// <param name="isRedirect"></param>
/// <returns>True to ABORT any request/redirect, False to ALLOW them.</returns>
public bool OnBeforeBrowse(IWebBrowser chromiumWebBrowser, CefSharp.IBrowser browser, IFrame frame, IRequest request, bool userGesture, bool isRedirect)
{
// URL Hook for online backup login. (Binding a JS object to new windows proved to be too painful)
if (request.Url.StartsWith("https://token.iagd.evilsoft.net/"))
{
var token = ExtractToken(request.Url);
var user = ExtractUser(request.Url);
Logger.Info($"Got a login request for {user}");
OnAuthentication?.Invoke(browser, new AuthResultEvent(user, token));
return(true);
}
// Allow localdev
else if (request.Url.StartsWith("http://localhost:3000"))
{
Logger.Debug($"URL Requested: {request.Url}, Status: Allowed");
return(false);
}
// TODO: Rewrite this, who the hell knows what this does.
else if (!request.Url.StartsWith("http://iagd.evilsoft.net") && !request.Url.StartsWith("https://api.iagd.evilsoft.net") && !frame.Url.Contains("grimdawn.evilsoft.net") && !frame.Url.Contains("iagd.evilsoft.net") && (request.Url.StartsWith("http://") || request.Url.StartsWith("https://")))
{
Logger.Debug($"URL Requested: {request.Url}, Status: Deny, Action: DefaultBrowser");
System.Diagnostics.Process.Start(request.Url);
return(true);
}
Logger.Debug($"URL Requested: {request.Url}, Status: Allowed");
return(false);
}
protected async void HandshakeHandler(NeutronPlayer player, double clientTime, Authentication authentication)
{
if (authentication.Pass.Decrypt(out string phrase))
{
authentication = new Authentication(authentication.User, phrase, false);
try
{
if (await OnAuthentication.Invoke(player, authentication)) //* First packet
{
using (NeutronStream stream = Neutron.PooledNetworkStreams.Pull()) //* Second First packet
{
NeutronStream.IWriter writer = stream.Writer;
writer.WritePacket((byte)Packet.Handshake);
writer.Write(LocalTime);
writer.Write(clientTime);
writer.Write(player.StateObject.UdpLocalEndPoint.Port);
writer.WriteWithInteger(player);
player.Write(writer);
}
OnPlayerConnected?.Invoke(player); //* Three packet
}
}
catch (Exception ex) // Tasks manual catch exception.
{
LogHelper.Stacktrace(ex);
}
}
else if (!LogHelper.Error("Auth decrypt failed!"))
{
DisconnectHandler(player);
}
}
private void fireOnAuthentication(bool success)
{
OnAuthentication callback = AuthenticationEvent;
if (callback != null)
{
callback(success);
}
}
/// <summary>
/// Authenticates an user using an identity procider
/// </summary>
/// <param name="user">User's name</param>
/// <param name="password">User's password</param>
/// <param name="provider">Provider name</param>
/// <returns>The result could contains an exception or an user instance</returns>
public async Task <KZUser> Authenticate(string user, string password, string provider = "default")
{
try
{
lock (sync)
{
if (!Initialized)
{
throw new Exception("The application was not initialized.");
}
if (IsAuthenticating)
{
throw new Exception("The application is already authenticating an user.");
}
IsAuthenticating = true;
Authenticated = false;
}
var userAuthenticated = await Authentication.Authenticate(user, password, provider);
lock (sync)
{
this.Authenticated = true;
IsAuthenticating = false;
var result = Task.Run(() =>
{
OnAuthentication.Invoke(this, new EventArgs());
});
return(userAuthenticated);
}
}
catch (Exception)
{
lock (sync)
{
this.Authenticated = false;
this.IsAuthenticating = false;
throw;
}
}
}
/// <summary>
/// 监听端口 创建WebSocket
/// </summary>
/// <param name="httpListener"></param>
private void CreateWebSocket(HttpListener httpListener)
{
if (httpListener == null)
{
throw new Exception("HttpListener未创建");
}
if (!httpListener.IsListening)
{
throw new Exception("HttpListener未启动");
}
HttpListenerContext listenerContext = null;
//try
//{
listenerContext = httpListener.GetContext();
//}
//catch (Exception)
//{
// //if (httpListener != null&& httpListener.IsListening)
// CreateWebSocket(httpListener);
// return;
//}
if (OnAuthentication != null)
{
foreach (OnAuthentication item in OnAuthentication.GetInvocationList())
{
if (!item.Invoke(listenerContext))
{
CreateWebSocket(httpListener);
return;
}
}
}
WebSocketContext webSocket = null;
try
{
webSocket = new WebSocketContext(listenerContext, SubProtocol);
}
catch (Exception ex)
{
Console.WriteLine(ex);
CreateWebSocket(HttpListener);
return;
}
Console.WriteLine($"成功创建WebSocket：{webSocket.ID}");
int workerThreads = 0, completionPortThreads = 0;
ThreadPool.GetAvailableThreads(out workerThreads, out completionPortThreads);
if (workerThreads <= ReservedThreadsCount + 1 || completionPortThreads <= ReservedThreadsCount + 1)
{
/**
* 可用线程小于5
* 通知客户端关闭连接
* */
webSocket.CloseAsync(WebSocketCloseStatus.InternalServerError, "可用线程不足，无法连接").Wait();
}
else
{
if (OnReceiveMessage != null)
{
webSocket.OnReceiveMessage += OnReceiveMessage;
}
webSocket.OnCloseWebSocket += WebSocket_OnCloseWebSocket;
webSocketContexts.Add(webSocket);
if (OnAddWebSocket != null)
{
OnAddWebSocket.Invoke(webSocket);
}
ThreadPool.QueueUserWorkItem(new WaitCallback(p =>
{
(p as WebSocketContext).ReceiveMessageAsync().Wait();
}), webSocket);
}
CreateWebSocket(HttpListener);
}
/// <summary>
/// 监听端口 创建WebSocket
/// </summary>
/// <param name="httpListener"></param>
private void CreateWebSocket(HttpListener httpListener)
{
if (!httpListener.IsListening)
{
throw new Exception("HttpListener未启动");
}
HttpListenerContext listenerContext = httpListener.GetContext();
if (OnAuthentication != null)
{
foreach (OnAuthentication item in OnAuthentication.GetInvocationList())
{
if (!item.Invoke(listenerContext))
{
CreateWebSocket(httpListener);
return;
}
}
}
if (!listenerContext.Request.IsWebSocketRequest)
{
log.Info($"非WebSocket请求：{listenerContext.Request.RequestTraceIdentifier}");
var byyes = Encoding.UTF8.GetBytes($"非WebSocket请求：{listenerContext.Request.RequestTraceIdentifier}");
listenerContext.Response.StatusCode = (int)HttpStatusCode.BadRequest;
listenerContext.Response.ContentEncoding = Encoding.UTF8;
listenerContext.Response.OutputStream.Write(byyes, 0, byyes.Length);
listenerContext.Response.OutputStream.Flush();
listenerContext.Response.Close();
CreateWebSocket(httpListener);
return;
}
WebSocketContext webSocket = null;
try
{
webSocket = new WebSocketContext(listenerContext, SubProtocol);
}
catch (Exception ex)
{
log.Error(ex);
CreateWebSocket(HttpListener);
return;
}
log.Info($"成功创建WebSocket：{webSocket.ID}");
int workerThreads = 0, completionPortThreads = 0;
ThreadPool.GetAvailableThreads(out workerThreads, out completionPortThreads);
//if (workerThreads <= ReservedThreadsCount + 1 || completionPortThreads <= ReservedThreadsCount + 1)
//{
// /**
// * 可用线程小于预留线程数量
// * 通知客户端关闭连接
// * */
// webSocket.CloseAsync(WebSocketCloseStatus.InternalServerError, "可用线程不足，无法连接").Wait();
//}
//else
//{
if (OnReceiveMessage != null)
{
webSocket.OnReceiveMessage += OnReceiveMessage;
}
webSocket.OnCloseWebSocket += WebSocket_OnCloseWebSocket;
webSocketContexts.Add(webSocket);
if (OnAddWebSocket != null)
{
OnAddWebSocket.Invoke(webSocket);
}
Task.Factory.StartNew(() =>
{
webSocket.ReceiveMessage();
}, cancellationToken, TaskCreationOptions.LongRunning, TaskScheduler.Default);
//ThreadPool.QueueUserWorkItem(new WaitCallback(p =>
//{
// (p as WebSocketContext).ReceiveMessageAsync().Wait();
//}), webSocket);
//}
CreateWebSocket(HttpListener);
}
private void Read()
{
byte[] packetSize = new byte[4];
try
{
while (_stream.Read(packetSize, 0, 4) != 0)
{
#region Deserialize Message Size
int messageSize = BitConverter.ToInt32(packetSize);
byte[] messageData = new byte[messageSize];
#endregion
#region Read Message
int bytesRead = 0;
do
{
bytesRead += _stream.Read(messageData, bytesRead, messageSize - bytesRead);
} while (bytesRead < messageSize);
#endregion
#region Deserialize Message
DataMessage message;
using (MemoryStream memoryStream = new MemoryStream(messageData))
{
if (memoryStream.CanRead)
{
message = (DataMessage) new BinaryFormatter().Deserialize(memoryStream);
}
else
{
return;
}
}
#endregion
#region Distribute Messages
lock (_lock)
{
//Check reserved routes firsts
switch (message.Route)
{
case "connect":
//assign client id
ClientId = message.ClientId;
_allowEmit = true;
OnConnect?.Invoke(message.ClientId);
break;
case "authentication":
Emit("authentication", OnAuthentication?.Invoke(message));
break;
case "prepare":
OnPrepare?.Invoke(message);
break;
case "ready":
_acceptData = true;
OnReady?.Invoke();
break;
case "disconnect":
Disconnect("Server Requested Disconnect");
break;
case "HeartBeat":
_heartBeatLength = _timer.ElapsedMilliseconds - _previousHeartBeat;
_previousHeartBeat = _timer.ElapsedMilliseconds;
break;
default:
{
#region Distribute Messages to Routes
if (!_acceptData)
{
continue;
}
if (!_handlers.ContainsKey(message.Route))
{
continue;
}
foreach (Action <DataMessage> handler in _handlers[message.Route])
{
handler(message);
}
break;
#endregion
}
}
}
#endregion
}
}
catch (IOException)
{
Disconnect("Read Error");
}
catch (ObjectDisposedException) { /*If this happens we do not care*/ }
catch (Exception ex)
{
Console.WriteLine("Write Exception: {0}", ex);
}
}
