public void Defaults ()
{
SocketAsyncEventArgs saea = new SocketAsyncEventArgs ();
Assert.IsNull (saea.AcceptSocket, "AcceptSocket");
Assert.IsNull (saea.Buffer, "Buffer");
Assert.IsNull (saea.BufferList, "BufferList");
Assert.AreEqual (0, saea.BytesTransferred, "BytesTransferred");
Assert.AreEqual (0, saea.Count, "Count");
Assert.IsFalse (saea.DisconnectReuseSocket, "DisconnectReuseSocket");
Assert.AreEqual (SocketAsyncOperation.None, saea.LastOperation, "LastOperation");
Assert.AreEqual (0, saea.Offset, "Offset");
Assert.IsNull (saea.RemoteEndPoint, "RemoteEndPoint");
#if !MOBILE
Assert.IsNotNull (saea.ReceiveMessageFromPacketInfo, "ReceiveMessageFromPacketInfo");
Assert.IsNull (saea.SendPacketsElements, "SendPacketsElements");
Assert.AreEqual (TransmitFileOptions.UseDefaultWorkerThread, saea.SendPacketsFlags, "SendPacketsFlags");
#endif
Assert.AreEqual (-1, saea.SendPacketsSendSize, "SendPacketsSendSize");
Assert.AreEqual (SocketError.Success, saea.SocketError, "SocketError");
Assert.AreEqual (SocketFlags.None, saea.SocketFlags, "SocketFlags");
Assert.IsNull (saea.UserToken, "UserToken");
saea.Dispose ();
saea.Dispose (); // twice
}
public void ConnectTo(string ip, int port)
{
State = ConnectionState.NotConnected;
socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
IPAddress[] ips = Dns.GetHostAddresses(ip);
var addr = ips[0];
var hostEndPoint = new IPEndPoint(addr, port);
var connectEA = new SocketAsyncEventArgs();
connectEA.RemoteEndPoint = hostEndPoint;
connectEA.Completed += (object sender, SocketAsyncEventArgs e)=>{
switch (e.LastOperation)
{
case SocketAsyncOperation.Connect:
UnityEngine.Debug.Log("Connect success");
break;
default:
throw new ArgumentException("The last operation completed on the socket was not a receive or send");
}
connectEA.Dispose();
State = ConnectionState.Connected;
};
State = ConnectionState.Connecting;
socket.ConnectAsync(connectEA);
}
/// <summary>
/// Create a UdpCommunication object using an existing Socket.
/// </summary>
public UdpCommunication(Socket socket, IPEndPoint endPoint)
{
_socket = socket;
_endPoint = endPoint;
// Start asynchronous read
try
{
_receiveArgs = new SocketAsyncEventArgs();
_receiveArgs.UserToken = _socket;
_receiveArgs.RemoteEndPoint = _endPoint;
_readBuffer = new byte[READBUFFERSIZE];
_receiveArgs.SetBuffer(_readBuffer, 0, _readBuffer.Length);
_receiveArgs.Completed += new EventHandler<SocketAsyncEventArgs>(_socket_ReceivedData);
if (_socket.ReceiveFromAsync(_receiveArgs) == false) // Returns true if the I/O operation is pending. Returns false if the I/O operation completed synchronously and the SocketAsyncEventArgs.Completed event will not be raised.
_socket_ReceivedData(_socket, _receiveArgs);
}
catch (Exception ex)
{
// On failure free up the SocketAsyncEventArgs
if (_receiveArgs != null)
{
_receiveArgs.Completed -= new EventHandler<SocketAsyncEventArgs>(_socket_ReceivedData);
_receiveArgs.Dispose();
_receiveArgs = null;
}
throw;
}
}
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;
}
void Complete(SocketAsyncEventArgs e, bool completeSynchronously)
{
TransportBase transport = null;
Exception exception = null;
if (e.SocketError != SocketError.Success)
{
exception = new SocketException((int)e.SocketError);
if (e.AcceptSocket != null)
{
e.AcceptSocket.Close(0);
}
}
else
{
Fx.Assert(e.AcceptSocket != null, "Must have a valid socket accepted.");
transport = new TcpTransport(e.AcceptSocket, this.transportSettings);
transport.Open();
}
e.Dispose();
this.callbackArgs.CompletedSynchronously = completeSynchronously;
this.callbackArgs.Exception = exception;
this.callbackArgs.Transport = transport;
if (!completeSynchronously)
{
this.callbackArgs.CompletedCallback(this.callbackArgs);
}
}
static void Accept_Completed(object sender, SocketAsyncEventArgs e)
{
Socket client = e.AcceptSocket;
Socket server = sender as Socket;
if (sender == null) return;
SocketAsyncEventArgs sendArg = new SocketAsyncEventArgs();
SocketAsyncEventArgs receciveArg = new SocketAsyncEventArgs();
ConnectInfo info = new ConnectInfo();
info.tmpList = new ArrayList();
info.SendArg = sendArg;
info.ReceiveArg = receciveArg;
info.ServerSocket=server;
byte[] sendbuffers=Encoding.ASCII.GetBytes("welcome\n");
sendArg.SetBuffer(sendbuffers, 0, sendbuffers.Length);
sendbuffers=new byte[1024];
receciveArg.SetBuffer(sendbuffers, 0, 1024);
receciveArg.UserToken = info;
receciveArg.Completed += new EventHandler<SocketAsyncEventArgs>(Rececive_Completed);
client.SendAsync(sendArg);
client.ReceiveAsync(receciveArg);
e.Dispose();
}
public static void FreeScEv(SocketAsyncEventArgs buf)
{
if (_evPool == null) {
return;
}
if (!_evPool.FreeObj(buf)) {
buf.Dispose();
}
}
private void TMNRPCClient_SocketError(object sender, SocketErrorEventArgs e)
{
SocketAsyncEventArgs.Dispose();
SocketAsyncEventArgs = null;
if (e.SocketError == System.Net.Sockets.SocketError.ConnectionReset && ServerClosedConnection != null)
{
ServerClosedConnection(this, EventArgs.Empty);
}
}
public void Release(SocketAsyncEventArgs args)
{
lock (_pool)
{
if (args.Buffer.Equals(_buffer))
_pool.Push(args);
else
args.Dispose();
}
_acquisitionGate.Release();
}
private void EndSend(object sender, SocketAsyncEventArgs pArguments)
{
if (mDisconnected != 0) return;
if (pArguments.BytesTransferred <= 0)
{
Disconnect();
return;
}
ByteArraySegment segment;
if (sendSegments.TryPeek(out segment))
{
if (segment.Advance(pArguments.BytesTransferred))
{
ByteArraySegment seg;
sendSegments.TryDequeue(out seg); //we try to get it out
}
if (sendSegments.Count > 0)
{
this.BeginSend();
}
else
{
mSending = 0;
}
}
pArguments.Dispose(); //clears out the whole async buffer
}
private void ApplyReceiveWorkaround()
{
_logger.Trace("Applying receive workaround for WP7");
var waitEvent = new ManualResetEvent(false);
var tempEventArgs = new SocketAsyncEventArgs();
tempEventArgs.SetBuffer(new byte[] { 0xff }, 0, 1);
tempEventArgs.RemoteEndPoint = _socketOperation.RemoteEndPoint;
tempEventArgs.Completed += (s, e) => waitEvent.Set();
_currentSocket.SendToAsync(tempEventArgs);
waitEvent.WaitOne();
waitEvent.Dispose();
tempEventArgs.Dispose();
_receiveWorkaroundApplied = true;
}
private void onConnected(object sender, SocketAsyncEventArgs e)
{
((ManualResetEvent)e.UserToken).Set();
e.Dispose();
}
private void AcceptCompleted(object sender, SocketAsyncEventArgs e)
{
try
{
var clientSocket = e.AcceptSocket;
Logger.WriteLine("Client connected!");
var client = this.CreateNewClient(clientSocket);
this.OnClientConnected(new ClientConnectedEventArgs(client));
client.WaitForClientData();
this.WaitForClientConnect();
}
catch (global::System.ObjectDisposedException)
{
Logger.WriteLine("OnClientConnection: Socket has been closed!", TraceEventType.Information);
}
catch (SocketException se)
{
Logger.WriteLine("SocketException: {0}!", TraceEventType.Warning, se);
}
finally
{
e.Dispose();
}
}
private void ProduceEnd(ProduceEndType endType)
{
Action drained = () =>
{
switch (endType)
{
case ProduceEndType.SocketShutdownSend:
_socket.Shutdown(SocketShutdown.Send);
break;
case ProduceEndType.ConnectionKeepAlive:
ThreadPool.QueueUserWorkItem(_ => Go(true, null));
break;
case ProduceEndType.SocketDisconnect:
_services.Trace.Event(TraceEventType.Stop, TraceMessage.Connection);
_baton.Free();
var receiveSocketEvent = Interlocked.Exchange(ref _receiveSocketEvent, null);
// this has a race condition
if (receiveSocketEvent.Completed == null)
{
_services.Memory.FreeSocketEvent(receiveSocketEvent);
}
else
{
receiveSocketEvent.Completed = () => _services.Memory.FreeSocketEvent(receiveSocketEvent);
}
_socket.Shutdown(SocketShutdown.Receive);
var e = new SocketAsyncEventArgs();
Action cleanup = () =>
{
e.Dispose();
_disconnected(_socket);
};
e.Completed += (_, __) => cleanup();
if (!_socket.DisconnectAsync(e))
{
cleanup();
}
break;
}
};
if (!_socketSender.Flush(drained))
{
drained.Invoke();
}
}
void Complete(SocketAsyncEventArgs e, bool completeSynchronously)
{
TransportBase transport = null;
Exception exception = null;
if (e.SocketError != SocketError.Success)
{
exception = new SocketException((int)e.SocketError);
if (e.AcceptSocket != null)
{
e.AcceptSocket.Dispose();
}
}
else
{
try
{
Fx.Assert(e.ConnectSocket != null, "Must have a valid socket accepted.");
e.ConnectSocket.NoDelay = true;
transport = new TcpTransport(e.ConnectSocket, this.transportSettings);
transport.Open();
}
catch (Exception exp)
{
if (Fx.IsFatal(exp))
{
throw;
}
exception = exp;
if (transport != null)
{
transport.SafeClose();
}
transport = null;
}
}
e.Dispose();
this.callbackArgs.CompletedSynchronously = completeSynchronously;
this.callbackArgs.Exception = exception;
this.callbackArgs.Transport = transport;
if (!completeSynchronously)
{
this.callbackArgs.CompletedCallback(this.callbackArgs);
}
}
private void Succeed()
{
OnSucceed();
_userArgs.FinishWrapperConnectSuccess(_internalArgs.ConnectSocket, _internalArgs.BytesTransferred, _internalArgs.SocketFlags);
_internalArgs.Dispose();
}
protected void Succeed()
{
OnSucceed();
userArgs.FinishWrapperConnectSuccess(internalArgs.ConnectSocket, internalArgs.BytesTransferred, internalArgs.SocketFlags);
internalArgs.Dispose();
}
private void OnSendCompleted(object sender, SocketAsyncEventArgs socketAsyncEventArgs)
{
OnMessageSended((NetworkMessage)socketAsyncEventArgs.UserToken);
socketAsyncEventArgs.Dispose();
}
void SocketAsyncEventArgs_Connected(object sender, SocketAsyncEventArgs e)
{
if (e.LastOperation == SocketAsyncOperation.Connect)
{
if (e.SocketError == SocketError.Success)
{
#if Matrix_Diagnostics
Monitor.ReportImportant("Socket connected.");
#endif
RaiseConnectedEvent();
AssignAsyncReceiveArgs(false);
}
else if (e.SocketError == SocketError.IsConnected)
{// Already connected.
// Connect failed.
#if Matrix_Diagnostics
Monitor.ReportImportant("Socket already connected.");
#endif
}
else
{
#if Matrix_Diagnostics
Monitor.ReportImportant("Socket connection failed: " + e.SocketError.ToString());
#endif
}
}
else
{
// Connect failed.
#if Matrix_Diagnostics
Monitor.ReportImportant("Socket async connect failed.");
#endif
}
lock (_syncRoot)
{
if (_asyncConnectArgs == e)
{
_asyncConnectArgs.Dispose();
_asyncConnectArgs = null;
}
else
{
#if Matrix_Diagnostics
Monitor.Error("SocketAsyncEventArgs mismatch.");
#endif
e.Dispose();
_asyncConnectArgs = null;
}
}
}
/// <summary>
/// release
/// </summary>
/// <param name="e"></param>
public void ReleaseSocketAsyncEventArgs(SocketAsyncEventArgs e)
{
if (e.Buffer == null || e.Buffer.Length != this.MessageBufferSize)
{
e.Dispose(); return;
}
if (this._stack.Count >= 50000) { e.Dispose(); return; }
this._stack.Push(e);
}
public void BeginDisconnectCallbackAsync(object sender, SocketAsyncEventArgs e)
{
if (Disposed)
return;
BaseSocketConnection connection = null;
try
{
connection = (BaseSocketConnection)e.UserToken;
e.Completed -= new EventHandler<SocketAsyncEventArgs>(BeginDisconnectCallbackAsync);
e.UserToken = null;
e.Dispose();
e = null;
if (!connection.Active)
return;
lock (connection.Context.SyncActive)
{
CloseConnection(connection);
FireOnDisconnected(connection);
}
}
finally
{
Console.WriteLine(connection.Context.ConnectionId + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss:fff"));
DisposeConnection(connection);
RemoveSocketConnection(connection);
connection = null;
}
}
/// <summary>
/// Accepts complete event's callback funciton.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void AcceptAsyncCompleted(object sender, SocketAsyncEventArgs e)
{
Socket sock = null;
try
{
sock = e.AcceptSocket;
sock.SendBufferSize = SEND_BUFF_SIZE;
BaseClient client = GetNewClient();
//TrieuLSL
try
{
if (log.IsInfoEnabled)
{
string ip = sock.Connected ? sock.RemoteEndPoint.ToString() : "socket disconnected";
log.Info("Incoming connection from " + ip);
}
lock (_clients.SyncRoot)
{
_clients.Add(client, client);//Add the client instance to a hy dictionary.
client.Disconnected += client_Disconnected;
}
client.Connect(sock);
client.ReceiveAsync();
}
catch (Exception ex)
{
log.ErrorFormat("create client failed:{0}", ex);
client.Disconnect();
}
}
catch
{
if (sock != null) // don't leave the socket open on exception
try { sock.Close(); }
catch { }
}
finally
{
e.Dispose();
AcceptAsync();
}
}
private void EndReceive(object sender, SocketAsyncEventArgs pArguments)
{
if (mDisconnected != 0) return;
if (pArguments.BytesTransferred <= 0)
{
Disconnect();
return;
}
mReceiveLength += pArguments.BytesTransferred;
if (mReceivingPacketLength == mReceiveLength)
{
if (mHeader) //parse headers
{
mReceivingPacketLength = BitConverter.ToInt32(mReceiveBuffer, 0);
mReceiveLength = 0;
mReceiveStart = 0;
mHeader = false;
// mReceiveBuffer = new byte[mReceivingPacketLength];
}
else
{ //parse packets
byte[] packetData = new byte[mReceivingPacketLength];
Buffer.BlockCopy(mReceiveBuffer, 0, packetData, 0, mReceivingPacketLength);
if (!mIVs)
{
InterPacket packet = new InterPacket(packetData);
if (packet.OpCode == InterHeader.IVS)
{
Log.WriteLine(LogLevel.Info, "IV data received");
packet.ReadBytes(mIVRecv);
mIVs = true;
}
else
{
Log.WriteLine(LogLevel.Info, "Got wrong packet.");
Disconnect();
}
}
else
{
packetData = InterCrypto.DecryptData(mIVRecv, packetData);
if (OnPacket != null)
{
InterPacket packet = new InterPacket(packetData);
this.OnPacket(this, new InterPacketReceivedEventArgs(packet, this));
}
}
//we reset this packet
mReceivingPacketLength = 4;
mReceiveLength = 0;
mReceiveStart = 0;
mHeader = true;
// mReceiveBuffer = new byte[4];
}
}
else
{
mReceiveStart += mReceivingPacketLength;
}
BeginReceive();
pArguments.Dispose();
}
private void ConnectCompleted(object sender, SocketAsyncEventArgs e)
{
try
{
if (e.SocketError != SocketError.Success)
{
HandleSocketError(e.SocketError);
return;
}
Debug.Assert(e.UserToken != null);
var token = (Tuple<bool, string, IrcRegistrationInfo>)e.UserToken;
// Create stream for received data. Use SSL stream on top of network stream, if specified.
this.receiveStream = new CircularBufferStream(socketReceiveBufferSize);
#if SILVERLIGHT
this.dataStream = this.receiveStream;
#else
this.dataStream = GetDataStream(token.Item1, token.Item2);
#endif
this.dataStreamReader = new StreamReader(this.dataStream, TextEncoding);
this.dataStreamLineReader = new SafeLineReader(this.dataStreamReader);
// Start sending and receiving data to/from server.
this.sendTimer.Change(0, Timeout.Infinite);
ReceiveAsync();
HandleClientConnected(token.Item3);
}
catch (SocketException exSocket)
{
HandleSocketError(exSocket);
}
catch (ObjectDisposedException)
{
// Ignore.
}
#if !DEBUG
catch (Exception ex)
{
OnConnectFailed(new IrcErrorEventArgs(ex));
}
#endif
finally
{
e.Dispose();
}
}
private void ReceiveCompleted(object sender, SocketAsyncEventArgs e)
{
try
{
if (e.SocketError != SocketError.Success)
{
HandleSocketError(e.SocketError);
return;
}
// Check if remote host has closed connection.
if (e.BytesTransferred == 0)
{
HandleClientDisconnected();
return;
}
// Indicate that block of data has been read into receive buffer.
this.receiveStream.WritePosition += e.BytesTransferred;
this.dataStreamReader.DiscardBufferedData();
// Read each terminated line of characters from data stream.
while (true)
{
// Read next line from data stream.
var line = this.dataStreamLineReader.ReadLine();
if (line == null)
break;
if (line.Length == 0)
continue;
string prefix = null;
string lineAfterPrefix = null;
// Extract prefix from message line, if it contains one.
if (line[0] == ':')
{
var firstSpaceIndex = line.IndexOf(' ');
Debug.Assert(firstSpaceIndex != -1);
prefix = line.Substring(1, firstSpaceIndex - 1);
lineAfterPrefix = line.Substring(firstSpaceIndex + 1);
}
else
{
lineAfterPrefix = line;
}
// Extract command from message.
var command = lineAfterPrefix.Substring(0, lineAfterPrefix.IndexOf(' '));
var paramsLine = lineAfterPrefix.Substring(command.Length + 1);
// Extract parameters from message.
// Each parameter is separated by single space, except last one, which may contain spaces if it
// is prefixed by colon.
var parameters = new string[maxParamsCount];
int paramStartIndex, paramEndIndex = -1;
int lineColonIndex = paramsLine.IndexOf(" :");
if (lineColonIndex == -1 && !paramsLine.StartsWith(":"))
lineColonIndex = paramsLine.Length;
for (int i = 0; i < parameters.Length; i++)
{
paramStartIndex = paramEndIndex + 1;
paramEndIndex = paramsLine.IndexOf(' ', paramStartIndex);
if (paramEndIndex == -1)
paramEndIndex = paramsLine.Length;
if (paramEndIndex > lineColonIndex)
{
paramStartIndex++;
paramEndIndex = paramsLine.Length;
}
parameters[i] = paramsLine.Substring(paramStartIndex, paramEndIndex - paramStartIndex);
if (paramEndIndex == paramsLine.Length)
break;
}
// Parse received IRC message.
var message = new IrcMessage(this, prefix, command, parameters);
var messageReceivedEventArgs = new IrcRawMessageEventArgs(message, line);
OnRawMessageReceived(messageReceivedEventArgs);
ReadMessage(message, line);
#if DEBUG
DebugUtilities.WriteIrcRawLine(this, ">>> " + messageReceivedEventArgs.RawContent);
#endif
}
// Continue reading data from socket.
ReceiveAsync();
}
catch (SocketException exSocket)
{
HandleSocketError(exSocket);
}
catch (ObjectDisposedException)
{
// Ignore.
}
#if !DEBUG
catch (Exception ex)
{
OnError(new IrcErrorEventArgs(ex));
}
#endif
finally
{
e.Dispose();
}
}
private void ReceiveCompleted(object sender, SocketAsyncEventArgs e)
{
try
{
if (e.SocketError != SocketError.Success)
{
HandleSocketError(e.SocketError);
return;
}
// Check if remote host has closed connection.
if (e.BytesTransferred == 0)
{
Disconnect();
return;
}
// Indicate that block of data has been read into receive buffer.
this.receiveStream.WritePosition += e.BytesTransferred;
this.dataStreamReader.DiscardBufferedData();
// Read each terminated line of characters from data stream.
while (true)
{
// Read next line from data stream.
var line = this.dataStreamLineReader.ReadLine();
if (line == null)
break;
if (line.Length == 0)
continue;
ParseMessage(line);
}
// Continue reading data from socket.
ReceiveAsync();
}
catch (SocketException exSocket)
{
HandleSocketError(exSocket);
}
catch (ObjectDisposedException)
{
// Ignore.
}
#if !DEBUG
catch (Exception ex)
{
OnError(new IrcErrorEventArgs(ex));
}
#endif
finally
{
e.Dispose();
}
}
private void DisconnectCompleted(object sender, SocketAsyncEventArgs e)
{
try
{
if (e.SocketError != SocketError.Success)
{
HandleSocketError(e.SocketError);
return;
}
HandleClientDisconnected();
}
catch (SocketException exSocket)
{
HandleSocketError(exSocket);
}
catch (ObjectDisposedException)
{
// Ignore.
}
#if !DEBUG
catch (Exception ex)
{
OnError(new IrcErrorEventArgs(ex));
}
#endif
finally
{
e.Dispose();
}
}
/// <summary>
/// Connect callback!
/// </summary>
/// <param name="ar"></param>
internal void BeginConnectCallbackAsync(object sender, SocketAsyncEventArgs e)
{
if (!Disposed)
{
BaseSocketConnection connection = null;
SocketConnector connector = null;
Exception exception = null;
if (e.SocketError == SocketError.Success)
{
try
{
connector = (SocketConnector)e.UserToken;
connection = new ClientSocketConnection(Context.Host, connector, connector.Socket);
//----- Adjust buffer size!
connector.Socket.ReceiveBufferSize = Context.Host.Context.SocketBufferSize;
connector.Socket.SendBufferSize = Context.Host.Context.SocketBufferSize; ;
//----- Initialize!
Context.Host.AddSocketConnection(connection);
connection.Active = true;
Context.Host.InitializeConnection(connection);
}
catch (Exception ex)
{
exception = ex;
if (connection != null)
{
Context.Host.DisposeConnection(connection);
Context.Host.RemoveSocketConnection(connection);
connection = null;
}
}
}
else
{
exception = new SocketException((int)e.SocketError);
}
if (exception != null)
{
FReconnectAttempted++;
ReconnectConnection(false, exception);
}
}
e.UserToken = null;
e.Dispose();
e = null;
}
private void SendCompleted(object sender, SocketAsyncEventArgs e)
{
try
{
if (e.SocketError != SocketError.Success)
{
HandleSocketError(e.SocketError);
return;
}
// Handle sent IRC message.
Debug.Assert(e.UserToken != null);
var messageSentEventArgs = (IrcRawMessageEventArgs)e.UserToken;
OnRawMessageSent(messageSentEventArgs);
#if DEBUG
DebugUtilities.WriteIrcRawLine(this, "<<< " + messageSentEventArgs.RawContent);
#endif
}
catch (ObjectDisposedException)
{
// Ignore.
}
#if !DEBUG
catch (Exception ex)
{
OnError(new IrcErrorEventArgs(ex));
}
#endif
finally
{
e.Dispose();
}
}
protected void ProcessConnect(Socket socket, object state, SocketAsyncEventArgs e)
{
if (e != null && e.SocketError != SocketError.Success)
{
e.Dispose();
m_InConnecting = false;
OnError(new SocketException((int)e.SocketError));
return;
}
if (socket == null)
{
m_InConnecting = false;
OnError(new SocketException((int)SocketError.ConnectionAborted));
return;
}
//To walk around a MonoTouch's issue
//one user reported in some cases the e.SocketError = SocketError.Succes but the socket is not connected in MonoTouch
if (!socket.Connected)
{
m_InConnecting = false;
#if SILVERLIGHT || NETFX_CORE
var socketError = SocketError.ConnectionReset;
#else
var socketError = (SocketError)socket.GetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Error);
#endif
OnError(new SocketException((int)socketError));
return;
}
if (e == null)
e = new SocketAsyncEventArgs();
e.Completed += SocketEventArgsCompleted;
Client = socket;
m_InConnecting = false;
#if !SILVERLIGHT && !NETFX_CORE
try
{
//Set keep alive
Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.KeepAlive, true);
}
catch
{
}
#endif
OnGetSocket(e);
}
private void EndReceive(object sender, SocketAsyncEventArgs pArguments)
{
if (mDisconnected != 0) return;
if (pArguments.BytesTransferred <= 0)
{
Disconnect();
return;
}
mReceiveLength += pArguments.BytesTransferred;
while (mReceiveLength > 1)
{
//parse headers
//TODO: proper rewrite!
if (mReceivingPacketLength == 0)
{
mReceivingPacketLength = receiveBuffer[mReceiveStart];
if (mReceivingPacketLength == 0)
{
if (mReceiveLength >= 3)
{
mReceivingPacketLength = BitConverter.ToUInt16(receiveBuffer, mReceiveStart + 1);
headerLength = 3;
}
else
{
break;
}
}
else
{
headerLength = 1;
}
}
//parse packets
if (mReceivingPacketLength > 0 && mReceiveLength >= mReceivingPacketLength + headerLength)
{
byte[] packetData = new byte[mReceivingPacketLength];
Buffer.BlockCopy(receiveBuffer, mReceiveStart + headerLength, packetData, 0, mReceivingPacketLength);
crypto.Crypt(packetData, 0, mReceivingPacketLength);
if (OnPacket != null)
{
Packet packet = new Packet(packetData);
if (packet.Header > 49)
{
Log.WriteLine(LogLevel.Warn, "Header out of range from {0} ({1}|{2})", Host, packet.Header, packet.Type);
Disconnect();
}
else
{
this.OnPacket(this, new PacketReceivedEventArgs(packet));
}
}
//we reset this packet
mReceiveStart += mReceivingPacketLength + headerLength;
mReceiveLength -= mReceivingPacketLength + headerLength;
mReceivingPacketLength = 0;
}
else break;
}
if (mReceiveLength == 0) mReceiveStart = 0;
else if (mReceiveStart > 0 && (mReceiveStart + mReceiveLength) >= receiveBuffer.Length)
{
Buffer.BlockCopy(receiveBuffer, mReceiveStart, receiveBuffer, 0, mReceiveLength);
mReceiveStart = 0;
}
if (mReceiveLength == receiveBuffer.Length)
{
Disconnect();
}
else BeginReceive();
pArguments.Dispose();
}
bool HandleAcceptComplete(SocketAsyncEventArgs e, bool completedSynchronously)
{
if (e.SocketError == SocketError.Success)
{
TcpTransport transport = new TcpTransport(e.AcceptSocket, this.transportSettings);
transport.Open();
TransportAsyncCallbackArgs args = new TransportAsyncCallbackArgs();
args.Transport = transport;
args.CompletedSynchronously = completedSynchronously;
this.OnTransportAccepted(args);
return true;
}
else
{
e.Dispose();
this.TryClose(new SocketException((int)e.SocketError));
return false;
}
}
private void SendCommand(string commandName, EventHandler<SocketAsyncEventArgs> callback, params string[] args)
{
if (commandName == null)
{
return;
}
DateTime sendCommandStartTime = DateTime.Now;
StringBuilder format = new StringBuilder("|" + Encode(commandName));
if ((args != null) && (args.Length > 0))
{
for (int i = 0; i < args.Length; i++)
{
format.AppendFormat("/{0}", Encode(args[i]));
}
}
format.Append("/?");
byte[] message = ASCIIEncoding.ASCII.GetBytes(format.ToString());
SocketAsyncEventArgs socketAsyncEventArgs = new SocketAsyncEventArgs();
socketAsyncEventArgs.SetBuffer(message, 0, message.Length);
socketAsyncEventArgs.Completed += (sender, e) =>
{
try
{
sendCommandTimeSpent = (DateTime.Now - sendCommandStartTime);
if (callback != null)
{
callback(sender, e);
}
}
catch (Exception)
{
// TODO: log
if (socketAsyncEventArgs != null)
{
socketAsyncEventArgs.Dispose();
}
}
};
if ((this.EndPoint == null) || (this.EndPoint.Client == null))
{
return;
}
if (this.EndPoint.Client.SendAsync(socketAsyncEventArgs))
{
sendCommandTimeSpent = (DateTime.Now - sendCommandStartTime);
if (callback != null)
{
callback(this, socketAsyncEventArgs);
}
}
ClientTxPerformanceIncrement(commandName);
}
public void Send(NetworkMessage message)
{
lock (this)
{
if (!IsConnected)
return;
var args = new SocketAsyncEventArgs();
args.Completed += OnSendCompleted;
args.UserToken = message;
byte[] data;
using (var writer = new BigEndianWriter())
{
message.Pack(writer);
data = writer.Data;
}
args.SetBuffer(data, 0, data.Length);
if (!Socket.SendAsync(args))
{
OnMessageSended(message);
args.Dispose();
}
LastActivity = DateTime.Now;
}
}