/// <summary>
/// 数据发送完成后的处理
/// </summary>
/// <returns></returns>
private bool onSend()
#endif
{
#if DOTNET2
System.Net.Sockets.Socket socket = new Net.UnionType { Value = async.AsyncState }.Socket;
if (socket == Socket)
{
SocketError socketError;
int count = socket.EndSend(async, out socketError);
if (socketError == SocketError.Success)
{
#else
START:
if (sendAsyncEventArgs.SocketError == SocketError.Success)
{
int count = sendAsyncEventArgs.BytesTransferred;
System.Net.Sockets.Socket socket;
#endif
Data.MoveStart(count);
if (Data.Length == 0)
{
SendSizeLessCount = 0;
//isShutdown = true;
switch (SendType)
{
case SendType.Next:
if (receiveNext()) return true;
break;
case SendType.Body:
switch (HttpResponse.Type)
{
case ResponseType.ByteArray:
Data.Array = HttpResponse.Body.Array;
Data.SetFull();
goto SENDDATA;
case ResponseType.SubByteArray:
case ResponseType.SubBuffer:
Data = HttpResponse.Body;
SENDDATA:
#if DOTNET2
if (socket != Socket) return false;
#else
if ((socket = Socket) == null) return false;
#endif
SendType = SendType.Next;
Timeout = Config.GetTimeout(Data.Length);
#if DOTNET2
async = socket.BeginSend(Data.Array, Data.Start, Data.Length, SocketFlags.None, out socketError, onSendAsyncCallback, socket);
if (socketError == SocketError.Success)
{
if (!async.CompletedSynchronously) Http.Header.ReceiveTimeout.Push(this, socket);
return true;
}
break;
#else
while (Interlocked.CompareExchange(ref sendAsyncLock, 1, 0) != 0) Thread.Sleep(0);
sendAsyncEventArgs.SetBuffer(Data.Array, Data.Start, Data.Length);
if (socket.SendAsync(sendAsyncEventArgs))
{
Http.Header.ReceiveTimeout.Push(this, socket);
Interlocked.Exchange(ref sendAsyncLock, 0);
return true;
}
Interlocked.Exchange(ref sendAsyncLock, 0);
goto START;
#endif
case ResponseType.File:
SendFileStream = new FileStream(HttpResponse.BodyFile.FullName, FileMode.Open, FileAccess.Read, FileShare.Read, Http.Header.BufferPool.Size, FileOptions.SequentialScan);
if (HttpResponse.State == ResponseState.PartialContent206) SendFileStream.Seek(Header.RangeStart, SeekOrigin.Begin);
SendType = SendType.File;
Buffer.ToSubByteArray(ref Data);
Timeout = Config.GetTimeout(ResponseSize);
goto SENDFILE;
}
break;
case SendType.File:
SENDFILE:
#if DOTNET2
if (socket != Socket) return false;
#else
if ((socket = Socket) == null) return false;
#endif
Data.Set(Buffer.StartIndex, (int)Math.Min(ResponseSize, Buffer.Length));
if (SendFileStream.Read(Data.Array, Data.Start, Data.Length) == Data.Length)
{
if ((ResponseSize -= Data.Length) == 0) SendType = SendType.Next;
#if DOTNET2
async = socket.BeginSend(Data.Array, Data.Start, Data.Length, SocketFlags.None, out socketError, onSendAsyncCallback, socket);
if (socketError == SocketError.Success)
{
if (!async.CompletedSynchronously) Http.Header.ReceiveTimeout.Push(this, socket);
return true;
}
#else
while (Interlocked.CompareExchange(ref sendAsyncLock, 1, 0) != 0) Thread.Sleep(0);
sendAsyncEventArgs.SetBuffer(Data.Start, Data.Length);
if (socket.SendAsync(sendAsyncEventArgs))
{
Http.Header.ReceiveTimeout.Push(this, socket);
Interlocked.Exchange(ref sendAsyncLock, 0);
return true;
}
Interlocked.Exchange(ref sendAsyncLock, 0);
goto START;
#endif
}
break;
case SendType.GetForm:
if (getForm()) return true;
break;
}
}
else if ((count >= TcpServer.Server.MinSocketSize || (count > 0 && SendSizeLessCount++ == 0)) && Date.NowTime.Now <= Timeout)
{
#if DOTNET2
if (socket == Socket)
{
async = socket.BeginSend(Data.Array, Data.Start, Data.Length, SocketFlags.None, out socketError, onSendAsyncCallback, socket);
if (socketError == SocketError.Success)
{
if (!async.CompletedSynchronously) Http.Header.ReceiveTimeout.Push(this, socket);
return true;
}
}
#else
if ((socket = Socket) != null)
{
while (Interlocked.CompareExchange(ref sendAsyncLock, 1, 0) != 0) Thread.Sleep(0);
sendAsyncEventArgs.SetBuffer(Data.Start, Data.Length);
if (socket.SendAsync(sendAsyncEventArgs))
{
Http.Header.ReceiveTimeout.Push(this, socket);
Interlocked.Exchange(ref sendAsyncLock, 0);
return true;
}
Interlocked.Exchange(ref sendAsyncLock, 0);
goto START;
}
#endif
}
#if DOTNET2
}
#endif
}
return false;
}
/// <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;
}
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.CheckCommandIndex)
{
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) && commandIndex != TcpServer.Server.RemoteExpressionCommandIndex && commandIndex != TcpServer.Server.RemoteExpressionNodeIdCommandIndex)
{
return Server.DoCommand(commandIndex, this, ref SubArray<byte>.Null);
}
}
else if (receiveCount == sizeof(int)) 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 onSend(object sender, SocketAsyncEventArgs async)
#endif
{
//IsBuildOutputSynchronize = 0;
bool isOutput = false;
try
{
#if DOTNET2
Socket socket = new Net.UnionType { Value = async.AsyncState }.Socket;
if (socket == Socket)
{
SocketError socketError;
int count = socket.EndSend(async, out socketError);
if (socketError == SocketError.Success)
{
#else
if (sendAsyncEventArgs.SocketError == SocketError.Success)
{
int count = sendAsyncEventArgs.BytesTransferred;
#endif
sendData.MoveStart(count);
if (sendData.Length == 0)
{
sendSizeLessCount = 0;
freeCopyBuffer();
isOutput = true;
}
else if (count >= TcpServer.Server.MinSocketSize || (count > 0 && sendSizeLessCount++ == 0))
{
switch (send())
{
case SendState.Asynchronous: return;
case SendState.Synchronize: isOutput = true; break;
}
}
#if DOTNET2
}
#endif
}
}
catch (Exception error)
{
Server.Log.Add(AutoCSer.Log.LogType.Debug, error);
}
if (IsSocket)
{
if (isOutput)
{
if (Outputs.IsEmpty)
{
Interlocked.Exchange(ref IsOutput, 0);
//IsOutput = 0;
if (!Outputs.IsEmpty)
{
if (Interlocked.CompareExchange(ref IsOutput, 1, 0) == 0) BuildOutput();
}
else
{
if (!IsSocket && Interlocked.CompareExchange(ref IsOutput, 1, 0) == 0) close();
}
}
else BuildOutput();
}
else closeSocket();
}
else close();
}
/// <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)
{
if (isDoCommandBig() && 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>
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;
if (isDoCommandLoop() && 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)
{
#if !DotNetStandard
while (Interlocked.CompareExchange(ref receiveAsyncLock, 1, 0) != 0) Thread.Sleep(0);
#endif
receiveAsyncEventArgs.SetBuffer(ReceiveBuffer.StartIndex + receiveCount, receiveBufferSize - receiveCount);
if (socket.ReceiveAsync(receiveAsyncEventArgs))
{
#if !DotNetStandard
Interlocked.Exchange(ref receiveAsyncLock, 0);
#endif
return;
}
#if !DotNetStandard
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();
}
