private void Verify(WebSocketContext Context, Action <EngineIOException> Callback)
{
EngineIOException Return = null;
bool AllowWebSocket = false;
try
{
if ((Return = Verify(Context.QueryString, Context.Headers, EngineIOTransportType.websocket)) == null)
{
string SID = EngineIOHttpManager.GetSID(Context.QueryString);
bool Contains = _Clients.ContainsKey(SID);
if (!string.IsNullOrEmpty(SID))
{
if (Contains && _Clients.TryGetValue(SID, out EngineIOSocket Socket))
{
if (Socket.Transport is EngineIOPolling && Option.AllowUpgrade && Option.WebSocket && !(Socket.Upgrading || Socket.Upgraded))
{
if (!(Socket.Upgrading || Socket.Upgraded))
{
Socket.UpgradeTransport(new EngineIOWebSocket(Context));
AllowWebSocket = true;
}
else
{
Return = Exceptions.BAD_REQUEST;
}
}
else
{
Return = Exceptions.BAD_REQUEST;
}
}
else
{
Return = Exceptions.UNKNOWN_SID;
}
}
else
{
if (Option.AllowWebSocket != null)
{
AllowWebSocket = true;
Option.AllowWebSocket(Context, Callback);
}
}
}
}
catch (Exception Exception)
{
EngineIOLogger.Error(this, Return = new EngineIOException("Unknown exception", Exception));
}
finally
{
if (!AllowWebSocket)
{
Callback(Return);
}
}
}
protected EngineIOTransport OnError(string Message, Exception Description)
{
EngineIOException Exception = new EngineIOException(Message, Description);
EngineIOLogger.Error(this, Exception);
Emit(Event.ERROR, Exception);
return(this);
}
private void Verify(HttpListenerRequest Request, Action <EngineIOException> Callback)
{
EngineIOException Return = null;
bool AllowHttpRequest = false;
try
{
if ((Return = Verify(Request.QueryString, Request.Headers, EngineIOTransportType.polling)) == null)
{
string SID = EngineIOHttpManager.GetSID(Request.QueryString);
bool Contains = _Clients.ContainsKey(SID);
if (string.IsNullOrEmpty(SID) || Contains)
{
if (Contains && !(_Clients[SID].Transport is EngineIOPolling))
{
Return = Exceptions.BAD_REQUEST;
}
else if (EngineIOHttpManager.ParseMethod(Request.HttpMethod) == EngineIOHttpMethod.GET)
{
if (Option.AllowHttpRequest != null)
{
AllowHttpRequest = true;
Option.AllowHttpRequest(Request, Callback);
}
}
else if (string.IsNullOrEmpty(SID))
{
Return = Exceptions.BAD_HANDSHAKE_METHOD;
}
}
else
{
Return = Exceptions.UNKNOWN_SID;
}
}
}
catch (Exception Exception)
{
EngineIOLogger.Error(this, Return = new EngineIOException("Unknown exception", Exception));
}
finally
{
if (!AllowHttpRequest)
{
Callback(Return);
}
}
}
private EngineIOException Verify(NameValueCollection QueryString, NameValueCollection Headers, EngineIOTransportType ExpectedTransportType)
{
EngineIOException Exception = Exceptions.UNKNOWN_TRANSPORT;
if (EngineIOHttpManager.GetTransport(QueryString).Equals(ExpectedTransportType.ToString()))
{
bool IsPolling = EngineIOHttpManager.IsPolling(QueryString) && Option.Polling;
bool IsWebSocket = EngineIOHttpManager.IsWebSocket(QueryString) && Option.WebSocket;
if (IsPolling || IsWebSocket)
{
if (EngineIOHttpManager.IsValidHeader(EngineIOHttpManager.GetOrigin(Headers)))
{
Exception = null;
}
else
{
Exception = Exceptions.BAD_REQUEST;
}
}
}
return(Exception);
}
public static void SendErrorMessage(HttpListenerRequest Request, HttpListenerResponse Response, EngineIOException Exception)
{
using (Response)
{
int Code = EngineIOServer.Exceptions.IndexOf(Exception);
string Message = Exception.Message;
if (EngineIOServer.Exceptions.Contains(Exception))
{
string Origin = GetOrigin(Request.Headers);
if (!string.IsNullOrWhiteSpace(Origin))
{
Response.Headers["Access-Control-Allow-Credentials"] = "true";
Response.Headers["Access-Control-Allow-Origin"] = Origin;
}
else
{
Response.Headers["Access-Control-Allow-Origin"] = "*";
}
Response.StatusCode = 400;
}
else
{
Response.StatusCode = 403;
Message = "Forbidden.";
}
byte[] RawData = Encoding.UTF8.GetBytes(new JObject()
{
["code"] = Code,
["message"] = Message
}.ToString());
using (Response.OutputStream)
{
Response.KeepAlive = false;
Response.ContentType = "application/json";
Response.ContentEncoding = Encoding.UTF8;
Response.ContentLength64 = RawData.Length;
Response.OutputStream.Write(RawData, 0, RawData.Length);
}
}
}
