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 "shill/default_profile.h"
18
19 #include <random>
20 #include <vector>
21
22 #include <base/files/file_path.h>
23 #include <base/strings/string_number_conversions.h>
24 #include <base/strings/stringprintf.h>
25 #if defined(__ANDROID__)
26 #include <dbus/service_constants.h>
27 #else
28 #include <chromeos/dbus/service_constants.h>
29 #endif // __ANDROID__
30
31 #include "shill/adaptor_interfaces.h"
32 #include "shill/connectivity_trial.h"
33 #include "shill/control_interface.h"
34 #include "shill/link_monitor.h"
35 #include "shill/manager.h"
36 #include "shill/portal_detector.h"
37 #include "shill/resolver.h"
38 #include "shill/store_interface.h"
39
40 #if !defined(DISABLE_WIFI)
41 #include "shill/wifi/wifi_provider.h"
42 #endif // DISABLE_WIFI
43
44 using base::FilePath;
45 using std::string;
46 using std::vector;
47
48 namespace shill {
49 // static
50 const char DefaultProfile::kDefaultId[] = "default";
51 // static
52 const char DefaultProfile::kStorageId[] = "global";
53 // static
54 const char DefaultProfile::kStorageArpGateway[] = "ArpGateway";
55 // static
56 const char DefaultProfile::kStorageCheckPortalList[] = "CheckPortalList";
57 // static
58 const char DefaultProfile::kStorageConnectionIdSalt[] = "ConnectionIdSalt";
59 // static
60 const char DefaultProfile::kStorageHostName[] = "HostName";
61 // static
62 const char DefaultProfile::kStorageIgnoredDNSSearchPaths[] =
63 "IgnoredDNSSearchPaths";
64 // static
65 const char DefaultProfile::kStorageLinkMonitorTechnologies[] =
66 "LinkMonitorTechnologies";
67 // static
68 const char DefaultProfile::kStorageName[] = "Name";
69 // static
70 const char DefaultProfile::kStorageNoAutoConnectTechnologies[] =
71 "NoAutoConnectTechnologies";
72 // static
73 const char DefaultProfile::kStorageOfflineMode[] = "OfflineMode";
74 // static
75 const char DefaultProfile::kStoragePortalURL[] = "PortalURL";
76 // static
77 const char DefaultProfile::kStoragePortalCheckInterval[] =
78 "PortalCheckInterval";
79 // static
80 const char DefaultProfile::kStorageProhibitedTechnologies[] =
81 "ProhibitedTechnologies";
82
DefaultProfile(ControlInterface * control,Metrics * metrics,Manager * manager,const FilePath & storage_directory,const string & profile_id,const Manager::Properties & manager_props)83 DefaultProfile::DefaultProfile(ControlInterface* control,
84 Metrics* metrics,
85 Manager* manager,
86 const FilePath& storage_directory,
87 const string& profile_id,
88 const Manager::Properties& manager_props)
89 : Profile(
90 control, metrics, manager, Identifier(profile_id),
91 storage_directory, true),
92 profile_id_(profile_id),
93 props_(manager_props),
94 random_engine_(time(nullptr)) {
95 PropertyStore* store = this->mutable_store();
96 store->RegisterConstBool(kArpGatewayProperty, &manager_props.arp_gateway);
97 store->RegisterConstString(kCheckPortalListProperty,
98 &manager_props.check_portal_list);
99 store->RegisterConstString(kCountryProperty, &manager_props.country);
100 store->RegisterConstString(kIgnoredDNSSearchPathsProperty,
101 &manager_props.ignored_dns_search_paths);
102 store->RegisterConstString(kLinkMonitorTechnologiesProperty,
103 &manager_props.link_monitor_technologies);
104 store->RegisterConstString(kNoAutoConnectTechnologiesProperty,
105 &manager_props.no_auto_connect_technologies);
106 store->RegisterConstBool(kOfflineModeProperty, &manager_props.offline_mode);
107 store->RegisterConstString(kPortalURLProperty, &manager_props.portal_url);
108 store->RegisterConstInt32(kPortalCheckIntervalProperty,
109 &manager_props.portal_check_interval_seconds);
110 store->RegisterConstString(kProhibitedTechnologiesProperty,
111 &manager_props.prohibited_technologies);
112 set_persistent_profile_path(
113 GetFinalStoragePath(storage_directory, Identifier(profile_id)));
114 }
115
~DefaultProfile()116 DefaultProfile::~DefaultProfile() {}
117
LoadManagerProperties(Manager::Properties * manager_props,DhcpProperties * dhcp_properties)118 void DefaultProfile::LoadManagerProperties(Manager::Properties* manager_props,
119 DhcpProperties* dhcp_properties) {
120 storage()->GetBool(kStorageId, kStorageArpGateway,
121 &manager_props->arp_gateway);
122 storage()->GetString(kStorageId, kStorageHostName, &manager_props->host_name);
123 storage()->GetBool(kStorageId, kStorageOfflineMode,
124 &manager_props->offline_mode);
125 if (!storage()->GetString(kStorageId,
126 kStorageCheckPortalList,
127 &manager_props->check_portal_list)) {
128 manager_props->check_portal_list = PortalDetector::kDefaultCheckPortalList;
129 }
130 if (!storage()->GetInt(kStorageId, kStorageConnectionIdSalt,
131 &manager_props->connection_id_salt)) {
132 manager_props->connection_id_salt =
133 std::uniform_int_distribution<int>()(random_engine_);
134 }
135 if (!storage()->GetString(kStorageId,
136 kStorageIgnoredDNSSearchPaths,
137 &manager_props->ignored_dns_search_paths)) {
138 manager_props->ignored_dns_search_paths =
139 Resolver::kDefaultIgnoredSearchList;
140 }
141 if (!storage()->GetString(kStorageId,
142 kStorageLinkMonitorTechnologies,
143 &manager_props->link_monitor_technologies)) {
144 manager_props->link_monitor_technologies =
145 LinkMonitor::kDefaultLinkMonitorTechnologies;
146 }
147 if (!storage()->GetString(kStorageId,
148 kStorageNoAutoConnectTechnologies,
149 &manager_props->no_auto_connect_technologies)) {
150 manager_props->no_auto_connect_technologies = "";
151 }
152 if (!storage()->GetString(kStorageId, kStoragePortalURL,
153 &manager_props->portal_url)) {
154 manager_props->portal_url = ConnectivityTrial::kDefaultURL;
155 }
156 std::string check_interval;
157 if (!storage()->GetString(kStorageId, kStoragePortalCheckInterval,
158 &check_interval) ||
159 !base::StringToInt(check_interval,
160 &manager_props->portal_check_interval_seconds)) {
161 manager_props->portal_check_interval_seconds =
162 PortalDetector::kDefaultCheckIntervalSeconds;
163 }
164 if (!storage()->GetString(kStorageId,
165 kStorageProhibitedTechnologies,
166 &manager_props->prohibited_technologies)) {
167 manager_props->prohibited_technologies = "";
168 }
169 dhcp_properties->Load(storage(), kStorageId);
170 }
171
ConfigureService(const ServiceRefPtr & service)172 bool DefaultProfile::ConfigureService(const ServiceRefPtr& service) {
173 if (Profile::ConfigureService(service)) {
174 return true;
175 }
176 if (service->technology() == Technology::kEthernet) {
177 // Ethernet services should have an affinity towards the default profile,
178 // so even if a new Ethernet service has no known configuration, accept
179 // it anyway.
180 UpdateService(service);
181 service->SetProfile(this);
182 return true;
183 }
184 return false;
185 }
186
Save()187 bool DefaultProfile::Save() {
188 storage()->SetBool(kStorageId, kStorageArpGateway, props_.arp_gateway);
189 storage()->SetString(kStorageId, kStorageHostName, props_.host_name);
190 storage()->SetString(kStorageId, kStorageName, GetFriendlyName());
191 storage()->SetBool(kStorageId, kStorageOfflineMode, props_.offline_mode);
192 storage()->SetString(kStorageId,
193 kStorageCheckPortalList,
194 props_.check_portal_list);
195 storage()->SetInt(kStorageId, kStorageConnectionIdSalt,
196 props_.connection_id_salt);
197 storage()->SetString(kStorageId,
198 kStorageIgnoredDNSSearchPaths,
199 props_.ignored_dns_search_paths);
200 storage()->SetString(kStorageId,
201 kStorageLinkMonitorTechnologies,
202 props_.link_monitor_technologies);
203 storage()->SetString(kStorageId,
204 kStorageNoAutoConnectTechnologies,
205 props_.no_auto_connect_technologies);
206 storage()->SetString(kStorageId,
207 kStoragePortalURL,
208 props_.portal_url);
209 storage()->SetString(kStorageId,
210 kStoragePortalCheckInterval,
211 base::IntToString(props_.portal_check_interval_seconds));
212 storage()->SetString(kStorageId,
213 kStorageProhibitedTechnologies,
214 props_.prohibited_technologies);
215 manager()->dhcp_properties().Save(storage(), kStorageId);
216 return Profile::Save();
217 }
218
UpdateDevice(const DeviceRefPtr & device)219 bool DefaultProfile::UpdateDevice(const DeviceRefPtr& device) {
220 return device->Save(storage()) && storage()->Flush();
221 }
222
223 #if !defined(DISABLE_WIFI)
UpdateWiFiProvider(const WiFiProvider & wifi_provider)224 bool DefaultProfile::UpdateWiFiProvider(const WiFiProvider& wifi_provider) {
225 return wifi_provider.Save(storage()) && storage()->Flush();
226 }
227 #endif // DISABLE_WIFI
228
229 } // namespace shill
230