static void SocketAsyncEventCompleted(object sender, SocketAsyncEventArgs e)
{
e.Completed -= SocketAsyncEventCompleted;
var token = (ConnectToken)e.UserToken;
e.UserToken = null;
token.Callback(sender as Socket, token.State, e);
}
public void Success()
{
AutoResetEvent completed = new AutoResetEvent(false);
if (Socket.OSSupportsIPv4)
{
int port, port1;
using (SocketTestServer.SocketTestServerFactory(IPAddress.Loopback, out port))
using (SocketTestServer.SocketTestServerFactory(IPAddress.Loopback, out port1))
{
SocketAsyncEventArgs args = new SocketAsyncEventArgs();
args.Completed += OnCompleted;
args.UserToken = completed;
args.RemoteEndPoint = new IPEndPoint(IPAddress.Loopback, port);
args.DisconnectReuseSocket = true;
Socket client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
Assert.True(client.ConnectAsync(args));
Assert.True(completed.WaitOne(Configuration.PassingTestTimeout), "Timed out while waiting for connection");
Assert.Equal<SocketError>(SocketError.Success, args.SocketError);
client.Disconnect(true);
args.RemoteEndPoint = new IPEndPoint(IPAddress.Loopback, port1);
Assert.True(client.ConnectAsync(args));
Assert.True(completed.WaitOne(Configuration.PassingTestTimeout), "Timed out while waiting for connection");
Assert.Equal<SocketError>(SocketError.Success, args.SocketError);
client.Dispose();
}
}
}
protected override void OnGetSocket(SocketAsyncEventArgs e)
{
try
{
#if SILVERLIGHT
var sslStream = new SslStream(new NetworkStream(Client));
sslStream.BeginAuthenticateAsClient(HostName, OnAuthenticated, sslStream);
#else
var securityOption = Security;
if (securityOption == null)
{
throw new Exception("securityOption was not configured");
}
#if NETSTANDARD
AuthenticateAsClientAsync(new SslStream(new NetworkStream(Client), false, ValidateRemoteCertificate), Security);
#else
var sslStream = new SslStream(new NetworkStream(Client), false, ValidateRemoteCertificate);
sslStream.BeginAuthenticateAsClient(HostName, securityOption.Certificates, securityOption.EnabledSslProtocols, false, OnAuthenticated, sslStream);
#endif
#endif
}
catch (Exception exc)
{
if (!IsIgnorableException(exc))
OnError(exc);
}
}
private SocketAsyncEventArgs NewBuffer()
{
SocketAsyncEventArgs e = new SocketAsyncEventArgs();
e.SetBuffer(new byte[1024], 0, 1024);
return e;
}
public void Socket_ConnectAsyncDnsEndPoint_Success()
{
Assert.True(Capability.IPv4Support());
int port;
SocketTestServer server = SocketTestServer.SocketTestServerFactory(IPAddress.Loopback, out port);
SocketAsyncEventArgs args = new SocketAsyncEventArgs();
args.RemoteEndPoint = new DnsEndPoint("localhost", port);
args.Completed += OnConnectAsyncCompleted;
ManualResetEvent complete = new ManualResetEvent(false);
args.UserToken = complete;
Socket sock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
Assert.True(sock.ConnectAsync(args));
complete.WaitOne();
Assert.Equal(SocketError.Success, args.SocketError);
Assert.Null(args.ConnectByNameError);
complete.Dispose();
sock.Dispose();
server.Dispose();
}
public void Success()
{
ManualResetEvent completed = new ManualResetEvent(false);
if (Socket.OSSupportsIPv4)
{
using (Socket receiver = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp))
{
int port = receiver.BindToAnonymousPort(IPAddress.Loopback);
receiver.SetSocketOption(SocketOptionLevel.IP, SocketOptionName.PacketInformation, true);
Socket sender = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
sender.Bind(new IPEndPoint(IPAddress.Loopback, 0));
sender.SendTo(new byte[1024], new IPEndPoint(IPAddress.Loopback, port));
SocketAsyncEventArgs args = new SocketAsyncEventArgs();
args.RemoteEndPoint = new IPEndPoint(IPAddress.Any, 0);
args.SetBuffer(new byte[1024], 0, 1024);
args.Completed += OnCompleted;
args.UserToken = completed;
Assert.True(receiver.ReceiveMessageFromAsync(args));
Assert.True(completed.WaitOne(Configuration.PassingTestTimeout), "Timeout while waiting for connection");
Assert.Equal(1024, args.BytesTransferred);
Assert.Equal(sender.LocalEndPoint, args.RemoteEndPoint);
Assert.Equal(((IPEndPoint)sender.LocalEndPoint).Address, args.ReceiveMessageFromPacketInfo.Address);
sender.Dispose();
}
}
}
/// <summary>
/// Connects to the server and begins listening for time updates.
/// </summary>
public void BeginRequestTime()
{
byte[] buffer = new byte[48];
buffer[0] = 0x1B;
for (var i = 1; i < buffer.Length; ++i)
{
buffer[i] = 0;
}
var endPoint = new DnsEndPoint(_ServerAddress, 123);
_Socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
var socketArgs = new SocketAsyncEventArgs() { RemoteEndPoint = endPoint };
socketArgs.Completed += (o, e) =>
{
if (e.SocketError == SocketError.Success)
{
var sArgs = new SocketAsyncEventArgs()
{
RemoteEndPoint = endPoint
};
sArgs.Completed += new EventHandler<SocketAsyncEventArgs>(sArgs_Completed);
sArgs.SetBuffer(buffer, 0, buffer.Length);
sArgs.UserToken = buffer;
_Socket.SendAsync(sArgs);
}
};
_Socket.ConnectAsync(socketArgs);
}
protected void AsyncEventArgsCompleted(object sender, SocketAsyncEventArgs e)
{
if (e.LastOperation == SocketAsyncOperation.Send)
ProcessSend(e);
else
ProcessReceive(e);
}
private IPPacketInformation GetNonDefaultIPPacketInformation()
{
const int ReceiveTimeout = 5000;
using (var receiver = new Socket(SocketType.Dgram, ProtocolType.Udp))
using (var sender = new Socket(SocketType.Dgram, ProtocolType.Udp))
{
int port = receiver.BindToAnonymousPort(IPAddress.Loopback);
var waitHandle = new ManualResetEvent(false);
SocketAsyncEventArgs receiveArgs = new SocketAsyncEventArgs {
RemoteEndPoint = new IPEndPoint(IPAddress.Loopback, port),
UserToken = waitHandle
};
receiveArgs.SetBuffer(new byte[1], 0, 1);
receiveArgs.Completed += (_, args) => ((ManualResetEvent)args.UserToken).Set();
Assert.True(receiver.ReceiveMessageFromAsync(receiveArgs));
sender.SendTo(new byte[1], new IPEndPoint(IPAddress.Loopback, port));
Assert.True(waitHandle.WaitOne(ReceiveTimeout));
return receiveArgs.ReceiveMessageFromPacketInfo;
}
}
public void DisconnectAsync_Success()
{
AutoResetEvent completed = new AutoResetEvent(false);
IPEndPoint loopback = new IPEndPoint(IPAddress.Loopback, 0);
using (var server1 = SocketTestServer.SocketTestServerFactory(SocketImplementationType.Async, loopback))
using (var server2 = SocketTestServer.SocketTestServerFactory(SocketImplementationType.Async, loopback))
{
SocketAsyncEventArgs args = new SocketAsyncEventArgs();
args.Completed += OnCompleted;
args.UserToken = completed;
args.RemoteEndPoint = server1.EndPoint;
args.DisconnectReuseSocket = true;
using (Socket client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
{
Assert.True(client.ConnectAsync(args));
completed.WaitOne();
Assert.Equal(SocketError.Success, args.SocketError);
Assert.True(client.DisconnectAsync(args));
completed.WaitOne();
Assert.Equal(SocketError.Success, args.SocketError);
args.RemoteEndPoint = server2.EndPoint;
Assert.True(client.ConnectAsync(args));
completed.WaitOne();
Assert.Equal(SocketError.Success, args.SocketError);
}
}
}
public Bot(BotManager manager,BotDescriptor BotDesc, int BotId)
{
FBotId = BotId;
FManager = manager;
FBotDesc = BotDesc;
FBufferManager = new BufferManager();
FBufferManager.Initialize(100, 100);
FPacketSpliter = new PacketSpliter();
FPacketSpliter.OnPacket += OnPacket;
FConnArg = new SocketAsyncEventArgs();
FConnArg.Completed += new EventHandler<SocketAsyncEventArgs>(IO_Completed);
FConnArg.UserToken = this;
FConnArg.RemoteEndPoint = FBotDesc.Host;
FDisconnArg = new SocketAsyncEventArgs();
FDisconnArg.Completed += new EventHandler<SocketAsyncEventArgs>(IO_Completed);
FDisconnArg.UserToken = this;
FDisconnArg.DisconnectReuseSocket = true;
FSock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
FTimer = new Timer(OnTimer);
}
private void StartReceiving(object sender, SocketAsyncEventArgs args)
{
// если входящее подключение принято
switch (args.SocketError)
{
case SocketError.Success:
Log.Trace("{0} подключен", args.AcceptSocket.RemoteEndPoint);
var recieveArgs = _clientPool.TakeObject();
recieveArgs.AcceptSocket = args.AcceptSocket;
//args.AcceptSocket.BeginReceive
//if (!args.AcceptSocket.ReceiveAsync(recieveArgs.AcceptSocket))
ProcessReceive(recieveArgs);
break;
case SocketError.OperationAborted:
break;
default:
Log.Error("Подключение не принято: {0}", args.SocketError);
break;
}
// освобождаем принятый сокет и начинаем новый прием
args.AcceptSocket = null;
StartAccepting();
}
private IPPacketInformation GetNonDefaultIPPacketInformation()
{
const int ReceiveTimeout = 5000;
using (var receiver = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp))
using (var sender = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp))
{
int port = receiver.BindToAnonymousPort(IPAddress.Loopback);
var waitHandle = new ManualResetEvent(false);
SocketAsyncEventArgs receiveArgs = new SocketAsyncEventArgs {
RemoteEndPoint = new IPEndPoint(IPAddress.Loopback, port),
UserToken = waitHandle
};
receiveArgs.SetBuffer(new byte[1], 0, 1);
receiveArgs.Completed += (_, args) => ((ManualResetEvent)args.UserToken).Set();
Assert.True(receiver.ReceiveMessageFromAsync(receiveArgs));
// Send a few packets, in case they aren't delivered reliably.
for (int i = 0; i < Configuration.UDPRedundancy; i++)
{
sender.SendTo(new byte[1], new IPEndPoint(IPAddress.Loopback, port));
}
Assert.True(waitHandle.WaitOne(ReceiveTimeout));
return receiveArgs.ReceiveMessageFromPacketInfo;
}
}
//生成自定义AsyncEventArg
private SocketAsyncEventArgs makeSocketAsyncEventArgs()
{
SocketAsyncEventArgs re = new SocketAsyncEventArgs();
re.UserToken = new AsyncUserToken(m_userTokenBufferLength);
re.SetBuffer(((AsyncUserToken)re.UserToken).buffer, 0, m_userTokenBufferLength);
re.Completed += new EventHandler<SocketAsyncEventArgs>(IO_Completed);
return re;
}
public void Dispose ()
{
if (result != null) {
result.Dispose ();
result = null;
args = null;
}
}
public DemoMain(IPAddress ip, int port, int bufferSize, int maxUserCount)
{
_serverEndPoint = new IPEndPoint(ip, port);
_listenArgs = new SocketAsyncEventArgs();
_listenArgs.Completed += StartReceiving;
}
public void SendData(string line)
{
byte[] data = System.Text.Encoding.UTF8.GetBytes(line + "\n");
SocketAsyncEventArgs socketAsyncData = new SocketAsyncEventArgs();
socketAsyncData.SetBuffer(data, 0, data.Length);
bool res = _clientSocket.SendAsync(socketAsyncData);
Debug.Log("Send line:" + line + " res:" + res);
}
private void ProcessConnect(SocketAsyncEventArgs e)
{
if (_s == null)
{
_s = e.ConnectSocket;
}
Action<SocketError> callback = (Action<SocketError>)e.UserToken;
callback(e.SocketError);
}
public void Free(SocketAsyncEventArgs buffer)
{
if (FBuffers.Count >= FBuffers.Capacity)
{
FBuffers.Capacity += FGrowth;
}
FBuffers.Add(buffer);
}
protected override void SocketEventArgsCompleted(object sender, SocketAsyncEventArgs e)
{
if (e.LastOperation == SocketAsyncOperation.Connect)
{
ProcessConnect(sender as Socket, null, e);
return;
}
ProcessReceive(e);
}
[Fact] // Base case
public void Socket_ConnectAsyncV4IPEndPointToV4Host_Throws()
{
Socket socket = new Socket(AddressFamily.InterNetworkV6, SocketType.Stream, ProtocolType.Tcp);
SocketAsyncEventArgs args = new SocketAsyncEventArgs();
args.RemoteEndPoint = new IPEndPoint(IPAddress.Loopback, UnusedPort);
Assert.Throws<NotSupportedException>(() =>
{
socket.ConnectAsync(args);
});
}
protected override void ProcessConnect(Socket socket, object targetEndPoint, SocketAsyncEventArgs e)
{
if (e != null)
{
if (!this.ValidateAsyncResult(e))
{
return;
}
}
if (socket == null)
{
this.OnException(new SocketException((int)SocketError.ConnectionAborted));
return;
}
SocketAsyncEventArgs localSocket = null;
if (e == null)
{
localSocket = new SocketAsyncEventArgs();
e = localSocket;
}
string request;
try
{
var targetDnsEndPoint = targetEndPoint as DnsEndPoint;
if (targetDnsEndPoint != null)
{
request = string.Format(CultureInfo.InvariantCulture, RequestTemplate, targetDnsEndPoint.Host, targetDnsEndPoint.Port);
}
else
{
var targetIPEndPoint = (IPEndPoint)targetEndPoint;
request = string.Format(CultureInfo.InvariantCulture, RequestTemplate, targetIPEndPoint.Address, targetIPEndPoint.Port);
}
var requestData = Encoding.ASCII.GetBytes(request);
e.Completed += this.AsyncEventArgsCompleted;
e.UserToken = new ConnectContext { Socket = socket, SearchState = new SearchMarkState<byte>(lineSeparator) };
e.SetBuffer(requestData, 0, requestData.Length);
this.StartSend(socket, e);
}
finally
{
if (localSocket != null)
{
localSocket.Dispose();
}
}
}
protected bool ValidateAsyncResult(SocketAsyncEventArgs e)
{
if (e.SocketError != SocketError.Success)
{
var socketException = new SocketException((int)e.SocketError);
OnCompleted(new ProxyEventArgs(new Exception(socketException.Message, socketException)));
return false;
}
return true;
}
public ClientConnection()
{
createProtocol();
m_ReadEventArg = makeSocketAsyncEventArgs();
int defaultLength = 5;
m_writeEventArgPool = new Stack<SocketAsyncEventArgs>(defaultLength);
for (int i = 0; i < defaultLength; i++)
{
m_writeEventArgPool.Push(makeSocketAsyncEventArgs());
}
}
protected override void OnGetSocket(SocketAsyncEventArgs e)
{
if (Buffer.Array == null)
Buffer = new ArraySegment<byte>(new byte[ReceiveBufferSize], 0, ReceiveBufferSize);
e.SetBuffer(Buffer.Array, Buffer.Offset, Buffer.Count);
m_SocketEventArgs = e;
OnConnected();
StartReceive();
}
public void Unix_NotSupported_ThrowsPlatformNotSupportedException(SocketImplementationType type)
{
int port;
using (SocketTestServer.SocketTestServerFactory(type, _serverAddress, out port))
using (var sock = new Socket(AddressFamily.InterNetworkV6, SocketType.Stream, ProtocolType.Tcp))
using (var args = new SocketAsyncEventArgs())
{
sock.Connect(new IPEndPoint(_serverAddress, port));
args.SendPacketsElements = new SendPacketsElement[1];
Assert.Throws<PlatformNotSupportedException>(() => sock.SendPacketsAsync(args));
}
}
public ConnectionServer()
{
createProtocol();
m_connectionServer = new Socket(AddressFamily.InterNetwork, SocketType.Stream,
ProtocolType.Tcp);
m_ReadEventArg = makeSocketAsyncEventArgs();
int defaultLength = 8;
for (int i = 0; i < defaultLength; i++)
{
m_writeEventArgPool.Push(makeSocketAsyncEventArgs());
}
}
protected override void OnGetSocket(SocketAsyncEventArgs e)
{
try
{
var sslStream = new SslStream(new NetworkStream(Client), false, ValidateRemoteCertificate);
sslStream.BeginAuthenticateAsClient(HostName, OnAuthenticated, sslStream);
}
catch (Exception exc)
{
if (!IsIgnorableException(exc))
OnError(exc);
}
}
public override void Connect(Action<SocketError> onConnectCallback)
{
var connectEventArgs = new SocketAsyncEventArgs();
connectEventArgs.RemoteEndPoint = _endpoint;
connectEventArgs.UserToken = onConnectCallback;
connectEventArgs.Completed += OnConnect;
bool willRaiseEvent = _s.ConnectAsync(connectEventArgs);
if (!willRaiseEvent)
{
ProcessConnect(connectEventArgs);
}
}
public async Task Socket_ConnectAsyncUnixDomainSocketEndPoint_Success()
{
string path = null;
SocketTestServer server = null;
UnixDomainSocketEndPoint endPoint = null;
for (int attempt = 0; attempt < 5; attempt++)
{
path = GetRandomNonExistingFilePath();
endPoint = new UnixDomainSocketEndPoint(path);
try
{
server = SocketTestServer.SocketTestServerFactory(endPoint, ProtocolType.Unspecified);
break;
}
catch (SocketException)
{
//Path selection is contingent on a successful Bind().
//If it fails, the next iteration will try another path.
}
}
try
{
Assert.NotNull(server);
SocketAsyncEventArgs args = new SocketAsyncEventArgs();
args.RemoteEndPoint = endPoint;
args.Completed += (s, e) => ((TaskCompletionSource<bool>)e.UserToken).SetResult(true);
var complete = new TaskCompletionSource<bool>();
args.UserToken = complete;
using (Socket sock = new Socket(AddressFamily.Unix, SocketType.Stream, ProtocolType.Unspecified))
{
Assert.True(sock.ConnectAsync(args));
await complete.Task;
Assert.Equal(SocketError.Success, args.SocketError);
Assert.Null(args.ConnectByNameError);
}
}
finally
{
server.Dispose();
try { File.Delete(path); }
catch { }
}
}
private void OnReceive(object sender, SocketAsyncEventArgs args)
private void SendSockerArg_Completed(object sender, SocketAsyncEventArgs e)
{
ProcessSend(e);
}
private void OnDisconnectComplete(object o)
{
SocketAsyncEventArgs e = (SocketAsyncEventArgs)o;
this.OnError((int)e.SocketError);
}
/// <summary>
/// Cancels an asynchronous request for a remote host connection.
/// </summary>
/// <param name="e">The System.Net.Sockets.SocketAsyncEventArgs object used to request the connection to the remote host by calling one of the ConnectAsync methods.</param>
public static void CancelConnectAsync([NotNull] SocketAsyncEventArgs e)
{
Socket.CancelConnectAsync(e);
}
private static void CheckSocketConnect <T>(object internetState)
{
InternetState <T> state = internetState as InternetState <T>;
Action <bool> callback = state.Callback;
Action <PubnubClientError> errorCallback = state.ErrorCallback;
string[] channels = state.Channels;
string[] channelGroups = state.ChannelGroups;
try
{
#if (SILVERLIGHT || WINDOWS_PHONE)
using (Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
{
SocketAsyncEventArgs sae = new SocketAsyncEventArgs();
sae.UserToken = state;
sae.RemoteEndPoint = new DnsEndPoint("pubsub.pubnub.com", 80);
sae.Completed += new EventHandler <SocketAsyncEventArgs>(socketAsync_Completed <T>);
bool test = socket.ConnectAsync(sae);
mreSocketAsync.WaitOne(1000);
sae.Completed -= new EventHandler <SocketAsyncEventArgs>(socketAsync_Completed <T>);
socket.Close();
}
#elif NETFX_CORE
CheckSocketConnectAsync();
#elif (UNITY_IOS || UNITY_ANDROID)
request = (HttpWebRequest)WebRequest.Create("http://pubsub.pubnub.com");
if (request != null)
{
request.Timeout = HeartbeatInterval * 1000;
request.ContentType = "application/json";
response = request.GetResponse();
if (response != null)
{
if (((HttpWebResponse)response).ContentLength <= 0)
{
_status = false;
throw new Exception("Failed to connect");
}
else
{
using (Stream dataStream = response.GetResponseStream()){
using (StreamReader reader = new StreamReader(dataStream)){
string responseFromServer = reader.ReadToEnd();
LoggingMethod.WriteToLog(string.Format("DateTime {0}, Response:{1}", DateTime.Now.ToString(), responseFromServer), LoggingMethod.LevelInfo);
_status = true;
callback(true);
reader.Close();
}
dataStream.Close();
}
}
}
}
#elif (__MonoCS__)
udp = new UdpClient("pubsub.pubnub.com", 80);
IPAddress localAddress = ((IPEndPoint)udp.Client.LocalEndPoint).Address;
if (udp != null && udp.Client != null)
{
EndPoint remotepoint = udp.Client.RemoteEndPoint;
string remoteAddress = (remotepoint != null) ? remotepoint.ToString() : "";
LoggingMethod.WriteToLog(string.Format("DateTime {0} checkInternetStatus LocalIP: {1}, RemoteEndPoint:{2}", DateTime.Now.ToString(), localAddress.ToString(), remoteAddress), LoggingMethod.LevelVerbose);
_status = true;
callback(true);
}
#else
using (UdpClient udp = new UdpClient("pubsub.pubnub.com", 80))
{
IPAddress localAddress = ((IPEndPoint)udp.Client.LocalEndPoint).Address;
EndPoint remotepoint = udp.Client.RemoteEndPoint;
string remoteAddress = (remotepoint != null) ? remotepoint.ToString() : "";
udp.Close();
LoggingMethod.WriteToLog(string.Format("DateTime {0} checkInternetStatus LocalIP: {1}, RemoteEndPoint:{2}", DateTime.Now.ToString(), localAddress.ToString(), remoteAddress), LoggingMethod.LevelVerbose);
callback(true);
}
#endif
}
#if (UNITY_IOS || UNITY_ANDROID)
catch (WebException webEx) {
if (webEx.Message.Contains("404"))
{
_status = true;
callback(true);
}
else
{
_status = false;
ParseCheckSocketConnectException <T>(webEx, channels, errorCallback, callback);
}
}
#endif
catch (Exception ex)
{
#if (__MonoCS__)
_status = false;
#endif
ParseCheckSocketConnectException <T>(ex, channels, channelGroups, errorCallback, callback);
}
finally
{
#if (UNITY_IOS || UNITY_ANDROID)
if (response != null)
{
response.Close();
response = null;
}
if (request != null)
{
request = null;
}
#elif (__MonoCS__)
if (udp != null)
{
udp.Close();
}
#endif
#if (UNITY_IOS)
GC.Collect();
#endif
}
#if (!UNITY_ANDROID && !UNITY_IOS)
mres.Set();
#endif
}
private void OnSaeaCompleted(object sender, SocketAsyncEventArgs args)
{
this.CompletedHandler();
}
/// <summary>
/// 关闭socket连接
/// </summary>
/// <param name="e">SocketAsyncEventArg associated with the completed send/receive operation.</param>
private void CloseClientSocket(SocketAsyncEventArgs e)
{
Socket s = e.UserToken as Socket;
this.CloseClientSocket(s, e);
}
protected override bool AsyReceive(SocketAsyncEventArgs saea)
{
return(this.listenSocket.AcceptAsync(saea));
}
private void AcceptEventArg_Completed(object sender, SocketAsyncEventArgs e)
{
ProcessAccept(e);
}
public bool Start()
{
int bufferSize = 0;//AppServer.Config.ReceiveBufferSize;
int maxConnection = int.Parse(JsonConfigManager.Instance.Configures["max_connect"]);
if (bufferSize <= 0)
{
bufferSize = 1024 * 4;
}
_bufferManager = new BufferManager(bufferSize * maxConnection, bufferSize);
try
{
_bufferManager.InitBuffer();
}
catch (Exception e)
{
throw e;
//AppServer.Logger.Error("Failed to allocate buffer for async socket communication, may because there is no enough memory, please decrease maxConnectionNumber in configuration!", e);
//return false;
}
var sendingQueuePool = new SmartPool <SendingQueue>();
sendingQueuePool.Initialize(Math.Max(maxConnection / 6, 256),
Math.Max(maxConnection * 2, 256),
new SendingQueueSourceCreator(5));
SendingQueuePool = sendingQueuePool;
// preallocate pool of SocketAsyncEventArgs objects
SocketAsyncEventArgs socketEventArg;
var socketArgsProxyList = new List <SocketAsyncEventArgsProxy>(maxConnection);
for (int i = 0; i < maxConnection; i++)
{
//Pre-allocate a set of reusable SocketAsyncEventArgs
socketEventArg = new SocketAsyncEventArgs();
_bufferManager.SetBuffer(socketEventArg);
socketArgsProxyList.Add(new SocketAsyncEventArgsProxy(socketEventArg));
}
_readWritePool = new ConcurrentStack <SocketAsyncEventArgsProxy>(socketArgsProxyList);
_socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.KeepAlive, true);
_socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.DontLinger, true);
SocketAsyncEventArgs acceptEventArg = new SocketAsyncEventArgs();
//m_AcceptSAE = acceptEventArg;
acceptEventArg.Completed += AcceptEventArg_Completed;
_socket.Listen(100);
if (!_socket.AcceptAsync(acceptEventArg))
{
ProcessAccept(acceptEventArg);
}
IsRunning = true;
return(true);
}
private void ReceiveSocketArg_Completed(object sender, SocketAsyncEventArgs e)
{
ProcessReceived(e);
}
public static Object ResolveServerPacket(PacketTypes packetType, Object receivedObj)
{
SocketAsyncEventArgs args = receivedObj as SocketAsyncEventArgs;
Object retObj = null;
int offset = 0;
int vsHeader = BitConverter.ToInt32(args.Buffer, offset);
int pSize = BitConverter.ToInt32(args.Buffer, offset += Constant.INT_SIZE);
//패킷 사이즈가 템플렛(헤더+사이즈+풋터) 보다 작으면 null 리턴
if (pSize < Constant.INT_SIZE * 3)
{
return(retObj);
}
int vsFooter = BitConverter.ToInt32(args.Buffer, pSize - Constant.INT_SIZE);
Byte[] packet = new Byte[pSize - Constant.INT_SIZE * 3];
Buffer.BlockCopy(args.Buffer, offset += Constant.INT_SIZE, packet, 0, packet.Length);
if (vsHeader == Constant.PACKET_VELOSTEP_HEADER && vsFooter == Constant.PACKET_VELOSTEP_FOOTER &&
pSize == args.BytesTransferred)
{
offset = 0;
switch (packetType)
{
case PacketTypes.FindServer:
ServerInfo serverInfo = new ServerInfo();
IPEndPoint remoteEndPoint = args.RemoteEndPoint as IPEndPoint;
serverInfo.ServerIP = remoteEndPoint.Address.ToString();
serverInfo.UdpPort = remoteEndPoint.Port;
serverInfo.TcpPort = BitConverter.ToInt32(packet, offset);
serverInfo.ServerName = Encoding.UTF8.GetString(packet, offset += Constant.INT_SIZE, packet.Length - Constant.INT_SIZE);
retObj = serverInfo;
break;
case PacketTypes.Coordinates:
break;
case PacketTypes.Authentication:
ServerExtraInfo serverExtraInfo = null;
//결과 bool로 파싱하지만 실제 길이는 INT_SIZE임.
if (BitConverter.ToBoolean(packet, offset))
{
byte[] macAddr = null;
int keybdCount = BitConverter.ToInt32(packet, offset += Constant.INT_SIZE);
int macAddrCount = BitConverter.ToInt32(packet, offset += Constant.INT_SIZE);
List <KeyboardLayoutTypes> keyboardList = new List <KeyboardLayoutTypes>();
List <Byte[]> macAddrList = new List <Byte[]>();
//키보드 리스트
for (int i = 0; i < keybdCount; i++)
{
keyboardList.Add((KeyboardLayoutTypes)BitConverter.ToInt32(packet, offset += Constant.INT_SIZE));
}
offset += Constant.INT_SIZE;
//맥 주소 리스트
for (int i = 0; i < macAddrCount; i++)
{
macAddr = new byte[6];
Buffer.BlockCopy(packet, offset, macAddr, 0, macAddr.Length);
macAddrList.Add(macAddr);
offset += macAddr.Length;
//for (int j=0; j<6; j++)
// System.Diagnostics.Debug.WriteLine(string.Format("{0:X}-", macAddr[j]));
}
if (keybdCount > 0 || macAddrCount > 0)
{
serverExtraInfo = new ServerExtraInfo();
serverExtraInfo.KeyboardList = keyboardList;
serverExtraInfo.MacAddressList = macAddrList;
}
}
retObj = serverExtraInfo;
break;
case PacketTypes.RequestImage:
break;
case PacketTypes.DeviceMode:
break;
case PacketTypes.VirtualButton:
break;
case PacketTypes.AutoConnect:
break;
case PacketTypes.CheckConnection:
ServerExtraInfo serverStatusInfo = null;
int nRet = BitConverter.ToInt32(packet, offset);
if (nRet == 1)
{
serverStatusInfo = new ServerExtraInfo();
serverStatusInfo.ScreenType = (ScreenTypes)BitConverter.ToInt32(packet, offset += Constant.INT_SIZE);
BitConverter.ToInt32(packet, offset += Constant.INT_SIZE);
BitConverter.ToInt32(packet, offset += Constant.INT_SIZE);
BitConverter.ToInt32(packet, offset += Constant.INT_SIZE);
}
retObj = serverStatusInfo;
break;
case PacketTypes.Keyboard:
break;
}
}
return(retObj);
}
static void OnWriteComplete(object sender, SocketAsyncEventArgs socketArgs)
{
WriteAsyncEventArgs socketArgsEx = (WriteAsyncEventArgs)socketArgs;
socketArgsEx.Transport.HandleWriteComplete(socketArgsEx.Args, false);
}
internal ClientCnxnSocketNIO(ClientCnxn cnxn) : base(cnxn)
{
receiveEventArgs = new SocketAsyncEventArgs();
receiveEventArgs.SetBuffer(new byte[0], 0, 0);
receiveEventArgs.Completed += delegate { ReceiveCompleted(); };
}
void ConnectAsyncCompleted(object sender, SocketAsyncEventArgs eventArgs)
{
connectingState.SetValue(CONNECTING, PENDINGCONNECTASYNC);
wakeupCnxn();
}
private void EndAccept(SocketAsyncEventArgs args)
{
using (this.trace.Open())
{
Socket client = null;
try
{
if (args.SocketError != SocketError.Success)
{
throw new SocketException((int)args.SocketError);
}
client = args.AcceptSocket;
if (this.cancel.IsCancellationRequested)
{
return;
}
NodeServerTrace.Information("Client connection accepted : " + client.RemoteEndPoint);
var cancel = CancellationTokenSource.CreateLinkedTokenSource(this.cancel.Token);
cancel.CancelAfter(TimeSpan.FromSeconds(10));
var stream = new NetworkStream(client, false);
while (true)
{
if (this.ConnectedNodes.Count >= this.MaxConnections)
{
NodeServerTrace.Information("MaxConnections limit reached");
Utils.SafeCloseSocket(client);
break;
}
cancel.Token.ThrowIfCancellationRequested();
PerformanceCounter counter;
Message message = Message.ReadNext(stream, this.Network, this.Version, cancel.Token, out counter);
this.messageProducer.PushMessage(new IncomingMessage()
{
Socket = client,
Message = message,
Length = counter.ReadBytes,
Node = null,
});
if (message.Payload is VersionPayload)
{
break;
}
NodeServerTrace.Error("The first message of the remote peer did not contained a Version payload", null);
}
}
catch (OperationCanceledException)
{
Utils.SafeCloseSocket(client);
if (!this.cancel.Token.IsCancellationRequested)
{
NodeServerTrace.Error("The remote connecting failed to send a message within 10 seconds, dropping connection", null);
}
}
catch (Exception ex)
{
if (this.cancel.IsCancellationRequested)
{
return;
}
if (client == null)
{
NodeServerTrace.Error("Error while accepting connection ", ex);
Thread.Sleep(3000);
}
else
{
Utils.SafeCloseSocket(client);
NodeServerTrace.Error("Invalid message received from the remote connecting node", ex);
}
}
this.BeginAccept();
}
}
// Token: 0x0600001D RID: 29 RVA: 0x000022A8 File Offset: 0x000004A8
private static void ClearSocketAsyncEventArgs(SocketAsyncEventArgs e)
{
e.Completed -= ConnectAsyncExtension.SocketConnectCompleted;
e.UserToken = null;
}
private void Accept_Completed(object sender, SocketAsyncEventArgs e)
{
this.EndAccept(e);
}
/// <summary>Begins an asynchronous request for a connection to a remote host.</summary>
/// <returns>Returns true if the I/O operation is pending. The <see cref="E:System.Net.Sockets.SocketAsyncEventArgs.Completed" /> event on the <paramref name="e" /> parameter will be raised upon completion of the operation. Returns false if the I/O operation completed synchronously. In this case, The <see cref="E:System.Net.Sockets.SocketAsyncEventArgs.Completed" /> event on the <paramref name="e" /> parameter will not be raised and the <paramref name="e" /> object passed as a parameter may be examined immediately after the method call returns to retrieve the result of the operation. </returns>
/// <param name="socketType">One of the <see cref="T:System.Net.Sockets.SocketType" /> values.</param>
/// <param name="protocolType">One of the <see cref="T:System.Net.Sockets.ProtocolType" /> values.</param>
/// <param name="e">The <see cref="T:System.Net.Sockets.SocketAsyncEventArgs" /> object to use for this asynchronous socket operation.</param>
/// <exception cref="T:System.ArgumentException">An argument is not valid. This exception occurs if multiple buffers are specified, the <see cref="P:System.Net.Sockets.SocketAsyncEventArgs.BufferList" /> property is not null. </exception>
/// <exception cref="T:System.ArgumentNullException">The <paramref name="e" /> parameter cannot be null and the <see cref="P:System.Net.Sockets.SocketAsyncEventArgs.RemoteEndPoint" /> cannot be null.</exception>
/// <exception cref="T:System.InvalidOperationException">The <see cref="T:System.Net.Sockets.Socket" /> is listening or a socket operation was already in progress using the <see cref="T:System.Net.Sockets.SocketAsyncEventArgs" /> object specified in the <paramref name="e" /> parameter.</exception>
/// <exception cref="T:System.Net.Sockets.SocketException">An error occurred when attempting to access the socket. See the Remarks section for more information.</exception>
/// <exception cref="T:System.NotSupportedException">Windows XP or later is required for this method. This exception also occurs if the local endpoint and the <see cref="P:System.Net.Sockets.SocketAsyncEventArgs.RemoteEndPoint" /> are not the same address family.</exception>
/// <exception cref="T:System.ObjectDisposedException">The <see cref="T:System.Net.Sockets.Socket" /> has been closed. </exception>
/// <exception cref="T:System.Security.SecurityException">A caller higher in the call stack does not have permission for the requested operation.</exception>
public static bool ConnectAsync(SocketType socketType, ProtocolType protocolType, [NotNull] SocketAsyncEventArgs e)
{
return(Socket.ConnectAsync(socketType, protocolType, e));
}
private static void AsyncOperationCompleted(object sender, SocketAsyncEventArgs e)
{
const int TIME_OUT = 10000;
var semaphoreAcquired = false;
try
{
semaphoreAcquired = s_semaphore.WaitOne(TIME_OUT);
if (semaphoreAcquired)
{
if (e.SocketError == SocketError.Success)
{
switch (e.LastOperation)
{
case SocketAsyncOperation.Accept:
ProcessAccept(e, true);
break;
case SocketAsyncOperation.Receive:
ProcessReceive(e, true);
break;
case SocketAsyncOperation.Send:
ProcessSend(e);
break;
default:
throw new Exception("Unexpected operation.");
}
}
else
{
if (Constants.Verbosity >= 3)
{
Logger.SayInfo($"A socket operation wasn't successful => {e.LastOperation}. Dropping connection.");
}
Drop(e);
// If the last operation was an accept operation, continue accepting
// for new connections.
if (e.LastOperation == SocketAsyncOperation.Accept)
{
var args = GetArgs();
StartAccept(args);
}
}
}
else
{
Logger.Error("SEMAPHORE DID NOT RESPOND IN TIME!");
Drop(e);
}
}
catch (Exception ex)
{
ExceptionLogger.Log(ex, "Exception occurred while processing async operation (potentially critical). Dropping connection");
Drop(e);
}
finally
{
if (semaphoreAcquired)
{
s_semaphore.Release();
}
}
}
/// <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 TcpOpenServer.SendState.Asynchronous: return;
case TcpOpenServer.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>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OnAsyncEventCompleted(object sender, SocketAsyncEventArgs e)
{
_tsa.AddToSyncAction(() => {
ProcessReceive(e);
});
}
private void OnReceiveAsyncCompleted(object sender, SocketAsyncEventArgs e)
{
// No other code should go here. All handling is the same on async and sync completion.
ProcessReceive(e);
}
public SocketAsyncEventArgsProxy(SocketAsyncEventArgs socketEventArgs)
{
SocketEventArgs = socketEventArgs;
SocketEventArgs.Completed += new EventHandler <SocketAsyncEventArgs>(SocketEventArgs_Completed);
}
void OnReceiveAsync(object _obj, SocketAsyncEventArgs _receiveArgs)
{
CUserToken _token = _receiveArgs.UserToken as CUserToken;
int _debugWorkNum = _token.GetWorkNum();
int _identityID = _token.identityID;
if (Protocol.DEBUG)
{
Console.WriteLine("[{0}]OnReceiveAsync (callback) \n >> socket:{1} BytesTransferred:{2} LastOperation:{3} SocketError:{4}", _identityID + "/" + _debugWorkNum, _token.socket.Connected, _receiveArgs.BytesTransferred, _receiveArgs.LastOperation, _receiveArgs.SocketError);
}
if (Protocol.DEBUG_PACKET_LOOP_SHOW && _debugWorkNum % Protocol.DEBUG_PACKET_LOOP_COUNT <= 1)
{
Console.WriteLine("[{0}]OnReceiveAsync (callback) \n >> socket:{1} BytesTransferred:{2} LastOperation:{3} SocketError:{4}", _identityID + "/" + _debugWorkNum, _token.socket.Connected, _receiveArgs.BytesTransferred, _receiveArgs.LastOperation, _receiveArgs.SocketError);
}
if (_receiveArgs.LastOperation == SocketAsyncOperation.Receive &&
_receiveArgs.SocketError == SocketError.Success &&
_receiveArgs.BytesTransferred > 0)
{
Socket _clientSocket = _token.socket;
SocketAsyncEventArgs _sendArgs = _token.sendArgs;
//---------------------------------------
// Client -> Socket -> (callback) -> OnReceiveAsync
// Data Parsing
//---------------------------------------
int _transferred = _receiveArgs.BytesTransferred;
Array.Copy(_receiveArgs.Buffer, _receiveArgs.Offset, _token.receiveBuffer2, 0, _transferred);
string _text = Encoding.ASCII.GetString(_token.receiveBuffer2, 0, _transferred);
if (Protocol.DEBUG_PACKET)
{
Console.WriteLine("[{0}] size:{1} >> {2}", _identityID + "/" + _debugWorkNum, _transferred, _text);
}
//-------------------------------
// SendAsync....
// Message Queue에 넣어두기... (보내는 byte[]가 반드시 다른 버퍼)
//-------------------------------
_token.SendMessage(Encoding.ASCII.GetBytes(_text), _debugWorkNum);
//-------------------------------
//ReceiveAsync...
//-------------------------------
bool _bReceiveAsync = _clientSocket.ReceiveAsync(_receiveArgs);
if (_bReceiveAsync == false)
{
Console.WriteLine(" [{0}]OnReceiveAsync .ReceiveAsync 재등록후(소켓꺼짐) {1}/{2}/{3}/{4}", _identityID + "/" + _debugWorkNum, _token.socket.Connected, _receiveArgs.BytesTransferred, _receiveArgs.LastOperation, _receiveArgs.SocketError);
if (_token.socket.Connected == false)
{
Console.WriteLine(" >> Disconnect ");
Disconnect("[정상종료2]", _token);
}
else
{
Console.WriteLine(" [{0}] #### OnReceiveAsync > _socket.ReceiveAsync 메세지 받기(2) 등록하자마사 바로 받음.{1}", _identityID, _clientSocket.Connected);
OnReceiveAsync(_clientSocket, _receiveArgs);
}
}
}
else
{
Console.WriteLine("[{0}]OnReceiveAsync [정상종료] >>> :{1} :{2} :{3} :{4}", _identityID + "/" + _debugWorkNum, _token.socket.Connected, _receiveArgs.BytesTransferred, _receiveArgs.LastOperation, _receiveArgs.SocketError);
Disconnect("[정상종료1]", _token);
}
}
private void OnSendAsyncCompleted(object sender, SocketAsyncEventArgs e)
{
// No other code should go here. All handling is the same for sync/async completion.
ProcessSend(e);
}
public void Poll()
{
int elapsed = Environment.TickCount - m_lastTickCount;
m_lastTickCount = Environment.TickCount;
GameConnectionState originalState = State;
switch (State)
{
case GameConnectionState.Disconnected:
{
m_connectionBackOffTimer -= elapsed;
if (m_connectionBackOffTimer <= 0.0f)
{
ChangeState(GameConnectionState.Connecting);
}
break;
}
case GameConnectionState.Connecting:
{
if (m_stateTime == 0.0f)
{
m_socket = new Socket(SocketType.Stream, ProtocolType.Tcp);
m_socket.NoDelay = true;
m_socket.LingerState.Enabled = false;
m_connect_args = new SocketAsyncEventArgs();
m_connect_args.Completed += AsyncConnectCompleted;
m_connect_args.RemoteEndPoint = new IPEndPoint(IPAddress.Parse(Configuration.IP), Configuration.Port);
System.Console.WriteLine("[{0}:{1}] Starting connection ...", Configuration.IP, Configuration.Port);
m_socket.ConnectAsync(m_connect_args);
}
break;
}
case GameConnectionState.Connected:
{
if ((m_socket.Poll(0, SelectMode.SelectRead) && m_socket.Available == 0) || !m_socket.Connected)
{
System.Console.WriteLine("[{0}:{1}] Disconnected.", Configuration.IP, Configuration.Port);
ChangeState(GameConnectionState.Disconnected);
m_connectionBackOffTimer = ConnectionFailureBackoff;
}
else
{
if (m_recieving_payload)
{
if (m_socket.Available >= 0)
{
int toRead = Math.Min((int)(m_payload_size - m_payload_buffer_read), (int)m_socket.Available);
m_socket.Receive(m_payload_buffer, m_payload_buffer_read, toRead, SocketFlags.None);
m_payload_buffer_read += toRead;
if (m_payload_buffer_read >= m_payload_size)
{
Recieve(m_payload_buffer);
m_payload_buffer_read = 0;
m_recieving_payload = false;
}
}
}
else if (m_socket.Available > 4)
{
byte[] sizeBuffer = new byte[4];
m_socket.Receive(sizeBuffer);
m_payload_size = BitConverter.ToUInt32(sizeBuffer, 0);
m_payload_buffer = new byte[m_payload_size];
m_payload_buffer_read = 0;
m_recieving_payload = true;
}
}
break;
}
}
if (State == originalState)
{
m_stateTime += elapsed;
}
}
static void OnReadComplete(object sender, SocketAsyncEventArgs socketArgs)
{
ReadAsyncEventArgs socketArgsEx = (ReadAsyncEventArgs)socketArgs;
socketArgsEx.Transport.HandleReadComplete(socketArgsEx.Args, false, false);
}
private void Connected_Completed(object sender, SocketAsyncEventArgs e)
{
ProccessConnected(e);
}
/// <summary>
/// accept 操作完成时回调函数
/// </summary>
/// <param name="sender">Object who raised the event.</param>
/// <param name="e">SocketAsyncEventArg associated with the completed accept operation.</param>
private void OnAcceptCompleted(object sender, SocketAsyncEventArgs e)
{
this.ProcessAccept(e);
}
