216 lines
7.7 KiB
C++
216 lines
7.7 KiB
C++
//
|
|
// Copyright (C) 2015 The Android Open Source Project
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
//
|
|
|
|
#include "shill/daemon_task.h"
|
|
|
|
#include <base/bind.h>
|
|
|
|
#if !defined(ENABLE_JSON_STORE)
|
|
#include <glib-object.h>
|
|
#include <glib.h>
|
|
#endif // ENABLE_JSON_STORE
|
|
|
|
#if defined(ENABLE_BINDER)
|
|
#include "shill/binder/binder_control.h"
|
|
#elif defined(ENABLE_CHROMEOS_DBUS)
|
|
#include "shill/dbus/chromeos_dbus_control.h"
|
|
#endif // ENABLE_BINDER, ENABLE_CHROMEOS_DBUS
|
|
#include "shill/control_interface.h"
|
|
#include "shill/dhcp/dhcp_provider.h"
|
|
#include "shill/error.h"
|
|
#include "shill/logging.h"
|
|
#include "shill/manager.h"
|
|
#include "shill/net/ndisc.h"
|
|
#include "shill/net/rtnl_handler.h"
|
|
#include "shill/process_manager.h"
|
|
#include "shill/routing_table.h"
|
|
#include "shill/shill_config.h"
|
|
|
|
#if !defined(DISABLE_WIFI)
|
|
#include "shill/net/netlink_manager.h"
|
|
#include "shill/net/nl80211_message.h"
|
|
#endif // DISABLE_WIFI
|
|
|
|
using base::Bind;
|
|
using base::Unretained;
|
|
using std::string;
|
|
|
|
namespace shill {
|
|
|
|
namespace Logging {
|
|
static auto kModuleLogScope = ScopeLogger::kDaemon;
|
|
static string ObjectID(DaemonTask* d) { return "(chromeos_daemon)"; }
|
|
}
|
|
|
|
DaemonTask::DaemonTask(const Settings& settings, Config* config)
|
|
: settings_(settings), config_(config) {}
|
|
|
|
DaemonTask::~DaemonTask() {}
|
|
|
|
void DaemonTask::ApplySettings() {
|
|
manager_->SetBlacklistedDevices(settings_.device_blacklist);
|
|
manager_->SetWhitelistedDevices(settings_.device_whitelist);
|
|
Error error;
|
|
manager_->SetTechnologyOrder(settings_.default_technology_order, &error);
|
|
CHECK(error.IsSuccess()); // Command line should have been validated.
|
|
manager_->SetIgnoreUnknownEthernet(settings_.ignore_unknown_ethernet);
|
|
if (settings_.use_portal_list) {
|
|
manager_->SetStartupPortalList(settings_.portal_list);
|
|
}
|
|
if (settings_.passive_mode) {
|
|
manager_->SetPassiveMode();
|
|
}
|
|
manager_->SetPrependDNSServers(settings_.prepend_dns_servers);
|
|
if (settings_.minimum_mtu) {
|
|
manager_->SetMinimumMTU(settings_.minimum_mtu);
|
|
}
|
|
manager_->SetAcceptHostnameFrom(settings_.accept_hostname_from);
|
|
manager_->SetDHCPv6EnabledDevices(settings_.dhcpv6_enabled_devices);
|
|
}
|
|
|
|
bool DaemonTask::Quit(const base::Closure& completion_callback) {
|
|
SLOG(this, 1) << "Starting termination actions.";
|
|
if (manager_->RunTerminationActionsAndNotifyMetrics(
|
|
Bind(&DaemonTask::TerminationActionsCompleted, Unretained(this)))) {
|
|
SLOG(this, 1) << "Will wait for termination actions to complete";
|
|
termination_completed_callback_ = completion_callback;
|
|
return false; // Note to caller: don't exit yet!
|
|
} else {
|
|
SLOG(this, 1) << "No termination actions were run";
|
|
StopAndReturnToMain();
|
|
return true; // All done, ready to exit.
|
|
}
|
|
}
|
|
|
|
void DaemonTask::Init() {
|
|
dispatcher_.reset(new EventDispatcher());
|
|
#if defined(ENABLE_BINDER)
|
|
control_.reset(new BinderControl(dispatcher_.get()));
|
|
#elif defined(ENABLE_CHROMEOS_DBUS)
|
|
control_.reset(new ChromeosDBusControl(dispatcher_.get()));
|
|
#else
|
|
// TODO(zqiu): use default stub control interface.
|
|
#error Control interface type not specified.
|
|
#endif // ENABLE_BINDER, ENABLE_CHROMEOS_DBUS
|
|
metrics_.reset(new Metrics(dispatcher_.get()));
|
|
rtnl_handler_ = RTNLHandler::GetInstance();
|
|
routing_table_ = RoutingTable::GetInstance();
|
|
dhcp_provider_ = DHCPProvider::GetInstance();
|
|
process_manager_ = ProcessManager::GetInstance();
|
|
#if !defined(DISABLE_WIFI)
|
|
netlink_manager_ = NetlinkManager::GetInstance();
|
|
callback80211_metrics_.reset(new Callback80211Metrics(metrics_.get()));
|
|
#endif // DISABLE_WIFI
|
|
manager_.reset(new Manager(control_.get(), dispatcher_.get(), metrics_.get(),
|
|
config_->GetRunDirectory(),
|
|
config_->GetStorageDirectory(),
|
|
config_->GetUserStorageDirectory()));
|
|
control_->RegisterManagerObject(
|
|
manager_.get(), base::Bind(&DaemonTask::Start, base::Unretained(this)));
|
|
ApplySettings();
|
|
}
|
|
|
|
void DaemonTask::TerminationActionsCompleted(const Error& error) {
|
|
SLOG(this, 1) << "Finished termination actions. Result: " << error;
|
|
metrics_->NotifyTerminationActionsCompleted(error.IsSuccess());
|
|
|
|
// Daemon::TerminationActionsCompleted() should not directly call
|
|
// Daemon::Stop(). Otherwise, it could lead to the call sequence below. That
|
|
// is not safe as the HookTable's start callback only holds a weak pointer to
|
|
// the Cellular object, which is destroyed in midst of the
|
|
// Cellular::OnTerminationCompleted() call. We schedule the
|
|
// Daemon::StopAndReturnToMain() call through the message loop instead.
|
|
//
|
|
// Daemon::Quit
|
|
// -> Manager::RunTerminationActionsAndNotifyMetrics
|
|
// -> Manager::RunTerminationActions
|
|
// -> HookTable::Run
|
|
// ...
|
|
// -> Cellular::OnTerminationCompleted
|
|
// -> Manager::TerminationActionComplete
|
|
// -> HookTable::ActionComplete
|
|
// -> Daemon::TerminationActionsCompleted
|
|
// -> Daemon::Stop
|
|
// -> Manager::Stop
|
|
// -> DeviceInfo::Stop
|
|
// -> Cellular::~Cellular
|
|
// -> Manager::RemoveTerminationAction
|
|
dispatcher_->PostTask(
|
|
Bind(&DaemonTask::StopAndReturnToMain, Unretained(this)));
|
|
}
|
|
|
|
void DaemonTask::StopAndReturnToMain() {
|
|
Stop();
|
|
if (!termination_completed_callback_.is_null()) {
|
|
termination_completed_callback_.Run();
|
|
}
|
|
}
|
|
|
|
void DaemonTask::Start() {
|
|
#if !defined(ENABLE_JSON_STORE)
|
|
g_type_init();
|
|
#endif
|
|
metrics_->Start();
|
|
rtnl_handler_->Start(RTMGRP_LINK | RTMGRP_IPV4_IFADDR | RTMGRP_IPV4_ROUTE |
|
|
RTMGRP_IPV6_IFADDR | RTMGRP_IPV6_ROUTE |
|
|
RTMGRP_ND_USEROPT);
|
|
routing_table_->Start();
|
|
dhcp_provider_->Init(control_.get(), dispatcher_.get(), metrics_.get());
|
|
process_manager_->Init(dispatcher_.get());
|
|
#if !defined(DISABLE_WIFI)
|
|
if (netlink_manager_) {
|
|
netlink_manager_->Init();
|
|
uint16_t nl80211_family_id =
|
|
netlink_manager_->GetFamily(Nl80211Message::kMessageTypeString,
|
|
Bind(&Nl80211Message::CreateMessage));
|
|
if (nl80211_family_id == NetlinkMessage::kIllegalMessageType) {
|
|
LOG(FATAL) << "Didn't get a legal message type for 'nl80211' messages.";
|
|
}
|
|
Nl80211Message::SetMessageType(nl80211_family_id);
|
|
netlink_manager_->Start();
|
|
|
|
// Install handlers for NetlinkMessages that don't have specific handlers
|
|
// (which are registered by message sequence number).
|
|
netlink_manager_->AddBroadcastHandler(
|
|
Bind(&Callback80211Metrics::CollectDisconnectStatistics,
|
|
callback80211_metrics_->AsWeakPtr()));
|
|
}
|
|
#endif // DISABLE_WIFI
|
|
|
|
manager_->Start();
|
|
}
|
|
|
|
void DaemonTask::Stop() {
|
|
manager_->Stop();
|
|
manager_ = nullptr; // Release manager resources, including DBus adaptor.
|
|
#if !defined(DISABLE_WIFI)
|
|
callback80211_metrics_ = nullptr;
|
|
#endif // DISABLE_WIFI
|
|
metrics_->Stop();
|
|
process_manager_->Stop();
|
|
dhcp_provider_->Stop();
|
|
metrics_ = nullptr;
|
|
// Must retain |control_|, as the D-Bus library may
|
|
// have some work left to do. See crbug.com/537771.
|
|
}
|
|
|
|
void DaemonTask::BreakTerminationLoop() {
|
|
// Break out of the termination loop, to continue on with other shutdown
|
|
// tasks.
|
|
brillo::MessageLoop::current()->BreakLoop();
|
|
}
|
|
|
|
} // namespace shill
|