| // Copyright 2018 The Chromium OS Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "diagnostics/diagnosticsd/diagnosticsd_core.h" |
| |
| #include <algorithm> |
| #include <cstddef> |
| #include <utility> |
| |
| #include <base/bind.h> |
| #include <base/files/file_util.h> |
| #include <base/logging.h> |
| #include <base/optional.h> |
| #include <base/threading/thread_task_runner_handle.h> |
| #include <dbus/diagnosticsd/dbus-constants.h> |
| #include <dbus/object_path.h> |
| #include <mojo/public/cpp/system/message_pipe.h> |
| |
| #include "diagnostics/diagnosticsd/bind_utils.h" |
| #include "diagnostics/diagnosticsd/json_utils.h" |
| |
| namespace diagnostics { |
| |
| namespace { |
| |
| using MojomDiagnosticsdWebRequestStatus = |
| chromeos::diagnosticsd::mojom::DiagnosticsdWebRequestStatus; |
| using MojomDiagnosticsdWebRequestHttpMethod = |
| chromeos::diagnosticsd::mojom::DiagnosticsdWebRequestHttpMethod; |
| |
| // Converts HTTP method into an appropriate mojom one. |
| MojomDiagnosticsdWebRequestHttpMethod ConvertWebRequestHttpMethodToMojom( |
| DiagnosticsdCore::WebRequestHttpMethod http_method) { |
| switch (http_method) { |
| case DiagnosticsdCore::WebRequestHttpMethod::kGet: |
| return MojomDiagnosticsdWebRequestHttpMethod::kGet; |
| case DiagnosticsdCore::WebRequestHttpMethod::kHead: |
| return MojomDiagnosticsdWebRequestHttpMethod::kHead; |
| case DiagnosticsdCore::WebRequestHttpMethod::kPost: |
| return MojomDiagnosticsdWebRequestHttpMethod::kPost; |
| case DiagnosticsdCore::WebRequestHttpMethod::kPut: |
| return MojomDiagnosticsdWebRequestHttpMethod::kPut; |
| } |
| } |
| |
| // Convert the result back from mojom status. |
| DiagnosticsdCore::WebRequestStatus ConvertStatusFromMojom( |
| MojomDiagnosticsdWebRequestStatus status) { |
| switch (status) { |
| case MojomDiagnosticsdWebRequestStatus::kOk: |
| return DiagnosticsdCore::WebRequestStatus::kOk; |
| case MojomDiagnosticsdWebRequestStatus::kNetworkError: |
| return DiagnosticsdCore::WebRequestStatus::kNetworkError; |
| case MojomDiagnosticsdWebRequestStatus::kHttpError: |
| return DiagnosticsdCore::WebRequestStatus::kHttpError; |
| } |
| } |
| |
| } // namespace |
| |
| DiagnosticsdCore::DiagnosticsdCore( |
| const std::string& grpc_service_uri, |
| const std::string& ui_message_receiver_diagnostics_processor_grpc_uri, |
| const std::vector<std::string>& diagnostics_processor_grpc_uris, |
| Delegate* delegate) |
| : delegate_(delegate), |
| grpc_service_uri_(grpc_service_uri), |
| ui_message_receiver_diagnostics_processor_grpc_uri_( |
| ui_message_receiver_diagnostics_processor_grpc_uri), |
| diagnostics_processor_grpc_uris_(diagnostics_processor_grpc_uris), |
| grpc_server_(base::ThreadTaskRunnerHandle::Get(), grpc_service_uri_) { |
| DCHECK(delegate); |
| } |
| |
| DiagnosticsdCore::~DiagnosticsdCore() = default; |
| |
| bool DiagnosticsdCore::Start() { |
| // Associate RPCs of the to-be-exposed gRPC interface with methods of |
| // |grpc_service_|. |
| grpc_server_.RegisterHandler( |
| &grpc_api::Diagnosticsd::AsyncService::RequestSendMessageToUi, |
| base::Bind(&DiagnosticsdGrpcService::SendMessageToUi, |
| base::Unretained(&grpc_service_))); |
| grpc_server_.RegisterHandler( |
| &grpc_api::Diagnosticsd::AsyncService::RequestGetProcData, |
| base::Bind(&DiagnosticsdGrpcService::GetProcData, |
| base::Unretained(&grpc_service_))); |
| grpc_server_.RegisterHandler( |
| &grpc_api::Diagnosticsd::AsyncService::RequestGetSysfsData, |
| base::Bind(&DiagnosticsdGrpcService::GetSysfsData, |
| base::Unretained(&grpc_service_))); |
| grpc_server_.RegisterHandler( |
| &grpc_api::Diagnosticsd::AsyncService::RequestRunEcCommand, |
| base::Bind(&DiagnosticsdGrpcService::RunEcCommand, |
| base::Unretained(&grpc_service_))); |
| grpc_server_.RegisterHandler( |
| &grpc_api::Diagnosticsd::AsyncService::RequestGetEcProperty, |
| base::Bind(&DiagnosticsdGrpcService::GetEcProperty, |
| base::Unretained(&grpc_service_))); |
| grpc_server_.RegisterHandler( |
| &grpc_api::Diagnosticsd::AsyncService::RequestPerformWebRequest, |
| base::Bind(&DiagnosticsdGrpcService::PerformWebRequest, |
| base::Unretained(&grpc_service_))); |
| grpc_server_.RegisterHandler( |
| &grpc_api::Diagnosticsd::AsyncService::RequestGetAvailableRoutines, |
| base::Bind(&DiagnosticsdGrpcService::GetAvailableRoutines, |
| base::Unretained(&grpc_service_))); |
| |
| // Start the gRPC server that listens for incoming gRPC requests. |
| VLOG(1) << "Starting gRPC server"; |
| if (!grpc_server_.Start()) { |
| LOG(ERROR) << "Failed to start the gRPC server listening on " |
| << grpc_service_uri_; |
| return false; |
| } |
| VLOG(0) << "Successfully started gRPC server listening on " |
| << grpc_service_uri_; |
| |
| // Start the gRPC clients that talk to the diagnostics_processor daemon. |
| for (const auto& uri : diagnostics_processor_grpc_uris_) { |
| diagnostics_processor_grpc_clients_.push_back( |
| std::make_unique<AsyncGrpcClient<grpc_api::DiagnosticsProcessor>>( |
| base::ThreadTaskRunnerHandle::Get(), uri)); |
| VLOG(0) << "Created gRPC diagnostics_processor client on " << uri; |
| } |
| |
| // Start the gRPC client that is allowed to receive UI messages as a normal |
| // gRPC client that talks to the diagnostics_processor daemon. |
| diagnostics_processor_grpc_clients_.push_back( |
| std::make_unique<AsyncGrpcClient<grpc_api::DiagnosticsProcessor>>( |
| base::ThreadTaskRunnerHandle::Get(), |
| ui_message_receiver_diagnostics_processor_grpc_uri_)); |
| VLOG(0) << "Created gRPC diagnostics_processor client on " |
| << ui_message_receiver_diagnostics_processor_grpc_uri_; |
| ui_message_receiver_diagnostics_processor_grpc_client_ = |
| diagnostics_processor_grpc_clients_.back().get(); |
| |
| // Start EC event service. |
| return ec_event_service_.Start(); |
| } |
| |
| void DiagnosticsdCore::ShutDown(const base::Closure& on_shutdown) { |
| VLOG(1) << "Tearing down gRPC server, gRPC diagnostics_processor clients and " |
| "EC event service"; |
| const base::Closure barrier_closure = BarrierClosure( |
| diagnostics_processor_grpc_clients_.size() + 2, on_shutdown); |
| ec_event_service_.Shutdown(barrier_closure); |
| grpc_server_.Shutdown(barrier_closure); |
| for (const auto& client : diagnostics_processor_grpc_clients_) { |
| client->Shutdown(barrier_closure); |
| } |
| ui_message_receiver_diagnostics_processor_grpc_client_ = nullptr; |
| } |
| |
| void DiagnosticsdCore::RegisterDBusObjectsAsync( |
| const scoped_refptr<dbus::Bus>& bus, |
| brillo::dbus_utils::AsyncEventSequencer* sequencer) { |
| DCHECK(bus); |
| DCHECK(!dbus_object_); |
| dbus_object_ = std::make_unique<brillo::dbus_utils::DBusObject>( |
| nullptr /* object_manager */, bus, |
| dbus::ObjectPath(kDiagnosticsdServicePath)); |
| brillo::dbus_utils::DBusInterface* dbus_interface = |
| dbus_object_->AddOrGetInterface(kDiagnosticsdServiceInterface); |
| DCHECK(dbus_interface); |
| dbus_interface->AddSimpleMethodHandlerWithError( |
| kDiagnosticsdBootstrapMojoConnectionMethod, |
| base::Unretained(&dbus_service_), |
| &DiagnosticsdDBusService::BootstrapMojoConnection); |
| dbus_object_->RegisterAsync(sequencer->GetHandler( |
| "Failed to register D-Bus object" /* descriptive_message */, |
| true /* failure_is_fatal */)); |
| } |
| |
| bool DiagnosticsdCore::StartMojoServiceFactory(base::ScopedFD mojo_pipe_fd, |
| std::string* error_message) { |
| DCHECK(mojo_pipe_fd.is_valid()); |
| |
| if (mojo_service_bind_attempted_) { |
| // This should not normally be triggered, since the other endpoint - the |
| // browser process - should bootstrap the Mojo connection only once, and |
| // when that process is killed the Mojo shutdown notification should have |
| // been received earlier. But handle this case to be on the safe side. After |
| // our restart the browser process is expected to invoke the bootstrapping |
| // again. |
| *error_message = "Mojo connection was already bootstrapped"; |
| ShutDownDueToMojoError( |
| "Repeated Mojo bootstrap request received" /* debug_reason */); |
| return false; |
| } |
| |
| if (!base::SetCloseOnExec(mojo_pipe_fd.get())) { |
| PLOG(ERROR) << "Failed to set FD_CLOEXEC on Mojo file descriptor"; |
| *error_message = "Failed to set FD_CLOEXEC"; |
| return false; |
| } |
| |
| mojo_service_bind_attempted_ = true; |
| mojo_service_factory_binding_ = delegate_->BindDiagnosticsdMojoServiceFactory( |
| this /* mojo_service_factory */, std::move(mojo_pipe_fd)); |
| if (!mojo_service_factory_binding_) { |
| *error_message = "Failed to bootstrap Mojo"; |
| ShutDownDueToMojoError("Mojo bootstrap failed" /* debug_reason */); |
| return false; |
| } |
| mojo_service_factory_binding_->set_connection_error_handler(base::Bind( |
| &DiagnosticsdCore::ShutDownDueToMojoError, base::Unretained(this), |
| "Mojo connection error" /* debug_reason */)); |
| LOG(INFO) << "Successfully bootstrapped Mojo connection"; |
| return true; |
| } |
| |
| void DiagnosticsdCore::GetService(MojomDiagnosticsdServiceRequest service, |
| MojomDiagnosticsdClientPtr client, |
| const GetServiceCallback& callback) { |
| // Mojo guarantees that these parameters are nun-null (see |
| // VALIDATION_ERROR_UNEXPECTED_INVALID_HANDLE). |
| DCHECK(service.is_pending()); |
| DCHECK(client); |
| |
| if (mojo_service_) { |
| LOG(WARNING) << "GetService Mojo method called multiple times"; |
| // We should not normally be called more than once, so don't bother with |
| // trying to reuse objects from the previous call. However, make sure we |
| // don't have duplicate instances of the service at any moment of time. |
| mojo_service_.reset(); |
| } |
| |
| // Create an instance of DiagnosticsdMojoService that will handle incoming |
| // Mojo calls. Pass |service| to it to fulfill the remote endpoint's request, |
| // allowing it to call into |mojo_service_|. Pass also |client| to allow |
| // |mojo_service_| to do calls in the opposite direction. |
| mojo_service_ = std::make_unique<DiagnosticsdMojoService>( |
| this /* delegate */, std::move(service), std::move(client)); |
| |
| callback.Run(); |
| } |
| |
| void DiagnosticsdCore::ShutDownDueToMojoError(const std::string& debug_reason) { |
| // Our daemon has to be restarted to be prepared for future Mojo connection |
| // bootstraps. We can't do this without a restart since Mojo EDK gives no |
| // guarantee to support repeated bootstraps. Therefore tear down and exit from |
| // our process and let upstart to restart us again. |
| LOG(INFO) << "Shutting down due to: " << debug_reason; |
| mojo_service_.reset(); |
| mojo_service_factory_binding_.reset(); |
| delegate_->BeginDaemonShutdown(); |
| } |
| |
| void DiagnosticsdCore::PerformWebRequestToBrowser( |
| WebRequestHttpMethod http_method, |
| const std::string& url, |
| const std::vector<std::string>& headers, |
| const std::string& request_body, |
| const PerformWebRequestToBrowserCallback& callback) { |
| VLOG(1) << "DiagnosticsCore::PerformWebRequestToBrowser"; |
| |
| if (!mojo_service_) { |
| LOG(WARNING) << "PerformWebRequestToBrowser happens before Mojo connection " |
| << "is established."; |
| callback.Run(WebRequestStatus::kInternalError, 0 /* http_status */, |
| "" /* response_body */); |
| return; |
| } |
| |
| mojo_service_->PerformWebRequest( |
| ConvertWebRequestHttpMethodToMojom(http_method), url, headers, |
| request_body, |
| base::Bind( |
| [](const PerformWebRequestToBrowserCallback& callback, |
| MojomDiagnosticsdWebRequestStatus status, int http_status, |
| base::StringPiece response_body) { |
| callback.Run(ConvertStatusFromMojom(status), http_status, |
| response_body); |
| }, |
| callback)); |
| } |
| |
| void DiagnosticsdCore::SendGrpcEcEventToDiagnosticsProcessor( |
| const DiagnosticsdEcEventService::EcEvent& ec_event) { |
| VLOG(1) << "DiagnosticsdCore::SendGrpcEcEventToDiagnosticsProcessor"; |
| |
| grpc_api::HandleEcNotificationRequest request; |
| request.set_type(ec_event.type); |
| |
| size_t data_size = |
| std::min(ec_event.size * sizeof(ec_event.data[0]), sizeof(ec_event.data)); |
| |
| request.set_payload(ec_event.data, data_size); |
| |
| for (auto& client : diagnostics_processor_grpc_clients_) { |
| client->CallRpc( |
| &grpc_api::DiagnosticsProcessor::Stub::AsyncHandleEcNotification, |
| request, |
| base::Bind([](std::unique_ptr<grpc_api::HandleEcNotificationResponse> |
| response) { |
| if (!response) { |
| LOG(ERROR) |
| << "Failed to call HandleEcNotificationRequest gRPC method on " |
| "diagnostics_processor: response message is nullptr"; |
| return; |
| } |
| VLOG(1) << "gRPC method HandleEcNotificationRequest was successfully" |
| "called on diagnostics_processor"; |
| })); |
| } |
| } |
| |
| void DiagnosticsdCore::SendGrpcUiMessageToDiagnosticsProcessor( |
| base::StringPiece json_message, |
| const SendGrpcUiMessageToDiagnosticsProcessorCallback& callback) { |
| VLOG(1) << "DiagnosticsdCore::SendGrpcMessageToDiagnosticsdProcessor"; |
| |
| if (!ui_message_receiver_diagnostics_processor_grpc_client_) { |
| VLOG(1) << "The UI message is discarded since the recipient has been shut " |
| << "down."; |
| callback.Run(std::string() /* response_json_message */); |
| return; |
| } |
| |
| grpc_api::HandleMessageFromUiRequest request; |
| request.set_json_message(json_message.data() ? json_message.data() : "", |
| json_message.length()); |
| |
| ui_message_receiver_diagnostics_processor_grpc_client_->CallRpc( |
| &grpc_api::DiagnosticsProcessor::Stub::AsyncHandleMessageFromUi, request, |
| base::Bind( |
| [](const SendGrpcUiMessageToDiagnosticsProcessorCallback& callback, |
| std::unique_ptr<grpc_api::HandleMessageFromUiResponse> response) { |
| if (!response) { |
| LOG(ERROR) |
| << "Failed to call HandleMessageFromUiRequest gRPC method on " |
| "diagnostics_processor: response message is nullptr"; |
| callback.Run(std::string() /* response_json_message */); |
| return; |
| } |
| |
| VLOG(1) << "gRPC method HandleMessageFromUiRequest was " |
| "successfully called on diagnostics_processor"; |
| |
| std::string json_error_message; |
| if (!IsJsonValid( |
| base::StringPiece(response->response_json_message()), |
| &json_error_message)) { |
| LOG(ERROR) << "Invalid JSON error: " << json_error_message; |
| callback.Run(std::string() /* response_json_message */); |
| return; |
| } |
| |
| callback.Run(response->response_json_message()); |
| }, |
| callback)); |
| } |
| |
| } // namespace diagnostics |
