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); }