internal EventHttpRequestArgs OnHttpRequesting(HttpRequest request, HttpResponse response)
{
HttpToken token = (HttpToken)request.Session.Tag;
token.RequestArgs.Request = request;
token.RequestArgs.Response = response;
token.RequestArgs.Cancel = false;
HttpRequesting?.Invoke(this, token.RequestArgs);
return(token.RequestArgs);
}
private void OnRequestHandler(PacketDecodeCompletedEventArgs e)
{
try
{
HttpToken token = (HttpToken)e.Session.Tag;
if (token.WebSocket)
{
OnWebSocketRequest(token.Request, e.Session, (WebSockets.DataFrame)e.Message);
}
else
{
HttpRequest request = (HttpRequest)e.Message;
if (EnableLog(LogType.Info))
{
mServer.Log(LogType.Info, null, $"HTTP {request.ID} {request.RemoteIPAddress} {request.Method} {request.Url}");
}
if (EnableLog(LogType.Debug))
{
mServer.Log(LogType.Debug, e.Session, $"HTTP {request.ID} {request.RemoteIPAddress} {request.Method} {request.Url} detail {request.ToString()}");
}
request.Server = this;
HttpResponse response = request.CreateResponse();
token.KeepAlive = request.KeepAlive;
if (token.FirstRequest && string.Compare(request.Header[HeaderTypeFactory.UPGRADE], "websocket", true) == 0)
{
token.FirstRequest = false;
OnWebSocketConnect(request, response);
}
else
{
token.FirstRequest = false;
if (!Options.IOQueueEnabled)
{
OnHttpRequest(request, response);
}
else
{
IOQueueProcessArgs args = new IOQueueProcessArgs
{
Request = request,
Response = response
};
token.IOQueue.Enqueue(args);
}
}
}
}
catch (Exception e_)
{
if (EnableLog(LogType.Error))
{
mServer.Error(e_, e.Session, $"HTTP {e.Session.RemoteEndPoint} {0} OnRequestHandler error {e_.Message}@{e_.StackTrace}");
}
}
}
protected virtual void OnWebSocketRequest(HttpRequest request, ISession session, DataFrame data)
{
if (session.Count > Options.WebSocketMaxRPS)
{
if (EnableLog(LogType.Error))
{
mServer.Log(LogType.Error, session, $"Websocket {request.ID} {request.RemoteIPAddress} session message queuing exceeds maximum rps!");
}
session.Dispose();
return;
}
if (EnableLog(LogType.Info))
{
mServer.Log(LogType.Info, session, $"Websocket {request.ID} {request.RemoteIPAddress} receive {data.Type.ToString()}");
}
HttpToken token = (HttpToken)session.Tag;
if (data.Type == DataPacketType.ping)
{
DataFrame pong = CreateDataFrame();
pong.Type = DataPacketType.pong;
pong.FIN = true;
session.Send(pong);
}
else if (data.Type == DataPacketType.connectionClose)
{
session.Dispose();
}
else
{
if (WebSocketReceive == null)
{
if (data.Type == DataPacketType.text)
{
ExecuteWS(token.Request, data);
}
}
else
{
try
{
var args = new WebSocketReceiveArgs();
args.Frame = data;
args.Sesson = session;
args.Server = this;
args.Request = token.Request;
WebSocketReceive?.Invoke(this, args);
}
finally
{
}
}
}
}
private void OnHttpDecode(ISession session, PipeStream pstream)
{
START:
if (mRequest == null)
{
mRequest = mServer.CreateRequest(session); //new HttpRequest(session, mServer);
}
if (mRequest.Read(pstream) == LoadedState.Completed)
{
int length = mRequest.Length;
if (mRequest.Method == "GET" || mRequest.Method == "POST")
{
Completed?.Invoke(this, mCompletedArgs.SetInfo(session, mRequest));
}
else
{
if (session.Server.EnableLog(LogType.Warring))
{
session.Server.Log(LogType.Warring, session, "{0} {1} {2} not support", session.RemoteEndPoint, mRequest.Method, mRequest.Url);
}
HttpToken token = (HttpToken)session.Tag;
token.KeepAlive = false;
NotSupportResult notSupport = new NotSupportResult("Method:" + mRequest.Method + " not supper");
mRequest.CreateResponse().Result(notSupport);
}
mRequest = null;
if (pstream.Length == 0)
{
return;
}
goto START;
}
else
{
if ((int)mRequest.State < (int)LoadedState.Header && pstream.Length > 1024 * 4)
{
if (session.Server.EnableLog(LogType.Warring))
{
session.Server.Log(LogType.Warring, session, "{0} http header too long!", session.RemoteEndPoint);
}
session.Dispose();
}
else if (mRequest.Length > mServerConfig.MaxBodyLength)
{
if (session.Server.EnableLog(LogType.Warring))
{
session.Server.Log(LogType.Warring, session, "{0} http body too long!", session.RemoteEndPoint);
}
session.Dispose();
return;
}
return;
}
}
internal HttpRequest CreateRequest(ISession session)
{
//HttpRequest request;
//if (!mRequestPool.TryPop(out request))
// request = new HttpRequest();
//request.Init(session, this);
//return request;
HttpToken token = (HttpToken)session.Tag;
return(token.Request);
}
public override void Connected(IServer server, ConnectedEventArgs e)
{
System.Threading.Interlocked.Increment(ref mTotalConnections);
HttpToken token = new HttpToken();
token.Request = new HttpRequest();
token.Request.Init(e.Session, this);
e.Session.Tag = token;
e.Session.SocketProcessHandler = this;
HttpConnected?.Invoke(server, e);
base.Connected(server, e);
}
private void OnRequestHandler(object state)
{
PacketDecodeCompletedEventArgs e = (PacketDecodeCompletedEventArgs)state;
try
{
System.Threading.Interlocked.Increment(ref mTotalRequests);
HttpToken token = (HttpToken)e.Session.Tag;
if (token.WebSocket)
{
OnWebSocketRequest(e.Session, (WebSockets.DataFrame)e.Message);
}
else
{
HttpRequest request = (HttpRequest)e.Message;
if (request.ClientIPAddress == null)
{
IPEndPoint IP = e.Session.RemoteEndPoint as IPEndPoint;
if (IP != null)
{
string ipstr = IP.Address.ToString() + ":" + IP.Port.ToString();
request.Header.Add(HeaderTypeFactory.CLIENT_IPADDRESS, ipstr);
}
}
if (EnableLog(LogType.Info))
{
mServer.Log(LogType.Info, e.Session, "{0} {1} {2}", request.ClientIPAddress, request.Method, request.Url);
}
if (EnableLog(LogType.Debug))
{
mServer.Log(LogType.Debug, e.Session, "{0} {1}", request.ClientIPAddress, request.ToString());
}
request.Server = this;
HttpResponse response = request.CreateResponse();
token.KeepAlive = request.KeepAlive;
if (token.FirstRequest && string.Compare(request.Header[HeaderTypeFactory.UPGRADE], "websocket", true) == 0)
{
token.FirstRequest = false;
OnWebSocketConnect(request, response);
}
else
{
token.FirstRequest = false;
OnHttpRequest(request, response);
}
}
}
catch (Exception e_)
{
mServer.Error(e_, e.Session, "{0} OnRequestHandler error {1}", e.Session.RemoteEndPoint, e.Message);
}
}
private void OnHttpDecode(ISession session, PipeStream pstream)
{
if (mRequest == null)
{
mRequest = mServer.CreateRequest(session);
}
if (mRequest.Read(pstream) == LoadedState.Completed)
{
try
{
Completed?.Invoke(this, mCompletedArgs.SetInfo(session, mRequest));
}
finally
{
mRequest = null;
}
//if (pstream.Length == 0)
// return;
//goto START;
return;
}
else
{
if (session.Server.EnableLog(LogType.Info))
{
session.Server.Log(LogType.Info, session, $"{session.RemoteEndPoint} Multi receive to http request");
}
if ((int)mRequest.State < (int)LoadedState.Header && pstream.Length > 1024 * 4)
{
if (session.Server.EnableLog(LogType.Warring))
{
session.Server.Log(LogType.Warring, session, "{0} http header too long!", session.RemoteEndPoint);
}
session.Dispose();
}
else if (mRequest.Length > mServerConfig.MaxBodyLength)
{
if (session.Server.EnableLog(LogType.Warring))
{
session.Server.Log(LogType.Warring, session, "{0} http body too long!", session.RemoteEndPoint);
}
HttpToken token = (HttpToken)session.Tag;
token.KeepAlive = false;
var response = mRequest.CreateResponse();
InnerErrorResult innerErrorResult = new InnerErrorResult("413", "Request Entity Too Large");
response.Result(innerErrorResult);
//session.Dispose();
return;
}
return;
}
}
private void OnWebSocketConnect(HttpRequest request, HttpResponse response)
{
HttpToken token = (HttpToken)request.Session.Tag;
token.KeepAlive = true;
token.WebSocket = true;
request.WebSocket = true;
if (EnableLog(LogType.Info))
{
mServer.Log(LogType.Info, request.Session, "{0} upgrade to websocket", request.Session.RemoteEndPoint);
}
ConnectionUpgradeWebsocket(request, response);
}
public void SendDataFrame(DataFrame data, ISession session)
{
if (session == null)
{
return;
}
HttpToken toke = (HttpToken)session.Tag;
if (toke.WebSocket)
{
session.Send(data);
}
}
private void OnWebSocketDecode(ISession session, PipeStream pstream)
{
START:
if (mDataPacket == null)
{
mDataPacket = new DataFrame(mServer);
mDataPacket.DataPacketSerializer = this.mDataPacketSerializer;
}
if (mDataPacket.Read(pstream) == DataPacketLoadStep.Completed)
{
mWebSocketRequest++;
long now = session.Server.GetRunTime();
if (now - mLastTime < 1000)
{
if (mServerConfig.WebSocketMaxRPS > 0 && mWebSocketRequest > mServerConfig.WebSocketMaxRPS)
{
if (session.Server.EnableLog(LogType.Warring))
{
session.Server.Log(LogType.Warring, session, $"Websocket {mRequest?.ID} {session.RemoteEndPoint} session rps limit!");
}
HttpToken token = (HttpToken)session.Tag;
token.KeepAlive = false;
var error = new ActionResult(500, "session rps limit!");
var frame = mServer.CreateDataFrame(error);
frame.Send(session);
// session.Dispose();
}
}
else
{
mWebSocketRequest = 0;
mLastTime = now;
}
DataFrame data = mDataPacket;
mDataPacket = null;
Completed?.Invoke(this, mCompletedArgs.SetInfo(session, data));
if (pstream.Length > 0)
{
goto START;
}
}
else
{
if (pstream.Length > mServerConfig.MaxBodyLength)
{
session.Dispose();
}
}
}
public override void SessionPacketDecodeCompleted(IServer server, PacketDecodeCompletedEventArgs e)
{
HttpToken token = (HttpToken)e.Session.Tag;
HttpRequest request = (HttpRequest)e.Message;
HttpResponse response = request.CreateResponse();
token.KeepAlive = request.KeepAlive;
if (string.IsNullOrEmpty(request.Ext) && request.BaseUrl != "/")
{
mActionFactory.Execute(request, response, this);
}
else
{
OnProcessResource(request, response);
}
}
protected virtual void OnWebSocketRequest(ISession session, DataFrame data)
{
if (EnableLog(LogType.Info))
{
mServer.Log(LogType.Info, session, "{0} receive websocket data {1}", session.RemoteEndPoint, data.Type.ToString());
}
HttpToken token = (HttpToken)session.Tag;
if (data.Type == DataPacketType.ping)
{
DataFrame pong = CreateDataFrame();
pong.Type = DataPacketType.pong;
pong.FIN = true;
session.Send(pong);
}
else if (data.Type == DataPacketType.connectionClose)
{
session.Dispose();
}
else
{
if (WebSocketReceive == null)
{
if (data.Type == DataPacketType.text)
{
ActionResult result = ExecuteWS(token.Request, data);
}
}
else
{
RequestExecting();
try
{
var args = new WebSocketReceiveArgs();
args.Frame = data;
args.Sesson = session;
args.Server = this;
args.Request = token.Request;
WebSocketReceive?.Invoke(this, args);
}
finally
{
RequestExecuted();
}
}
}
}
public override void SessionPacketDecodeCompleted(IServer server, PacketDecodeCompletedEventArgs e)
{
System.Threading.Interlocked.Increment(ref mRequests);
HttpToken token = (HttpToken)e.Session.Tag;
if (token.WebSocket)
{
OnReceiveWebSocketData(e.Session, (WebSockets.DataFrame)e.Message);
}
else
{
HttpRequest request = (HttpRequest)e.Message;
if (EnableLog(LogType.Info))
{
mServer.Log(LogType.Info, e.Session, "{0} Http {1} {2}", request.ClientIPAddress, request.Method, request.Url);
}
if (EnableLog(LogType.Debug))
{
mServer.Log(LogType.Info, e.Session, "{0} {1}", request.ClientIPAddress, request.ToString());
}
request.Server = this;
if (request.ClientIPAddress == null)
{
request.Header.Add(HeaderType.CLIENT_IPADDRESS, ((IPEndPoint)e.Session.RemoteEndPoint).Address.ToString());
}
HttpResponse response = request.CreateResponse();
token.KeepAlive = request.KeepAlive;
if (token.FirstRequest && string.Compare(request.Header[HeaderType.UPGRADE], "websocket", true) == 0)
{
token.FirstRequest = false;
OnWebSocketConnect(request, response);
}
else
{
token.FirstRequest = false;
if (string.IsNullOrEmpty(request.Ext) && request.BaseUrl != "/")
{
mActionFactory.Execute(request, response, this);
}
else
{
OnProcessResource(request, response);
}
}
}
}
public virtual void SendCompleted(ISession session, SocketAsyncEventArgs e)
{
HttpToken token = (HttpToken)session.Tag;
if (token.File != null)
{
token.File = token.File.Next();
if (token.File != null)
{
session.Send(token.File);
return;
}
}
if (session.Count == 0 && !token.KeepAlive)
{
session.Dispose();
}
}
private void OnRequestHandler(object state)
{
PacketDecodeCompletedEventArgs e = (PacketDecodeCompletedEventArgs)state;
try
{
System.Threading.Interlocked.Increment(ref mTotalRequests);
HttpToken token = (HttpToken)e.Session.Tag;
if (token.WebSocket)
{
OnWebSocketRequest(e.Session, (WebSockets.DataFrame)e.Message);
}
else
{
HttpRequest request = (HttpRequest)e.Message;
if (EnableLog(LogType.Info))
{
mServer.Log(LogType.Info, e.Session, $"{request.RemoteIPAddress} {request.Method} {request.Url} request");
}
if (EnableLog(LogType.Debug))
{
mServer.Log(LogType.Debug, e.Session, $"{request.RemoteIPAddress} {request.Method} {request.Url} request detail {request.ToString()}");
}
request.Server = this;
HttpResponse response = request.CreateResponse();
token.KeepAlive = request.KeepAlive;
if (token.FirstRequest && string.Compare(request.Header[HeaderTypeFactory.UPGRADE], "websocket", true) == 0)
{
token.FirstRequest = false;
OnWebSocketConnect(request, response);
}
else
{
token.FirstRequest = false;
OnHttpRequest(request, response);
}
}
}
catch (Exception e_)
{
mServer.Error(e_, e.Session, "{0} OnRequestHandler error {1}", e.Session.RemoteEndPoint, e.Message);
}
}
public void Decode(ISession session, Stream stream)
{
HttpToken token = (HttpToken)session.Tag;
PipeStream pstream = stream.ToPipeStream();
if (pstream.Length > mServerConfig.MaxBodyLength)
{
session.Server.Log(LogType.Error, session, "http body too long!");
session.Dispose();
return;
}
if (!token.WebSocket)
{
OnHttpDecode(session, pstream);
}
else
{
OnWebSocketDecode(session, pstream);
}
}
public void Decode(ISession session, Stream stream)
{
HttpToken token = (HttpToken)session.Tag;
try
{
PipeStream pstream = stream.ToPipeStream();
if (pstream.Length > mServerConfig.MaxBodyLength)
{
if (session.Server.EnableLog(LogType.Warring))
{
session.Server.Log(LogType.Warring, session, $"HTTP {session.RemoteEndPoint} protocol data to long!");
}
session.Dispose();
return;
}
if (!token.WebSocket)
{
OnHttpDecode(session, pstream);
}
else
{
OnWebSocketDecode(session, pstream);
}
}
catch (Exception e_)
{
if (session.Server.EnableLog(LogType.Warring))
{
if (token.WebSocket)
{
session.Server.Log(LogType.Warring, session, $"Websocket {session.RemoteEndPoint} protocol decoding error {e_.Message}@{e_.StackTrace}!");
}
else
{
session.Server.Log(LogType.Warring, session, $"HTTP {session.RemoteEndPoint} protocol decoding error {e_.Message}@{e_.StackTrace}");
}
}
session.Dispose();
}
}
public override void Disconnect(IServer server, SessionEventArgs e)
{
try
{
HttpToken token = (HttpToken)e.Session.Tag;
if (token != null && token.WebSocketRequest != null)
{
token.WebSocketRequest.Response = null;
}
if (LogOutput == e.Session)
{
LogOutput = null;
}
HttpDisconnect?.Invoke(server, e);
base.Disconnect(server, e);
}
finally
{
e.Session.Tag = null;
}
}
public override void SessionPacketDecodeCompleted(IServer server, PacketDecodeCompletedEventArgs e)
{
System.Threading.Interlocked.Increment(ref mTotalRequests);
HttpToken token = (HttpToken)e.Session.Tag;
if (token.WebSocket)
{
OnWebSocketRequest(e.Session, (WebSockets.DataFrame)e.Message);
}
else
{
HttpRequest request = (HttpRequest)e.Message;
if (request.ClientIPAddress == null)
{
request.Header.Add(HeaderTypeFactory.CLIENT_IPADDRESS, e.Session.RemoteEndPoint.ToString());
}
if (EnableLog(LogType.Info))
{
mServer.Log(LogType.Info, e.Session, "{0} {1} {2}", request.ClientIPAddress, request.Method, request.Url);
}
if (EnableLog(LogType.Debug))
{
mServer.Log(LogType.Debug, e.Session, "{0} {1}", request.ClientIPAddress, request.ToString());
}
request.Server = this;
HttpResponse response = request.CreateResponse();
token.KeepAlive = request.KeepAlive;
if (token.FirstRequest && string.Compare(request.Header[HeaderTypeFactory.UPGRADE], "websocket", true) == 0)
{
token.FirstRequest = false;
OnWebSocketConnect(request, response);
}
else
{
token.FirstRequest = false;
OnHttpRequest(request, response);
}
}
}
public void Decode(ISession session, Stream stream)
{
HttpToken token = (HttpToken)session.Tag;
PipeStream pstream = stream.ToPipeStream();
if (pstream.Length > mServerConfig.MaxBodyLength)
{
if (session.Server.EnableLog(LogType.Warring))
{
session.Server.Log(LogType.Warring, session, "{0} http protocol data to long!", session.RemoteEndPoint);
}
session.Dispose();
return;
}
if (!token.WebSocket)
{
OnHttpDecode(session, pstream);
}
else
{
OnWebSocketDecode(session, pstream);
}
}
private void OnHttpDecode(ISession session, PipeStream pstream)
{
mReceives++;
if (mRequest == null)
{
mRequest = mServer.CreateRequest(session);
mRequest.ID = HttpRequest.GetID();
}
if (mRequest.Read(pstream) == LoadedState.Completed)
{
try
{
Completed?.Invoke(this, mCompletedArgs.SetInfo(session, mRequest));
}
finally
{
mRequest = null;
mReceives = 0;
}
return;
}
else
{
HttpToken token = (HttpToken)session.Tag;
if (session.Server.EnableLog(LogType.Info))
{
session.Server.Log(LogType.Info, session, $"HTTP {mRequest.ID} {session.RemoteEndPoint} request from multi receive");
}
if (mRequest.State == LoadedState.None)
{
if (mReceives > 2 || pstream.FirstBuffer.Length < 32)
{
if (session.Server.EnableLog(LogType.Warring))
{
session.Server.Log(LogType.Warring, session, $"HTTP {mRequest.ID} {session.RemoteEndPoint} receive data error!");
}
token.KeepAlive = false;
var response = mRequest.CreateResponse();
InnerErrorResult innerErrorResult = new InnerErrorResult("400", "Request http receive data error!");
response.Result(innerErrorResult);
return;
}
var span = pstream.FirstBuffer.Memory.Slice(0, 10).Span;
var method = Encoding.ASCII.GetString(span.ToArray());
bool ismethod = method.IndexOf("GET") == 0 || method.IndexOf("POST") == 0 || method.IndexOf("HEAD") == 0 ||
method.IndexOf("PUT") == 0 || method.IndexOf("DELETE") == 0 || method.IndexOf("CONNECT") == 0 || method.IndexOf("OPTIONS") == 0 ||
method.IndexOf("TRACE") == 0;
if (!ismethod)
{
if (session.Server.EnableLog(LogType.Warring))
{
session.Server.Log(LogType.Warring, session, $"HTTP {mRequest.ID} {session.RemoteEndPoint} protocol data error!");
}
token.KeepAlive = false;
var response = mRequest.CreateResponse();
InnerErrorResult innerErrorResult = new InnerErrorResult("400", "Request http protocol data error!");
response.Result(innerErrorResult);
return;
}
}
if ((int)mRequest.State < (int)LoadedState.Header && (pstream.Length > 1024 * 4 || mReceives > 20))
{
if (session.Server.EnableLog(LogType.Warring))
{
session.Server.Log(LogType.Warring, session, $"HTTP {mRequest.ID} {session.RemoteEndPoint} header too long!");
}
token.KeepAlive = false;
var response = mRequest.CreateResponse();
InnerErrorResult innerErrorResult = new InnerErrorResult("400", "Request header too large");
response.Result(innerErrorResult);
}
else if (mRequest.Length > mServerConfig.MaxBodyLength)
{
if (session.Server.EnableLog(LogType.Warring))
{
session.Server.Log(LogType.Warring, session, $"HTTP {mRequest.ID} {session.RemoteEndPoint} body too long!");
}
token.KeepAlive = false;
var response = mRequest.CreateResponse();
InnerErrorResult innerErrorResult = new InnerErrorResult("400", "Request entity too large");
response.Result(innerErrorResult);
return;
}
return;
}
}
internal HttpRequest CreateRequest(ISession session)
{
HttpToken token = (HttpToken)session.Tag;
return(token.Request);
}
