static void Main(string[] args)
        {
            var m_Config = new ServerConfig
            {
                Port = 911,
                Ip = "Any",
                MaxConnectionNumber = 1000,
                Mode = SocketMode.Tcp,
                Name = "CustomProtocolServer"
            };

            var m_Server = new CustomProtocolServer();
            m_Server.Setup(m_Config, logFactory: new ConsoleLogFactory());
            m_Server.Start();

            EndPoint serverAddress = new IPEndPoint(IPAddress.Parse("127.0.0.1"), m_Config.Port);

            using (Socket socket = new Socket(serverAddress.AddressFamily, SocketType.Stream, ProtocolType.Tcp))
            {
                socket.Connect(serverAddress);

                var socketStream = new NetworkStream(socket);
                var reader = new StreamReader(socketStream, Encoding.ASCII, false);

                string charSource = Guid.NewGuid().ToString().Replace("-", string.Empty)
                    + Guid.NewGuid().ToString().Replace("-", string.Empty)
                    + Guid.NewGuid().ToString().Replace("-", string.Empty);

                Random rd = new Random();

                var watch = Stopwatch.StartNew();
                for (int i = 0; i < 10; i++)
                {
                    int startPos = rd.Next(0, charSource.Length - 2);
                    int endPos = rd.Next(startPos + 1, charSource.Length - 1);

                    var currentMessage = charSource.Substring(startPos, endPos - startPos + 1);

                    byte[] requestNameData = Encoding.ASCII.GetBytes("ECHO");
                    socketStream.Write(requestNameData, 0, requestNameData.Length);
                    var data = Encoding.ASCII.GetBytes(currentMessage);
                    socketStream.Write(new byte[] { (byte)(data.Length / 256), (byte)(data.Length % 256) }, 0, 2);
                    socketStream.Write(data, 0, data.Length);
                    socketStream.Flush();

                   // Console.WriteLine("Sent: " + currentMessage);

                    var line = reader.ReadLine();
                    //Console.WriteLine("Received: " + line);
                    //Assert.AreEqual(currentMessage, line);
                }

                

                watch.Stop();
                Console.WriteLine(watch.ElapsedMilliseconds);
            }

            Console.ReadLine();
        }

		public void NetworkStreamConnection ()
		{
			IPEndPoint ipe = new IPEndPoint(Dns.GetHostEntry ("www.google.com").AddressList [0], 80);
			Socket s = new Socket(ipe.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
			s.Close ();
			NetworkStream ns = new NetworkStream (s);
		}

	static string PostStream (Mono.Security.Protocol.Tls.SecurityProtocolType protocol, string url, byte[] buffer)
	{
		Uri uri = new Uri (url);
		string post = "POST " + uri.AbsolutePath + " HTTP/1.0\r\n";
		post += "Content-Type: application/x-www-form-urlencoded\r\n";
		post += "Content-Length: " + (buffer.Length + 5).ToString () + "\r\n";
		post += "Host: " + uri.Host + "\r\n\r\n";
		post += "TEST=";
		byte[] bytes = Encoding.Default.GetBytes (post);

		IPHostEntry host = Dns.Resolve (uri.Host);
		IPAddress ip = host.AddressList [0];
		Socket socket = new Socket (ip.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
		socket.Connect (new IPEndPoint (ip, uri.Port));
		NetworkStream ns = new NetworkStream (socket, false);
		SslClientStream ssl = new SslClientStream (ns, uri.Host, false, protocol);
		ssl.ServerCertValidationDelegate += new CertificateValidationCallback (CertificateValidation);

		ssl.Write (bytes, 0, bytes.Length);
		ssl.Write (buffer, 0, buffer.Length);
		ssl.Flush ();

		StreamReader reader = new StreamReader (ssl, Encoding.UTF8);
		string result = reader.ReadToEnd ();
		int start = result.IndexOf ("\r\n\r\n") + 4;
		start = result.IndexOf ("\r\n\r\n") + 4;
		return result.Substring (start);
	}

        void SendCommand(NetworkStream stream, byte command, byte[] host, int port)
        {
            byte[] request = new byte[9];
            request[0] = Version;
            request[1] = command;
            request[2] = (byte)(port / 256);
            request[3] = (byte)(port % 256);
            host.CopyTo(request, 4);
            request[8] = 0;
            stream.Write(request, 0, request.Length);

            byte[] response = new byte[8];
            stream.Read(response, 0, response.Length);
            // check null byte
            if (response[0] != 0)
                throw new Socks4Exception("Server response: invalid null byte");
            switch (response[1])
            {
                case Reply.RequestGranted:
                    return;
                case Reply.RequestRejectedOrFailed:
                    throw new Socks4Exception("Server response: request rejected or failed");
                case Reply.ClientNotIdent:
                    throw new Socks4Exception("Server response: request failed because client is not running identd (or not reachable from the server)");
                case Reply.ClientIdentUserIDFailed:
                    throw new Socks4Exception("request failed because client's identd could not confirm the user ID string in the request");
                default:
                    throw new Socks4Exception("Server response: unknown reply");
            }
        }

 public void certConnectReply(byte[] packet, NetworkStream client)
 {
     // Just send the viewData
     byte[] response = { 0x04, 0x00, 0x00, 0x00, 0x00 };
     byte[] encryptedResponse = marginEncr.encrypt(response);
     sendTCPVariableLenPacket(encryptedResponse, client);
 }

 public static void Main()
 {
     TcpListener tcpListener = new TcpListener(10);
     tcpListener.Start();
     Socket socketForClient = tcpListener.AcceptSocket();
     if (socketForClient.Connected)
     {
         Console.WriteLine("Client connected");
         NetworkStream networkStream = new NetworkStream(socketForClient);
         System.IO.StreamWriter streamWriter =
         new System.IO.StreamWriter(networkStream);
         System.IO.StreamReader streamReader =
         new System.IO.StreamReader(networkStream);
         string theString = "Sending";
         streamWriter.WriteLine(theString);
         Console.WriteLine(theString);
         streamWriter.Flush();
         theString = streamReader.ReadLine();
         Console.WriteLine(theString);
         streamReader.Close();
         networkStream.Close();
         streamWriter.Close();
     }
     socketForClient.Close();
     Console.WriteLine("Exiting...");
 }

        public void TestCustomProtocol()
        {
            EndPoint serverAddress = new IPEndPoint(IPAddress.Parse("127.0.0.1"), m_Config.Port);

            using (Socket socket = new Socket(serverAddress.AddressFamily, SocketType.Stream, ProtocolType.Tcp))
            {
                socket.Connect(serverAddress);

                var socketStream = new NetworkStream(socket);
                var reader = new StreamReader(socketStream, Encoding.ASCII, false);
                var writer = new StreamWriter(socketStream, Encoding.ASCII, 1024);

                string charSource = Guid.NewGuid().ToString().Replace("-", string.Empty)
                    + Guid.NewGuid().ToString().Replace("-", string.Empty)
                    + Guid.NewGuid().ToString().Replace("-", string.Empty);

                Random rd = new Random();

                for (int i = 0; i < 10; i++)
                {
                    int startPos = rd.Next(0, charSource.Length - 2);
                    int endPos = rd.Next(startPos + 1, charSource.Length - 1);

                    var currentMessage = charSource.Substring(startPos, endPos - startPos + 1);

                    writer.Write("ECHO {0} {1}", currentMessage.Length.ToString().PadLeft(4, '0'), currentMessage);
                    writer.Flush();

                    var line = reader.ReadLine();
                    Console.WriteLine("Received: " + line);
                    Assert.AreEqual(currentMessage, line);
                }
            }
        }

        public void TestBatchRequest()
        {
            using (var socket = CreateClient())
            {
                var socketStream = new NetworkStream(socket);
                using (var reader = new StreamReader(socketStream, Encoding.ASCII, true))
                using (var writer = new ConsoleWriter(socketStream, Encoding.ASCII, 1024 * 8))
                {
                    reader.ReadLine();

                    int size = 100;

                    var lines = new string[size];

                    for (var i = 0; i < size; i++)
                    {
                        var line = Guid.NewGuid().ToString();
                        lines[i] = line;
                        var request = CreateRequest(line);
                        writer.Write(request);
                    }

                    writer.Flush();

                    for (var i = 0; i < size; i++)
                    {
                        var receivedLine = reader.ReadLine();
                        Assert.AreEqual(lines[i], receivedLine);
                    }
                }
            }
        }

        static void BackupProcess()
        {
            Console.WriteLine("I am backup!");
            
            IPAddress ipAddress = Dns.GetHostEntry("localhost").AddressList[0];
            TcpListener listener = new TcpListener(ipAddress, port);
            listener.Start();
            Socket sock = listener.AcceptSocket();
            Stream str = new NetworkStream(sock);
            StreamReader sr = new StreamReader(str);

            string line = "-1";

            try
            {
                while (true)
                    line = sr.ReadLine();
            }
            catch(IOException)
            { 
                sr.Close();
                listener.Stop();

                PrimaryProcess(Convert.ToInt32(line) + 1);
            }
        }

 public void HandleRequest(Url url, NetworkStream stream)
 {
     foreach (IPlugin p in plugins)
     {
         p.handleRequest(url, stream);
     }
 }

        public Game(NetworkStream ns, string op_name)
        {
            InitializeComponent();
            GridX = new int[15];
            GridY = new int[10];
            Network_Stream = ns;
            arr = new char[19, 29];
            lines = new int[29];

            player1 = new Player();
            client = new Client();
            player1.OpponentName = op_name;
            if (Player.IsServer)
            {
                turn = Player.Name;
                waiting = player1.OpponentName;
            }
            else
            {
                turn = player1.OpponentName;
                waiting = Player.Name;
            }

            Thread read = new Thread(() => Read_Stream());
            read.IsBackground = true;
            read.Start();
        }

        public void TestWorkerIncompleteData()
        {
            StringBuilder output = new StringBuilder();
            Process worker;
            TcpListener CSharpRDD_SocketServer = CreateServer(output, out worker);

            using (var serverSocket = CSharpRDD_SocketServer.AcceptSocket())
            using (var s = new NetworkStream(serverSocket))
            {
                WriteWorker(s);

                SerDe.Write(s, command.Length);
                s.Write(command, 0, command.Length);

                for (int i = 0; i < 100; i++)
                    SerDe.Write(s, i.ToString());

                int count = 0;
                foreach (var bytes in ReadWorker(s, 100))
                {
                    Assert.AreEqual(count++.ToString(), Encoding.UTF8.GetString(bytes));
                }

                Assert.AreEqual(100, count);
            }

            AssertWorker(worker, output, -1, "System.NullReferenceException: Object reference not set to an instance of an object.");

            CSharpRDD_SocketServer.Stop();
        }

        void ConnectCompleted( Socket sock )
        {
            if ( sock == null )
            {
                OnDisconnected( EventArgs.Empty );
                return;
            }

            if ( !sock.Connected )
            {
                DebugLog.WriteLine( "TcpConnection", "Unable to connect" );
                OnDisconnected( EventArgs.Empty );
                return;
            }

            DebugLog.WriteLine( "TcpConnection", "Connected!" );

            isConnected = true;

            netStream = new NetworkStream( sock, false );

            netReader = new BinaryReader( netStream );
            netWriter = new BinaryWriter( netStream );

            // initialize our network thread
            netThread = new Thread( NetLoop );
            netThread.Name = "TcpConnection Thread";
            netThread.Start();

            OnConnected( EventArgs.Empty );
        }

        public static void SendXContent(NetworkStream nstm, byte[] content, int offset, int length)
        {
            byte[] balen = IntHexBytes(length); // Don't use LongLength here because nstm.Write only uses int anyway.
            nstm.Write(balen, 0, balen.Length);

            nstm.Write(content, offset, length);
        }

        private static ConnectionDetails GetConnectionDetails(NetworkStream networkStream, TcpClient tcpClient)
        {
            // read the header and check that it is a GET request
            string header = HttpHelper.ReadHttpHeader(networkStream);
            Regex getRegex = new Regex(@"^GET(.*)HTTP\/1\.1");

            Match getRegexMatch = getRegex.Match(header);
            if (getRegexMatch.Success)
            {
                // extract the path attribute from the first line of the header
                string path = getRegexMatch.Groups[1].Value.Trim();

                // check if this is a web socket upgrade request
                Regex webSocketUpgradeRegex = new Regex("Upgrade: websocket");
                Match webSocketUpgradeRegexMatch = webSocketUpgradeRegex.Match(header);

                if (webSocketUpgradeRegexMatch.Success)
                {
                    return new ConnectionDetails(networkStream, tcpClient, path, ConnectionType.WebSocket, header);
                }
                else
                {
                    return new ConnectionDetails(networkStream, tcpClient, path, ConnectionType.Http, header);
                }
            }
            else
            {
                return new ConnectionDetails(networkStream, tcpClient, string.Empty, ConnectionType.Unknown, header); 
            }
        }

		internal HttpClient(Socket socket, HttpServer server)
		{
			this.server = server;
			this.socket = socket;
			IPEndPoint remoteEndPoint = (IPEndPoint)socket.RemoteEndPoint;
			isConnected = true;
			this.remoteAddress = remoteEndPoint.Address.ToString();
			this.remotePort = remoteEndPoint.Port;

			server.Stopping += new EventHandler(server_Stopping);

			stream = new NetworkStream(socket, true);

			try
			{
				stream.BeginRead(buffer, 0, buffer.Length, new AsyncCallback(OnReceiveData), this);
				
			}
			catch(IOException)
			{
				Disconnect();
				throw;
			}
			server.OneHertzTick += new EventHandler(server_OneHertzTick);
		}

        void ConnectCompleted( object sender, SocketAsyncEventArgs e )
        {
            sock = sender as Socket;

            if ( sock == null )
            {
                OnDisconnected( EventArgs.Empty );
                return;
            }

            if ( e.SocketError != SocketError.Success )
            {
                DebugLog.WriteLine( "TcpConnection", "Unable to connect: {0}", e.SocketError );
                OnDisconnected( EventArgs.Empty );
                return;
            }

            DebugLog.WriteLine( "TcpConnection", "Connected!" );

            isConnected = true;

            netStream = new NetworkStream( sock, false );

            netReader = new BinaryReader( netStream );
            netWriter = new BinaryWriter( netStream );

            // initialize our network thread
            netThread = new Thread( NetLoop );
            netThread.Name = "TcpConnection Thread";
            netThread.Start();

            OnConnected( EventArgs.Empty );
        }

        public Client(String host, Int32 port)
        {
            try
            {

                clientName = Dns.GetHostName();

            }
            catch (SocketException se)
            {

                MessageBox.Show("ERROR: Could not retrieve client's DNS hostname.  Please try again." + se.Message + ".", "Client Socket Exception", MessageBoxButtons.OK, MessageBoxIcon.Error);
                return;

            }

            serverName = host;
            gamePort = port;
            client = new TcpClient(host, port);
            netStream = client.GetStream();
            reader = new StreamReader(netStream);
            writer = new StreamWriter(netStream);
            ssl = new SslStream(netStream, false, new RemoteCertificateValidationCallback(ValidateCert));
            cert = new X509Certificate2("server.crt");
            ssl.AuthenticateAsClient(serverName);
            writer.AutoFlush = true;
        }

        public void checkConflict()
        {
            Server_Client.Client client= new Server_Client.Client();
             this.tcpClient = client.Connect(Luu.IP, Luu.Ports);

             Entities.KhoHang kh = new Entities.KhoHang("Select");
             Entities.KhoHang[] kh1 = new Entities.KhoHang[1];
             networkStream = client.SerializeObj(this.tcpClient, "KhoHang", kh);

             kh1 = (Entities.KhoHang[])client.DeserializeHepper1(networkStream, kh1);
             if (kh1 != null)
             {
                 for (int j = 0; j < kh1.Length; j++)
                 {
                     if (kh1[j].MaKho == txtMaKho.Text)
                     {
                         MessageBox.Show("Thất bại");
                         chck = "No";
                         txtMaKho.Text = new Common.Utilities().ProcessID(txtMaKho.Text);
                         break;
                     }
                     else
                         chck = "Yes";
                 }
             }
        }

	static void Main (string [] args)
	{
		int i = 0;

		while (args [i].StartsWith ("-")){
			if (args [i] == "-debug")
				debug = true;
			if (args [i] == "-headers")
				headers = true;
			if (args [i] == "-header")
				header = args [++i];
			i++;
		}
		
		c = new TcpClient (args [i], Int32.Parse (args [i+1]));
		c.ReceiveTimeout = 1000;
		ns = c.GetStream ();
		
		sw = new StreamWriter (ns);
		sr = new StreamReader (ns);

		string host = args [i];
		if (args [i+1] != "80")
			host += ":" + args [i+1];
		send (String.Format ("GET {0} HTTP/1.1\r\nHost: {1}\r\n\r\n", args [i+2], host));

		MemoryStream ms = new MemoryStream ();
		
		try {
			byte [] buf = new byte [1024];
			int n;
			
			while ((n = ns.Read (buf, 0, 1024)) != 0){
				ms.Write (buf, 0, n);
			}
		} catch {}

		ms.Position = 0;
		sr = new StreamReader (ms);

		string s;
		
		while ((s = sr.ReadLine ()) != null){
			if (s == ""){
				if (headers)
					return;
				
				string x = sr.ReadToEnd ();
				Console.Write (x);
				break;
			}  else {
				if (debug || headers)
					Console.WriteLine (s);
				if (header != null && s.StartsWith (header)){
					Console.WriteLine (s);
					return;
				}
			}
		}
	}