default_profile.cc revision 036dba0c6641acdbe02d52260c6fa6dca84b1af2 
1// Copyright (c) 2012 The Chromium OS Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "shill/default_profile.h"
6
7#include <vector>
8
9#include <base/file_path.h>
10#include <base/string_number_conversions.h>
11#include <base/stringprintf.h>
12#include <chromeos/dbus/service_constants.h>
13
14#include "shill/adaptor_interfaces.h"
15#include "shill/control_interface.h"
16#include "shill/link_monitor.h"
17#include "shill/manager.h"
18#include "shill/portal_detector.h"
19#include "shill/resolver.h"
20#include "shill/store_interface.h"
21
22using std::string;
23using std::vector;
24
25namespace shill {
26// static
27const char DefaultProfile::kDefaultId[] = "default";
28// static
29const char DefaultProfile::kStorageId[] = "global";
30// static
31const char DefaultProfile::kStorageArpGateway[] = "ArpGateway";
32// static
33const char DefaultProfile::kStorageCheckPortalList[] = "CheckPortalList";
34// static
35const char DefaultProfile::kStorageHostName[] = "HostName";
36// static
37const char DefaultProfile::kStorageLinkMonitorTechnologies[] =
38    "LinkMonitorTechnologies";
39// static
40const char DefaultProfile::kStorageName[] = "Name";
41// static
42const char DefaultProfile::kStorageOfflineMode[] = "OfflineMode";
43// static
44const char DefaultProfile::kStoragePortalURL[] = "PortalURL";
45// static
46const char DefaultProfile::kStoragePortalCheckInterval[] =
47    "PortalCheckInterval";
48// static
49const char DefaultProfile::kStorageShortDNSTimeoutTechnologies[] =
50    "ShortDNSTimeoutTechnologies";
51
52DefaultProfile::DefaultProfile(ControlInterface *control,
53                               Manager *manager,
54                               const FilePath &storage_path,
55                               const string &profile_id,
56                               const Manager::Properties &manager_props)
57    : Profile(control, manager, Identifier(profile_id), "", true),
58      storage_path_(storage_path),
59      profile_id_(profile_id),
60      props_(manager_props) {
61  PropertyStore *store = this->mutable_store();
62  store->RegisterConstBool(flimflam::kArpGatewayProperty,
63                           &manager_props.arp_gateway);
64  store->RegisterConstString(flimflam::kCheckPortalListProperty,
65                             &manager_props.check_portal_list);
66  store->RegisterConstString(flimflam::kCountryProperty,
67                             &manager_props.country);
68  store->RegisterConstString(shill::kLinkMonitorTechnologiesProperty,
69                             &manager_props.link_monitor_technologies);
70  store->RegisterConstBool(flimflam::kOfflineModeProperty,
71                           &manager_props.offline_mode);
72  store->RegisterConstString(flimflam::kPortalURLProperty,
73                             &manager_props.portal_url);
74  store->RegisterConstInt32(shill::kPortalCheckIntervalProperty,
75                            &manager_props.portal_check_interval_seconds);
76  store->RegisterConstString(shill::kShortDNSTimeoutTechnologiesProperty,
77                             &manager_props.short_dns_timeout_technologies);
78}
79
80DefaultProfile::~DefaultProfile() {}
81
82bool DefaultProfile::LoadManagerProperties(Manager::Properties *manager_props) {
83  storage()->GetBool(kStorageId, kStorageArpGateway,
84                     &manager_props->arp_gateway);
85  storage()->GetString(kStorageId, kStorageHostName, &manager_props->host_name);
86  storage()->GetBool(kStorageId, kStorageOfflineMode,
87                     &manager_props->offline_mode);
88  if (!storage()->GetString(kStorageId,
89                            kStorageCheckPortalList,
90                            &manager_props->check_portal_list)) {
91    manager_props->check_portal_list = PortalDetector::kDefaultCheckPortalList;
92  }
93  if (!storage()->GetString(kStorageId,
94                            kStorageLinkMonitorTechnologies,
95                            &manager_props->link_monitor_technologies)) {
96    manager_props->link_monitor_technologies =
97        LinkMonitor::kDefaultLinkMonitorTechnologies;
98  }
99  if (!storage()->GetString(kStorageId, kStoragePortalURL,
100                            &manager_props->portal_url)) {
101    manager_props->portal_url = PortalDetector::kDefaultURL;
102  }
103  std::string check_interval;
104  if (!storage()->GetString(kStorageId, kStoragePortalCheckInterval,
105                            &check_interval) ||
106      !base::StringToInt(check_interval,
107                         &manager_props->portal_check_interval_seconds)) {
108    manager_props->portal_check_interval_seconds =
109        PortalDetector::kDefaultCheckIntervalSeconds;
110  }
111  if (!storage()->GetString(kStorageId,
112                            kStorageShortDNSTimeoutTechnologies,
113                            &manager_props->short_dns_timeout_technologies)) {
114    manager_props->short_dns_timeout_technologies =
115        Resolver::kDefaultShortTimeoutTechnologies;
116  }
117  return true;
118}
119
120bool DefaultProfile::ConfigureService(const ServiceRefPtr &service) {
121  if (Profile::ConfigureService(service)) {
122    return true;
123  }
124  if (service->technology() == Technology::kEthernet) {
125    // Ethernet services should have an affinity towards the default profile,
126    // so even if a new Ethernet service has no known configuration, accept
127    // it anyway.
128    UpdateService(service);
129    service->set_profile(this);
130    return true;
131  }
132  return false;
133}
134
135bool DefaultProfile::Save() {
136  storage()->SetBool(kStorageId, kStorageArpGateway, props_.arp_gateway);
137  storage()->SetString(kStorageId, kStorageHostName, props_.host_name);
138  storage()->SetString(kStorageId, kStorageName, GetFriendlyName());
139  storage()->SetBool(kStorageId, kStorageOfflineMode, props_.offline_mode);
140  storage()->SetString(kStorageId,
141                       kStorageCheckPortalList,
142                       props_.check_portal_list);
143  storage()->SetString(kStorageId,
144                       kStorageLinkMonitorTechnologies,
145                       props_.link_monitor_technologies);
146  storage()->SetString(kStorageId,
147                       kStoragePortalURL,
148                       props_.portal_url);
149  storage()->SetString(kStorageId,
150                       kStoragePortalCheckInterval,
151                       base::IntToString(props_.portal_check_interval_seconds));
152  storage()->SetString(kStorageId,
153                       kStorageShortDNSTimeoutTechnologies,
154                       props_.short_dns_timeout_technologies);
155  return Profile::Save();
156}
157
158bool DefaultProfile::UpdateDevice(const DeviceRefPtr &device) {
159  return device->Save(storage()) && storage()->Flush();
160}
161
162bool DefaultProfile::GetStoragePath(FilePath *path) {
163  *path = storage_path_.Append(base::StringPrintf("%s.profile",
164                                                  profile_id_.c_str()));
165  return true;
166}
167
168}  // namespace shill
169