Host port range policy is no longer ignored in it2me host.

remoting/host/it2me/it2me_host_unittest.cc

 // Copyright 2016 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/it2me/it2me_host.h"
 
 #include <memory>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/location.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/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/policy/policy_constants.h"
 #include "remoting/base/auto_thread_task_runner.h"
+#include "remoting/host/chromoting_host.h"
 #include "remoting/host/chromoting_host_context.h"
 #include "remoting/host/it2me/it2me_confirmation_dialog.h"
 #include "remoting/host/policy_watcher.h"
+#include "remoting/protocol/transport_context.h"
 #include "remoting/signaling/fake_signal_strategy.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(OS_LINUX)
 #include "base/linux_util.h"
 #endif  // defined(OS_LINUX)
 
 namespace remoting {
 
 namespace {
 
 // Shortening some type names for readability.
 typedef protocol::ValidatingAuthenticator::Result ValidationResult;
 typedef It2MeConfirmationDialog::Result DialogResult;
 
 const char kTestUserName[] = "ficticious_user@gmail.com";
 const char kTestClientJid[] = "ficticious_user@gmail.com/jid_resource";
 const char kTestClientJid2[] = "ficticious_user_2@gmail.com/jid_resource";
 const char kTestClientUsernameNoJid[] = "completely_ficticious_user@gmail.com";
 const char kTestClientJidWithSlash[] = "fake/user@gmail.com/jid_resource";
 const char kResourceOnly[] = "/jid_resource";
 const char kMatchingDomain[] = "gmail.com";
 const char kMismatchedDomain1[] = "similar_to_gmail.com";
 const char kMismatchedDomain2[] = "gmail_at_the_beginning.com";
 const char kMismatchedDomain3[] = "not_even_close.com";
+// Note that this is intentionally different from the default port range.
+const char kPortRange[] = "12401-12408";
 
 }  // namespace
 
 class FakeIt2MeConfirmationDialog : public It2MeConfirmationDialog {
  public:
   FakeIt2MeConfirmationDialog(const std::string& remote_user_email,
                               DialogResult dialog_result);
   ~FakeIt2MeConfirmationDialog() override;
 
   // It2MeConfirmationDialog implementation.
@@ skipping 96 matching lines @@
 
   ValidationResult validation_result_ = ValidationResult::SUCCESS;
 
   base::Closure state_change_callback_;
 
   It2MeHostState last_host_state_ = It2MeHostState::kDisconnected;
 
   // Used to set ConfirmationDialog behavior.
   FakeIt2MeDialogFactory* dialog_factory_ = nullptr;
 
+  scoped_refptr<It2MeHost> it2me_host_;
+
  private:
   void StartupHostStateHelper(const base::Closure& quit_closure);
 
   std::unique_ptr<base::MessageLoop> message_loop_;
   std::unique_ptr<base::RunLoop> run_loop_;
 
   scoped_refptr<AutoThreadTaskRunner> network_task_runner_;
   scoped_refptr<AutoThreadTaskRunner> ui_task_runner_;
 
-  scoped_refptr<It2MeHost> it2me_host_;
-
   base::WeakPtrFactory<It2MeHostTest> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(It2MeHostTest);
 };
 
 It2MeHostTest::It2MeHostTest() : weak_factory_(this) {}
 
 It2MeHostTest::~It2MeHostTest() {}
 
 void It2MeHostTest::SetUp() {
@@ skipping 310 matching lines @@
   SetPolicies({{policy::key::kRemoteAccessHostClientDomainList,
                 MakeList({kMismatchedDomain1, kMismatchedDomain2,
                           kMismatchedDomain3})}});
   StartHost();
   RunValidationCallback(kTestClientJid);
   ASSERT_EQ(ValidationResult::ERROR_INVALID_ACCOUNT, validation_result_);
   RunUntilStateChanged(It2MeHostState::kDisconnected);
   ASSERT_EQ(It2MeHostState::kDisconnected, last_host_state_);
 }
 
+TEST_F(It2MeHostTest, HostUdpPortRangePolicy_ValidRange) {
+  PortRange port_range_actual;
+  ASSERT_TRUE(PortRange::Parse(kPortRange, &port_range_actual));
+  SetPolicies(
+      {{policy::key::kRemoteAccessHostUdpPortRange, base::Value(kPortRange)}});
+  StartHost();
+  PortRange port_range = it2me_host_->host_->transport_context_for_tests()
+                             ->network_settings()
+                             .port_range;
+  ASSERT_EQ(port_range_actual.min_port, port_range.min_port);
+  ASSERT_EQ(port_range_actual.max_port, port_range.max_port);
+}
+
+TEST_F(It2MeHostTest, HostUdpPortRangePolicy_NoRange) {
+  StartHost();
+  PortRange port_range = it2me_host_->host_->transport_context_for_tests()
+                             ->network_settings()
+                             .port_range;
+  ASSERT_TRUE(port_range.is_null());
+}
+
 TEST_F(It2MeHostTest, ConnectionValidation_ConfirmationDialog_Accept) {
   StartHost();
   RunValidationCallback(kTestClientJid);
   ASSERT_EQ(ValidationResult::SUCCESS, validation_result_);
   ASSERT_EQ(It2MeHostState::kConnecting, last_host_state_);
   ShutdownHost();
   ASSERT_EQ(It2MeHostState::kDisconnected, last_host_state_);
 }
 
 TEST_F(It2MeHostTest, ConnectionValidation_ConfirmationDialog_Reject) {
@@ skipping 11 matching lines @@
   ASSERT_EQ(ValidationResult::SUCCESS, validation_result_);
   ASSERT_EQ(It2MeHostState::kConnecting, last_host_state_);
 
   RunValidationCallback(kTestClientJid2);
   ASSERT_EQ(ValidationResult::ERROR_TOO_MANY_CONNECTIONS, validation_result_);
   RunUntilStateChanged(It2MeHostState::kDisconnected);
   ASSERT_EQ(It2MeHostState::kDisconnected, last_host_state_);
 }
 
 }  // namespace remoting