예제 #1
0
파일: WmAnpTunnel.cs 프로젝트: tmbx/kwm-ng
        protected override void Run()
        {
            // Connect the tunnel.
            InternalAnpTunnel = new AnpTunnel(Host, Port);
            Tunnel tunnel = InternalAnpTunnel.GetTunnel();

            InternalAnpTunnel.BeginConnect(ReconnectHost, ReconnectPort);

            while (true)
            {
                SelectSockets set = new SelectSockets();
                set.Timeout = 100;
                tunnel.CheckTls();
                set.AddRead(tunnel.Sock);
                Block(set);
                if (set.ReadSockets.Contains(tunnel.Sock))
                {
                    InternalAnpTunnel.CreateTransport();
                    break;
                }
            }

            // Handle the tunnel.
            OnTunnelConnected();
        }
예제 #2
0
        /// <summary>
        /// Helper method for StartKmod().
        /// </summary>
        private void SetSelectTimeout(DateTime startTime, int msec, SelectSockets select, String msg)
        {
            int remaining = msec - (int)(DateTime.Now - startTime).TotalMilliseconds;

            if (remaining < 0)
            {
                throw new Exception(msg);
            }
            select.Timeout = remaining * 1000;
        }
예제 #3
0
        /// <summary>
        /// Analyse the result of the select() call for the specified KCD.
        /// </summary>
        private void UpdateStateAfterSelect(KcdThreadHost k, SelectSockets selectSockets)
        {
            try
            {
                k.CheckNoMessageReceivedInvariant();

                // We have nothing to do if we don't have an established TCP
                // connection.
                if (k.ConnStatus != KcdThreadConnStatus.Connected &&
                    k.ConnStatus != KcdThreadConnStatus.RoleReply)
                {
                    return;
                }

                // Perform transfers only if the socket is ready.
                Debug.Assert(k.Tunnel.Sock != null);
                if (!selectSockets.InReadOrWrite(k.Tunnel.Sock))
                {
                    return;
                }

                // Do up to 20 transfers (the limit exists for quenching purposes).
                for (int i = 0; i < 20; i++)
                {
                    // Send a message if possible.
                    k.SendNextQueuedMsgIfNeeded();

                    // Remember if we are sending a message.
                    bool sendingFlag = k.Tunnel.IsSendingMessage();

                    // Do transfers.
                    k.Tunnel.DoXfer();

                    // Stop if no message has been received and no message has been sent.
                    if (!k.Tunnel.HasReceivedMessage() &&
                        (!sendingFlag || k.Tunnel.IsSendingMessage()))
                    {
                        break;
                    }

                    // Process the message received.
                    if (k.Tunnel.HasReceivedMessage())
                    {
                        ProcessIncomingKcdMessage(k, k.Tunnel.GetMsg());
                    }
                }

                k.CheckNoMessageReceivedInvariant();
            }

            catch (Exception ex)
            {
                HandleDisconnectedKcd(k, ex);
            }
        }
예제 #4
0
파일: Tunnel.cs 프로젝트: fdgonthier/TbxLib
 /// <summary>
 /// Update the select set specified with the socket of the tunnel.
 /// </summary>
 public void UpdateSelect(SelectSockets select)
 {
     Debug.Assert(transport.isReceiving || transport.doneReceiving);
     if (transport.isSending)
     {
         select.AddWrite(tunnel.Sock);
     }
     if (transport.isReceiving && !transport.doneReceiving)
     {
         select.AddRead(tunnel.Sock);
     }
 }
예제 #5
0
파일: WmAnpTunnel.cs 프로젝트: tmbx/kwm-ng
        /// <summary>
        /// If the tunnel is connected, a new AnpTransport is created and the
        /// method returns true. Otherwise, the method returns false.
        /// </summary>
        public bool CheckConnect()
        {
            SelectSockets select = new SelectSockets();

            select.Timeout = 0;
            select.AddRead(tunnel.Sock);
            tunnel.CheckTls();
            select.Select();
            if (select.ReadSockets.Contains(tunnel.Sock))
            {
                CreateTransport();
                return(true);
            }
            return(false);
        }
예제 #6
0
        protected override void Run()
        {
            while (true)
            {
                SelectSockets s = new SelectSockets();
                Block(s);

                // If we were notified, process the WM messages. This refreshes
                // the quench deadline.
                if (m_wmNotifFlag)
                {
                    m_wmNotifFlag = false;
                    ProcessIncomingWmMessages();
                }
            }
        }
예제 #7
0
파일: Tunnel.cs 프로젝트: fdgonthier/TbxLib
 /// <summary>
 /// Send an AnpMsg. This method blocks if a message is currently being
 /// transferred.
 /// </summary>
 /// <param name="msg"></param>
 public void SendMsg(AnpMsg msg)
 {
     Debug.Assert(transport.isReceiving || transport.doneReceiving);
     while (transport.isSending)
     {
         SelectSockets select = new SelectSockets();
         transport.doXfer();
         UpdateSelect(select);
         if (transport.isSending)
         {
             select.Select();
         }
     }
     transport.sendMsg(msg);
     transport.doXfer();
 }
예제 #8
0
파일: Tunnel.cs 프로젝트: fdgonthier/TbxLib
        /// <summary>
        /// Block until the tunnel is connected or a timeout occurs. If the tunnel
        /// is connected, a new AnpTransport is created and the method returns true.
        /// Otherwise, the method returns false.
        /// </summary>
        /// <param name="timeout">Microseconds to wait in the Select.</param>
        public bool CheckConnect(int timeout)
        {
            // FIXME : loop to call tunnel.CheckTls()
            // at regular intervals.
            SelectSockets select = new SelectSockets();

            select.Timeout = timeout;
            select.AddRead(tunnel.Sock);
            tunnel.CheckTls();
            select.Select();
            if (select.ReadSockets.Contains(tunnel.Sock))
            {
                CreateTransport();
                return(true);
            }
            return(false);
        }
예제 #9
0
파일: Tunnel.cs 프로젝트: fdgonthier/TbxLib
        /// <summary>
        /// Get an AnpMsg. This is a blocking method, unless a message has already
        /// been received.
        /// </summary>
        public AnpMsg GetMsg()
        {
            Debug.Assert(transport.isReceiving || transport.doneReceiving);
            while (!transport.doneReceiving)
            {
                SelectSockets select = new SelectSockets();
                transport.doXfer();
                UpdateSelect(select);
                if (!transport.doneReceiving)
                {
                    select.Select();
                }
            }
            AnpMsg msg = transport.getRecv();

            transport.beginRecv();
            return(msg);
        }
예제 #10
0
파일: WmAnpTunnel.cs 프로젝트: tmbx/kwm-ng
        /// <summary>
        /// Send a message on the tunnel.
        /// </summary>
        protected void SendAnpMsg(AnpMsg m)
        {
            AnpTransport transfer = InternalAnpTunnel.GetTransport();

            Debug.Assert(transfer.IsReceiving || transfer.DoneReceiving);
            Debug.Assert(!transfer.IsSending);
            transfer.SendMsg(m);

            while (transfer.IsSending)
            {
                transfer.DoXfer();

                if (transfer.IsSending)
                {
                    SelectSockets set = new SelectSockets();
                    InternalAnpTunnel.UpdateSelect(set);
                    Block(set);
                }
            }
        }
예제 #11
0
파일: WmAnpTunnel.cs 프로젝트: tmbx/kwm-ng
        /// <summary>
        /// Retrieve a message from the tunnel.
        /// </summary>
        protected AnpMsg GetAnpMsg()
        {
            AnpTransport transfer = InternalAnpTunnel.GetTransport();

            Debug.Assert(transfer.IsReceiving || transfer.DoneReceiving);
            Debug.Assert(!transfer.IsSending);

            while (!transfer.DoneReceiving)
            {
                transfer.DoXfer();

                if (!transfer.DoneReceiving)
                {
                    SelectSockets set = new SelectSockets();
                    InternalAnpTunnel.UpdateSelect(set);
                    Block(set);
                }
            }

            AnpMsg msg = transfer.GetRecv();

            transfer.BeginRecv();
            return(msg);
        }
예제 #12
0
        /// <summary>
        /// Add the socket of the KCD in the select sets as needed and manage
        /// ktlstunnel.exe processes.
        /// </summary>
        private void PrepareStateForSelect(KcdThreadHost k, SelectSockets selectSockets, bool quenchFlag,
                                           ref bool connWatchFlag)
        {
            // Note: the KCD should never have received a message when this function
            // is called. The function UpdateStateAfterSelect() is responsible for
            // doing all the transfers and handling any message received after these
            // transfers.
            try
            {
                k.CheckNoMessageReceivedInvariant();

                if (k.ConnStatus == KcdThreadConnStatus.Scheduled)
                {
                    // Start ktlstunnel.exe.
                    k.ConnStatus = KcdThreadConnStatus.Connecting;
                    k.Tunnel.BeginConnect();
                }

                if (k.ConnStatus == KcdThreadConnStatus.Connecting)
                {
                    // The TCP connection is now open.
                    if (k.Tunnel.CheckConnect())
                    {
                        // Send the select role command.
                        k.SendSelectRoleMsg();

                        // Wait for the reply to arrive.
                        k.ConnStatus = KcdThreadConnStatus.RoleReply;
                    }

                    // Wait for the TCP connection to be established. We busy wait
                    // to monitor the status of ktlstunnel.exe regularly, to detect
                    // the case where the connection fails.
                    else
                    {
                        connWatchFlag = true;
                    }
                }

                if (k.ConnStatus == KcdThreadConnStatus.RoleReply)
                {
                    // Wait for the reply to arrive.
                    if (!quenchFlag)
                    {
                        k.Tunnel.UpdateSelect(selectSockets);
                    }
                }

                if (k.ConnStatus == KcdThreadConnStatus.Connected)
                {
                    // Send the next message, if possible.
                    k.SendNextQueuedMsgIfNeeded();
                    if (!quenchFlag)
                    {
                        k.Tunnel.UpdateSelect(selectSockets);
                    }
                }

                k.CheckNoMessageReceivedInvariant();
            }

            catch (Exception ex)
            {
                HandleDisconnectedKcd(k, ex);
            }
        }
예제 #13
0
        /// <summary>
        /// Loop processing KCDs.
        /// </summary>
        private void MainLoop()
        {
            while (true)
            {
                Debug.Assert(!MustReplyToWm());

                // Refresh the quench deadline if it depends on the amount of
                // time elapsed.
                if (m_quenchDeadline != DateTime.MinValue && m_quenchDeadline != DateTime.MaxValue)
                {
                    m_wmNotifFlag = true;
                }

                // If we were notified, process the WM messages. This refreshes
                // the quench deadline.
                if (m_wmNotifFlag)
                {
                    m_wmNotifFlag = false;
                    ProcessIncomingWmMessages();
                }

                Debug.Assert(!MustReplyToWm());

                // Determine whether we are quenched and the value of the
                // select timeout. By default we wait forever in select().
                bool quenchFlag = false;
                int  timeout    = -2;

                // Be quenched until we are notified.
                if (m_quenchDeadline == DateTime.MaxValue)
                {
                    quenchFlag = true;
                }

                // Be quenched up to the deadline we were given.
                else if (m_quenchDeadline != DateTime.MinValue)
                {
                    DateTime now = DateTime.Now;
                    if (m_quenchDeadline > now)
                    {
                        quenchFlag = true;
                        timeout    = (int)(m_quenchDeadline - now).TotalMilliseconds;
                    }
                }

                // Prepare the call to select.
                bool          connWatchFlag = false;
                SelectSockets selectSockets = new SelectSockets();
                foreach (KcdThreadHost k in m_kcdTree.Values)
                {
                    PrepareStateForSelect(k, selectSockets,
                                          quenchFlag, ref connWatchFlag);
                }

                // Our state has changed. Notify the WM and recompute our state.
                if (MustReplyToWm())
                {
                    ReplyToWm();
                    continue;
                }

                // Reduce the timeout to account for ktlstunnel.exe.
                if (connWatchFlag)
                {
                    DecrementTimeout(ref timeout, 300);
                }

                // Block in the call to select(). Note that we receive notifications
                // here.
                selectSockets.Timeout = timeout * 1000;
                Block(selectSockets);

                // If we are not quenched, perform transfers.
                if (!quenchFlag)
                {
                    foreach (KcdThreadHost k in m_kcdTree.Values)
                    {
                        UpdateStateAfterSelect(k, selectSockets);
                    }
                    ReplyToWm();
                }
            }
        }
예제 #14
0
        /// <summary>
        /// Start kmod and connect to it.
        /// </summary>
        private void StartKmod()
        {
            FileStream  file       = null;
            Socket      listenSock = null;
            RegistryKey kwmRegKey  = null;

            try
            {
                // Get the path to the kmod executable in the registry.
                kwmRegKey = Base.GetKwmLMRegKey();
                String Kmod = "\"" + (String)kwmRegKey.GetValue("InstallDir", @"C:\Program Files\Teambox\Teambox Manager") + "\\kmod\\kmod.exe\"";

                // The directory where KMOD will save logs and its database for use with the kwm.
                String KmodDir = Misc.GetKmodDirPath();
                Directory.CreateDirectory(KmodDir);

                // Start listening for kmod to connect when it'll be started.
                IPEndPoint endPoint = new IPEndPoint(IPAddress.Loopback, 0);
                listenSock = new Socket(endPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
                listenSock.Bind(endPoint);
                listenSock.Listen(1);
                int port = ((IPEndPoint)listenSock.LocalEndPoint).Port;

                // Start KMOD in debugging mode if our settings say so.
                //String debug = Misc.ApplicationSettings.ktlstunnelLoggingLevel > 0 ? " -l 3" : "";
                String debug   = "-l 3";
                String args    = " -C kmod_connect -p " + port + debug + " -m 20000 -k \"" + KmodDir + "\"";
                String cmdLine = Kmod + args;
                Logging.Log("About to start kmod.exe: " + cmdLine);
                m_kmodProc = new RawProcess(cmdLine);
                m_kmodProc.InheritHandles = false;
                m_kmodProc.CreationFlags  = (uint)Syscalls.CREATION_FLAGS.CREATE_NO_WINDOW;
                m_kmodProc.Start();

                // Wait for KMOD to connect for about 10 seconds.
                DateTime startTime = DateTime.Now;
                while (true)
                {
                    SelectSockets select = new SelectSockets();
                    select.AddRead(listenSock);
                    SetSelectTimeout(startTime, 10000, select, "no KMOD connection received");
                    Block(select);

                    if (select.InRead(listenSock))
                    {
                        m_kmodSock          = listenSock.Accept();
                        m_kmodSock.Blocking = false;
                        break;
                    }
                }

                // Read the authentication data.
                byte[] authSockData = new byte[32];
                byte[] authFileData = new byte[32];

                startTime = DateTime.Now;
                int nbRead = 0;
                while (nbRead != 32)
                {
                    SelectSockets select = new SelectSockets();
                    select.AddRead(m_kmodSock);
                    SetSelectTimeout(startTime, 2000, select, "no authentication data received");
                    Block(select);
                    int r = Base.SockRead(m_kmodSock, authSockData, nbRead, 32 - nbRead);
                    if (r > 0)
                    {
                        nbRead += r;
                    }
                }

                file = File.Open(KmodDir + "\\connect_secret", FileMode.Open);
                file.Read(authFileData, 0, 32);
                if (!Base.ByteArrayEqual(authFileData, authSockData))
                {
                    throw new Exception("invalid authentication data received");
                }

                // Set the transport.
                m_transport = new K3pTransport(m_kmodSock);
            }

            finally
            {
                if (file != null)
                {
                    file.Close();
                }
                if (listenSock != null)
                {
                    listenSock.Close();
                }
                if (kwmRegKey != null)
                {
                    kwmRegKey.Close();
                }
            }
        }
예제 #15
0
        /// <summary>
        /// Run one pass of the main loop.
        /// </summary>
        private void RunPass()
        {
            // Wait for a command.
            while (m_commandQueue.Count == 0)
            {
                Block(new SelectSockets());
            }

            // Get the next command.
            KmodThreadCommand command = m_commandQueue.Dequeue();

            // Send the command.
            m_transport.sendMsg(command.Msg);
            while (true)
            {
                m_transport.doXfer();
                if (!m_transport.isSending)
                {
                    break;
                }
                SelectSockets select = new SelectSockets();
                select.AddWrite(m_kmodSock);
                Block(select);
            }

            // We're done.
            if (!command.HaveResultFlag)
            {
                return;
            }

            // Wait for the results or the next command.
            bool firstFlag = true;

            while (m_commandQueue.Count == 0)
            {
                if (!m_transport.isReceiving)
                {
                    m_transport.beginRecv();
                }
                m_transport.doXfer();

                // Push the next result.
                if (m_transport.doneReceiving)
                {
                    lock (Mon)
                    {
                        m_elementQueue.Enqueue(m_transport.getRecv());
                        Monitor.Pulse(Mon);
                    }

                    // Send the notification that results are ready for this command.
                    if (firstFlag)
                    {
                        firstFlag = false;
                        PostToUI(new KmodThreadNotif(m_broker, command));
                    }
                }

                // Wait for the next result or the next command.
                else
                {
                    SelectSockets select = new SelectSockets();
                    select.AddRead(m_kmodSock);
                    Block(select);
                }
            }
        }
예제 #16
0
파일: WmAnpTunnel.cs 프로젝트: tmbx/kwm-ng
 /// <summary>
 /// Update the select set specified with the socket of the tunnel.
 /// </summary>
 public void UpdateSelect(SelectSockets selectSocket)
 {
     transport.UpdateSelect(selectSocket);
 }