1 //
2 // Copyright (C) 2012 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 #include "update_engine/cros/connection_manager.h"
18
19 #include <memory>
20 #include <set>
21 #include <string>
22
23 #include <base/stl_util.h>
24 #include <base/strings/string_util.h>
25 #include <policy/device_policy.h>
26 #include <shill/dbus-constants.h>
27 #include <shill/dbus-proxies.h>
28
29 #include "update_engine/common/connection_utils.h"
30 #include "update_engine/common/prefs.h"
31 #include "update_engine/common/system_state.h"
32 #include "update_engine/common/utils.h"
33 #include "update_engine/cros/shill_proxy.h"
34 #include "update_engine/cros/update_attempter.h"
35
36 using org::chromium::flimflam::ManagerProxyInterface;
37 using org::chromium::flimflam::ServiceProxyInterface;
38 using std::set;
39 using std::string;
40
41 namespace chromeos_update_engine {
42
43 namespace connection_manager {
CreateConnectionManager()44 std::unique_ptr<ConnectionManagerInterface> CreateConnectionManager() {
45 return std::unique_ptr<ConnectionManagerInterface>(
46 new ConnectionManager(new ShillProxy()));
47 }
48 } // namespace connection_manager
49
ConnectionManager(ShillProxyInterface * shill_proxy)50 ConnectionManager::ConnectionManager(ShillProxyInterface* shill_proxy)
51 : shill_proxy_(shill_proxy) {}
52
IsUpdateAllowedOver(ConnectionType type,ConnectionTethering tethering) const53 bool ConnectionManager::IsUpdateAllowedOver(
54 ConnectionType type, ConnectionTethering tethering) const {
55 if (type != ConnectionType::kCellular) {
56 if (tethering != ConnectionTethering::kConfirmed) {
57 return true;
58 }
59
60 // Treat this connection as if it is a cellular connection.
61 LOG(INFO)
62 << "Current connection is confirmed tethered, using Cellular setting.";
63 }
64
65 const policy::DevicePolicy* device_policy =
66 SystemState::Get()->device_policy();
67
68 // The device_policy is loaded in a lazy way before an update check. Load
69 // it now from the libbrillo cache if it wasn't already loaded.
70 if (!device_policy) {
71 UpdateAttempter* update_attempter = SystemState::Get()->update_attempter();
72 if (update_attempter) {
73 update_attempter->RefreshDevicePolicy();
74 device_policy = SystemState::Get()->device_policy();
75 }
76 }
77
78 if (!device_policy) {
79 // Device policy fails to be loaded (possibly due to guest account). We
80 // do not check the local user setting here, which should be checked by
81 // |OmahaRequestAction| during checking for update.
82 LOG(INFO) << "Allowing updates over cellular as device policy fails to be "
83 "loaded.";
84 return true;
85 }
86
87 set<string> allowed_types;
88 if (device_policy->GetAllowedConnectionTypesForUpdate(&allowed_types)) {
89 // The update setting is enforced by the device policy.
90
91 // TODO(crbug.com/1054279): Use base::Contains after uprev to r680000.
92 if (allowed_types.find(shill::kTypeCellular) == allowed_types.end()) {
93 LOG(INFO) << "Disabling updates over cellular connection as it's not "
94 "allowed in the device policy.";
95 return false;
96 }
97
98 LOG(INFO) << "Allowing updates over cellular per device policy.";
99 return true;
100 }
101
102 // If there's no update setting in the device policy, we do not check
103 // the local user setting here, which should be checked by
104 // |OmahaRequestAction| during checking for update.
105 LOG(INFO) << "Allowing updates over cellular as device policy does "
106 "not include update setting.";
107 return true;
108 }
109
IsAllowedConnectionTypesForUpdateSet() const110 bool ConnectionManager::IsAllowedConnectionTypesForUpdateSet() const {
111 const policy::DevicePolicy* device_policy =
112 SystemState::Get()->device_policy();
113 if (!device_policy) {
114 LOG(INFO) << "There's no device policy loaded yet.";
115 return false;
116 }
117
118 set<string> allowed_types;
119 if (!device_policy->GetAllowedConnectionTypesForUpdate(&allowed_types)) {
120 return false;
121 }
122
123 return true;
124 }
125
GetConnectionProperties(ConnectionType * out_type,ConnectionTethering * out_tethering)126 bool ConnectionManager::GetConnectionProperties(
127 ConnectionType* out_type, ConnectionTethering* out_tethering) {
128 dbus::ObjectPath default_service_path;
129 TEST_AND_RETURN_FALSE(GetDefaultServicePath(&default_service_path));
130 if (!default_service_path.IsValid())
131 return false;
132 // Shill uses the "/" service path to indicate that it is not connected.
133 if (default_service_path.value() == "/") {
134 *out_type = ConnectionType::kDisconnected;
135 *out_tethering = ConnectionTethering::kUnknown;
136 return true;
137 }
138 TEST_AND_RETURN_FALSE(
139 GetServicePathProperties(default_service_path, out_type, out_tethering));
140 return true;
141 }
142
GetDefaultServicePath(dbus::ObjectPath * out_path)143 bool ConnectionManager::GetDefaultServicePath(dbus::ObjectPath* out_path) {
144 brillo::VariantDictionary properties;
145 brillo::ErrorPtr error;
146 ManagerProxyInterface* manager_proxy = shill_proxy_->GetManagerProxy();
147 if (!manager_proxy)
148 return false;
149 TEST_AND_RETURN_FALSE(manager_proxy->GetProperties(&properties, &error));
150
151 const auto& prop_default_service =
152 properties.find(shill::kDefaultServiceProperty);
153 if (prop_default_service == properties.end())
154 return false;
155
156 *out_path = prop_default_service->second.TryGet<dbus::ObjectPath>();
157 return out_path->IsValid();
158 }
159
GetServicePathProperties(const dbus::ObjectPath & path,ConnectionType * out_type,ConnectionTethering * out_tethering)160 bool ConnectionManager::GetServicePathProperties(
161 const dbus::ObjectPath& path,
162 ConnectionType* out_type,
163 ConnectionTethering* out_tethering) {
164 // We create and dispose the ServiceProxyInterface on every request.
165 std::unique_ptr<ServiceProxyInterface> service =
166 shill_proxy_->GetServiceForPath(path);
167
168 brillo::VariantDictionary properties;
169 brillo::ErrorPtr error;
170 TEST_AND_RETURN_FALSE(service->GetProperties(&properties, &error));
171
172 // Populate the out_tethering.
173 const auto& prop_tethering = properties.find(shill::kTetheringProperty);
174 if (prop_tethering == properties.end()) {
175 // Set to Unknown if not present.
176 *out_tethering = ConnectionTethering::kUnknown;
177 } else {
178 // If the property doesn't contain a string value, the empty string will
179 // become kUnknown.
180 *out_tethering = connection_utils::ParseConnectionTethering(
181 prop_tethering->second.TryGet<string>());
182 }
183
184 // Populate the out_type property.
185 const auto& prop_type = properties.find(shill::kTypeProperty);
186 if (prop_type == properties.end()) {
187 // Set to Unknown if not present.
188 *out_type = ConnectionType::kUnknown;
189 return false;
190 }
191
192 string type_str = prop_type->second.TryGet<string>();
193 if (type_str == shill::kTypeVPN) {
194 const auto& prop_physical =
195 properties.find(shill::kPhysicalTechnologyProperty);
196 if (prop_physical == properties.end()) {
197 LOG(ERROR) << "No PhysicalTechnology property found for a VPN"
198 " connection (service: "
199 << path.value() << "). Returning default kUnknown value.";
200 *out_type = ConnectionType::kUnknown;
201 } else {
202 *out_type = connection_utils::ParseConnectionType(
203 prop_physical->second.TryGet<string>());
204 }
205 } else {
206 *out_type = connection_utils::ParseConnectionType(type_str);
207 }
208 return true;
209 }
210
211 } // namespace chromeos_update_engine
212