private void button1_Click(object sender, EventArgs e)
        {
            System.Diagnostics.Stopwatch watch = new System.Diagnostics.Stopwatch();
            var ControllerIPAddress = new IPAddress(new byte[] { 192, 168, 0, 2 });
            var ControllerPort = 40001;
            var ControllerEndPoint = new IPEndPoint(ControllerIPAddress, ControllerPort);
            _client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

            var header = "@";
            var command = "00C";
            var checksum = "E3";
            var end = "\r\n";
            var data = header + command + checksum + end;
            byte[] bytes = new byte[1024];

            //Start Connect
            _connectDone.Reset();
            watch.Start();
            _client.BeginConnect(ControllerIPAddress, ControllerPort, new AsyncCallback(ConnectCallback), _client);
            //wait 2s
            _connectDone.WaitOne(2000, false);

            var text = (_client.Connected) ? "ok" : "ng";
            richTextBox1.AppendText(text + "\r\n");
            watch.Stop();
            richTextBox1.AppendText("Consumer time: " + watch.ElapsedMilliseconds + "\r\n");
        }

 public IPv4Destination(IPAddress ip, uint port, bool isOpenExternally)
     : base(ip, port, isOpenExternally)
 {
     if (ip.AddressFamily != AddressFamily.InterNetwork) {
         throw new ArgumentException(String.Format("ip must be IPv4 (was {0})", ip));
     }
 }

        private void HandleRData(NetBinaryReader nbr)
        {
            long startPos = nbr.BaseStream.Position;

            switch (Type)
            {
                case (QType.A):
                case (QType.AAAA):
                    recordValue = new IPAddress(nbr.ReadBytes(ByteCount));
                    break;
                    /*
                case (QType.NS):
                case (QType.CNAME):
                    recordValue = nbr.ReadLblOrPntString();
                    ReadPadOctets(nbr, startPos);
                    break;
                case (QType.SOA):
                    recordValue = new SOA(nbr);
                    ReadPadOctets(nbr, startPos);
                    break;
                    */
                default:
                    recordValue = nbr.ReadBytes(ByteCount);
                    break;
            }
        }

		public IPNetwork(IPAddress address, int cidr)
		{
			if (address == null)
			{
				throw new ArgumentNullException("address");
			}

			int addressBitLength;

			if (address.AddressFamily == AddressFamily.InterNetwork)
			{
				addressBitLength = 32;
			}
			else if (address.AddressFamily == AddressFamily.InterNetworkV6)
			{
				addressBitLength = 128;
			}
			else
			{
				throw new FormatException("Unsupported network address family.");
			}

			if (cidr < 0 || cidr > addressBitLength)
			{
				throw new ArgumentOutOfRangeException("cidr");
			}

			_NetworkAddress = address;
			_CIDR = cidr;
			_Mask = GenerateMask(cidr, addressBitLength);
		}

        /// <summary>
        /// Start the WebDAV interface using the given ip address, port and HTTPSecurity parameters.
        /// </summary>
        /// <param name="myIPAddress">The IPAddress for binding the interface at</param>
        /// <param name="myPort">The port for binding the interface at</param>
        /// <param name="myHttpWebSecurity">A HTTPSecurity class for checking security parameters like user credentials</param>
        public static Exceptional<HTTPServer<GraphDSWebDAV_Service>> StartWebDAV(this AGraphDSSharp myAGraphDSSharp, IPAddress myIPAddress, UInt16 myPort, HTTPSecurity myHttpWebSecurity = null)
        {
            try
            {
                // Initialize WebDAV service
                var _HttpWebServer = new HTTPServer<GraphDSWebDAV_Service>(
                    myIPAddress,
                    myPort,
                    new GraphDSWebDAV_Service(myAGraphDSSharp),
                    myAutoStart: true)
                {
                    HTTPSecurity = myHttpWebSecurity,
                };

                // Register the WebDAV service within the list of services
                // to stop before shutting down the GraphDSSharp instance
                myAGraphDSSharp.ShutdownEvent += new GraphDSSharp.ShutdownEventHandler((o, e) =>
                {
                    _HttpWebServer.StopAndWait();
                });

                return new Exceptional<HTTPServer<GraphDSWebDAV_Service>>(_HttpWebServer);

            }
            catch (Exception e)
            {
                return new Exceptional<HTTPServer<GraphDSWebDAV_Service>>(new GeneralError(e.Message, new System.Diagnostics.StackTrace(e)));
            }
        }

 public void Start(string address, int port, string path)
 {
     IPAddress ipaddr = new IPAddress(address.Split('.').Select(a => (byte)a.to_i()).ToArray());
     WebSocketServer wss = new WebSocketServer(ipaddr, port, this);
     wss.AddWebSocketService<ServerReceiver>(path);
     wss.Start();
 }

        /// <summary>
        /// Checks if a ipv4 address is a local network address / zeroconf
        /// </summary>
        /// <param name="ip"></param>
        /// <returns></returns>
        public static bool IsLocalIP(IPAddress ip)
        {
            if (ip.AddressFamily == AddressFamily.InterNetwork)
            {
                byte[] ipBytes = ip.GetAddressBytes();

                //    10.0.0.0 bis  10.255.255.255 :: 10.0.0.0/8       (1 Class C)
                if (ipBytes[0] == 10)
                {
                    return true;
                }

                //  172.16.0.0 bis  172.31.255.255 :: 172.16.0.0/12   (16 Class B)
                if ((ipBytes[0] == 172) && (ipBytes[1] > 15) && (ipBytes[1] < 32))
                {
                    return true;
                }

                // 192.168.0.0 bis 192.168.255.255 :: 192.168/16     (256 Class C)
                if ((ipBytes[0] == 192) && (ipBytes[1] == 168))
                {
                    return true;
                }

                // 169.254.0.0 bis 169.254.255.255 :: 169.254.0.0/16    (Zeroconf)
                if ((ipBytes[0] == 169) && (ipBytes[1] == 255))
                {
                    return true;
                }
            }
            return false;
        }

		public static bool TryParse(string ip, out IPAddress address) {
			// Only handle IPv4
			if (ip == null) {
				throw new ArgumentNullException("ip");
			}
			if (ip.Length == 0 || ip == " ") {
				address = new IPAddress(0);
				return true;
			}
			string[] parts = ip.Split('.');
			if (parts.Length != 4) {
				address = null;
				return false;
			}
			uint a = 0;
			for (int i = 0; i < 4; i++) {
				int val;
				if (!int.TryParse(parts[i], out val)) {
					address = null;
					return false;
				}
				a |= ((uint)val) << (i << 3);
			}
			address = new IPAddress((long)a);
			return true;
		}

 public virtual void Blacklist(IPAddress senderAddress)
 {
     if (!_blacklist.ContainsKey(senderAddress))
     {
         _blacklist.Add(senderAddress, true);
     }
 }

 public ClientSocket(IPAddress address, int port)
     : base(10, LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType))
 {
     this.Setup(new IPEndPoint(address, port), new ClientMessageProcessor());
     Handler = new Handler();
     Rpc = new BinarySenderStub(this);
 }

        public SslServer(X509Certificate2 cert, bool certRequired, SslProtocols enabledProt, bool expectedExcep)
        {
            certificate = cert;
            clientCertificateRequired = certRequired;
            enabledSslProtocols = enabledProt;
            expectedException = expectedExcep;

            if (!certificate.HasPrivateKey)
            {
                Console.WriteLine("ERROR: The cerfiticate does not have a private key.");
                throw new Exception("No Private Key in the certificate file");
            }

            //Get the IPV4 address on this machine which is all that the MF devices support.
            foreach (IPAddress address in Dns.GetHostAddresses(Dns.GetHostName()))
            {
                if (address.AddressFamily == AddressFamily.InterNetwork)
                {
                    ipAddress = address;
                    break;
                }
            }

            if (ipAddress == null)
                throw new Exception("No IPV4 address found.");

            //Console.WriteLine("ipAddress is: " + ipAddress.ToString());
            //Console.WriteLine("port          is: " + port.ToString());
        }

 partial void OpenSocket(IPAddress connectedHost, uint connectedPort)
 {
     var ep = new IPEndPoint(connectedHost, (int)connectedPort);
     this._socket = new Socket(ep.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
     this._socket.Connect(ep);
     this._socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.NoDelay, 1);
 }

 public void init()
 {
     try
     {
         Console.WriteLine("Init");
         //set up socket
         Socket client = new Socket(AddressFamily.InterNetwork,
         SocketType.Stream, ProtocolType.Tcp);
         //IPHostEntry hostInfo = Dns.Resolve("localhost:8000");
         //IPAddress address = hostInfo.AddressList[0];
         //IPAddress ipAddress = Dns.GetHostEntry("localhost:8000").AddressList[0];
         IPAddress ipAddress = new IPAddress(new byte[] { 128, 61, 105, 215 });
         IPEndPoint ep = new IPEndPoint(ipAddress, 8085);
         client.BeginConnect(ep, new AsyncCallback(ConnectCallback), client);
         connectDone.WaitOne();
         //receiveForever(client);
         byte[] msg = Encoding.ASCII.GetBytes("This is a test<EOF>");
         StateObject state = new StateObject();
         state.workSocket = client;
         client.BeginReceive(buffer, 0, StateObject.BufferSize, 0,
                 new AsyncCallback(ReceiveCallback), state);
         client.Send(msg);
     }
     catch (Exception e)
     {
         Console.WriteLine(e.ToString());
     }
 }

        public virtual BEncodedDictionary Handle(string queryString, IPAddress remoteAddress, bool isScrape)
        {
            if (queryString == null)
                throw new ArgumentNullException("queryString");

            return Handle(ParseQuery(queryString), remoteAddress, isScrape);
        }

 /// <summary>
 /// Initializes a new connection to RNET.
 /// </summary>
 /// <param name="ip"></param>
 /// <param name="port"></param>
 public RnetTcpConnection(IPAddress ip, int port)
     : this(new IPEndPoint(ip, port))
 {
     Contract.Requires(ip != null);
     Contract.Requires(port >= 0);
     Contract.Requires(port <= 65535);
 }

        public EmbeddedSmtpServer(IPAddress address, int port = 25)
        {
            Address = address;
            Port = port;

            Listener = new TcpListener(Address, port);
        }

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="gpsDataParser">数据解析器</param>
        /// <param name="ipAddress">向应用层公开的IP地址</param>
        /// <param name="udpPort">UDP监听端口号</param>
        /// <param name="maxSendPacket">发送数据包的最大长度</param>
        /// <param name="tcpserver"></param>
        /// <param name="bufferSize">收发缓冲区大小</param>
        /// <param name="useTcp">是否使用TCP通信</param>
        public UdpServer(AnalyseBase gpsDataParser,IPAddress ipAddress,int udpPort,int maxSendPacket,int bufferSize,bool useTcp,int udpPortByWeb)
        {
            try
            {
                GpsDataParser = gpsDataParser;

                localIPAddress = ipAddress;
                localPort = udpPort;
                webPort = udpPortByWeb;
                GpsDataParser.AddConnectionEvent += new AnalyseBase.AddConnectionHandler(gpsDataParse_AddConnectionEvent);
                GpsDataParser.DataSource = new IPEndPoint(ipAddress, udpPortByWeb);

                _UdpServerBase = new UdpServerBase(ipAddress, udpPort, maxSendPacket, bufferSize);

                //注册事件
                _UdpServerBase.PostReceivedMsgEvent += new UdpServerBase.PostReceivedMsgHandler(_UdpServerBase_PostReceivedMsgEvent);

                _UdpServerBase.AddSocketToListEvent += new UdpServerBase.AddSocketToListHandler(AdddSocketToList);

                AsyncEventHashtable = new Hashtable();

                CodeKeyHashtable = new Hashtable();
                GatewayRoutingTable = new Dictionary<string, string>();
            }
            catch (Exception ex)
            {
                Logger.Error(ex,null);
            }
        }

		/// <summary>
		///   Creates a new instance of the WksRecord class
		/// </summary>
		/// <param name="name"> Name of the host </param>
		/// <param name="timeToLive"> Seconds the record should be cached at most </param>
		/// <param name="address"> IP address of the host </param>
		/// <param name="protocol"> Type of the protocol </param>
		/// <param name="ports"> List of ports which are supported by the host </param>
		public WksRecord(DomainName name, int timeToLive, IPAddress address, ProtocolType protocol, List<ushort> ports)
			: base(name, RecordType.Wks, RecordClass.INet, timeToLive)
		{
			Address = address ?? IPAddress.None;
			Protocol = protocol;
			Ports = ports ?? new List<ushort>();
		}

 public FileServerDLMessage(string targetFile, string saveDir, IPAddress owner, long size)
 {
     this.TargetFile = targetFile;
     this.SaveDir = saveDir;
     this.Owner = owner;
     this.Size = size;
 }

 public void Connect(IPAddress ip, int port)
 {
     var client = new TcpClientSocket();
     client.OnConnect += onConnected;
     client.Connect(ip, port);
     socket = client;
 }