// 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. // Most of this code is copied from: // src/chrome/browser/policy/asynchronous_policy_loader.{h,cc} #include "remoting/host/policy_hack/policy_watcher.h" #include "base/bind.h" #include "base/compiler_specific.h" #include "base/location.h" #include "base/memory/weak_ptr.h" #include "base/single_thread_task_runner.h" #include "base/synchronization/waitable_event.h" #include "base/time/time.h" #include "base/values.h" #include "remoting/host/dns_blackhole_checker.h" #if !defined(NDEBUG) #include "base/json/json_reader.h" #endif namespace remoting { namespace policy_hack { namespace { // The time interval for rechecking policy. This is our fallback in case the // delegate never reports a change to the ReloadObserver. const int kFallbackReloadDelayMinutes = 15; // Copies all policy values from one dictionary to another, using values from // |default| if they are not set in |from|, or values from |bad_type_values| if // the value in |from| has the wrong type. scoped_ptr<base::DictionaryValue> CopyGoodValuesAndAddDefaults( const base::DictionaryValue* from, const base::DictionaryValue* default_values, const base::DictionaryValue* bad_type_values) { scoped_ptr<base::DictionaryValue> to(default_values->DeepCopy()); for (base::DictionaryValue::Iterator i(*default_values); !i.IsAtEnd(); i.Advance()) { const base::Value* value = NULL; // If the policy isn't in |from|, use the default. if (!from->Get(i.key(), &value)) { continue; } // If the policy is the wrong type, use the value from |bad_type_values|. if (!value->IsType(i.value().GetType())) { CHECK(bad_type_values->Get(i.key(), &value)); } to->Set(i.key(), value->DeepCopy()); } #if !defined(NDEBUG) // Replace values with those specified in DebugOverridePolicies, if present. std::string policy_overrides; if (from->GetString(PolicyWatcher::kHostDebugOverridePoliciesName, &policy_overrides)) { scoped_ptr<base::Value> value(base::JSONReader::Read(policy_overrides)); const base::DictionaryValue* override_values; if (value && value->GetAsDictionary(&override_values)) { to->MergeDictionary(override_values); } } #endif // defined(NDEBUG) return to.Pass(); } } // namespace const char PolicyWatcher::kNatPolicyName[] = "RemoteAccessHostFirewallTraversal"; const char PolicyWatcher::kHostRequireTwoFactorPolicyName[] = "RemoteAccessHostRequireTwoFactor"; const char PolicyWatcher::kHostDomainPolicyName[] = "RemoteAccessHostDomain"; const char PolicyWatcher::kHostMatchUsernamePolicyName[] = "RemoteAccessHostMatchUsername"; const char PolicyWatcher::kHostTalkGadgetPrefixPolicyName[] = "RemoteAccessHostTalkGadgetPrefix"; const char PolicyWatcher::kHostRequireCurtainPolicyName[] = "RemoteAccessHostRequireCurtain"; const char PolicyWatcher::kHostTokenUrlPolicyName[] = "RemoteAccessHostTokenUrl"; const char PolicyWatcher::kHostTokenValidationUrlPolicyName[] = "RemoteAccessHostTokenValidationUrl"; const char PolicyWatcher::kHostAllowClientPairing[] = "RemoteAccessHostAllowClientPairing"; const char PolicyWatcher::kHostDebugOverridePoliciesName[] = "RemoteAccessHostDebugOverridePolicies"; PolicyWatcher::PolicyWatcher( scoped_refptr<base::SingleThreadTaskRunner> task_runner) : task_runner_(task_runner), old_policies_(new base::DictionaryValue()), default_values_(new base::DictionaryValue()), weak_factory_(this) { // Initialize the default values for each policy. default_values_->SetBoolean(kNatPolicyName, true); default_values_->SetBoolean(kHostRequireTwoFactorPolicyName, false); default_values_->SetBoolean(kHostRequireCurtainPolicyName, false); default_values_->SetBoolean(kHostMatchUsernamePolicyName, false); default_values_->SetString(kHostDomainPolicyName, std::string()); default_values_->SetString(kHostTalkGadgetPrefixPolicyName, kDefaultHostTalkGadgetPrefix); default_values_->SetString(kHostTokenUrlPolicyName, std::string()); default_values_->SetString(kHostTokenValidationUrlPolicyName, std::string()); default_values_->SetBoolean(kHostAllowClientPairing, true); #if !defined(NDEBUG) default_values_->SetString(kHostDebugOverridePoliciesName, std::string()); #endif // Initialize the fall-back values to use for unreadable policies. // For most policies these match the defaults. bad_type_values_.reset(default_values_->DeepCopy()); bad_type_values_->SetBoolean(kNatPolicyName, false); } PolicyWatcher::~PolicyWatcher() { } void PolicyWatcher::StartWatching(const PolicyCallback& policy_callback) { if (!OnPolicyWatcherThread()) { task_runner_->PostTask(FROM_HERE, base::Bind(&PolicyWatcher::StartWatching, base::Unretained(this), policy_callback)); return; } policy_callback_ = policy_callback; StartWatchingInternal(); } void PolicyWatcher::StopWatching(base::WaitableEvent* done) { if (!OnPolicyWatcherThread()) { task_runner_->PostTask(FROM_HERE, base::Bind(&PolicyWatcher::StopWatching, base::Unretained(this), done)); return; } StopWatchingInternal(); weak_factory_.InvalidateWeakPtrs(); policy_callback_.Reset(); done->Signal(); } void PolicyWatcher::ScheduleFallbackReloadTask() { DCHECK(OnPolicyWatcherThread()); ScheduleReloadTask( base::TimeDelta::FromMinutes(kFallbackReloadDelayMinutes)); } void PolicyWatcher::ScheduleReloadTask(const base::TimeDelta& delay) { DCHECK(OnPolicyWatcherThread()); task_runner_->PostDelayedTask( FROM_HERE, base::Bind(&PolicyWatcher::Reload, weak_factory_.GetWeakPtr()), delay); } const base::DictionaryValue& PolicyWatcher::Defaults() const { return *default_values_; } bool PolicyWatcher::OnPolicyWatcherThread() const { return task_runner_->BelongsToCurrentThread(); } void PolicyWatcher::UpdatePolicies( const base::DictionaryValue* new_policies_raw) { DCHECK(OnPolicyWatcherThread()); // Use default values for any missing policies. scoped_ptr<base::DictionaryValue> new_policies = CopyGoodValuesAndAddDefaults( new_policies_raw, default_values_.get(), bad_type_values_.get()); // Find the changed policies. scoped_ptr<base::DictionaryValue> changed_policies( new base::DictionaryValue()); base::DictionaryValue::Iterator iter(*new_policies); while (!iter.IsAtEnd()) { base::Value* old_policy; if (!(old_policies_->Get(iter.key(), &old_policy) && old_policy->Equals(&iter.value()))) { changed_policies->Set(iter.key(), iter.value().DeepCopy()); } iter.Advance(); } // Save the new policies. old_policies_.swap(new_policies); // Notify our client of the changed policies. if (!changed_policies->empty()) { policy_callback_.Run(changed_policies.Pass()); } } } // namespace policy_hack } // namespace remoting