private bool isCommand()
{
#if DOTNET2
Socket socket = new Net.UnionType { Value = receiveAsyncEventArgs.AsyncState }.Socket;
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.Buffer)
{
receiveDataStart = receiveDataFixed + ReceiveBuffer.StartIndex;
return loop(true);
}
#if DOTNET2
}
#endif
}
#if !DOTNET2
else socketError = receiveAsyncEventArgs.SocketError;
#endif
return false;
}
/// <summary>
/// 接收验证命令
/// </summary>
/// <returns></returns>
private bool isVerifyCommand()
{
#if DOTNET2
Socket socket = new Net.UnionType { Value = receiveAsyncEventArgs.AsyncState }.Socket;
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)
{
fixed (byte* receiveDataFixed = ReceiveBuffer.Buffer)
{
CommandIndex = (uint)(command = *(int*)(receiveDataStart = receiveDataFixed + ReceiveBuffer.StartIndex)) & TcpServer.Server.CommandFlagsAnd;
if ((command &= (int)TcpServer.Server.CommandIndexAnd) == Server.VerifyCommandIdentity)
{
if ((compressionDataSize = *(int*)(receiveDataStart + sizeof(int))) > 0)
{
int maxVerifyDataSize = Math.Min(Server.Attribute.MaxVerifyDataSize, receiveBufferSize - sizeof(int) * 2);
if (compressionDataSize <= maxVerifyDataSize)
{
int nextSize = compressionDataSize - (receiveCount - sizeof(int) * 2);
if (nextSize == 0)
{
if (doVerifyCommand()) return true;
}
else if (nextSize > 0 && isReceiveVerifyData()) return true;
if (!IsVerifyMethod) return false;
}
else
{
if (Server.Log.isAnyType(AutoCSer.Log.LogType.Debug)) Server.Log.add(AutoCSer.Log.LogType.Debug, "TCP 验证函数接收数据长度超限 " + compressionDataSize.toString() + " > " + maxVerifyDataSize.toString());
return false;
}
}
else return false;
}
if (Server.Log.isAnyType(AutoCSer.Log.LogType.Info))
{
#if !DOTNET2
Socket socket = Socket;
#endif
Server.Log.add(AutoCSer.Log.LogType.Info, socket == null ? "TCP 验证函数命令错误" : ("TCP 验证函数命令错误 " + socket.RemoteEndPoint.ToString()));
}
}
}
#if DOTNET2
}
#endif
}
#if !DOTNET2
else socketError = receiveAsyncEventArgs.SocketError;
#endif
return false;
}
/// <summary>
/// 接收验证命令
/// </summary>
/// <returns></returns>
private bool isVerifyCommand()
{
if (IsVerifyMethod)
{
receiveIndex = receiveCount = 0;
return isCommand();
}
#if DOTNET2
Socket socket = new Net.UnionType { Value = receiveAsyncEventArgs.AsyncState }.Socket;
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.Buffer)
{
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.IsAnyType(AutoCSer.Log.LogType.Info))
{
#if !DOTNET2
Socket socket = Socket;
#endif
Server.Log.Add(AutoCSer.Log.LogType.Info, socket == null ? "TCP 验证函数命令错误" : ("TCP 验证函数命令错误 " + socket.RemoteEndPoint.ToString()));
}
}
}
#if DOTNET2
}
#endif
}
#if !DOTNET2
else socketError = receiveAsyncEventArgs.SocketError;
#endif
return false;
}
/// <summary>
/// 获取数据
/// </summary>
private void dataAsync()
{
try
{
#if DOTNET2
Socket socket = new Net.UnionType { Value = receiveAsyncEventArgs.AsyncState }.Socket;
if (socket == Socket)
{
receiveCount += socket.EndReceive(receiveAsyncEventArgs, out socketError);
if (socketError == SocketError.Success)
{
#else
CHECK:
if (receiveAsyncEventArgs.SocketError == SocketError.Success)
{
receiveCount += receiveAsyncEventArgs.BytesTransferred;
#endif
if (compressionDataSize <= receiveCount - receiveIndex)
{
fixed (byte* receiveDataFixed = ReceiveBuffer.Buffer)
{
receiveDataStart = receiveDataFixed + ReceiveBuffer.StartIndex;
doCommandLoop();
if (loop(false)) return;
}
}
else
{
#if DOTNET2
if (socket == Socket)
{
socket.BeginReceive(ReceiveBuffer.Buffer, ReceiveBuffer.StartIndex + receiveCount, receiveBufferSize - receiveCount, SocketFlags.None, out socketError, onReceiveAsyncCallback, socket);
if (socketError == SocketError.Success) return;
}
#else
Socket socket = Socket;
if (socket != null)
{
receiveAsyncEventArgs.SetBuffer(ReceiveBuffer.StartIndex + receiveCount, receiveBufferSize - receiveCount);
if (socket.ReceiveAsync(receiveAsyncEventArgs)) return;
goto CHECK;
}
#endif
}
#if DOTNET2
}
#endif
}
#if !DOTNET2
else socketError = receiveAsyncEventArgs.SocketError;
#endif
}
catch (Exception error)
{
Server.Log.add(AutoCSer.Log.LogType.Debug, error);
}
close();
}
/// <summary>
/// 获取数据
/// </summary>
/// <returns></returns>
private bool bigDataAsync()
{
#if DOTNET2
if (!receiveAsyncEventArgs.CompletedSynchronously) Server.CancelReceiveVerifyCommandTimeout(this);
Socket socket = new Net.UnionType { Value = receiveAsyncEventArgs.AsyncState }.Socket;
if (socket == Socket)
{
int count = socket.EndReceive(receiveAsyncEventArgs, out socketError);
if (socketError == SocketError.Success)
{
#else
Server.CancelReceiveVerifyCommandTimeout(this);
CHECK:
if (receiveAsyncEventArgs.SocketError == SocketError.Success)
{
int count = receiveAsyncEventArgs.BytesTransferred;
#endif
int nextSize = compressionDataSize - (receiveBigBufferCount += count);
if (nextSize == 0)
{
ReceiveSizeLessCount = 0;
doCommandBig();
if (isReceiveCommand()) return true;
}
else if (count >= TcpServer.Server.MinSocketSize || (count > 0 && ReceiveSizeLessCount++ == 0))
{
#if DOTNET2
if (socket == Socket)
{
IAsyncResult async = socket.BeginReceive(ReceiveBigBuffer.Buffer, ReceiveBigBuffer.StartIndex + receiveBigBufferCount, nextSize, SocketFlags.None, out socketError, onReceiveAsyncCallback, socket);
if (socketError == SocketError.Success)
{
if (!async.CompletedSynchronously) Server.PushReceiveVerifyCommandTimeout(this, Socket);
return true;
}
}
#else
Socket socket = Socket;
if (socket != null)
{
receiveAsyncEventArgs.SetBuffer(ReceiveBigBuffer.Buffer, ReceiveBigBuffer.StartIndex + receiveBigBufferCount, nextSize);
if (socket.ReceiveAsync(receiveAsyncEventArgs))
{
Server.PushReceiveVerifyCommandTimeout(this, Socket);
return true;
}
goto CHECK;
}
#endif
}
#if DOTNET2
}
#endif
}
#if !DOTNET2
else socketError = receiveAsyncEventArgs.SocketError;
#endif
return false;
}
private bool isCommand()
{
#if DOTNET2
Socket socket = new Net.UnionType { Value = asyncEventArgs.AsyncState }.Socket;
if (socket == Socket)
{
receiveCount = socket.EndReceive(asyncEventArgs, out socketError);
if (socketError == SocketError.Success)
{
#else
if (asyncEventArgs.SocketError == SocketError.Success)
{
receiveCount = asyncEventArgs.BytesTransferred;
#endif
if (receiveCount >= sizeof(int))
{
fixed (byte* receiveDataFixed = Buffer.Buffer)
{
command = *(int*)(bufferStart = receiveDataFixed + Buffer.StartIndex);
int commandIndex = base.commandIndex;
if (Server.IsCommand(commandIndex))
{
if (commandIndex >= TcpServer.Server.CommandStartIndex)
{
if (((uint)command & (uint)TcpServer.CommandFlags.NullData) == 0)
{
if (receiveCount >= sizeof(int) * 2)
{
if ((compressionDataSize = *(int*)(bufferStart + sizeof(uint))) > 0)
{
dataSize = compressionDataSize;
receiveIndex = sizeof(int) + sizeof(uint);
return checkCommandData();
}
else if (compressionDataSize < 0 && receiveCount >= (sizeof(int) * 2 + sizeof(uint)))
{
if ((dataSize = *(int*)(bufferStart + (sizeof(uint) + sizeof(int)))) > (compressionDataSize = -compressionDataSize))
{
receiveIndex = sizeof(int) * 2 + sizeof(uint);
return checkCommandData();
}
}
}
}
else if (receiveCount == sizeof(int)) return Server.DoCommand(commandIndex, this, ref SubArray<byte>.Null);
}
else if (((commandIndex ^ TcpServer.Server.CheckCommandIndex) | (receiveCount ^ sizeof(int))) == 0) return Send(TcpServer.ReturnType.Success);
}
}
}
#if DOTNET2
}
#endif
}
#if !DOTNET2
else socketError = asyncEventArgs.SocketError;
#endif
return false;
}
/// <summary>
/// 接收表单数据处理
/// </summary>
/// <param name="sender"></param>
/// <param name="async">异步回调参数</param>
private void onReceive(object sender, SocketAsyncEventArgs async)
#endif
{
#if DOTNET2
try
{
if (!async.CompletedSynchronously)
{
Header.ReceiveTimeout.Cancel(httpSocket);
}
System.Net.Sockets.Socket socket = new Net.UnionType {
Value = async.AsyncState
}.Socket;
if (socket == httpSocket.Socket)
{
SocketError socketError;
int count = socket.EndReceive(async, out socketError);
if (count > 0 && socketError == SocketError.Success)
{
receiveEndIndex += count;
contentLength -= count;
if (onReceive())
{
return;
}
}
}
}
catch (Exception error)
{
httpSocket.DomainServer.RegisterServer.TcpServer.Log.Add(AutoCSer.Log.LogType.AutoCSer, error);
}
#else
try
{
Header.ReceiveTimeout.Cancel(httpSocket);
if (socketAsyncEventArgs.SocketError == SocketError.Success)
{
int count = socketAsyncEventArgs.BytesTransferred;
if (count > 0)
{
receiveEndIndex += count;
contentLength -= count;
if (onReceive())
{
return;
}
}
}
}
catch (Exception error)
{
httpSocket.DomainServer.RegisterServer.TcpServer.Log.Add(AutoCSer.Log.LogType.AutoCSer, error);
}
#endif
this.error();
}
/// <summary>
/// 获取数据
/// </summary>
private void compressionDataAsync()
{
try
{
#if DOTNET2
Socket socket = new Net.UnionType { Value = receiveAsyncEventArgs.AsyncState }.Socket;
if (socket == Socket)
{
receiveCount += socket.EndReceive(receiveAsyncEventArgs, out socketError);
if (socketError == SocketError.Success)
{
#else
CHECK:
if (receiveAsyncEventArgs.SocketError == SocketError.Success)
{
receiveCount += receiveAsyncEventArgs.BytesTransferred;
#endif
int nextSize = compressionDataSize - (receiveCount - receiveIndex);
if (nextSize == 0)
{
if (doCompressionCommand() && isReceiveCommand()) return;
}
else
{
#if DOTNET2
if (socket == Socket)
{
socket.BeginReceive(ReceiveBuffer.Buffer, ReceiveBuffer.StartIndex + receiveCount, nextSize, SocketFlags.None, out socketError, onReceiveAsyncCallback, socket);
if (socketError == SocketError.Success) return;
}
#else
Socket socket = Socket;
if (socket != null)
{
receiveAsyncEventArgs.SetBuffer(ReceiveBuffer.StartIndex + receiveCount, nextSize);
if (socket.ReceiveAsync(receiveAsyncEventArgs)) return;
goto CHECK;
}
#endif
}
#if DOTNET2
}
#endif
}
#if !DOTNET2
else socketError = receiveAsyncEventArgs.SocketError;
#endif
}
catch (Exception error)
{
Server.Log.add(AutoCSer.Log.LogType.Debug, error);
}
close();
}
/// <summary>
/// 数据接收完成后的回调委托
/// </summary>
/// <param name="sender"></param>
/// <param name="async">异步回调参数</param>
private void onReceive(object sender, SocketAsyncEventArgs async)
#endif
{
try
{
#if DOTNET2
Socket socket = new Net.UnionType { Value = async.AsyncState }.Socket;
if (socket == Socket)
{
int count = socket.EndReceive(async, out socketError);
if (socketError == SocketError.Success)
{
#else
if (receiveAsyncEventArgs.SocketError == SocketError.Success)
{
int count = receiveAsyncEventArgs.BytesTransferred;
#endif
if (count > 0)
{
++ReceiveCount;
switch (ReceiveType)
{
case TcpServer.ClientSocketReceiveType.CommandIdentity: if (dataSizeAsync(count)) return; break;
case TcpServer.ClientSocketReceiveType.Data: if (dataAsync(count)) return; break;
case TcpServer.ClientSocketReceiveType.BigData: if (bigDataAsync(count)) return; break;
case TcpServer.ClientSocketReceiveType.CompressionData: if (compressionDataAsync(count)) return; break;
case TcpServer.ClientSocketReceiveType.CompressionBigData: if (compressionBigDataAsync(count)) return; break;
}
}
#if DOTNET2
}
#endif
}
#if !DOTNET2
else socketError = receiveAsyncEventArgs.SocketError;
#endif
}
catch (Exception error)
{
Log.Add(AutoCSer.Log.LogType.Debug, error);
}
if (CheckCreateVersion())
{
//Console.WriteLine("... CreateNew ...");
close();
CreateNew();
}
else close();
freeCommandQueue();
}
/// <summary>
/// 数据接收完成后的回调委托
/// </summary>
/// <param name="sender"></param>
/// <param name="async">异步回调参数</param>
private void onReceive(object sender, SocketAsyncEventArgs async)
#endif
{
try
{
#if DOTNET2
Socket socket = new Net.UnionType { Value = async.AsyncState }.Socket;
if (socket == Socket)
{
int count = socket.EndReceive(async, out socketError);
if (socketError == SocketError.Success)
{
#else
if (receiveAsyncEventArgs.SocketError == SocketError.Success)
{
int count = receiveAsyncEventArgs.BytesTransferred;
#endif
if (count > 0)
{
++ReceiveCount;
switch (ReceiveType)
{
case TcpServer.ClientSocketReceiveType.CommandIdentity: if (commandIdentityAsync(count)) return; break;
case TcpServer.ClientSocketReceiveType.Data: if (dataAsync(count)) return; break;
case TcpServer.ClientSocketReceiveType.BigData: if (bigDataAsync(count)) return; break;
}
}
#if DOTNET2
}
#endif
}
}
catch (Exception error)
{
Log.Add(AutoCSer.Log.LogType.Debug, error);
}
if (CheckCreateVersion())
{
close();
CreateNew();
}
else
{
close();
if(CreateVersion == ClientCreator.CreateVersion) ClientCreator.CommandClient.SocketWait.Set();
}
}
/// <summary>
/// 数据接收完成后的回调委托
/// </summary>
/// <param name="sender"></param>
/// <param name="async">异步回调参数</param>
private unsafe void onReceive(object sender, SocketAsyncEventArgs async)
#endif
{
try
{
#if DOTNET2
Socket socket = new Net.UnionType {
Value = async.AsyncState
}.Socket;
if (socket == this.socket)
{
int count = socket.EndReceive(async, out socketError);
if (count >= 0 && socketError == SocketError.Success)
{
onReceive(count);
if (receive())
{
return;
}
}
}
#else
if (async.SocketError == SocketError.Success)
{
onReceive(async.BytesTransferred);
if (receive())
{
return;
}
}
#endif
}
catch (Exception error)
{
this.log.add(Log.LogType.Error, error);
}
if (isDisposed == 0)
{
start();
}
else
{
free();
}
}
/// <summary>
/// 获取验证数据
/// </summary>
/// <returns></returns>
private bool isVerifyData()
{
if (Date.NowTime.Now < receiveTimeout)
{
#if DOTNET2
Socket socket = new Net.UnionType { Value = receiveAsyncEventArgs.AsyncState }.Socket;
if (socket == Socket)
{
int count = socket.EndReceive(receiveAsyncEventArgs, out socketError);
if (socketError == SocketError.Success)
{
#else
if (receiveAsyncEventArgs.SocketError == SocketError.Success)
{
int count = receiveAsyncEventArgs.BytesTransferred;
#endif
int nextSize = compressionDataSize - ((receiveCount += count) - sizeof(int) * 2);
if (nextSize == 0)
{
ReceiveSizeLessCount = 0;
return doVerifyCommand();
}
return nextSize > 0 && (count >= TcpServer.Server.MinSocketSize || (count > 0 && ReceiveSizeLessCount++ == 0)) && isReceiveVerifyData();
#if DOTNET2
}
#endif
}
#if !DOTNET2
socketError = receiveAsyncEventArgs.SocketError;
#endif
}
else if (Server.Log.isAnyType(AutoCSer.Log.LogType.Info))
{
Socket socket = Socket;
Server.Log.add(AutoCSer.Log.LogType.Info, socket == null ? "TCP 验证数据接收超时" : ("TCP 验证数据接收超时 " + socket.RemoteEndPoint.ToString()));
}
return false;
}
/// <summary>
/// 获取数据
/// </summary>
private void bigDataAsync()
{
try
{
#if DOTNET2
Socket socket = new Net.UnionType { Value = receiveAsyncEventArgs.AsyncState }.Socket;
if (socket == Socket)
{
receiveBigBufferCount += socket.EndReceive(receiveAsyncEventArgs, out socketError);
if (socketError == SocketError.Success)
{
#else
CHECK:
if (receiveAsyncEventArgs.SocketError == SocketError.Success)
{
receiveBigBufferCount += receiveAsyncEventArgs.BytesTransferred;
#endif
int nextSize = compressionDataSize - receiveBigBufferCount;
if (nextSize == 0)
{
doCommandBig();
if (isReceiveCommand()) return;
}
else
{
#if DOTNET2
if (socket == Socket)
{
socket.BeginReceive(ReceiveBigBuffer.Buffer, ReceiveBigBuffer.StartIndex + receiveBigBufferCount, nextSize, SocketFlags.None, out socketError, onReceiveAsyncCallback, socket);
if (socketError == SocketError.Success) return;
}
#else
Socket socket = Socket;
if (socket != null)
{
#if !DotNetStandard
while (Interlocked.CompareExchange(ref receiveAsyncLock, 1, 0) != 0) Thread.Sleep(0);
#endif
receiveAsyncEventArgs.SetBuffer(ReceiveBigBuffer.Buffer, ReceiveBigBuffer.StartIndex + receiveBigBufferCount, nextSize);
if (socket.ReceiveAsync(receiveAsyncEventArgs))
{
#if !DotNetStandard
Interlocked.Exchange(ref receiveAsyncLock, 0);
#endif
return;
}
#if !DotNetStandard
Interlocked.Exchange(ref receiveAsyncLock, 0);
#endif
goto CHECK;
}
#endif
}
#if DOTNET2
}
#endif
}
#if !DOTNET2
else socketError = receiveAsyncEventArgs.SocketError;
#endif
}
catch (Exception error)
{
Server.Log.Add(AutoCSer.Log.LogType.Debug, error);
}
close();
}
/// <summary>
/// 数据接收完成后的处理
/// </summary>
/// <returns></returns>
private bool onReceive()
#endif
{
#if DOTNET2
System.Net.Sockets.Socket socket = new Net.UnionType { Value = async.AsyncState }.Socket;
if (socket == Socket)
{
SocketError socketError;
int count = socket.EndReceive(async, out socketError);
if (socketError == SocketError.Success)
{
#else
START:
if (receiveAsyncEventArgs.SocketError == SocketError.Success)
{
int count = receiveAsyncEventArgs.BytesTransferred;
#endif
Data.MoveStart(count);
if (Data.Length == 0)
{
ReceiveSizeLessCount = 0;
switch (ReceiveType)
{
case ReceiveType.Response:
if ((Header.ContentLength -= Buffer.Length) <= 0) return responseHeader();
Data.Set(Buffer.Buffer, Buffer.StartIndex, Math.Min(Header.ContentLength, Buffer.Length));
#if DOTNET2
if (socket == Socket)
{
async = socket.BeginReceive(Data.Array, Data.Start, Data.Length, SocketFlags.None, out socketError, onReceiveAsyncCallback, socket);
if (socketError == SocketError.Success)
{
if (!async.CompletedSynchronously) Http.Header.ReceiveTimeout.Push(this, socket);
return true;
}
}
return false;
#else
System.Net.Sockets.Socket socket = Socket;
if (socket == null) return false;
while (Interlocked.CompareExchange(ref ReceiveAsyncLock, 1, 0) != 0) Thread.Sleep(0);
receiveAsyncEventArgs.SetBuffer(Data.Array, Data.Start, Data.Length);
if (socket.ReceiveAsync(receiveAsyncEventArgs))
{
Http.Header.ReceiveTimeout.Push(this, socket);
Interlocked.Exchange(ref ReceiveAsyncLock, 0);
return true;
}
Interlocked.Exchange(ref ReceiveAsyncLock, 0);
goto START;
#endif
case ReceiveType.GetForm: return OnGetForm();
}
}
if ((count >= TcpServer.Server.MinSocketSize || (count > 0 && ReceiveSizeLessCount++ == 0)) && Date.NowTime.Now <= Timeout)
{
#if DOTNET2
if (socket == Socket)
{
async = socket.BeginReceive(Data.Array, Data.Start, Data.Length, SocketFlags.None, out socketError, onReceiveAsyncCallback, socket);
if (socketError == SocketError.Success)
{
if (!async.CompletedSynchronously) Http.Header.ReceiveTimeout.Push(this, socket);
return true;
}
}
#else
System.Net.Sockets.Socket socket = Socket;
if (socket == null) return false;
while (Interlocked.CompareExchange(ref ReceiveAsyncLock, 1, 0) != 0) Thread.Sleep(0);
receiveAsyncEventArgs.SetBuffer(Data.Start, Data.Length);
if (socket.ReceiveAsync(receiveAsyncEventArgs))
{
Http.Header.ReceiveTimeout.Push(this, socket);
Interlocked.Exchange(ref ReceiveAsyncLock, 0);
return true;
}
Interlocked.Exchange(ref ReceiveAsyncLock, 0);
goto START;
#endif
}
#if DOTNET2
}
#endif
}
return false;
}