| public ReceiveAsync ( SocketAsyncEventArgs e ) : bool | ||
| e | SocketAsyncEventArgs | |
| return | bool | |
public void Receive(object obj)
{
string received = "";
while (isok)
{
socketReceiveArgs = new SocketAsyncEventArgs();
socketReceiveArgs.SetBuffer(new byte[5120], 0, 5120);
socketReceiveArgs.Completed += SocketReceiveArgs_Completed;
try
{
done.Reset();
if (tcpc.ReceiveAsync(socketReceiveArgs))
{
done.WaitOne();
}
System.Threading.Thread.Sleep(50);
}
catch (Exception e)
{
}
}
}
public Client(Socket sock, ushort size)
{
try
{
Initialize();
Items[0].SetBuffer(new byte[size], 0, size);
_handle = sock;
_handle.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.KeepAlive, true);
_handle.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.NoDelay, true);
_handle.NoDelay = true;
BufferSize = size;
_endPoint = (IPEndPoint)_handle.RemoteEndPoint;
Connected = true;
if (!_handle.ReceiveAsync(Items[0]))
Process(null, Items[0]);
}
catch
{
Disconnect();
}
}
public IObservable<string> Receive(Socket connectedSocket, SocketAsyncEventArgs socketEventArgs, IScheduler scheduler, byte[] buffer)
{
if (connectedSocket == null)
throw new ArgumentNullException("connectedSocket");
if (socketEventArgs == null)
throw new ArgumentNullException("socketEventArgs");
return Observable.Create<string>(observer =>
{
var disposable = new CompositeDisposable();
var disposableEventSubscription = socketEventArgs.CompletedObservable().ObserveOn(scheduler).Subscribe(_ =>
{
SendNotificationToObserver(observer, socketEventArgs);
});
var disposableActions = scheduler.Schedule(() =>
{
socketEventArgs.SetBuffer(buffer, 0, buffer.Length);
if (!connectedSocket.ReceiveAsync(socketEventArgs))
{
SendNotificationToObserver(observer, socketEventArgs);
}
});
disposable.Add(disposableEventSubscription);
disposable.Add(disposableActions);
return disposable;
});
}
public System.Threading.Tasks.Task <ReceivedUdpData> ReceiveAsync()
{
ThrowIfDisposed();
var tcs = new TaskCompletionSource <ReceivedUdpData>();
var socketEventArg = new SocketAsyncEventArgs();
try
{
socketEventArg.RemoteEndPoint = new IPEndPoint(IPAddress.Any, 0);
socketEventArg.UserToken = tcs;
socketEventArg.SetBuffer(new Byte[SsdpConstants.DefaultUdpSocketBufferSize], 0, SsdpConstants.DefaultUdpSocketBufferSize);
socketEventArg.Completed += socketEventArg_ReceiveCompleted;
_Socket.ReceiveAsync(socketEventArg);
}
catch
{
socketEventArg.Dispose();
throw;
}
return(tcs.Task);
}
/// <summary>
/// 监听Socket接受处理
/// </summary>
/// <param name="e">SocketAsyncEventArg associated with the completed accept operation.</param>
private void ProcessAccept(SocketAsyncEventArgs e)
{
if (e.SocketError == SocketError.Success)
{
System.Net.Sockets.Socket s = e.AcceptSocket;//和客户端关联的socket
if (s.Connected)
{
try
{
Interlocked.Increment(ref _clientCount);//原子操作加1
SocketAsyncEventArgs asyniar = _objectPool.Pop();
asyniar.UserToken = s;
Clients.Add(e);
Sockets.Add(s);
LogInfo.SetText($"客户 {s.RemoteEndPoint.ToString()} 连入, 共有 {_clientCount} 个连接。");
if (!s.ReceiveAsync(asyniar))//投递接收请求
{
ProcessReceive(asyniar);
}
}
catch (SocketException ex)
{
LogInfo.SetText($"接收客户 {s.RemoteEndPoint} 数据出错, 异常信息： {ex.ToString()} 。");
//TODO 异常处理
}
//投递下一个接受请求
StartAccept(e);
}
}
}
public async void Receive(object obj)
{
//string received = "";
socketReceiveArgs = new SocketAsyncEventArgs();
socketReceiveArgs.SetBuffer(new byte[5120], 0, 5120);
socketReceiveArgs.Completed += SocketReceiveArgs_Completed;
while (isok)
{
try
{
if (reccomed)
{
if (tcpc.ReceiveAsync(socketReceiveArgs))
{
reccomed = false;
}
}
TimeSpan ts = DateTime.Now - timeout;
if (ts.TotalSeconds > mytimeout)
{
stop();
//isreceives = false;
timeoutevent();
return;
}
await System.Threading.Tasks.Task.Delay(100);
}
catch (Exception e)
{
}
}
}
public void ReceiveAsync()
{
if (!socket.ReceiveAsync(recvArgs))
{
ProcessReceive(recvArgs);
}
}
public void AsyncFrom(System.Net.Sockets.Socket socket, object useToken, int size)
{
this.IsReceive = true;
this.UserToken = useToken;
this.SetBuffer(BufferX.Memory);
var lastSocket = LastSocket;
LastSocket = socket;
if (!socket.ReceiveAsync(this))
{
if (lastSocket == socket)
{
LoopCount++;
}
else
{
LoopCount = 0;
}
if (LoopCount > 50)
{
LoopCount = 0;
Task.Run(() => { this.InvokeCompleted(); });
}
else
{
this.InvokeCompleted();
}
}
else
{
LastSocket = null;
LoopCount = 0;
}
}
async Task ReceiveLoop()
{
Exception exception = null;
try
{
while (true)
{
var buffer = writer.GetMemory();
var numberOfBytes = await socket.ReceiveAsync(buffer, SocketFlags.None);
if (numberOfBytes == 0)
{
break;
}
writer.Advance(numberOfBytes);
var result = await writer.FlushAsync();
if (result.IsCompleted)
{
break;
}
}
}
catch (Exception ex)
{
exception = ex;
}
writer.Complete(exception);
}
internal string ReceiveMessage()
{
if (isConnected)
{
aborted = false;
receiveWait.Reset();
SocketAsyncEventArgs args = new SocketAsyncEventArgs();
byte[] empBuf = new byte[8193];
args.SetBuffer(empBuf, 0, 8192);
//args.UserToken = socket;
args.RemoteEndPoint = endPoint;
args.Completed += OnReceive;
socket.ReceiveAsync(args);
receiveWait.WaitOne();
if (aborted == false)
{
return(Encoding.UTF8.GetString(args.Buffer, args.Offset, args.BytesTransferred));
}
else
{
return("ABORT");
}
}
else
{
throw new SocketException(Convert.ToInt32(SocketError.NotConnected));
}
}
private void Socket_Completed_Receive(object sender, SocketAsyncEventArgs e)
{
System.Net.Sockets.Socket socket = null;
try
{
e.Completed -= this.Socket_Completed_Receive;
socket = ((System.Net.Sockets.Socket)sender);
if (e.SocketError == SocketError.Success)
{
var buffer = (byte[])e.Buffer;
var socketArgs = new SocketAsyncEventArgs();
socketArgs.RemoteEndPoint = e.RemoteEndPoint;
socketArgs.SetBuffer(buffer, 0, buffer.Length);
try
{
socketArgs.Completed += Socket_Completed_ProcessResult;
//Sometimes ReceiveAsync doesn't receive any data (UDP packet loss?)
//which can leave us in a hung state. Setup a 1 second timer
//here to close the socket, which will cancel the request
//and raise the completed event with an OperationAbandoned
//error code if we haven't already completed.
#if SUPPORTS_TASKDELAY
var waitTask = System.Threading.Tasks.Task.Delay(1000);
#else
var waitTask = TaskEx.Delay(1000);
#endif
waitTask.ContinueWith(
(pt) =>
{
var receiveComplete = (bool)(socketArgs.UserToken ?? false);
if (!receiveComplete)
{
socket?.Dispose();
}
}
);
if (!socket.ReceiveAsync(socketArgs))
{
Socket_Completed_ProcessResult(socket, socketArgs);
}
}
catch
{
socketArgs.Completed -= this.Socket_Completed_ProcessResult;
throw;
}
}
else
{
throw NtpNetworkExceptionFromSocketArgs(e);
}
}
catch (Exception ex)
{
OnErrorOccurredAndDisposeSocket(ex, socket);
}
}
public Client(Socket socket)
{
this.socket = socket;
SocketAsyncEventArgs args = new SocketAsyncEventArgs();
args.Completed += RecieveComplete;
args.SetBuffer(new byte[4000], 0, 4000);
socket.ReceiveAsync(args);
}
public void Connect()
{
_clientSocket.Connect(_hostEndPoint);
Connected.RaiseEvent(this, EventArgs.Empty);
SocketAsyncEventArgs readEventArgs = new SocketAsyncEventArgs();
readEventArgs.Completed += new EventHandler <SocketAsyncEventArgs>(IO_Completed);
readEventArgs.SetBuffer(new byte[_bufferSize], 0, _bufferSize);
// As soon as the client is connected, post a receive to the connection
bool willRaiseEvent = _clientSocket.ReceiveAsync(readEventArgs);
if (!willRaiseEvent)
{
ProcessReceive(readEventArgs);
}
}
private void receive(Socket socket)
{
if (!checkSocketConnect(socket))
return;
var client = dic_client[socket];
client.context_head.SetBuffer(new byte[packageHeadLen], 0, packageHeadLen);
socket.ReceiveAsync(client.context_head);
}
//接收到客户端的数据事件
private void process_receive(SocketAsyncEventArgs e)
{
// check if the remote host closed the connection
if (e.SocketError == SocketError.Success && e.BytesTransferred > 0)
{
AsyncUserToken token = e.UserToken as AsyncUserToken;
System.Net.Sockets.Socket socket = token.Socket;
//放入对应的robot的queue中
int socketId = m_robotSystem.get_socketToRobotMap()[socket];
Robot robot = m_robotSystem.get_robots()[socketId];
byte[] data = new byte[e.BytesTransferred];
Array.Copy(e.Buffer, e.Offset, data, 0, data.Length);
lock (token.Buffer)
{
token.Buffer.AddRange(data);
}
do// (packedDataOffset < e.BytesTransferred)
{
byte[] lengthByte = token.Buffer.GetRange(0, 4).ToArray();
int length = BitConverter.ToInt32(lengthByte, 0);
if (length > token.Buffer.Count - 4)
{
break;
}
byte[] msgData = token.Buffer.GetRange(4, length).ToArray();
lock (token.Buffer)
{
token.Buffer.RemoveRange(0, length + 4);
}
//放入对应的robot的queue中
NetworkMsg netMsg = PBSerializer.deserialize <NetworkMsg>(msgData);
robot.m_clientSocket.dump_receive_queue(netMsg);
} while (token.Buffer.Count > 4);
Interlocked.Add(ref m_totalBytesRead, e.BytesTransferred);
if (!socket.ReceiveAsync(e))
{
process_receive(e);
}
}
else
{
close_clientSocket(e);
}
}
/// <summary>
/// Helper, assign a new set of receive args.
/// </summary>
protected bool AssignAsyncReceiveArgs(bool releaseExisting)
{
#if Matrix_Diagnostics
InstanceMonitor monitor = Monitor;
if (monitor != null && monitor.IsReportAllowed)
{
monitor.Info(string.Format("AssignAsyncReceiveArgs, release existing [{0}].", releaseExisting));
}
#endif
System.Net.Sockets.Socket socket = _socket;
if (socket == null)
{
return(false);
}
if (releaseExisting)
{
ReleaseAsyncReceiveArgs();
}
SocketAsyncEventArgs args;
lock (_syncRoot)
{
if (_lastReceiveArgs != null)
{
_lastReceiveArgs.Dispose();
_lastReceiveArgs = null;
#if Matrix_Diagnostics
Monitor.Fatal("Assign async receive args logic error.");
#endif
return(false);
}
_lastReceiveArgs = new SocketAsyncEventArgs();
_lastReceiveArgs.Completed += new EventHandler <SocketAsyncEventArgs>(SocketAsyncEventArgs_Received);
_lastReceiveArgs.SetBuffer(_receiveBuffer, 0, _receiveBuffer.Length);
args = _lastReceiveArgs;
}
if (socket.ReceiveAsync(args) == false)
{
if (args.SocketError == SocketError.Success)
{
SocketAsyncEventArgs_Received(socket, args);
}
else
{
ReleaseAsyncReceiveArgs();
return(false);
}
}
return(true);
}
public void connect()
{
m_socket.ConnectAsync(m_connectEventArg);//Begins an asynchronous request for a connection to a remote host.
m_autoConnectSignal.WaitOne();
Log.ASSERT("connect failed!", m_connectEventArg.SocketError == SocketError.Success);
if (!m_socket.ReceiveAsync(m_receiveEventArg))
{
process_receive(m_receiveEventArg);
}
}
public ClientWorker(Socket client)
{
_client = client;
eventArgs = new SocketAsyncEventArgs();
buffer = new byte[1024 * 1024];//1Mb
eventArgs.SetBuffer(buffer, 0, buffer.Length);
eventArgs.Completed += eventArgsCompleted;
_client.ReceiveAsync(eventArgs);
IP = client.RemoteEndPoint.ToString();
}
public void Connect()
{
if (_disposed)
{
throw new ObjectDisposedException($"Can't connect because SocketClient is disposed.");
}
_clientSocket.Connect(_hostEndPoint);
Connected.RaiseEvent(this, EventArgs.Empty);
_readEventArgs.Completed += new EventHandler <SocketAsyncEventArgs>(IO_Completed);
_readEventArgs.SetBuffer(new byte[_bufferSize], 0, _bufferSize);
// As soon as the client is connected, post a receive to the connection
bool willRaiseEvent = _clientSocket.ReceiveAsync(_readEventArgs);
if (!willRaiseEvent)
{
ProcessReceive(_readEventArgs);
}
}
public string ReadMessage(Socket socket)
{
message = string.Empty;
socketEventArgs = new SocketAsyncEventArgs();
socketEventArgs.RemoteEndPoint = socket.RemoteEndPoint;
socketEventArgs.SetBuffer(new Byte[2048], 0, 2048);
socketEventArgs.Completed += OnReadCompleted;
clientDone.Reset();
socket.ReceiveAsync(socketEventArgs);
clientDone.WaitOne();
return message;
}
public void Initialize(SystemSocket acceptSocket)
{
socket = acceptSocket;
socketEventProvider = SocketEventProvider.Create(this);
DoAsync(OnConnected);
bool willRaiseEvent = socket.ReceiveAsync(socketEventProvider.ReceiveEvent);
if (willRaiseEvent == false)
{
socketEventProvider.ProcessReceive(socketEventProvider.ReceiveEvent);
}
}
/// <summary>
/// Start the session's receive events.
/// </summary>
void ISetupSocketSession.Start()
{
if (CurrentState != State.Connecting)
{
return;
}
CurrentState = State.Connected;
ConnectedTime = DateTime.UtcNow;
// Start receiving data.
_socket.ReceiveAsync(_receiveArgs);
OnConnected();
}
public bool Receive()
{
try
{
if (iReceive == null) { return false; }
if (!ClientSocket.ReceiveAsync(iReceive))
{
iReceive_Completed(null, iReceive);
}
return true;
}
catch (Exception ex) { Close(952, "ReceiveAsync: " + ex.Message); return false; }
}
public TunnelClient(Socket client)
{
Client = client;
SendArgs = TunnelServer.Instance.PopArgs();
ReceiveArgs = TunnelServer.Instance.PopArgs();
SendArgs.Completed += Send_Completed;
ReceiveArgs.Completed += Receive_Completed;
ReceiveArgs.SetBuffer(new byte[1500], 0, 1500);
if (!Client.ReceiveAsync(ReceiveArgs))
{
Receive_Completed(Client, ReceiveArgs);
}
}
async Task ReadAsync(Socket s)
{
// Reusable SocketAsyncEventArgs and awaitable wrapper
var args = new SocketAsyncEventArgs();
args.SetBuffer(new byte[0x100000], 0, 0x100000);
var awaitable = new SocketAwaitable(args);
while (true)
{
await s.ReceiveAsync(awaitable);
int bytesRead = args.BytesTransferred;
if (bytesRead <= 0) throw new Exception("Raw socket is disconnected");
var ipPacket = new IPv4Packet(new ByteArraySegment(args.Buffer, 0, bytesRead));
if (ipPacket.Version != IpVersion.IPv4 || ipPacket.Protocol!=IPProtocolType.TCP)
continue;
OnPacketReceived(ipPacket);
}
}
//internal Socket (AddressFamily family, SocketType type, ProtocolType proto, IntPtr sock)
static bool EnsureSocket ()
{
lock (_lock) {
if (nl_sock != null)
return true;
IntPtr fd = CreateNLSocket ();
if (fd.ToInt64 () == -1)
return false;
nl_sock = new Socket (0, SocketType.Raw, ProtocolType.Udp, fd);
nl_args = new SocketAsyncEventArgs ();
nl_args.SetBuffer (new byte [8192], 0, 8192);
nl_args.Completed += OnDataAvailable;
nl_sock.ReceiveAsync (nl_args);
}
return true;
}
/// <summary>
/// 获取请求表单数据
/// </summary>
/// <returns></returns>
private bool getForm()
{
switch (Header.PostType)
{
case PostType.Json:
case PostType.Form:
case PostType.Xml:
case PostType.Data:
FormBuffer = GetBuffer(Header.ContentLength + 1);
Data.Set(FormBuffer.Buffer, FormBuffer.StartIndex, FormBufferReceiveEndIndex = Header.ContentLength);
Header.CopyToForm(ref Data);
if (Data.Length == 0) return OnGetForm();
System.Net.Sockets.Socket socket = Socket;
if (socket == null) return false;
ReceiveType = ReceiveType.GetForm;
Timeout = Config.GetTimeout(Data.Length);
#if DOTNET2
SocketError socketError;
IAsyncResult 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
receiveAsyncEventArgs.SocketError = SocketError.Success;
ReceiveAsyncLock.EnterSleepFlag();
receiveAsyncEventArgs.SetBuffer(Data.Array, Data.Start, Data.Length);
if (socket.ReceiveAsync(receiveAsyncEventArgs))
{
ReceiveAsyncLock.SleepFlag = 0;
Http.Header.ReceiveTimeout.Push(this, socket);
ReceiveAsyncLock.Exit();
return true;
}
ReceiveAsyncLock.ExitSleepFlag();
return onReceive();
#endif
case PostType.FormData:
if (boundaryReceiver == null) boundaryReceiver = new SocketBoundaryReceiver(this);
boundaryReceiver.Receive();
return true;
default: return false;
}
}
public SocksClient(short id, Socket client)
{
ID = id;
Client = client;
SendArgs = SocksServer.Instance.PopArgs();
ReceiveArgs = SocksServer.Instance.PopArgs();
SendArgs.Completed += Send_Completed;
ReceiveArgs.Completed += Receive_Completed;
ReceiveArgs.SetBuffer(new byte[16384], 0, 16384);
if (!Client.ReceiveAsync(ReceiveArgs))
{
Receive_Completed(Client, ReceiveArgs);
}
}
/// <summary>
/// 开始接收表单数据
/// </summary>
/// <returns></returns>
private bool receive()
{
System.Net.Sockets.Socket socket = this.httpSocket.Socket;
if (socket != null)
{
#if DOTNET2
SocketError socketError;
IAsyncResult async = socket.BeginReceive(buffer.Buffer, buffer.StartIndex + receiveEndIndex, Math.Min(bufferSize - receiveEndIndex, contentLength), SocketFlags.None, out socketError, onReceiveAsyncCallback, socket);
if (socketError == SocketError.Success)
{
if (!async.CompletedSynchronously)
{
Header.ReceiveTimeout.Push(this.httpSocket, socket);
}
return(true);
}
#else
while (Interlocked.CompareExchange(ref httpSocket.ReceiveAsyncLock, 1, 0) != 0)
{
Thread.Sleep(0);
}
socketAsyncEventArgs.SetBuffer(buffer.StartIndex + receiveEndIndex, Math.Min(bufferSize - receiveEndIndex, contentLength));
if (socket.ReceiveAsync(socketAsyncEventArgs))
{
Header.ReceiveTimeout.Push(this.httpSocket, socket);
Interlocked.Exchange(ref httpSocket.ReceiveAsyncLock, 0);
return(true);
}
Interlocked.Exchange(ref httpSocket.ReceiveAsyncLock, 0);
#endif
#if !DOTNET2
if (socketAsyncEventArgs.SocketError == SocketError.Success)
{
int count = socketAsyncEventArgs.BytesTransferred;
if (count > 0)
{
receiveEndIndex += count;
contentLength -= count;
return(onReceive());
}
}
#endif
}
return(false);
}
private void ResumeReceive()
{
if (_tcpSock != null && _tcpSock.Connected)
{
SocketAsyncEventArgs socketArgs = SocketHelpers.AcquireSocketArg();
//int offset = _offset + _remainingLength;
socketArgs.SetBuffer(recvDataBuffer.Data, recvDataBuffer.Postion, BufferSize - _remainingLength);
socketArgs.UserToken = this;
socketArgs.Completed += ReceiveAsyncComplete;
bool willRaiseEvent = _tcpSock.ReceiveAsync(socketArgs);
if (!willRaiseEvent)
{
ProcessRecieve(socketArgs);
}
}
}
public Connection(Socket socket)
{
this.socket = socket;
RemoteEndPoint = (IPEndPoint)socket.RemoteEndPoint;
SocketAsyncEventArgs e = new SocketAsyncEventArgs();
e.SetBuffer(new byte[1000], 0, 1000);
e.DisconnectReuseSocket = true;
e.Completed += new EventHandler<SocketAsyncEventArgs>(OnMessageReceived);
Console.WriteLine("Connected to " + RemoteEndPoint.Address.ToString());
if (!socket.ReceiveAsync(e))
{
Disconnect();
}
}
protected virtual void StartReceive(Mysocket.Socket socket, SocketAsyncEventArgs e)
{
bool raiseEvent = false;
try
{
raiseEvent = socket.ReceiveAsync(e);
}
catch (Exception exc)
{
OnException(new Exception(exc.Message, exc));
return;
}
if (!raiseEvent)
{
ProcessReceive(e);
}
}
public string ReadMessage(Socket socket)
{
string message = string.Empty;
socketEventArgs = new SocketAsyncEventArgs();
socketEventArgs.RemoteEndPoint = socket.RemoteEndPoint;
socketEventArgs.SetBuffer(new Byte[2048], 0, 2048);
socketEventArgs.Completed += new EventHandler<SocketAsyncEventArgs>(
delegate(object sender, SocketAsyncEventArgs e)
{
if (e.SocketError == SocketError.Success)
{
message = Encoding.Unicode.GetString(e.Buffer, e.Offset, e.BytesTransferred);
message = message.Trim('\0');
}
clientDone.Set();
});
clientDone.Reset();
socket.ReceiveAsync(socketEventArgs);
clientDone.WaitOne(5000);
return message;
}
public async Task <byte[]> ReceiveAsync(int size)
{
var totalReceivedBytes = 0;
var data = new byte[size];
var validData = new byte[size];
while (totalReceivedBytes < size)
{
var receivedBytes = await _socket.ReceiveAsync(data, SocketFlags.None);
Buffer.BlockCopy(data, totalReceivedBytes, validData, totalReceivedBytes, receivedBytes);
if (receivedBytes == 0)
{
throw new SocketException();
}
totalReceivedBytes += receivedBytes;
}
return(data);
}
public Client(Socket sock, ushort size)
{
try
{
Initialize();
Items[0].SetBuffer(new byte[size], 0, size);
Handle = sock;
Size = size;
_EndPoint = (IPEndPoint)Handle.RemoteEndPoint;
_Connection = true;
if (!Handle.ReceiveAsync(Items[0]))
Process(null, Items[0]);
}
catch
{
Disconnect();
}
}
/// <summary>
///接收完成时处理函数
/// </summary>
/// <param name="e">与接收完成操作相关联的SocketAsyncEventArg对象</param>
private void ProcessReceive(SocketAsyncEventArgs e)
{
if (e.SocketError == SocketError.Success)//if (e.BytesTransferred > 0 && e.SocketError == SocketError.Success)
{
// 检查远程主机是否关闭连接
if (e.BytesTransferred > 0)
{
System.Net.Sockets.Socket s = (System.Net.Sockets.Socket)e.UserToken;
//判断所有需接收的数据是否已经完成
if (s.Available == 0)
{
byte[] data = new byte[e.BytesTransferred];
Array.Copy(e.Buffer, e.Offset, data, 0, data.Length);//从e.Buffer块中复制数据出来，保证它可重用
string info = Encoding.Default.GetString(data);
//LogInfo.SetText(String.Format("收到 {0} 数据为 {1}", s.RemoteEndPoint.ToString(), info));
//TODO 处理数据
OnReadClientMessage?.Invoke(this, info);
OnReadClientBytes?.Invoke(this, data);
//iRecCount++;
//string sendmsg = DateTime.Now.ToString() + " Rec " + info + " RecCounts " + iRecCount.ToString();
//byte[] senddata = Encoding.Default.GetBytes(sendmsg);
//Send(s, senddata, 0, senddata.Count(), 100); //同步发送
////增加服务器接收的总字节数。
}
if (!s.ReceiveAsync(e))//为接收下一段数据，投递接收请求，这个函数有可能同步完成，这时返回false，并且不会引发SocketAsyncEventArgs.Completed事件
{
//同步接收时处理接收完成事件
ProcessReceive(e);
}
}
}
else
{
CloseClientSocket(e);
}
}
public System.Threading.Tasks.Task <ReceivedUdpData> ReceiveAsync()
{
ThrowIfDisposed();
var tcs = new TaskCompletionSource <ReceivedUdpData>();
var socketEventArg = new SocketAsyncEventArgs();
try
{
try
{
socketEventArg.RemoteEndPoint = new IPEndPoint(IPAddress.Any, 0);
socketEventArg.UserToken = tcs;
socketEventArg.SetBuffer(new Byte[SsdpConstants.DefaultUdpSocketBufferSize], 0, SsdpConstants.DefaultUdpSocketBufferSize);
socketEventArg.Completed += socketEventArg_ReceiveCompleted;
_Socket.ReceiveAsync(socketEventArg);
}
catch
{
socketEventArg.Dispose();
throw;
}
}
catch (SocketException se)
{
if (se.SocketErrorCode == SocketError.Shutdown || se.SocketErrorCode == SocketError.OperationAborted || se.SocketErrorCode == SocketError.NotConnected)
{
throw new SocketClosedException(se.Message, se);
}
throw;
}
return(tcs.Task);
}
private Socket SendingSocketCreator(IPEndPoint target)
{
var s = new Socket(target.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
try
{
s.Connect(target);
// Prep the socket so it will reset on close and won't Nagle
s.LingerState = new LingerOption(true, 0);
s.NoDelay = true;
WriteConnectionPreamble(s, Constants.SiloDirectConnectionId); // Identifies this client as a direct silo-to-silo socket
// Start an asynch receive off of the socket to detect closure
var receiveAsyncEventArgs = new SocketAsyncEventArgs
{
BufferList = new List<ArraySegment<byte>> { new ArraySegment<byte>(new byte[4]) },
UserToken = new Tuple<Socket, IPEndPoint, SocketManager>(s, target, this)
};
receiveAsyncEventArgs.Completed += ReceiveCallback;
bool receiveCompleted = s.ReceiveAsync(receiveAsyncEventArgs);
NetworkingStatisticsGroup.OnOpenedSendingSocket();
if (!receiveCompleted)
{
ReceiveCallback(this, receiveAsyncEventArgs);
}
}
catch (Exception)
{
try
{
s.Dispose();
}
catch (Exception)
{
// ignore
}
throw;
}
return s;
}
/// <summary>
/// 비동기 패킷 수신을 시작한다.
/// </summary>
/// <param name="clientSocket"></param>
/// <param name="receiveArgs"></param>
/// <param name="sendArgs"></param>
protected void BeginReceive(System.Net.Sockets.Socket clientSocket, SocketAsyncEventArgs receiveArgs, SocketAsyncEventArgs sendArgs)
{
// receive_args, send_args 아무곳에서나 꺼내와도 됨. 둘 다 동일한 clientSession 물고 있음
ClientSession clientSession = receiveArgs.UserToken as ClientSession;
clientSession.SetEventArgs(receiveArgs, sendArgs);
// 생성된 클라이언트 소켓을 보관해 놓고 통신할 때 사용함
clientSession.Socket = clientSocket;
clientSession.SetKeepAlive(_keepAliveTime, _keepAliveInterval);
// 데이터를 받을 수 있도록 소켓 메소드를 호출해준다.
// 비동기로 수신할 경우 워커 스레드에서 대기중으로 있다가 Completed에 설정해놓은 메소드가 호출된다.
// 동기로 완료될 경우에는 직접 완료 메소드를 호출해줘야 한다.
bool pending = clientSocket.ReceiveAsync(receiveArgs);
if (pending == false)
{
ProcessReceive(receiveArgs);
}
}
public void AsyncFrom(System.Net.Sockets.Socket socket, object useToken, int size)
{
this.IsReceive = true;
this.UserToken = useToken;
#if (NETSTANDARD2_0)
this.SetBuffer(BufferX.Data, 0, size);
#else
this.SetBuffer(BufferX.Memory);
#endif
var lastSocket = LastSocket;
LastSocket = socket;
if (!socket.ReceiveAsync(this))///to call => base.Completed <see cref="SocketAsyncEventArgs.Completed"/>
{
if (lastSocket == socket)
{
LoopCount++;
}
else
{
LoopCount = 0;
}
if (LoopCount > 50)
{
LoopCount = 0;
Task.Run(() => { this.InvokeCompleted(); });
}
else
{
this.InvokeCompleted();
}
}
else
{
LastSocket = null;
LoopCount = 0;
}
}
private void BeginReceive()
{
try
{
if (!mSocket.ReceiveAsync(mReceiveSAEA))
{
ReceiveCompleted(this, mReceiveSAEA);
}
}
catch (SocketException se)
{
ReleaseSocket();
OnError(se);
}
catch (ObjectDisposedException ode)
{
ReleaseSocket();
OnError(ode);
}
catch (Exception e_)
{
OnError(e_);
}
}
public Connection(Socket socket)
{
this.socket = socket;
RemoteEndPoint = (IPEndPoint)socket.RemoteEndPoint;
pollTimer = new Timer();
pollTimer.Elapsed += new ElapsedEventHandler(pollTimer_Elapsed);
pollTimer.Interval = 1000 * 60;
pollTimer.Start();
SocketAsyncEventArgs e = new SocketAsyncEventArgs();
e.SetBuffer(new byte[1000], 0, 1000);
e.DisconnectReuseSocket = true;
e.Completed += new EventHandler<SocketAsyncEventArgs>(OnMessageReceived);
Console.WriteLine("Connected to " + RemoteEndPoint.Address.ToString());
if (!socket.ReceiveAsync(e))
{
Disconnect();
Console.WriteLine("Couldn't start receiving data for " + RemoteEndPoint.Address.ToString());
}
}
public void ReceiveAsync_NullBuffer ()
{
using (Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)) {
SocketAsyncEventArgs saea = new SocketAsyncEventArgs ();
saea.SetBuffer (null, 0, 0);
s.ReceiveAsync (null);
}
}
public void ReceiveAsync_Default ()
{
using (Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)) {
SocketAsyncEventArgs saea = new SocketAsyncEventArgs ();
s.ReceiveAsync (saea);
}
}
public void ReceiveAsync_Null ()
{
using (Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)) {
s.ReceiveAsync (null);
}
}
static Stream GetPolicyStream (IPEndPoint endpoint)
{
MemoryStream ms = new MemoryStream ();
ManualResetEvent mre = new ManualResetEvent (false);
// Silverlight only support TCP
Socket socket = new Socket (endpoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
// Application code can't connect to port 943, so we need a special/internal API/ctor to allow this
SocketAsyncEventArgs saea = new SocketAsyncEventArgs (true);
saea.RemoteEndPoint = new IPEndPoint (endpoint.Address, PolicyPort);
saea.Completed += delegate (object sender, SocketAsyncEventArgs e) {
if (e.SocketError != SocketError.Success) {
mre.Set ();
return;
}
switch (e.LastOperation) {
case SocketAsyncOperation.Connect:
e.SetBuffer (socket_policy_file_request, 0, socket_policy_file_request.Length);
socket.SendAsync (e);
break;
case SocketAsyncOperation.Send:
byte [] buffer = new byte [256];
e.SetBuffer (buffer, 0, buffer.Length);
socket.ReceiveAsync (e);
break;
case SocketAsyncOperation.Receive:
int transfer = e.BytesTransferred;
if (transfer > 0) {
ms.Write (e.Buffer, 0, transfer);
// Console.Write (Encoding.UTF8.GetString (e.Buffer, 0, transfer));
}
if ((transfer == 0) || (transfer < e.Buffer.Length)) {
ms.Position = 0;
mre.Set ();
} else {
socket.ReceiveAsync (e);
}
break;
}
};
socket.ConnectAsync (saea);
// behave like there's no policy (no socket access) if we timeout
if (!mre.WaitOne (Timeout))
return null;
return ms;
}
/// <summary>
/// Assign a new socket & client to this context.
/// </summary>
/// <param name="socket">Socket that connected</param>
/// <param name="client">Your own class dealing with this particular client.</param>
public void Assign(Socket socket, INetworkService client)
{
if (socket == null) throw new ArgumentNullException("socket");
if (client == null) throw new ArgumentNullException("client");
_socket = socket;
_client = client;
_client.Assign(this);
_writer.Assign(socket);
var ep = (IPEndPoint) _socket.RemoteEndPoint;
_remoteEndPoint = new IPEndPoint(ep.Address, ep.Port);
var willRaiseEvent = _socket.ReceiveAsync(_readArgs);
if (!willRaiseEvent)
OnReadCompleted(_socket, _readArgs);
}
// Start wating data for specified socket
private void BeginReceiveAsync(Socket sock, SocketAsyncEventArgs e)
{
if (!sock.ReceiveAsync(e))
{
// IO operation finished synchronously
// Lets call data handler manually
ReceiveCompleted(sock, e);
}
}
/// <summary>
/// 输出 HTTP 响应数据
/// </summary>
/// <param name="response">HTTP 响应数据</param>
private void response(ref Response response)
{
bool isHeaderError = false;
try
{
CheckNotChanged304(ref response);
if (Header.Method == MethodType.POST && (Flag & SocketFlag.IsLoadForm) == 0)
{
Header.IgnoreContentLength();
if (Header.ContentLength == 0)
{
isHeaderError = true;
if (responseHeader(ref response)) return;
}
else
{
System.Net.Sockets.Socket socket = Socket;
if (socket == null) Http.Response.Push(ref response);
else
{
this.HttpResponse = response;
ReceiveType = ReceiveType.Response;
Data.Set(Buffer.Buffer, Buffer.StartIndex, Math.Min(Header.ContentLength, Buffer.Length));
response = null;
Timeout = Config.GetTimeout(Header.ContentLength);
#if DOTNET2
SocketError socketError;
IAsyncResult async = socket.BeginReceive(Buffer.Buffer, Buffer.StartIndex, Data.Length, SocketFlags.None, out socketError, onReceiveAsyncCallback, socket);
if (socketError == SocketError.Success)
{
if (!async.CompletedSynchronously) Http.Header.ReceiveTimeout.Push(this, socket);
return;
}
#else
receiveAsyncEventArgs.SocketError = SocketError.Success;
ReceiveAsyncLock.EnterSleepFlag();
receiveAsyncEventArgs.SetBuffer(Buffer.Buffer, Buffer.StartIndex, Data.Length);
if (socket.ReceiveAsync(receiveAsyncEventArgs))
{
ReceiveAsyncLock.SleepFlag = 0;
Http.Header.ReceiveTimeout.Push(this, socket);
ReceiveAsyncLock.Exit();
return;
}
ReceiveAsyncLock.ExitSleepFlag();
isHeaderError = true;
if (onReceive()) return;
#endif
}
}
}
else
{
isHeaderError = true;
if (responseHeader(ref response)) return;
}
}
catch (Exception error)
{
Server.RegisterServer.TcpServer.Log.Exception(error, null, LogLevel.Exception | LogLevel.AutoCSer);
}
if (isHeaderError) HeaderError();
else ResponseError(ResponseState.ServerError500);
}
private bool TryUnsafeSocketOperation(Socket socket, SocketAsyncOperation operation, SocketAsyncEventArgs socketAsyncEventArgs)
{
try
{
bool result = false;
switch (operation)
{
case SocketAsyncOperation.Accept:
result = socket.AcceptAsync(socketAsyncEventArgs);
break;
case SocketAsyncOperation.Send:
result = socket.SendAsync(socketAsyncEventArgs);
break;
case SocketAsyncOperation.Receive:
result = socket.ReceiveAsync(socketAsyncEventArgs);
break;
default:
throw new InvalidOperationException("Unknown case called, should program something for this");
}
if (!result)
{
OperationCallback(socket, socketAsyncEventArgs);
}
}
catch (SocketException ex)
{
if (operation != SocketAsyncOperation.Accept)
{
HandleCommunicationError(socket, ex);
}
return false;
}
catch (ObjectDisposedException)
{
// If disposed, handle communication error was already done and we're just catching up on other threads. suppress it.
return false;
}
return true;
}
public override void Start(Uri uri)
{
lock (_syncObject)
{
if (_running) return;
_running = true;
Uri = uri;
switch (uri.HostNameType)
{
case UriHostNameType.IPv4:
case UriHostNameType.IPv6:
_sourceAddress = IPAddress.Parse(uri.Host);
break;
default:
var addresses = Dns.GetHostAddresses(uri.DnsSafeHost);
if (addresses.Length < 1) throw new ArgumentException("Host not found.");
_sourceAddress = addresses[0];
break;
}
if ((_sourceAddress.AddressFamily == AddressFamily.InterNetwork &&
_sourceAddress.GetAddressBytes()[0] >= 224 && _sourceAddress.GetAddressBytes()[0] <= 239) ||
(_sourceAddress.AddressFamily == AddressFamily.InterNetworkV6 && _sourceAddress.IsIPv6Multicast))
{
_multicast = true;
}
if (_sourceAddress.AddressFamily == AddressFamily.InterNetworkV6)
_localAddress = IPAddress.IPv6Any;
_socket = new Socket(_sourceAddress.AddressFamily, SocketType.Dgram, ProtocolType.Udp);
_socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ExclusiveAddressUse, false);
_socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReceiveBuffer, _receiveBufferSize);
_socket.Bind(new IPEndPoint(_localAddress, uri.Port));
switch (_sourceAddress.AddressFamily)
{
case AddressFamily.InterNetwork:
if (_multicast)
_socket.SetSocketOption(SocketOptionLevel.IP, SocketOptionName.AddMembership,
new MulticastOption(_sourceAddress));
break;
case AddressFamily.InterNetworkV6:
if (_multicast)
_socket.SetSocketOption(SocketOptionLevel.IPv6, SocketOptionName.AddMembership,
new IPv6MulticastOption(_sourceAddress));
break;
}
var socketArgs = new SocketAsyncEventArgs();
byte[] buffer;
if (!_bufferPool.TryDequeue(out buffer)) buffer = new byte[9000];
socketArgs.SetBuffer(buffer, 0, buffer.Length);
socketArgs.Completed += ReceiveCompleted;
_bitrate.Start();
_packetrate.Start();
_highResTimer.Start();
_processingThread = new Thread(ProcessPackets) {IsBackground = true};
_processingThread.Start();
_socket.ReceiveAsync(socketArgs);
}
}
/// <summary>
///
/// </summary>
/// <param name="s"></param>
/// <param name="buf"></param>
/// <param name="begin"></param>
/// <param name="len"></param>
/// <returns>byte count</returns>
internal static int TcpRecieve(Socket s, byte[] buf, int begin, int len)
{
string response = "Operation Timeout";
int read_bytes = 0;
if (s != null)
{
// Create SocketAsyncEventArgs context object
SocketAsyncEventArgs socketEventArg = new SocketAsyncEventArgs();
socketEventArg.RemoteEndPoint = s.RemoteEndPoint;
// Setup the buffer to receive the data
socketEventArg.SetBuffer(new Byte[len], 0, len);
// Inline event handler for the Completed event.
// Note: This even handler was implemented inline in order to make this method self-contained.
socketEventArg.Completed += new EventHandler<SocketAsyncEventArgs>(delegate(object ss, SocketAsyncEventArgs e)
{
if (e.SocketError == SocketError.Success)
{
// Retrieve the data from the buffer
read_bytes = e.BytesTransferred;
Array.Copy(e.Buffer, e.Offset, buf, begin, e.BytesTransferred);
}
else
{
response = e.SocketError.ToString();
}
try
{
_clientDone[s].Set();
}
catch (KeyNotFoundException)
{
}
});
// Sets the state of the event to nonsignaled, causing threads to block
_clientDone[s].Reset();
// Make an asynchronous Receive request over the socket
if (s.ReceiveAsync(socketEventArg) == false)
{
if (socketEventArg.SocketError == SocketError.Success)
{
// Retrieve the data from the buffer
read_bytes = socketEventArg.BytesTransferred;
Array.Copy(socketEventArg.Buffer, socketEventArg.Offset, buf, begin, socketEventArg.BytesTransferred);
}
else
{
response = socketEventArg.SocketError.ToString();
}
try
{
_clientDone[s].Set();
}
catch (KeyNotFoundException)
{
}
}
// Block the UI thread for a maximum of TIMEOUT_MILLISECONDS milliseconds.
// If no response comes back within this time then proceed
_clientDone[s].WaitOne();//(TimeOut);
}
return read_bytes;
}
private void Room_Load(object sender, EventArgs e)
{
MessageBox.Show(port+"!");
m_ClientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
IPEndPoint ipep = new IPEndPoint(IPAddress.Parse("127.0.0.1"), port); //포트 대기 설정
SocketAsyncEventArgs args = new SocketAsyncEventArgs();
args.RemoteEndPoint = ipep;
m_ClientSocket.ConnectAsync(args);
SocketAsyncEventArgs args1 = new SocketAsyncEventArgs();
byte[] szData1 = new byte[1024];
args1.SetBuffer(szData1, 0, 1024);
args1.UserToken = m_ClientSocket;
args1.Completed += new EventHandler<SocketAsyncEventArgs>(Receive_Completed);
m_ClientSocket.ReceiveAsync(args1);
}
public bool Connect(string hostname, int port)
{
DnsEndPoint host = null;
try
{
host = new DnsEndPoint(hostname, port);
}
catch
{
return false;
}
_socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
ManualResetEvent sync = new ManualResetEvent(false);
SocketAsyncEventArgs co = new SocketAsyncEventArgs();
error = SocketError.TimedOut.ToString();
co.Completed += new EventHandler<SocketAsyncEventArgs>(delegate(object o, SocketAsyncEventArgs e)
{
sync.Set();
error = e.SocketError.ToString();
if (e.SocketError == SocketError.Success)
isConnected = true;
});
co.RemoteEndPoint = host;
recvEvents.RemoteEndPoint = host;
Array.Clear(recvEvents.Buffer, 0, recvEvents.Buffer.Length);
sendEvents.RemoteEndPoint = host;
isConnected = false;
sync.Reset();
if (_socket.ConnectAsync(co))
sync.WaitOne(10000);
else
{
sync.Set();
}
isReceiving = true;
_socket.ReceiveAsync(recvEvents);
return isConnected;
}
public void Connect(string server, int port = 1883)
{
socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
socket.Connect(server, port);
socket.ReceiveAsync(socketAsynPool.Pop());
}
public void ReceiveAsync_ClosedSocket ()
{
Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
s.Close ();
s.ReceiveAsync (null);
}
protected virtual void StartReceive(Socket socket, SocketAsyncEventArgs e)
{
if (socket == null)
{
throw new ArgumentNullException("socket");
}
if (e == null)
{
throw new ArgumentNullException("e");
}
bool raiseEvent = false;
try
{
raiseEvent = socket.ReceiveAsync(e);
}
catch (Exception exc)
{
this.OnException(new Exception(exc.Message, exc));
return;
}
if (!raiseEvent)
{
this.ProcessReceive(e);
}
}
bool Utils.Wrappers.Interfaces.ISocket.ReceiveAsync(SocketAsyncEventArgs e)
{
return(InternalSocket.ReceiveAsync(e));
}
/// <summary>
/// 数据接收完成后的处理
/// </summary>
/// <returns></returns>
private bool onReceive()
#endif
{
#if DOTNET2
System.Net.Sockets.Socket socket = (System.Net.Sockets.Socket)async.AsyncState;
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;
ReceiveAsyncLock.EnterSleepFlag();
receiveAsyncEventArgs.SetBuffer(Data.Array, Data.Start, Data.Length);
if (socket.ReceiveAsync(receiveAsyncEventArgs))
{
ReceiveAsyncLock.SleepFlag = 0;
Http.Header.ReceiveTimeout.Push(this, socket);
ReceiveAsyncLock.Exit();
return true;
}
ReceiveAsyncLock.ExitSleepFlag();
goto START;
#endif
case ReceiveType.GetForm: return OnGetForm();
}
}
if ((count >= TcpServer.Server.MinSocketSize || (count > 0 && ReceiveSizeLessCount++ == 0)) && AutoCSer.Threading.SecondTimer.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;
ReceiveAsyncLock.EnterSleepFlag();
receiveAsyncEventArgs.SetBuffer(Data.Start, Data.Length);
if (socket.ReceiveAsync(receiveAsyncEventArgs))
{
ReceiveAsyncLock.SleepFlag = 0;
Http.Header.ReceiveTimeout.Push(this, socket);
ReceiveAsyncLock.Exit();
return true;
}
ReceiveAsyncLock.ExitSleepFlag();
goto START;
#endif
}
#if DOTNET2
}
#endif
}
return false;
}
protected virtual void StartReceive(Socket socket, SocketAsyncEventArgs e)
{
bool raiseEvent = false;
try
{
raiseEvent = socket.ReceiveAsync(e);
}
catch (Exception exc)
{
OnException(new Exception(exc.Message, exc));
return;
}
if (!raiseEvent)
{
ProcessReceive(e);
}
}
