| // Copyright 2019 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "remoting/host/remoting_register_support_host_request.h" |
| |
| #include "base/logging.h" |
| #include "net/traffic_annotation/network_traffic_annotation.h" |
| #include "remoting/base/http_status.h" |
| #include "remoting/base/oauth_token_getter.h" |
| #include "remoting/base/protobuf_http_client.h" |
| #include "remoting/base/protobuf_http_request.h" |
| #include "remoting/base/protobuf_http_request_config.h" |
| #include "remoting/base/service_urls.h" |
| #include "remoting/proto/remoting/v1/chrome_os_enterprise_options.pb.h" |
| #include "remoting/proto/remoting/v1/remote_support_host_messages.pb.h" |
| #include "remoting/signaling/signaling_address.h" |
| #include "services/network/public/cpp/shared_url_loader_factory.h" |
| |
| namespace remoting { |
| |
| namespace { |
| |
| constexpr net::NetworkTrafficAnnotationTag kTrafficAnnotation = |
| net::DefineNetworkTrafficAnnotation( |
| "remoting_register_support_host_request", |
| R"( |
| semantics { |
| sender: "Chrome Remote Desktop" |
| description: |
| "Request used by Chrome Remote Desktop to register a new remote " |
| "support host." |
| trigger: |
| "User requests for remote assistance using Chrome Remote Desktop." |
| user_data { |
| type: CREDENTIALS |
| type: ACCESS_TOKEN |
| } |
| data: |
| "The user's OAuth token for Chrome Remote Desktop (CRD) and CRD " |
| "host information such as CRD host public key, host version, and " |
| "OS version." |
| destination: GOOGLE_OWNED_SERVICE |
| internal { |
| contacts { email: "garykac@chromium.org" } |
| contacts { email: "jamiewalch@chromium.org" } |
| contacts { email: "joedow@chromium.org" } |
| contacts { email: "lambroslambrou@chromium.org" } |
| contacts { email: "rkjnsn@chromium.org" } |
| contacts { email: "yuweih@chromium.org" } |
| } |
| last_reviewed: "2023-07-07" |
| } |
| policy { |
| cookies_allowed: NO |
| setting: |
| "This request cannot be stopped in settings, but will not be sent " |
| "if the user does not use Chrome Remote Desktop." |
| chrome_policy { |
| RemoteAccessHostAllowRemoteSupportConnections { |
| RemoteAccessHostAllowRemoteSupportConnections: false |
| } |
| RemoteAccessHostAllowEnterpriseRemoteSupportConnections { |
| RemoteAccessHostAllowEnterpriseRemoteSupportConnections: false |
| } |
| } |
| })"); |
| |
| constexpr char kRegisterSupportHostPath[] = |
| "/v1/remotesupport:registersupporthost"; |
| |
| } // namespace |
| |
| class RemotingRegisterSupportHostRequest::RegisterSupportHostClientImpl final |
| : public RegisterSupportHostClient { |
| public: |
| RegisterSupportHostClientImpl( |
| OAuthTokenGetter* token_getter, |
| scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory); |
| |
| RegisterSupportHostClientImpl(const RegisterSupportHostClientImpl&) = delete; |
| RegisterSupportHostClientImpl& operator=( |
| const RegisterSupportHostClientImpl&) = delete; |
| |
| ~RegisterSupportHostClientImpl() override; |
| |
| void RegisterSupportHost( |
| std::unique_ptr<apis::v1::RegisterSupportHostRequest> request, |
| RegisterSupportHostResponseCallback callback) override; |
| void CancelPendingRequests() override; |
| |
| private: |
| ProtobufHttpClient http_client_; |
| }; |
| |
| RemotingRegisterSupportHostRequest::RegisterSupportHostClientImpl:: |
| RegisterSupportHostClientImpl( |
| OAuthTokenGetter* token_getter, |
| scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory) |
| : http_client_(ServiceUrls::GetInstance()->remoting_server_endpoint(), |
| token_getter, |
| url_loader_factory) {} |
| |
| RemotingRegisterSupportHostRequest::RegisterSupportHostClientImpl:: |
| ~RegisterSupportHostClientImpl() = default; |
| |
| void RemotingRegisterSupportHostRequest::RegisterSupportHostClientImpl:: |
| RegisterSupportHost( |
| std::unique_ptr<apis::v1::RegisterSupportHostRequest> request, |
| RegisterSupportHostResponseCallback callback) { |
| auto request_config = |
| std::make_unique<ProtobufHttpRequestConfig>(kTrafficAnnotation); |
| request_config->path = kRegisterSupportHostPath; |
| request_config->request_message = std::move(request); |
| auto http_request = |
| std::make_unique<ProtobufHttpRequest>(std::move(request_config)); |
| http_request->SetResponseCallback(std::move(callback)); |
| http_client_.ExecuteRequest(std::move(http_request)); |
| } |
| |
| void RemotingRegisterSupportHostRequest::RegisterSupportHostClientImpl:: |
| CancelPendingRequests() { |
| http_client_.CancelPendingRequests(); |
| } |
| |
| // End of RegisterSupportHostClientImpl. |
| |
| RemotingRegisterSupportHostRequest::RemotingRegisterSupportHostRequest( |
| std::unique_ptr<OAuthTokenGetter> token_getter, |
| scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory) |
| : token_getter_(std::move(token_getter)), |
| register_host_client_(std::make_unique<RegisterSupportHostClientImpl>( |
| token_getter_.get(), |
| url_loader_factory)) {} |
| |
| RemotingRegisterSupportHostRequest::~RemotingRegisterSupportHostRequest() = |
| default; |
| |
| void RemotingRegisterSupportHostRequest::Initialize( |
| std::unique_ptr<net::ClientCertStore> client_cert_store) {} |
| |
| void RemotingRegisterSupportHostRequest::RegisterHost( |
| const internal::RemoteSupportHostStruct& host, |
| const std::optional<ChromeOsEnterpriseParams>& enterprise_params, |
| RegisterHostCallback callback) { |
| auto request = std::make_unique<apis::v1::RegisterSupportHostRequest>(); |
| request->set_public_key(host.public_key); |
| std::string tachyon_id = SignalingAddress::CreateFtlSignalingAddress( |
| host.tachyon_account_info.account_id, |
| host.tachyon_account_info.registration_id) |
| .id(); |
| request->set_tachyon_id(tachyon_id); |
| request->set_host_version(host.version); |
| request->set_host_os_name(host.operating_system_info.name); |
| request->set_host_os_version(host.operating_system_info.version); |
| |
| if (enterprise_params.has_value()) { |
| apis::v1::ChromeOsEnterpriseOptions* enterprise_options = |
| request->mutable_chrome_os_enterprise_options(); |
| enterprise_options->set_allow_troubleshooting_tools( |
| enterprise_params->allow_troubleshooting_tools); |
| enterprise_options->set_show_troubleshooting_tools( |
| enterprise_params->show_troubleshooting_tools); |
| enterprise_options->set_allow_reconnections( |
| enterprise_params->allow_reconnections); |
| enterprise_options->set_allow_file_transfer( |
| enterprise_params->allow_file_transfer); |
| enterprise_options->set_connection_dialog_required( |
| enterprise_params->connection_dialog_required); |
| enterprise_options->set_allow_remote_input( |
| enterprise_params->allow_remote_input); |
| enterprise_options->set_allow_clipboard_sync( |
| enterprise_params->allow_clipboard_sync); |
| if (!enterprise_params->connection_auto_accept_timeout.is_zero()) { |
| enterprise_options->mutable_connection_auto_accept_timeout()->set_seconds( |
| enterprise_params->connection_auto_accept_timeout.InSeconds()); |
| } |
| } |
| |
| if (!host.authorized_helper_email.empty()) { |
| request->set_authorized_helper(host.authorized_helper_email); |
| } |
| |
| register_host_client_->RegisterSupportHost( |
| std::move(request), |
| base::BindOnce( |
| [](RegisterHostCallback callback, const HttpStatus& status, |
| std::unique_ptr<apis::v1::RegisterSupportHostResponse> response) { |
| if (response) { |
| std::move(callback).Run( |
| status, response->support_id(), |
| base::Seconds(response->support_id_lifetime_seconds())); |
| } else { |
| std::move(callback).Run(status, {}, {}); |
| } |
| }, |
| std::move(callback))); |
| } |
| |
| void RemotingRegisterSupportHostRequest::CancelPendingRequests() { |
| register_host_client_->CancelPendingRequests(); |
| } |
| |
| } // namespace remoting |
