コード例 #1
0
        private void HandleAsyncReceive(IAsyncResult res)
        {
            ServerStateObject state  = (ServerStateObject)res.AsyncState;
            TClient           client = state.client;

            try
            {
                // read data from the client socket
                int read = client.Socket.EndReceive(res);

                // data was read from client socket
                if (read > 0)
                {
                    using (MemoryStream stream = new MemoryStream(state.buffer, 0, read, false, true))
                        ReceiveMessage(client, stream);

                    // begin receiving again after handling, so we can re-usse the same stateobject/buffer without issues.
                    client.Socket.BeginReceive(state.buffer, 0, ServerStateObject.BufferSize, 0, HandleAsyncReceive, state);
                }
                else
                {
                    // connection was closed.
                    Log.Info("Client closed connection: {0}", client.Socket.RemoteEndPoint);
                    client.Close();
                }
            }
            catch (SocketException e)
            {
                switch (e.SocketErrorCode)
                {
                // TODO: More SocketError handling.
                case SocketError.ConnectionReset:
                    Log.ErrorException(string.Format("Client {0} issued a ConnectionReset error.", client), e);
                    client.Close();
                    break;

                default:
                    // Swallow the exception, but make sure a log is created and close the client.
                    //Log.ErrorException(string.Format("Unhandled SocketException (Error:{0}) for client {1} while receiving. Closing the client.", e.SocketErrorCode, client.ToString()), e);
                    client.Close();
                    break;
                }
            }
            catch (Exception e)
            {
                // Note: State for this client may have been corrupted at this point, this is
                //  an important issue when we reach this handler. This will force process to close.

                // Todo: Close anything else if needed (i.e. session, this will catch every unhandled exception in the handler, ect).
                Log.ErrorException("Exception occured while handling a packet", e);

                // We're most likely crashing, client is going to close anyway,
                //  maybe it's better not to do more with it.
                //client.Close();

                throw;
            }
        }
コード例 #2
0
        private void HandleAsyncConnection(IAsyncResult res)
        {
            m_listener.BeginAcceptTcpClient(HandleAsyncConnection, m_listener);
            TcpClient client = m_listener.EndAcceptTcpClient(res);

            if (!IsClientAccepted(client.Client))
            {
                Log.Warn("Refused connection from {0}", client.Client.RemoteEndPoint);
                return;
            }

            Log.Info("Openned connection from {0}", client.Client.RemoteEndPoint);

            ServerStateObject state = new ServerStateObject();

            state.client = CreateClient(client.Client);

            ClientConnected(state.client);
            client.Client.BeginReceive(state.buffer, 0, ServerStateObject.BufferSize, SocketFlags.None, HandleAsyncReceive, state);
        }
コード例 #3
0
        //private void StateChangedCallback(ServerStateObject param)
        //{
        //}
        protected void StartListening(ServerStateObject context)
        {
            //context.StateChangedHandler = new Action<ServerStateObject>(StateChangedCallback);

            // Data buffer for incoming data.
            byte[] bytes = new Byte[1024];

            // Establish the local endpoint for the socket.
            // The DNS name of the computer
            // running the listener is "host.contoso.com".
            IPHostEntry ipHostInfo = Dns.GetHostEntry(Dns.GetHostName());
            IPAddress ipAddress = ipHostInfo.AddressList.FirstOrDefault(ip => { return ip.AddressFamily == AddressFamily.InterNetwork; });
            if (ipAddress == null)
            {
                this.OnError(ErrorType.Error, new NotSupportedException("IPv4 주소만 지원합니다. 컴퓨터에 IPv4 주소로 인터넷이 연결되어 있는지 확인하세요"));
                return;
            }

            this.HostAddress = ipAddress;

            IPEndPoint localEndPoint = new IPEndPoint(ipAddress, context.Port);

            // Create a TCP/IP socket.
            Socket listener = new Socket(AddressFamily.InterNetwork,
                SocketType.Stream, ProtocolType.Tcp);

            // Bind the socket to the local endpoint and listen for incoming connections.
            try
            {
                listener.Bind(localEndPoint);
                listener.Listen(100);

                this.OnStartListening(listener);

                while (context.IsListening)
                {
                    // Set the event to nonsignaled state.
                    allDone.Reset();

                    // Start an asynchronous socket to listen for connections.
                    Console.WriteLine("Waiting for a connection...");
                    listener.BeginAccept(
                        new AsyncCallback(AcceptCallback),
                        listener);

                    // Wait until a connection is made before continuing.
                    allDone.WaitOne(TimeSpan.FromMilliseconds(1000));
                }

                this.OnStopListening(listener);

            }
            catch (Exception e)
            {
                Console.WriteLine(e.ToString());

                this.OnError(ErrorType.Error, e);
            }

            Console.WriteLine("\nPress ENTER to continue...");
            Console.Read();
        }