public RealmClientSession(Socket pmSocket)
{
this.clientSocket = pmSocket;
realmReceiveBuffer = new ReceiveBuffer(1048576);
outRPQueue = new Queue <RealmPacket>();
this.working = false;
}
private bool isCommand()
{
#if DOTNET2
Socket socket = (Socket)receiveAsyncEventArgs.AsyncState;
if (socket == Socket)
{
receiveCount += socket.EndReceive(receiveAsyncEventArgs, out socketError);
if (socketError == SocketError.Success)
{
#else
if (receiveAsyncEventArgs.SocketError == SocketError.Success)
{
receiveCount += receiveAsyncEventArgs.BytesTransferred;
#endif
fixed (byte* receiveDataFixed = ReceiveBuffer.GetFixedBuffer())
{
receiveDataStart = receiveDataFixed + ReceiveBuffer.StartIndex;
return loop(true);
}
#if DOTNET2
}
#endif
}
#if !DOTNET2
else socketError = receiveAsyncEventArgs.SocketError;
#endif
return false;
}
private static void WaitForReceive(ReceiveBuffer serverBuffer, int queueCount)
{
for (int countdown = 10; countdown >= 0 && serverBuffer.Count != queueCount; countdown--)
{
Thread.Sleep(1);
}
}
void Client_DataReceived(Client sender, ReceiveBuffer e)
{
// 받아온 데이터 포멧
// 4byte 마우스를 클릭했을 때의 해당 좌표 온도 - 클릭하지 않았을때 0도
// 8byte 영상에서의 최대 온도 (4) 최저 온도 (4)
// 나머지 이미지 데이터
BinaryReader r = new BinaryReader(e.BufStream);
tempurture = r.ReadSingle();
// 최대 온도
max_T = r.ReadSingle();
// 최저 온도
min_T = r.ReadSingle();
//Debug.Log("Max T " + maxT + " MIN T " + minT);
float[] iBytes = new float[384 * 288];
for (int i = 0; i < 384 * 288; i++)
{
iBytes[i] = r.ReadSingle();
}
idata = iBytes;
falg = true;
}
public virtual bool ProcessReceive(byte[] buffer, int offset, int count) //接收异步事件返回的数据，用于对数据进行缓存和分包
{
try
{
ActiveTime = DateTime.UtcNow;
ReceiveBuffer.WriteBuffer(buffer, offset, count);
int Len = BitConverter.ToInt32(buffer, offset); //取出信息长度
offset += sizeof(int);
// 收到的数据不全
if (Len + sizeof(int) > count)
{
return(true);
}
string msg = Encoding.UTF8.GetString(buffer, offset, Len);
ReceiveBuffer.Clear(Len + sizeof(int));
if (serverSocket.Receive != null)
{
serverSocket.Receive(this, new ClientData(msg));
}
return(true);
}
catch (Exception e)
{
Global.Logger.Error(e.Message);
Global.Logger.Error(e.StackTrace);
return(false);
}
}
public virtual bool ProcessReceive(byte[] buffer, int offset, int count) //接收异步事件返回的数据，用于对数据进行缓存和分包
{
try
{
ActiveTime = DateTime.UtcNow;
ReceiveBuffer.WriteBuffer(buffer, offset, count);
int Len = BitConverter.ToInt32(buffer, offset); //取出信息长度
offset += sizeof(int);
// 收到的数据不全
if (Len + sizeof(int) > count)
{
return(true);
}
string msg = Encoding.UTF8.GetString(buffer, offset, Len);
ReceiveBuffer.Clear(Len + sizeof(int));
serverSocket.Receive(this, msg);
return(true);
}
catch (Exception e)
{
Tools.MyLog.Error("Error: {0}\nStackTrace: {1}", e.Message, e.StackTrace);
return(false);
}
}
void client_DataReceived(Client sender, ReceiveBuffer e)
{
try
{
DataPacket.Packet pkt = DataPacket.DataParser(e.BufStream, e.pkt);
PktType header = pkt.type;
UpdateCompLogMsg(sender.name + " - Received data: " + pkt.ToString());
switch (header)
{
case PktType.AUTH:
UpdateReceivedImage(pkt.fingerPrint);
UpdateCompMatchedUser(sender.RunAuth(pkt));
//sender.RunAuth(pkt);
break;
case PktType.PASSENGER:
sender.RunPassenger(pkt);
break;
case PktType.ORDER:
sender.RunOrder(pkt);
break;
case PktType.ONCE:
UpdateReceivedImage(pkt.fingerPrint);
UpdateCompMatchedUser(sender.RunAtOnce(pkt));
break;
}
}
catch (Exception ee)
{
UpdateCompLogMsg(ee.Message);
}
}
private bool ProcessReceive(byte[] buffer, int offset, int count) //接收异步事件返回的数据，用于对数据进行缓存和分包
{
try
{
ActiveTime = DateTime.UtcNow;
ReceiveBuffer.WriteBuffer(buffer, offset, count);
int Len = BitConverter.ToInt32(buffer, offset); //取出信息长度
offset += sizeof(int);
// 收到的数据不全
if (Len + sizeof(int) > count)
{
return(true);
}
string msg = Encoding.UTF8.GetString(buffer, offset, Len);
ReceiveBuffer.Clear(Len + sizeof(int));
Receive(msg);
return(true);
}
catch (Exception e)
{
MyLog.Error(e.Message + e.StackTrace);
return(false);
}
}
/// <summary>
/// 接收到策略请求
/// </summary>
/// <param name="session">会话对象</param>
/// <param name="buffer">数据</param>
protected override void OnReceive(SessionBase session, ReceiveBuffer buffer)
{
var xml = new StringBuilder();
xml.AppendLine("<?xml version=\"1.0\" encoding=\"utf-8\" ?>");
xml.AppendLine("<access-policy>");
xml.AppendLine("<cross-domain-access>");
xml.AppendLine("<policy>");
xml.AppendLine("<allow-from>");
xml.AppendLine("<domain uri=\"*\"/>");
xml.AppendLine("</allow-from>");
xml.AppendLine("<grant-to>");
xml.AppendLine("<socket-resource port=\"4502-4534\" protocol=\"tcp\"/>");
xml.AppendLine("</grant-to>");
xml.AppendLine("</policy>");
xml.AppendLine("</cross-domain-access>");
xml.AppendLine("</access-policy>");
var bytes = Encoding.UTF8.GetBytes(xml.ToString());
var byteRange = new ByteRange(bytes);
try
{
session.Send(byteRange);
}
finally
{
session.Close();
}
}
/// <summary>
/// 接收验证命令
/// </summary>
/// <returns></returns>
private bool isVerifyCommand()
{
if (IsVerifyMethod)
{
receiveIndex = receiveCount = 0;
return isCommand();
}
#if DOTNET2
Socket socket = (Socket)receiveAsyncEventArgs.AsyncState;
if (socket == Socket)
{
receiveCount = socket.EndReceive(receiveAsyncEventArgs, out socketError);
if (socketError == SocketError.Success)
{
#else
if (receiveAsyncEventArgs.SocketError == SocketError.Success)
{
receiveCount = receiveAsyncEventArgs.BytesTransferred;
#endif
if (receiveCount >= (sizeof(int) * 2 + sizeof(uint)))
{
fixed (byte* receiveDataFixed = ReceiveBuffer.GetFixedBuffer())
{
if (*(int*)(receiveDataStart = receiveDataFixed + ReceiveBuffer.StartIndex) == Server.VerifyCommandIdentity)
{
if ((compressionDataSize = *(int*)(receiveDataStart + (sizeof(uint) + sizeof(int)))) > 0)
{
CommandIndex = *(uint*)(receiveDataStart + sizeof(int));
dataSize = compressionDataSize;
receiveIndex = sizeof(int) * 2 + sizeof(uint);
return checkVerifyCommandFixed();
}
else if (compressionDataSize < 0 && receiveCount >= (sizeof(int) * 3 + sizeof(uint)))
{
if ((dataSize = *(int*)(receiveDataStart + (sizeof(uint) + sizeof(int) * 2))) > (compressionDataSize = -compressionDataSize))
{
CommandIndex = *(uint*)(receiveDataStart + sizeof(int));
receiveIndex = sizeof(int) * 3 + sizeof(uint);
return checkVerifyCommandFixed();
}
}
}
else if (Server.Log.IsAnyLevel(LogLevel.Info))
{
#if !DOTNET2
Socket socket = Socket;
#endif
Server.Log.Info(socket == null ? "TCP 验证函数命令错误" : ("TCP 验证函数命令错误 " + socket.RemoteEndPoint.ToString()), LogLevel.Info | LogLevel.AutoCSer);
}
}
}
#if DOTNET2
}
#endif
}
#if !DOTNET2
else socketError = receiveAsyncEventArgs.SocketError;
#endif
return false;
}
public override void Parse(byte b)
{
switch (ReadState)
{
case States.ReadingData:
if (b == IAC)
{
ReadState = States.ReadingVerb;
}
else
{
ReceiveBuffer.Add(b);
if (b < 32 || b > 127)
{
System.Diagnostics.Debug.Write("[" + (int)b + "]");
}
}
break;
case States.ReadingVerb:
LastVerbRec = (Verbs)b;
ReadState = States.ReadingOption;
break;
case States.ReadingOption:
HandleNVTCmd(LastVerbRec, (Options)b);
break;
}
}
/// <summary>
/// 处理握手
/// </summary>
/// <param name="session">会话对象</param>
/// <param name="buffer">接收到的数据</param>
private void ProcessHandshake(T session, ReceiveBuffer buffer)
{
var request = HandshakeRequest.From(buffer);
if (request == null)
{
session.Close();
return;
}
if (this.OnHandshake(session, request) == false)
{
session.Close();
return;
}
// 握手成功
try
{
var response = new HandshakeResponse(request);
session.SendResponse(response);
}
finally
{
session.TagData.Set("HANDSHAKED", true);
}
}
/// <summary>
/// 生成Post得到的表单和文件
/// </summary>
/// <param name="request"></param>
/// <param name="buffer"></param>
private static void GeneratePostFormAndFiles(HttpRequest request, ReceiveBuffer buffer)
{
var boundary = default(string);
if (request.IsApplicationFormRequest() == true)
{
HttpRequest.GenerateApplicationForm(request);
}
else if (request.IsMultipartFormRequest(out boundary) == true)
{
if (request.InputStrem.Length >= boundary.Length)
{
HttpRequest.GenerateMultipartFormAndFiles(request, buffer, boundary);
}
}
if (request.Form == null)
{
request.Form = new HttpNameValueCollection();
}
if (request.Files == null)
{
request.Files = new HttpFile[0];
}
}
internal bool Receive(byte[] buffer, int offset, int count)
{
ReceiveBuffer.WriteBytes(buffer, offset, count); // 写入数据内容
bool result = true;
while (ReceiveBuffer.DataCount > sizeof(int))
{
//按照长度分包
int packetLength = BitConverter.ToInt32(ReceiveBuffer.Buffer, 0); //获取包长度 // 老版代码
if ((packetLength > 10 * 1024 * 1024) | (buffer.Length > 10 * 1024 * 1024)) //最大Buffer异常保护
{
App.Logger.Error("内存超出, 数据不进行操作, 关闭远程连接");
return(false);
}
if ((ReceiveBuffer.DataCount - sizeof(int)) >= packetLength) //收到的数据达到包长度
{
result = PacketProcess.Process(this, ReceiveBuffer.Buffer, sizeof(int), packetLength);
if (result)
{
ReceiveBuffer.Clear(packetLength + sizeof(int));
}
else
{
return(result);
}
}
else
{
return(true);
}
}
return(true);
}
public bool ConnectServer(string strIP, int strPort)
{
if (this.m_ReceiveBuffer == null)
{
this.m_ReceiveBuffer = new List <byte>();
}
strIP.Trim();
if (this.m_Socket != null)
{
this.Quit();
}
this.m_Socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
this.m_Socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReceiveBuffer, this.m_iBufferSize);
IPAddress.TryParse(strIP, out this.m_kServeripaddress);
Debug.Log("===========> m_kServeripaddress : " + this.m_kServeripaddress.ToString());
Debug.Log("===========> strPort : " + strPort.ToString());
try
{
this.m_Socket.Connect(this.m_kServeripaddress, strPort);
}
catch (Exception ex)
{
TsLog.Log(ex.Message, new object[0]);
return(false);
}
this.m_Buffer = new ReceiveBuffer(this.m_Socket.ReceiveBufferSize);
NrTSingleton <NrUpdateProcessor> .Instance.AddUpdate(new UpdateFunc(this.NetUpdate));
SendPacket.GetInstance().SetSocket(this.m_Socket);
this.m_IPAddress_Relogin = strIP;
this.m_Port_Relogin = strPort;
return(this.m_Socket.Connected);
}
/// <summary>
/// 初始化新的TCP客户端接收器实例
/// </summary>
/// <param name="clientSocket">客户端Socket</param>
public TcpClientManager(Socket clientSocket)
{
ClientGuid = new Guid();
_clientSocket = clientSocket;
ReceiveBuffer.Add(new ArraySegment <byte>(new byte[AppConfig.TcpBufferSize]));
IsConnected = true;
}
private bool TryDeliverNextMessage(ReceiveBuffer buffer, out RequestMessage message)
{
if (buffer.Buffered != null)
{
using (var e = buffer.Buffered.GetEnumerator())
{
if (e.MoveNext())
{
var pred = e.Current.Value.Predecessor;
if (pred <= buffer.Last || pred < this.ReceiveHorizon)
{
message = e.Current.Value;
buffer.Last = message.Timestamp >= this.ReceiveHorizon ? message.Timestamp : DateTime.MinValue;
buffer.Buffered.Remove(message.Timestamp);
return(true);
}
}
}
}
message = null;
return(false);
}
/// <summary>
/// Updates statistics and calls <see
/// cref="M:ExitGames.Net.Sockets.PooledReceiver.OnReceive(System.Net.EndPoint,System.Byte[],System.Int32,System.Int32)"/> for each message in the batch.
/// </summary>
/// <param name="buffer">The buffer.</param>
private void ProcessBufferBatched(ReceiveBuffer buffer)
{
try
{
BatchMessage batchMessage = BatchMessage.FromBinary(buffer.Data);
ReceivedPackages = ReceivedPackages + 1;
ReceivedMessages = ReceivedMessages + batchMessage.MessageCount;
for (int i = 0; i < batchMessage.MessageCount; i++)
{
ArraySegment <byte> segment = batchMessage[i];
OnReceive(buffer.EndPoint, segment.Array, segment.Offset, segment.Count);
}
}
catch (ThreadAbortException)
{
throw;
}
catch (OutOfMemoryException)
{
throw;
}
catch (Exception exception)
{
log.Error(exception);
}
}
private void ReceiveHeader(ReceiveBuffer buffer)
{
lock (_connection)
{
_connection.BeginReceive(buffer.Buffer, buffer.ReceivedBytes, buffer.Buffer.Length, SocketFlags.None,
_readHeaderCallback, buffer);
}
}
/**
* create a new {@link UDTInputStream} connected to the given socket
* @param socket - the {@link UDTSocket}
* @throws IOException
*/
public UDTInputStream(UDTSocket socket)
{
this.socket = socket;
int capacity = socket != null? 2 * socket.GetSession().FlowWindowSize : 128;
long initialSequenceNum = socket != null?socket.GetSession().InitialSequenceNumber : 1;
receiveBuffer = new ReceiveBuffer(capacity, initialSequenceNum);
}
public void ClearTest()
{
ReceiveBuffer target = new ReceiveBuffer(); // TODO: 初始化为适当的值
target.Add(new byte[] { 1, 2 }, 0, 2);
target.Clear();
Assert.IsTrue(target.Length == 0);
}
/// <summary>
/// 解析连接请求信息
/// </summary>
/// <param name="buffer">接收到的原始数量</param>
/// <returns></returns>
public static HttpRequest From(ReceiveBuffer buffer)
{
buffer.Position = 0;
var bytes = buffer.ReadArray();
buffer.Clear();
return(HttpRequest.From(bytes, "ws"));
}
public void Update(long timestamp)
{
if (IsShutdown)
{
return;
}
ReceiveBuffer.Update(timestamp);
SendBuffer.Update(timestamp);
}
private void Shutdown()
{
if (isShutdown.Exchange(true))
{
return;
}
ReceiveBuffer.Shutdown();
SendBuffer.Shutdown();
}
/// <summary>
/// 解析请求帧
/// </summary>
/// <param name="buffer">接收到的历史数据</param>
/// <returns></returns>
private IEnumerable <FrameRequest> GetFrameRequestsFromBuffer(ReceiveBuffer buffer)
{
FrameRequest request;
while ((request = FrameRequest.From(buffer)) != null)
{
yield return(request);
}
}
/// <summary>
/// 获取数据包
/// </summary>
/// <param name="buffer">接收到的历史数据</param>
/// <returns></returns>
private IEnumerable <FastPacket> GetPacketsFromBuffer(ReceiveBuffer buffer)
{
FastPacket packet;
while ((packet = FastPacket.From(buffer)) != null)
{
yield return(packet);
}
}
public void ReceiveCallback(IAsyncResult ar)
{
// Debug.Log("ReceiveCallback");
BitConverter.ToInt32(lenBuffer, 0);
try
{
// 넘겨 받은 바이트의 갯수
int rec = socket.EndReceive(ar);
if (rec == 0)
{
if (Disconnected != null)
{
Disconnected(this);
return;
}
}
if (rec != 4)
{
throw new Exception();
}
}
catch (SocketException se)
{
switch (se.SocketErrorCode)
{
case SocketError.ConnectionAborted:
case SocketError.ConnectionReset:
if (Disconnected != null)
{
Disconnected(this);
return;
}
break;
}
}
catch (ObjectDisposedException)
{
return;
}
catch (NullReferenceException)
{
return;
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
return;
}
buffer = new ReceiveBuffer(BitConverter.ToInt32(lenBuffer, 0));
socket.BeginReceive(buffer.Buffer, 0, buffer.Buffer.Length, SocketFlags.None, receivePacketCallBack, null);
}
private void ReceiveBody(int size)
{
var buffer = ReceiveBuffer.Create(size);
lock (_connection)
{
_connection.BeginReceive(buffer.Buffer, buffer.ReceivedBytes, buffer.Buffer.Length, SocketFlags.None,
_readBodyCallback, buffer);
}
}
/// <summary>
/// 处理请求
/// </summary>
/// <param name="session">会话对象</param>
/// <param name="buffer">接收到的历史数据</param>
private void ProcessRequest(T session, ReceiveBuffer buffer)
{
var requests = this.GetFrameRequestsFromBuffer(buffer);
foreach (var request in requests)
{
// 新线程处理业务内容
Task.Factory.StartNew(() => this.OnRecvRequest(session, request));
}
}
/// <summary>
/// 当接收到远程端的数据时，将触发此方法
/// </summary>
/// <param name="buffer">接收到的历史数据</param>
protected override void OnReceive(ReceiveBuffer buffer)
{
var packets = this.GetPacketsFromBuffer(buffer);
foreach (var packet in packets)
{
// 新线程处理业务内容
Task.Factory.StartNew(() => this.OnRecvPacket(packet));
}
}
/// <summary>
/// 解析连接请求信息
/// 如果数据未完整则返回null
/// </summary>
/// <param name="buffer">接收到的原始数量</param>
/// <param name="localEndpoint">服务器的本地终结点</param>
/// <param name="remoteEndpoint">远程端的IP和端口</param>
/// <exception cref="HttpException"></exception>
/// <returns></returns>
public static HttpRequest Parse(ReceiveBuffer buffer, IPEndPoint localEndpoint, IPEndPoint remoteEndpoint)
{
buffer.Position = 0;
var doubleCrlf = Encoding.ASCII.GetBytes("\r\n\r\n");
var headerIndex = buffer.IndexOf(doubleCrlf);
if (headerIndex < 0)
{
return null; // 数据未完整
}
var headerLength = headerIndex + doubleCrlf.Length;
var headerString = buffer.ReadString(headerLength, Encoding.ASCII);
const string pattern = @"^(?<method>[^\s]+)\s(?<path>[^\s]+)\sHTTP\/1\.1\r\n" +
@"((?<field_name>[^:\r\n]+):\s(?<field_value>[^\r\n]*)\r\n)+" +
@"\r\n";
var match = Regex.Match(headerString, pattern, RegexOptions.IgnoreCase);
if (match.Success == false)
{
throw new HttpException(400, "请求中有语法问题，或不能满足请求");
}
var httpMethod = GetHttpMethod(match.Groups["method"].Value);
var httpHeader = new HttpHeader(match.Groups["field_name"].Captures, match.Groups["field_value"].Captures);
var contentLength = httpHeader.TryGet<int>("Content-Length");
if (httpMethod == HttpMethod.POST && buffer.Length - headerLength < contentLength)
{
return null; // 数据未完整
}
var request = new HttpRequest
{
LocalEndPoint = localEndpoint,
RemoteEndPoint = remoteEndpoint,
HttpMethod = httpMethod,
Headers = httpHeader
};
request.Url = new Uri("http://localhost:" + localEndpoint.Port + match.Groups["path"].Value);
request.Path = request.Url.AbsolutePath;
request.Query = new HttpNameValueCollection(HttpUtility.UrlDecode(request.Url.Query.TrimStart('?')));
if (httpMethod == HttpMethod.GET)
{
request.InputStrem = new byte[0];
request.Form = new HttpNameValueCollection();
request.Files = new HttpFile[0];
}
else
{
request.InputStrem = buffer.ReadArray(contentLength);
buffer.Position = headerLength;
HttpRequest.GeneratePostFormAndFiles(request, buffer);
}
buffer.Clear(headerLength + contentLength);
return request;
}
/// <summary>
/// 生成表单和文件
/// </summary>
/// <param name="request"></param>
/// <param name="buffer"></param>
/// <param name="boundary">边界</param>
private static void GenerateMultipartFormAndFiles(HttpRequest request, ReceiveBuffer buffer, string boundary)
{
var doubleCrlf = Encoding.ASCII.GetBytes("\r\n\r\n");
var boundaryBytes = Encoding.ASCII.GetBytes("\r\n--" + boundary);
var maxPosition = buffer.Length - Encoding.ASCII.GetBytes("--\r\n").Length;
var files = new List<HttpFile>();
var form = new HttpNameValueCollection();
buffer.Position = buffer.Position + boundaryBytes.Length;
while (buffer.Position < maxPosition)
{
var headLength = buffer.IndexOf(doubleCrlf) + doubleCrlf.Length;
if (headLength < doubleCrlf.Length)
{
break;
}
var head = buffer.ReadString(headLength, Encoding.UTF8);
var bodyLength = buffer.IndexOf(boundaryBytes);
if (bodyLength < 0)
{
break;
}
var mHead = new MultipartHead(head);
if (mHead.IsFile == true)
{
var stream = buffer.ReadArray(bodyLength);
var file = new HttpFile(mHead, stream);
files.Add(file);
}
else
{
var value = HttpUtility.UrlDecode(buffer.ReadString(bodyLength, Encoding.UTF8));
form.Add(mHead.Name, value);
}
buffer.Position = buffer.Position + boundaryBytes.Length;
}
request.Form = form;
request.Files = files.ToArray();
}
/// <summary>
/// 生成Post得到的表单和文件
/// </summary>
/// <param name="request"></param>
/// <param name="buffer"></param>
private static void GeneratePostFormAndFiles(HttpRequest request, ReceiveBuffer buffer)
{
var boundary = default(string);
if (request.IsApplicationFormRequest() == true)
{
HttpRequest.GenerateApplicationForm(request);
}
else if (request.IsMultipartFormRequest(out boundary) == true)
{
if (request.InputStrem.Length >= boundary.Length)
{
HttpRequest.GenerateMultipartFormAndFiles(request, buffer, boundary);
}
}
if (request.Form == null)
{
request.Form = new HttpNameValueCollection();
}
if (request.Files == null)
{
request.Files = new HttpFile[0];
}
}
/// <summary>
/// 解析连接请求信息
/// </summary>
/// <param name="buffer">接收到的原始数量</param>
/// <param name="localEndpoint">服务器的本地终结点</param>
/// <param name="remoteEndpoint">远程端的IP和端口</param>
/// <returns></returns>
public static HttpRequest From(ReceiveBuffer buffer, IPEndPoint localEndpoint, IPEndPoint remoteEndpoint)
{
buffer.Position = 0;
var bytes = buffer.ReadArray();
var request = HttpRequest.From(bytes, localEndpoint, remoteEndpoint);
if (request != null)
{
buffer.Clear();
}
return request;
}
/// <summary>
/// 解析一个数据包
/// 不足一个封包时返回null
/// </summary>
/// <param name="buffer">接收到的历史数据</param>
/// <exception cref="ProtocolException"></exception>
/// <returns></returns>
public static FastPacket From(ReceiveBuffer buffer)
{
if (buffer.Length < 4)
{
return null;
}
buffer.Position = 0;
var totalBytes = buffer.ReadInt32();
const int packegMaxSize = 10 * 1204 * 1024; // 10M
if (totalBytes > packegMaxSize)
{
throw new ProtocolException();
}
// 少于15字节是异常数据，清除收到的所有数据
const int packetMinSize = 15;
if (totalBytes < packetMinSize)
{
throw new ProtocolException();
}
// 数据包未接收完整
if (buffer.Length < totalBytes)
{
return null;
}
// api名称数据长度
var apiNameLength = buffer.ReadByte();
if (totalBytes < apiNameLength + packetMinSize)
{
throw new ProtocolException();
}
// api名称数据
var apiNameBytes = buffer.ReadArray(apiNameLength);
// 标识符
var id = buffer.ReadInt64();
// 是否为客户端封包
var isFromClient = buffer.ReadBoolean();
// 是否异常
var isException = buffer.ReadBoolean();
// 实体数据
var body = buffer.ReadArray(totalBytes - buffer.Position);
// 清空本条数据
buffer.Clear(totalBytes);
var apiName = Encoding.UTF8.GetString(apiNameBytes);
var packet = new FastPacket(apiName, id, isFromClient)
{
TotalBytes = totalBytes,
ApiNameLength = apiNameLength,
IsException = isException,
Body = body
};
return packet;
}
/// <summary>
/// 解析请求的数据
/// 返回请求数据包
/// </summary>
/// <param name="buffer">所有收到的数据</param>
/// <returns></returns>
public static unsafe FrameRequest From(ReceiveBuffer buffer)
{
if (buffer.Length < 2)
{
return null;
}
ByteBits byte0 = buffer[0];
var fin = byte0[0];
var frameCode = (FrameCodes)(byte)byte0.Take(4, 4);
if (fin == false || frameCode == FrameCodes.Continuation)
{
return null;
}
var rsv = byte0.Take(1, 3);
ByteBits byte1 = buffer[1];
var mask = byte1[0];
if (mask == false || Enum.IsDefined(typeof(FrameCodes), frameCode) == false || rsv != 0)
{
return null;
}
var contentLength = (int)byte1.Take(1, 7);
buffer.Position = 2;
if (contentLength == 127)
{
contentLength = (int)buffer.ReadUInt64();
}
else if (contentLength == 126)
{
contentLength = (int)buffer.ReadUInt16();
}
var packetLength = 6 + contentLength;
if (buffer.Length < packetLength)
{
return null;
}
var maskingKey = buffer.ReadArray(4);
var content = buffer.ReadArray(contentLength);
buffer.Clear(packetLength);
if (contentLength > 0)
{
fixed (byte* pcontent = &content[0], pmask = &maskingKey[0])
{
for (var i = 0; i < contentLength; i++)
{
*(pcontent + i) = (byte)(*(pcontent + i) ^ *(pmask + i % 4));
}
}
}
return new FrameRequest
{
Fin = fin,
Rsv = rsv,
Mask = mask,
Frame = frameCode,
ContentLength = contentLength,
MaskingKey = maskingKey,
Content = content
};
}
/// <summary>
/// 解析连接请求信息
/// </summary>
/// <param name="buffer">接收到的原始数量</param>
/// <returns></returns>
public static HttpRequest From(ReceiveBuffer buffer)
{
buffer.Position = 0;
var bytes = buffer.ReadArray();
buffer.Clear();
return HttpRequest.From(bytes, "ws");
}
