Add policy to restrict client domain for Me2Me.

remoting/host/it2me/it2me_host.cc

 // Copyright 2013 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 <stddef.h>
 
 #include <utility>
 
@@ skipping 280 matching lines @@
 
   // ChromotingHost doesn't allow multiple concurrent connection and the
   // host is destroyed in OnClientDisconnected() after the first connection.
   CHECK_NE(state_, kConnected);
 
   std::string client_username = jid;
   size_t pos = client_username.find('/');
   if (pos != std::string::npos)
     client_username.replace(pos, std::string::npos, "");
 
+  // Check the client domain policy.

[Jamie, 2016/01/28 01:02:22]

Is there a better place to test this? Doing it here means that the disconnect
dialog pops up briefly.

[Sergey Ulanov, 2016/01/28 19:42:46]

I think the best approach would be to put this check in
It2MeHostAuthenticatorFactory. That would allow to reject the client even before
authentication starts. See
https://code.google.com/p/chromium/codesearch#chromium/src/remoting/protocol/...
for example of how it's implemented for me2me.

[Jamie, 2016/01/29 02:23:27]

Done.

+  if (!required_client_domain_.empty() &&
+      !base::EndsWith(client_username,
+                      std::string("@") + required_client_domain_,
+                      base::CompareCase::INSENSITIVE_ASCII)) {
+    SetState(kInvalidDomainError, "Client domain mismatch");
+    return;
+  }
+
   HOST_LOG << "Client " << client_username << " connected.";
 
   // Pass the client user name to the script object before changing state.
   task_runner_->PostTask(
       FROM_HERE, base::Bind(&It2MeHost::Observer::OnClientAuthenticated,
                             observer_, client_username));
 
   SetState(kConnected, "");
 }
 
@@ skipping 14 matching lines @@
 
   bool nat_policy;
   if (policies->GetBoolean(policy::key::kRemoteAccessHostFirewallTraversal,
                            &nat_policy)) {
     UpdateNatPolicy(nat_policy);
   }
   std::string host_domain;
   if (policies->GetString(policy::key::kRemoteAccessHostDomain, &host_domain)) {
     UpdateHostDomainPolicy(host_domain);
   }
+  std::string client_domain;
+  if (policies->GetString(policy::key::kRemoteAccessHostClientDomain,
+                          &client_domain)) {
+    UpdateClientDomainPolicy(client_domain);
+  }
 
   policy_received_ = true;
 
   if (!pending_connect_.is_null()) {
     base::ResetAndReturn(&pending_connect_).Run();
   }
 }
 
 void It2MeHost::OnPolicyError() {
   // TODO(lukasza): Report the policy error to the user.  crbug.com/433009
@@ skipping 25 matching lines @@
   VLOG(2) << "UpdateHostDomainPolicy: " << host_domain;
 
   // When setting a host domain policy, force disconnect any existing session.
   if (!host_domain.empty() && IsConnected()) {
     Shutdown();
   }
 
   required_host_domain_ = host_domain;
 }
 
+void It2MeHost::UpdateClientDomainPolicy(const std::string& client_domain) {
+  DCHECK(host_context_->network_task_runner()->BelongsToCurrentThread());
+
+  VLOG(2) << "UpdateClientDomainPolicy: " << client_domain;
+
+  // When setting a host domain policy, force disconnect any existing session.
+  if (!client_domain.empty() && IsConnected()) {
+    Shutdown();
+  }
+
+  required_client_domain_ = client_domain;
+}
+
 It2MeHost::~It2MeHost() {
   // Check that resources that need to be torn down on the UI thread are gone.
   DCHECK(!desktop_environment_factory_.get());
   DCHECK(!policy_watcher_.get());
 }
 
 void It2MeHost::SetState(It2MeHostState state,
                          const std::string& error_message) {
   DCHECK(host_context_->network_task_runner()->BelongsToCurrentThread());
 
   switch (state_) {
     case kDisconnected:
       DCHECK(state == kStarting ||
              state == kError) << state;
       break;
     case kStarting:
       DCHECK(state == kRequestedAccessCode ||
              state == kDisconnected ||
              state == kError ||
              state == kInvalidDomainError) << state;
       break;
     case kRequestedAccessCode:
       DCHECK(state == kReceivedAccessCode ||
              state == kDisconnected ||
              state == kError) << state;
       break;
     case kReceivedAccessCode:
       DCHECK(state == kConnected ||
              state == kDisconnected ||
-             state == kError) << state;
+             state == kError ||
+             state == kInvalidDomainError) << state;
       break;
     case kConnected:
       DCHECK(state == kDisconnected ||
              state == kError) << state;
       break;
     case kError:
       DCHECK(state == kDisconnected) << state;
       break;
     case kInvalidDomainError:
       DCHECK(state == kDisconnected) << state;
@@ skipping 72 matching lines @@
   scoped_ptr<It2MeConfirmationDialogFactory> confirmation_dialog_factory(
       new It2MeConfirmationDialogFactory());
   scoped_ptr<PolicyWatcher> policy_watcher =
       PolicyWatcher::Create(policy_service_, context->file_task_runner());
   return new It2MeHost(std::move(context), std::move(policy_watcher),
                        std::move(confirmation_dialog_factory), observer,
                        xmpp_server_config, directory_bot_jid);
 }
 
 }  // namespace remoting