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;
+  if (!RetrieveDwordRegistryValue(kRdpTcpSettingsKeyName, kRdpPortValueName,
+                                  &server_port) ||
+      server_port > 65535) {
+    server_port = kDefaultRdpPort;

[Jamie, 2016/05/03 00:18:12]

I realize you haven't changed the behaviour here, but this feels wrong. If the
user has attempted to configure something but set a bogus value, we should log
an error and fail (this would especially be true if we logged somewhere the user
could easily read it). Falling back on the default might give them false
confidence that they have done what they intended, leading to confusing
behaviour later on.

[joedow, 2016/05/03 19:07:08]

I think that makes sense.  It wouldn't have worked before but would have been
difficult to track the failure down.  This makes it deterministic which is good.

+  }
+
   // 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