Пример #1
0
        private void ErrorHandler(object sender, Exception exn)
        {
            Program.AssertOffEventThread();

            if (this.Disposing || this.IsDisposed)
            {
                return;
            }

            Program.Invoke(this, delegate()
            {
                VNCGraphicsClient v = (VNCGraphicsClient)sender;

                if (exn is VNCAuthenticationException || exn is CryptographicException)
                {
                    Log.Debug(exn, exn);

                    // Clear the stored VNC password for this server.
                    Settings.SetVNCPassword(sourceVM.uuid, null);
                    RetryConnection(v, exn);
                }
                else if (exn is IOException || exn is Failure)
                {
                    Log.Debug(exn, exn);
                    SleepAndRetryConnection_(v);
                }
                else
                {
                    Log.Warn(exn, exn);
                    this.errorMessage = exn.Message;
                }
            });
        }
Пример #2
0
 private void RetryConnection(VNCGraphicsClient v, Exception exn)
 {
     if (vncClient == v && !v.Terminated && Source.power_state == vm_power_state.Running)
     {
         ThreadPool.QueueUserWorkItem(new WaitCallback(Connect), new KeyValuePair <VNCGraphicsClient, Exception>(v, exn));
     }
 }
Пример #3
0
        private void ConnectHostedConsole(VNCGraphicsClient v, Console console)
        {
            Program.AssertOffEventThread();

            Host host = console.Connection.Resolve(Source.resident_on);

            if (host == null)
            {
                throw new Failure(Failure.INTERNAL_ERROR, Messages.VNC_HOST_GONE);
            }

            Uri    uri = new Uri(console.location);
            String SessionUUID;

            lock (activeSessionLock)
            {
                // use the elevated credentials, if provided, for connecting to the console (CA-91132)
                activeSession = (string.IsNullOrEmpty(ElevatedUsername) || string.IsNullOrEmpty(ElevatedPassword)) ?
                                console.Connection.DuplicateSession() : console.Connection.ElevatedSession(ElevatedUsername, ElevatedPassword);
                SessionUUID = activeSession.uuid;
            }

            Stream stream = HTTPHelper.CONNECT(uri, console.Connection, SessionUUID, false, true);

            InvokeConnection(v, stream, console);
        }
Пример #4
0
        private void ConnectHostedConsole(VNCGraphicsClient v, XenAPI.Console console, string session_uuid)
        {
            //Program.AssertOffEventThread();
            Uri    uri    = new Uri(console.location);
            Stream stream = HTTP.CONNECT(uri, null, session_uuid, 0);

            InvokeConnection(v, stream, console, m_vncPassword);
        }
Пример #5
0
        private void SleepAndRetryConnection(object o)
        {
            VNCGraphicsClient v = (VNCGraphicsClient)o;

            Program.AssertOffEventThread();

            ConnectionRetries++;
            Thread.Sleep(ConnectionRetries < SHORT_RETRY_COUNT ? SHORT_RETRY_SLEEP_TIME : RETRY_SLEEP_TIME);
            RetryConnection(v, null);
        }
Пример #6
0
 private void InvokeConnection(VNCGraphicsClient v, Stream stream, Console console)
 {
     Program.Invoke(this, delegate()
     {
         // This is the last chance that we have to make sure that we've not already
         // connected this VNCGraphicsClient.  Now that we are back on the event thread,
         // we're guaranteed that no-one will beat us to the v.connect() call.  We
         // hand over responsibility for closing the stream at that point, so we have to
         // close it ourselves if the client is already connected.
         if (v.Connected || v.Terminated)
         {
             stream.Close();
         }
         else
         {
             v.SendScanCodes = UseSource && !this.sourceIsPV;
             v.SourceVM      = sourceVM;
             v.Console       = console;
             v.connect(stream, this.vncPassword);
         }
     });
 }
Пример #7
0
        private void Connect(object o)
        {
            if (Program.RunInAutomatedTestMode)
            {
                return;
            }

            Program.AssertOffEventThread();

            KeyValuePair <VNCGraphicsClient, Exception> kvp = (KeyValuePair <VNCGraphicsClient, Exception>)o;

            VNCGraphicsClient v     = kvp.Key;
            Exception         error = kvp.Value;

            try
            {
                if (UseSource)
                {
                    List <Console> consoles;
                    lock (hostedConsolesLock)
                    {
                        consoles = sourceVM.Connection.ResolveAll(hostedConsoles);
                    }

                    foreach (Console console in consoles)
                    {
                        if (vncClient != v)
                        {
                            // We've been replaced.  Give up.
                            return;
                        }

                        if (console.protocol == console_protocol.rfb)
                        {
                            try
                            {
                                ConnectHostedConsole(v, console);
                                return;
                            }
                            catch (Exception exn)
                            {
                                Failure failure           = exn as Failure;
                                bool    isHostGoneMessage = failure != null &&
                                                            failure.ErrorDescription.Count == 2 &&
                                                            failure.ErrorDescription[0] == Failure.INTERNAL_ERROR &&
                                                            failure.ErrorDescription[1] == Messages.VNC_HOST_GONE;

                                if (isHostGoneMessage)
                                {
                                    if (!_suppressHostGoneMessage)
                                    {
                                        Log.Debug(exn, exn);
                                        _suppressHostGoneMessage = true;
                                    }
                                }
                                else
                                {
                                    Log.Debug(exn, exn);
                                    _suppressHostGoneMessage = false;
                                }
                            }
                        }
                    }

                    Log.Debug("Did not find any hosted consoles");
                    SleepAndRetryConnection(v);
                }
                else
                {
                    if (vncIP == null)
                    {
                        Log.DebugFormat("vncIP is null. Abort VNC connection attempt");
                        OnVncConnectionAttemptCancelled();
                        return;
                    }
                    this.vncPassword = Settings.GetVNCPassword(sourceVM.uuid);
                    if (this.vncPassword == null)
                    {
                        bool lifecycleOperationInProgress = sourceVM.current_operations.Values.Any(VM.is_lifecycle_operation);
                        if (haveTriedLoginWithoutPassword && !lifecycleOperationInProgress)
                        {
                            Program.Invoke(this, delegate
                            {
                                promptForPassword(ignoreNextError ? null : error);
                            });
                            ignoreNextError = false;
                            if (this.vncPassword == null)
                            {
                                Log.Debug("User cancelled VNC password prompt: aborting connection attempt");
                                OnUserCancelledAuth();
                                return;
                            }
                        }
                        else
                        {
                            Log.Debug("Attempting passwordless VNC login");
                            this.vncPassword = new char[0];
                            ignoreNextError  = true;
                            haveTriedLoginWithoutPassword = true;
                        }
                    }

                    Stream s;
                    lock (pendingVNCConnectionLock)
                    {
                        s = pendingVNCConnection;
                        Log.DebugFormat("Using pending VNC connection");
                        pendingVNCConnection = null;
                    }
                    if (s == null)
                    {
                        Log.DebugFormat("Connecting to vncIP={0}, port={1}", this.vncIP, VNC_PORT);
                        s = connectGuest(this.vncIP, VNC_PORT, sourceVM.Connection);
                        Log.DebugFormat("Connected to vncIP={0}, port={1}", this.vncIP, VNC_PORT);
                    }
                    InvokeConnection(v, s, null);

                    // store the empty vnc password after a successful passwordless login
                    if (haveTriedLoginWithoutPassword && this.vncPassword.Length == 0)
                    {
                        Program.Invoke(this, () => Settings.SetVNCPassword(sourceVM.uuid, this.vncPassword));
                    }
                }
            }
            catch (Exception exn)
            {
                Log.Warn(exn, exn);
                SleepAndRetryConnection(v);
            }
        }
Пример #8
0
        /// <summary>
        /// Creates the actual VNC or RDP client control.
        /// </summary>
        private void initSubControl()
        {
            Program.AssertOnEventThread();

            //When switch to RDP from VNC, if RDP IP is empty, do not try to switch.
            if (String.IsNullOrEmpty(rdpIP) && !UseVNC && RemoteConsole != null)
            {
                return;
            }

            bool wasFocused = false;

            this.Controls.Clear();

            Size oldSize = new Size(1024, 768);

            // Kill the old client.
            if (RemoteConsole != null)
            {
                oldSize    = RemoteConsole.DesktopSize;
                wasFocused = RemoteConsole.ConsoleControl != null && RemoteConsole.ConsoleControl.Focused;
                RemoteConsole.DisconnectAndDispose();
                RemoteConsole    = null;
                this.vncPassword = null;
            }

            // Reset
            haveTriedLoginWithoutPassword = false;

            if (UseVNC || String.IsNullOrEmpty(rdpIP))
            {
                this.AutoScroll        = false;
                this.AutoScrollMinSize = new Size(0, 0);

                vncClient = new VNCGraphicsClient(this);

                vncClient.UseSource          = UseSource;
                vncClient.DesktopResized    += ResizeHandler;
                vncClient.Resize            += ResizeHandler;
                vncClient.ErrorOccurred     += ErrorHandler;
                vncClient.ConnectionSuccess += ConnectionSuccess;
                vncClient.Dock = DockStyle.Fill;
            }
            else
            {
                if (rdpClient == null)
                {
                    if (this.ParentForm is FullScreenForm)
                    {
                        oldSize = ((FullScreenForm)ParentForm).contentPanel.Size;
                    }
                    this.AutoScroll        = true;
                    this.AutoScrollMinSize = oldSize;

                    rdpClient = new RdpClient(this, oldSize, ResizeHandler);

                    rdpClient.OnDisconnected += new EventHandler(parentVNCTabView.RdpDisconnectedHandler);
                }
            }

            if (RemoteConsole != null && RemoteConsole.ConsoleControl != null)
            {
                RemoteConsole.KeyHandler    = this.KeyHandler;
                RemoteConsole.SendScanCodes = !this.sourceIsPV;
                RemoteConsole.Scaling       = Scaling;
                RemoteConsole.DisplayBorder = this.displayFocusRectangle;
                SetKeyboardAndMouseCapture(autoCaptureKeyboardAndMouse);
                if (wasPaused)
                {
                    RemoteConsole.Pause();
                }
                else
                {
                    RemoteConsole.Unpause();
                }
                ConnectToRemoteConsole();

                if (wasFocused)
                {
                    RemoteConsole.Activate();
                }
            }

            parentVNCTabView.ShowGpuWarningIfRequired();
        }
Пример #9
0
 private void SleepAndRetryConnection_(VNCGraphicsClient v)
 {
     ThreadPool.QueueUserWorkItem(new WaitCallback(SleepAndRetryConnection), v);
 }
Пример #10
0
        /// <summary>
        /// Creates the actual VNC client control.
        /// </summary>
        private void initSubControl(int width, int height, bool scaling, bool show_border)
        {
            Program.MainWindow = this;
            bool wasFocused = m_vncClient != null && m_vncClient.Focused;

            this.Controls.Clear();

            Size newSize;
            Size oldSize = new Size(1024, 768);

            if (width == 0 || height == 0)
            {
                newSize = new Size(1024, 768);
            }
            else
            {
                newSize = new Size(width, height);
            }

            // Kill the old client.
            if (m_vncClient != null)
            {
                oldSize = m_vncClient.DesktopSize;
                m_vncClient.Disconnect();
                m_vncClient.Dispose();
                m_vncClient = null;
            }
            // Reset
            this.AutoScroll        = false;
            this.AutoScrollMinSize = new Size(0, 0);
            m_vncClient            = new VNCGraphicsClient(this);
            m_vncClient.Size       = newSize;
            this.Size                       = newSize;
            m_vncClient.UseSource           = true;
            m_vncClient.SendScanCodes       = !this.m_sourceIsPV;
            m_vncClient.Dock                = DockStyle.Fill;
            this.m_vncClient.Scaling        = scaling; // SCVMM requires a scaled image
            m_vncClient.DisplayBorder       = show_border;
            m_vncClient.AutoScaleDimensions = newSize;
            m_vncClient.AutoScaleMode       = AutoScaleMode.Inherit;

            this.m_vncClient.DesktopResized += ResolutionChangeHandler;
            //this.m_vncClient.Resize += ResizeHandler;
            //this.m_vncClient.ErrorOccurred += ErrorHandler;
            //this.m_vncClient.ConnectionSuccess += ConnectionSuccess;
            //this.m_vncClient.ErrorOccurred
            //this.m_vncClient.MouseDown += new MouseEventHandler(vncClient_MouseDown);
            //this.m_vncClient.KeyDown += new KeyEventHandler(vncClient_KeyDown);

            m_vncClient.KeyHandler = new ConsoleKeyHandler();
            this.m_vncClient.Unpause();

            foreach (Set <Keys> keys in extraCodes.Keys)
            {
                m_vncClient.KeyHandler.AddKeyHandler(keys, extraCodes[keys]);
            }

            foreach (Set <int> keys in extraScans.Keys)
            {
                m_vncClient.KeyHandler.AddKeyHandler(keys, extraScans[keys]);
            }
        }