1 //
2 // Copyright (C) 2014 The Android Open Source Project
3 //
4 // Licensed under the Apache License, Version 2.0 (the "License");
5 // you may not use this file except in compliance with the License.
6 // You may obtain a copy of the License at
7 //
8 //      http://www.apache.org/licenses/LICENSE-2.0
9 //
10 // Unless required by applicable law or agreed to in writing, software
11 // distributed under the License is distributed on an "AS IS" BASIS,
12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 // See the License for the specific language governing permissions and
14 // limitations under the License.
15 //
16 
17 #ifndef UPDATE_ENGINE_UPDATE_MANAGER_REAL_DEVICE_POLICY_PROVIDER_H_
18 #define UPDATE_ENGINE_UPDATE_MANAGER_REAL_DEVICE_POLICY_PROVIDER_H_
19 
20 #include <memory>
21 #include <set>
22 #include <string>
23 
24 #include <brillo/message_loops/message_loop.h>
25 #include <gtest/gtest_prod.h>  // for FRIEND_TEST
26 #include <policy/libpolicy.h>
27 #if USE_DBUS
28 #include <session_manager/dbus-proxies.h>
29 #endif  // USE_DBUS
30 
31 #include "update_engine/update_manager/device_policy_provider.h"
32 #include "update_engine/update_manager/generic_variables.h"
33 
34 namespace chromeos_update_manager {
35 
36 // DevicePolicyProvider concrete implementation.
37 class RealDevicePolicyProvider : public DevicePolicyProvider {
38  public:
39 #if USE_DBUS
40   RealDevicePolicyProvider(
41       std::unique_ptr<org::chromium::SessionManagerInterfaceProxyInterface>
42           session_manager_proxy,
43       policy::PolicyProvider* policy_provider)
44       : policy_provider_(policy_provider),
45         session_manager_proxy_(std::move(session_manager_proxy)) {}
46 #endif  // USE_DBUS
47   explicit RealDevicePolicyProvider(policy::PolicyProvider* policy_provider)
48       : policy_provider_(policy_provider) {}
49   ~RealDevicePolicyProvider();
50 
51   // Initializes the provider and returns whether it succeeded.
52   bool Init();
53 
54   Variable<bool>* var_device_policy_is_loaded() override {
55     return &var_device_policy_is_loaded_;
56   }
57 
58   Variable<std::string>* var_release_channel() override {
59     return &var_release_channel_;
60   }
61 
62   Variable<bool>* var_release_channel_delegated() override {
63     return &var_release_channel_delegated_;
64   }
65 
66   Variable<bool>* var_update_disabled() override {
67     return &var_update_disabled_;
68   }
69 
70   Variable<std::string>* var_target_version_prefix() override {
71     return &var_target_version_prefix_;
72   }
73 
74   Variable<base::TimeDelta>* var_scatter_factor() override {
75     return &var_scatter_factor_;
76   }
77 
78   Variable<std::set<chromeos_update_engine::ConnectionType>>*
79       var_allowed_connection_types_for_update() override {
80     return &var_allowed_connection_types_for_update_;
81   }
82 
83   Variable<std::string>* var_owner() override {
84     return &var_owner_;
85   }
86 
87   Variable<bool>* var_http_downloads_enabled() override {
88     return &var_http_downloads_enabled_;
89   }
90 
91   Variable<bool>* var_au_p2p_enabled() override {
92     return &var_au_p2p_enabled_;
93   }
94 
95   Variable<bool>* var_allow_kiosk_app_control_chrome_version() override {
96     return &var_allow_kiosk_app_control_chrome_version_;
97   }
98 
99  private:
100   FRIEND_TEST(UmRealDevicePolicyProviderTest, RefreshScheduledTest);
101   FRIEND_TEST(UmRealDevicePolicyProviderTest, NonExistentDevicePolicyReloaded);
102   FRIEND_TEST(UmRealDevicePolicyProviderTest, ValuesUpdated);
103 
104   // A static handler for the PropertyChangedCompleted signal from the session
105   // manager used as a callback.
106   void OnPropertyChangedCompletedSignal(const std::string& success);
107 
108   // Called when the signal in UpdateEngineLibcrosProxyResolvedInterface is
109   // connected.
110   void OnSignalConnected(const std::string& interface_name,
111                          const std::string& signal_name,
112                          bool successful);
113 
114   // Schedules a call to periodically refresh the device policy.
115   void RefreshDevicePolicyAndReschedule();
116 
117   // Reloads the device policy and updates all the exposed variables.
118   void RefreshDevicePolicy();
119 
120   // Updates the async variable |var| based on the result value of the method
121   // passed, which is a DevicePolicy getter method.
122   template<typename T>
123   void UpdateVariable(AsyncCopyVariable<T>* var,
124                       bool (policy::DevicePolicy::*getter_method)(T*) const);
125 
126   // Updates the async variable |var| based on the result value of the getter
127   // method passed, which is a wrapper getter on this class.
128   template<typename T>
129   void UpdateVariable(
130       AsyncCopyVariable<T>* var,
131       bool (RealDevicePolicyProvider::*getter_method)(T*) const);
132 
133   // Wrapper for DevicePolicy::GetScatterFactorInSeconds() that converts the
134   // result to a base::TimeDelta. It returns the same value as
135   // GetScatterFactorInSeconds().
136   bool ConvertScatterFactor(base::TimeDelta* scatter_factor) const;
137 
138   // Wrapper for DevicePolicy::GetAllowedConnectionTypesForUpdate() that
139   // converts the result to a set of ConnectionType elements instead of strings.
140   bool ConvertAllowedConnectionTypesForUpdate(
141       std::set<chromeos_update_engine::ConnectionType>* allowed_types) const;
142 
143   // Used for fetching information about the device policy.
144   policy::PolicyProvider* policy_provider_;
145 
146   // Used to schedule refreshes of the device policy.
147   brillo::MessageLoop::TaskId scheduled_refresh_{
148       brillo::MessageLoop::kTaskIdNull};
149 
150 #if USE_DBUS
151   // The DBus (mockable) session manager proxy.
152   std::unique_ptr<org::chromium::SessionManagerInterfaceProxyInterface>
153       session_manager_proxy_;
154 #endif  // USE_DBUS
155 
156   // Variable exposing whether the policy is loaded.
157   AsyncCopyVariable<bool> var_device_policy_is_loaded_{
158       "policy_is_loaded", false};
159 
160   // Variables mapping the exposed methods from the policy::DevicePolicy.
161   AsyncCopyVariable<std::string> var_release_channel_{"release_channel"};
162   AsyncCopyVariable<bool> var_release_channel_delegated_{
163       "release_channel_delegated"};
164   AsyncCopyVariable<bool> var_update_disabled_{"update_disabled"};
165   AsyncCopyVariable<std::string> var_target_version_prefix_{
166       "target_version_prefix"};
167   AsyncCopyVariable<base::TimeDelta> var_scatter_factor_{"scatter_factor"};
168   AsyncCopyVariable<std::set<chromeos_update_engine::ConnectionType>>
169       var_allowed_connection_types_for_update_{
170           "allowed_connection_types_for_update"};
171   AsyncCopyVariable<std::string> var_owner_{"owner"};
172   AsyncCopyVariable<bool> var_http_downloads_enabled_{"http_downloads_enabled"};
173   AsyncCopyVariable<bool> var_au_p2p_enabled_{"au_p2p_enabled"};
174   AsyncCopyVariable<bool> var_allow_kiosk_app_control_chrome_version_{
175       "allow_kiosk_app_control_chrome_version"};
176 
177   DISALLOW_COPY_AND_ASSIGN(RealDevicePolicyProvider);
178 };
179 
180 }  // namespace chromeos_update_manager
181 
182 #endif  // UPDATE_ENGINE_UPDATE_MANAGER_REAL_DEVICE_POLICY_PROVIDER_H_
183