Fixing curtain mode using non-default RDP port for Windows host.

remoting/host/desktop_session_win.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "remoting/host/desktop_session_win.h"
 
 #include <sddl.h>
 
 #include <limits>
 #include <memory>
 #include <utility>
 
 #include "base/base_switches.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/guid.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_checker.h"
 #include "base/timer/timer.h"
+#include "base/win/registry.h"
 #include "base/win/scoped_bstr.h"
 #include "base/win/scoped_comptr.h"
 #include "base/win/scoped_handle.h"
 #include "base/win/windows_version.h"
 #include "ipc/ipc_message_macros.h"
 #include "ipc/ipc_platform_file.h"
 #include "remoting/base/auto_thread_task_runner.h"
 // MIDL-generated declarations and definitions.
 #include "remoting/host/chromoting_lib.h"
 #include "remoting/host/chromoting_messages.h"
@@ skipping 40 matching lines @@
 // The minimum effective screen dimensions supported by Windows are 800x600.
 const int kMinRdpScreenWidth = 800;
 const int kMinRdpScreenHeight = 600;
 
 // Default dots per inch used by RDP is 96 DPI.
 const int kDefaultRdpDpi = 96;
 
 // The session attach notification should arrive within 30 seconds.
 const int kSessionAttachTimeoutSeconds = 30;
 
+// The default port number used for establishing an RDP session.
+const int kDefaultRdpPort = 3389;
+
+// The values used to establish RDP connections are stored in the registry.
+const wchar_t kRdpTcpSettingsKeyName[] = L"SYSTEM\\CurrentControlSet\\"
+    L"Control\\Terminal Server\\WinStations\\RDP-Tcp";
+const wchar_t kRdpPortValueName[] = L"PortNumber";
+
 // DesktopSession implementation which attaches to the host's physical console.
 // Receives IPC messages from the desktop process, running in the console
 // session, via |WorkerProcessIpcDelegate|, and monitors console session
-// attach/detach events via |WtsConsoleObserer|.
+// attach/detach events via |WtsConsoleObserver|.
 class ConsoleSession : public DesktopSessionWin {
  public:
   // Same as DesktopSessionWin().
   ConsoleSession(
     scoped_refptr<AutoThreadTaskRunner> caller_task_runner,
     scoped_refptr<AutoThreadTaskRunner> io_task_runner,
     DaemonProcess* daemon_process,
     int id,
     WtsTerminalMonitor* monitor);
   ~ConsoleSession() override;
 
  protected:
   // DesktopSession overrides.
   void SetScreenResolution(const ScreenResolution& resolution) override;
 
   // DesktopSessionWin overrides.
   void InjectSas() override;
 
  private:
   std::unique_ptr<SasInjector> sas_injector_;
 
   DISALLOW_COPY_AND_ASSIGN(ConsoleSession);
 };
 
 // DesktopSession implementation which attaches to virtual RDP console.
 // Receives IPC messages from the desktop process, running in the console
 // session, via |WorkerProcessIpcDelegate|, and monitors console session
-// attach/detach events via |WtsConsoleObserer|.
+// attach/detach events via |WtsConsoleObserver|.
 class RdpSession : public DesktopSessionWin {
  public:
   // Same as DesktopSessionWin().
   RdpSession(
     scoped_refptr<AutoThreadTaskRunner> caller_task_runner,
     scoped_refptr<AutoThreadTaskRunner> io_task_runner,
     DaemonProcess* daemon_process,
     int id,
     WtsTerminalMonitor* monitor);
   ~RdpSession() override;
@@ skipping 34 matching lines @@
 
     // Points to the desktop session object receiving OnRdpXxx() notifications.
     base::WeakPtr<RdpSession> desktop_session_;
 
     // This class must be used on a single thread.
     base::ThreadChecker thread_checker_;
 
     DISALLOW_COPY_AND_ASSIGN(EventHandler);
   };
 
+  // Retrieves a DWORD value from the registry.  Returns true on success.
+  bool RetrieveDwordRegistryValue(const wchar_t* key_name,
+                                  const wchar_t* value_name,
+                                  DWORD* value);
+
   // Used to create an RDP desktop session.
   base::win::ScopedComPtr<IRdpDesktopSession> rdp_desktop_session_;
 
   // Used to match |rdp_desktop_session_| with the session it is attached to.
   std::string terminal_id_;
 
   base::WeakPtrFactory<RdpSession> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(RdpSession);
 };
@@ skipping 67 matching lines @@
   webrtc::DesktopSize host_size = local_resolution.ScaleDimensionsToDpi(
       webrtc::DesktopVector(kDefaultRdpDpi, kDefaultRdpDpi));
 
   // Make sure that the host resolution is within the limits supported by RDP.
   host_size = webrtc::DesktopSize(
       std::min(kMaxRdpScreenWidth,
                std::max(kMinRdpScreenWidth, host_size.width())),
       std::min(kMaxRdpScreenHeight,
                std::max(kMinRdpScreenHeight, host_size.height())));
 
+  // Read the port number used by RDP.
+  DWORD server_port = kDefaultRdpPort;
+  if (RetrieveDwordRegistryValue(kRdpTcpSettingsKeyName, kRdpPortValueName,
+                                 &server_port) &&
+      server_port > 65535) {
+    LOG(ERROR) << "Invalid RDP port specified: " << server_port;
+    return false;
+  }
+
   // Create an RDP session.
   base::win::ScopedComPtr<IRdpDesktopSessionEventHandler> event_handler(
       new EventHandler(weak_factory_.GetWeakPtr()));
   terminal_id_ = base::GenerateGUID();
   base::win::ScopedBstr terminal_id(base::UTF8ToUTF16(terminal_id_).c_str());
   result = rdp_desktop_session_->Connect(host_size.width(), host_size.height(),
-                                         terminal_id, event_handler.get());
+                                         terminal_id, server_port,
+                                         event_handler.get());
   if (FAILED(result)) {
     LOG(ERROR) << "RdpSession::Create() failed, 0x"
                << std::hex << result << std::dec << ".";
     return false;
   }
 
   return true;
 }
 
 void RdpSession::OnRdpConnected() {
@@ skipping 16 matching lines @@
   // See http://crbug.com/137696.
   NOTIMPLEMENTED();
 }
 
 void RdpSession::InjectSas() {
   DCHECK(caller_task_runner()->BelongsToCurrentThread());
 
   rdp_desktop_session_->InjectSas();
 }
 
+bool RdpSession::RetrieveDwordRegistryValue(const wchar_t* key_name,
+                                            const wchar_t* value_name,
+                                            DWORD* value) {
+  DCHECK(key_name);
+  DCHECK(value_name);
+  DCHECK(value);
+
+  base::win::RegKey key(HKEY_LOCAL_MACHINE, key_name, KEY_READ);
+  if (!key.Valid()) {
+    LOG(WARNING) << "Failed to open key: " << key_name;
+    return false;
+  }
+
+  if (key.ReadValueDW(value_name, value) != ERROR_SUCCESS) {
+    LOG(WARNING) << "Failed to read registry value: " << value_name;
+    return false;
+  }
+
+  return true;
+}
+
 RdpSession::EventHandler::EventHandler(
     base::WeakPtr<RdpSession> desktop_session)
     : ref_count_(0),
       desktop_session_(desktop_session) {
 }
 
 RdpSession::EventHandler::~EventHandler() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (desktop_session_)
@@ skipping 288 matching lines @@
                                 exploded.hour,
                                 exploded.minute,
                                 exploded.second,
                                 exploded.millisecond,
                                 passed.c_str());
 
   last_timestamp_ = now;
 }
 
 }  // namespace remoting