public void SetResult(ConnectionStatus status)
 {
     if (!_enabled)
         return;
     this._result = status;
     this._stopwatch.Stop();
 }

 /// <summary>
 /// Public constructor for createing a Client object
 /// </summary>
 /// <param name="iSocket">Socket associated with the Client object</param>
 /// <param name="iClientStreamIndex">Index number of the associated Client object</param>
 public ClientStream(Socket iSocket, int iClientStreamIndex)
 {
     Socket = iSocket;
     Index = iClientStreamIndex;
     ConnectionStatus = ConnectionStatus.Pending;
     OnClientConnect();
 }

        public lokunclientform()
        {
            InitializeComponent();
            lokun = Lokun.instance;
            connected = ConnectionStatus.NotRunning;
            chkAutostart.Checked = lokun.Autostart;
            btnDownload.Enabled = false;

            switch(lokun.UserRoutingSetting)
            {
                case RoutingSetting.Everything:
                    rdTunnelEverything.Checked = true;
                    break;
                case RoutingSetting.ExcludeISNets:
                    rdExcludeIcelandic.Checked = true;
                    break;
                case RoutingSetting.OnlyISNets:
                    rdOnlyIcelandic.Checked = true;
                    break;
            }

            StartStopSetUI(lokun.OpenVPNServiceIsRunning);

            var username = lokun.GetCurrentUsername();
            if (username != null)
            {
                txtUsername.Text = username;
                txtPassword.Text = "hunter2";
                //ststrpLabel.Text = "Current account: " + username;
            }
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="ProScanMobile.NetworkConnection"/> class.
        /// </summary>
        /// <description>
        /// Creates a new _tcpSocket and tries to connect to Host/Port 
        /// </description>
        /// <param name="host">Host</param>
        /// <param name="port">Port</param>
        public NetworkConnection(string host, int port)
        {
            _connectDone.Reset ();

            try
            {
                IPHostEntry ipHostInfo = Dns.GetHostEntry (host);
                IPAddress ipAddress = ipHostInfo.AddressList [0];
                IPEndPoint remoteEP = new IPEndPoint (ipAddress, port);

                _tcpSocket = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                _tcpSocket.Blocking = true;

                var result = _tcpSocket.BeginConnect (remoteEP, null, null);

                bool success = result.AsyncWaitHandle.WaitOne (5000, true);
                if (success) {
                    _tcpSocket.EndConnect (result);
                    _connectionStatus = ConnectionStatus.Connected;
                    _connectionStatusMessage = "Connected.";
                } else {
                    _tcpSocket.Close ();
                    _connectionStatus = ConnectionStatus.Error;
                    _connectionStatusMessage = "Connection timed out.";
                }
            } catch {
                _connectionStatus = ConnectionStatus.Error;
                _connectionStatusMessage = string.Format("An error occured connecting to {0} on port {1}.", host, port);
                _connectDone.Set();
                return;
            } finally {
                _connectDone.Set ();
            }
        }

        public void Update()
        {
            if (_connectStarted.Elapsed.TotalSeconds > 120)
            {
                if (_bot != null)
                    _bot.Disconnect();
                Status = ConnectionStatus.Disconnected;
            }

            if (Status != ConnectionStatus.Disconnected)
                return;

            _hasConnected = false;
            _connectStarted.Restart();
            Program.Logger.Info("Connecting");

            _bot = new SteamBot(Program.Settings.Username, Program.Settings.Password, Program.Settings.AuthCode);
            _bot.OnConnected += sender =>
            {
                _hasConnected = true;
                _connectStarted.Stop();

                _bot.DisplayName = Program.Settings.PersonaName;
                _bot.PersonaState = EPersonaState.Online;
                Status = ConnectionStatus.Connected;

                Program.Logger.Info("Connected");
            };

            _bot.OnDisconnected += (sender, reason) =>
            {
                if (reason == SteamBotDisconnectReason.SteamGuard)
                    Thread.Sleep(TimeSpan.FromMinutes(2)); // TODO: need a better way of entering steamguard auth

                if (_hasConnected)
                {
                    Program.Logger.InfoFormat("Disconnected {0}", reason);
                    _hasConnected = false;
                }

                Status = ConnectionStatus.Disconnected;
            };

            _bot.OnFriendRequest += (sender, user) => _bot.AddFriend(user.Id);

            _bot.OnPrivateEnter += (sender, chat) =>
            {
                chat.OnMessage += (chatSender, messageSender, message) =>
                    Command.Handle(new CommandTarget(chatSender, messageSender), message, "");
            };

            _bot.OnChatInvite += (sender, chat, @by) =>
            {
                if (chat.Id.IsIndividualAccount)
                    _bot.Join(chat.Id);
            };

            _bot.Connect();
            Status = ConnectionStatus.Connecting;
        }

 private async void btnCheckConnection_Click(object sender, EventArgs e)
 {
     lblCheckConnection.Text = "Checking...";
     lblCheckConnection.Refresh();
     connected = await lokun.FullyCheckConnectionStatusAsync();
     if (connected == ConnectionStatus.EverythingTunneled)
     {
         lblCheckConnection.Text = "Tunnel active";
     }
     else if (connected == ConnectionStatus.ConnectedWithoutDGW)
     {
         lblCheckConnection.Text = "Tunnel idle";
     }
     else if (connected == ConnectionStatus.RunningNotConnected)
     {
         lblCheckConnection.Text = "Tunnel not in use";
     }
     else if (connected == ConnectionStatus.OpenVPNNotInstalled)
     {
         lblCheckConnection.Text = "Error: OpenVPN missing";
     }
     else
     {
         lblCheckConnection.Text = "Tunnel down";
     }
     lblCheckConnection.Refresh();
 }

        public void Connect(HTransportOptions options)
        {
            this.connStatus = ConnectionStatus.CONNECTING;
            this.options = options;

            //TODO init the connection timeout value!!
            connTimeout = new TimeSpan(0, 0, 0, 0, options.Timeout);

            string endpointHost = options.EndpointHost;
            int endpointPort = options.EndpointPort;
            string endpointPath = options.EndpointPath;

            string endpointAdress = ToEndpointAdress(endpointHost, endpointPort, endpointPath);

            connTimeoutTimer = ThreadPoolTimer.CreateTimer(timeout_Elapsed, connTimeout);

            socketIO = new Client(endpointAdress);

            socketIO.Message += socketIO_Message;
            socketIO.SocketConnectionClosed += socketIO_SocketConnectionClosed;
            socketIO.Error += socketIO_Error;
            socketIO.On("connect", (message) =>
                {
                    if (this.options.AuthCb != null)
                        this.options.AuthCb(options.Login, Login);
                    else
                        Login(options.Login, options.Password);
                });
            socketIO.ConnectAsync();
        }

 private void OnConnectionStatus_callback(object sender, ConnectionStatus status, ref RspUserLoginField userLogin, int size1)
 {
     if (null != OnConnectionStatus)
     {
         OnConnectionStatus(this, new OnConnectionStatusEventArgs(status, ref userLogin, size1));
     }
 }

        public void DisplayStatus(ConnectionStatus status)
        {
            _notificator.Visibility = Visibility.Visible;
            _notificator.Source = new BitmapImage(new Uri("ms-appx:///Assets/"+status+".png"));

             _timer.Start();
        }

 public NetworkStatus(ConnectionStatus connectionStatus, ConnectionProtocolType protocolType, TCPRole tcpRole, int clientCount, string classroomName)
 {
     this.ConnectionStatus = connectionStatus;
     this.ProtocolType = protocolType;
     this.TCPRole = tcpRole;
     this.ClientCount = clientCount;
     this.ClassroomName = classroomName;
 }

 protected internal AuthenticationResult AbortedAuthentication(string message, ConnectionStatus status = ConnectionStatus.Faulted)
 {
     return new AuthenticationResult
     {
         Status = status,
         Message = message,
     };
 }

 /// <summary>
 /// Public constructor for createing a Server object
 /// </summary>
 /// <param name="iSocket">Socket associated with Server object</param>
 /// <param name="iServerInfoIndex">Index number of the associated Server object</param>
 public ServerInfo(Socket iSocket, int iServerInfoIndex, ConnectionInfo iConnectionInfo, ConnectionMode iConnectionMode)
 {
     Socket = iSocket;
     Index = iServerInfoIndex;
     ConnectionInfo = iConnectionInfo;
     ConnectionMode = iConnectionMode;
     ConnectionStatus = ConnectionStatus.Pending;
     OnServerConnect();
 }

        public void Update()
        {
            if (_connectStarted.Elapsed.TotalSeconds > 120)
            {
                if (_bot != null)
                    _bot.Disconnect();
                Status = ConnectionStatus.Disconnected;
            }

            if (Status != ConnectionStatus.Disconnected)
                return;

            _hasConnected = false;
            _connectStarted.Restart();
            Program.Logger.Info("Connecting");

            _bot = new Bot(Program.Settings.Username, Program.Settings.Password);
            _bot.OnConnected += sender =>
            {
                _hasConnected = true;
                _connectStarted.Stop();

                _bot.PersonaName = Program.Settings.PersonaName;
                _bot.PersonaState = EPersonaState.Online;
                Status = ConnectionStatus.Connected;

                Program.Logger.Info("Connected");
            };

            _bot.OnDisconnected += (sender, reason) =>
            {
                if (_hasConnected)
                {
                    Program.Logger.Info("Disconnected");
                    _hasConnected = false;
                }

                Status = ConnectionStatus.Disconnected;
            };

            _bot.OnFriendRequest += (sender, user) => _bot.AddFriend(user.Id);

            _bot.OnPrivateEnter += (sender, chat) =>
            {
                chat.OnMessage += (chatSender, messageSender, message) =>
                    Command.Handle(new CommandTarget(chatSender, messageSender.Id), message, "");
            };

            _bot.OnChatInvite += (sender, chat, @by) =>
            {
                if (chat.Id.IsIndividualAccount)
                    _bot.Join(chat.Id);
            };

            _bot.Connect();
            Status = ConnectionStatus.Connecting;
        }

        //public fnOnRtnForQuoteRsp OnRtnForQuoteRsp
        //{
        //    set
        //    {
        //        OnRtnForQuoteRsp_1 = value;
        //        OnRtnForQuoteRsp_2 = OnRtnForQuoteRsp_3;
        //        MdApi.CTP_RegOnRtnForQuoteRsp(_MsgQueue.Queue, OnRtnForQuoteRsp_2);
        //    }
        //}

        //private void OnRtnForQuoteRsp_3(IntPtr pMdUserApi, ref CThostFtdcForQuoteRspField pForQuoteRsp)
        //{
        //    OnRtnForQuoteRsp_1(this, pMdUserApi, ref pForQuoteRsp);
        //}

        protected override void OnConnect_3(IntPtr pApi, ref CThostFtdcRspUserLoginField pRspUserLogin, ConnectionStatus result)
        {
            IsConnected = false;
            if (result == ConnectionStatus.Logined)
            {
                IsConnected = true;
            }
            OnConnect_1(this, pApi, ref pRspUserLogin, result);
        }

 public void ClientStatusUpdate(ConnectionStatus cs, string msg)
 {
     if (cs == ConnectionStatus.Connected)
     {
         RunOnUiThread(() => Toast.MakeText(this, "Connected to Server", ToastLength.Short).Show());
     }
     else
     {
         RunOnUiThread(() => Toast.MakeText(this, "Could not connect to server", ToastLength.Short).Show());
     }
 }

 static void OnConnectionStatus2(object sender, ConnectionStatus status, ref RspUserLoginField userLogin, int size1)
 {
     if (size1 > 0)
     {
         Console.WriteLine("222222" + userLogin.ToFormattedStringLong());
     }
     else
     {
         Console.WriteLine("222222" + status);
     }
 }

        internal Connection(CapiApplication application, Controller controller,
            uint plci, string calledPartyNumber, string callingPartyNumber) {

            _dtfmDuration = 40;
            _dtfmPause = 40;
            _application = application;
            _controller = controller;
            _plci = plci;
            _calledPartyNumber = calledPartyNumber;
            _callingPartyNumber = callingPartyNumber;
            _status = ConnectionStatus.Disconnected;
        }

        public HttpResponse(ConnectionStatus status, String Connection, String filePath)
        {
            cookies = new Dictionary<String, String>();
            headers = new Dictionary<String, String>();
            this.status = status;
            this.filePath = filePath;

            //headers.Add("Allow", "GET");
            headers.Add("Date", DateTime.Now.ToString("r"));
            headers.Add("Server", "MyMobiControllerServer");
            headers.Add("Connection", Connection);
        }

 public void Start(Socket socket)
 {
     lock (lockObject)
     {
         TcpSocket = socket;
         _tcpOffset = 0;
         Status = ConnectionStatus.Connected;
         _messageInQueue = new BlockingCollection<IMessage>();
         _messageOutQueue = new BlockingCollection<IMessage>();
         BeginReading();
         BeginSending();
     }
 }

 public void Close()
 {
     Debug.Assert(Status == ConnectionStatus.Opend, "Connection.Close: Status must be Opened.");
     if (Status == ConnectionStatus.Opend)
     {
         try
         {
             while (_transactions.Count > 0)
                 _transactions[0].Dispose();
             Status = ConnectionStatus.Closed;
         }
         catch { }
     }
 }