| // |
| // Copyright (C) 2020 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 "update_engine/cros/download_action_chromeos.h" |
| |
| #include <errno.h> |
| |
| #include <algorithm> |
| #include <string> |
| |
| #include <base/check.h> |
| #include <base/files/file_path.h> |
| #include <base/logging.h> |
| #include <base/metrics/statistics_recorder.h> |
| #include <base/strings/stringprintf.h> |
| |
| #include "update_engine/common/action_pipe.h" |
| #include "update_engine/common/boot_control_interface.h" |
| #include "update_engine/common/error_code_utils.h" |
| #include "update_engine/common/multi_range_http_fetcher.h" |
| #include "update_engine/common/system_state.h" |
| #include "update_engine/common/utils.h" |
| #include "update_engine/cros/omaha_request_params.h" |
| #include "update_engine/cros/p2p_manager.h" |
| #include "update_engine/cros/payload_state_interface.h" |
| #include "update_engine/cros/update_attempter.h" |
| #include "update_engine/update_manager/update_manager.h" |
| |
| using base::FilePath; |
| using std::string; |
| |
| namespace chromeos_update_engine { |
| |
| DownloadActionChromeos::DownloadActionChromeos( |
| std::unique_ptr<HttpFetcher> http_fetcher, bool interactive) |
| : http_fetcher_(new MultiRangeHttpFetcher(http_fetcher.release())), |
| interactive_(interactive), |
| writer_(nullptr), |
| code_(ErrorCode::kSuccess), |
| delegate_(nullptr), |
| p2p_sharing_fd_(-1), |
| p2p_visible_(true) {} |
| |
| void DownloadActionChromeos::CloseP2PSharingFd(bool delete_p2p_file) { |
| if (p2p_sharing_fd_ != -1) { |
| if (close(p2p_sharing_fd_) != 0) { |
| PLOG(ERROR) << "Error closing p2p sharing fd"; |
| } |
| p2p_sharing_fd_ = -1; |
| } |
| |
| if (delete_p2p_file) { |
| FilePath path = |
| SystemState::Get()->p2p_manager()->FileGetPath(p2p_file_id_); |
| if (unlink(path.value().c_str()) != 0) { |
| PLOG(ERROR) << "Error deleting p2p file " << path.value(); |
| } else { |
| LOG(INFO) << "Deleted p2p file " << path.value(); |
| } |
| } |
| |
| // Don't use p2p from this point onwards. |
| p2p_file_id_.clear(); |
| p2p_visible_ = false; |
| } |
| |
| bool DownloadActionChromeos::SetupP2PSharingFd() { |
| P2PManager* p2p_manager = SystemState::Get()->p2p_manager(); |
| |
| if (!p2p_manager->FileShare(p2p_file_id_, payload_->size)) { |
| LOG(ERROR) << "Unable to share file via p2p"; |
| CloseP2PSharingFd(true); // delete p2p file |
| return false; |
| } |
| |
| // File has already been created (and allocated, xattrs been |
| // populated etc.) by FileShare() so just open it for writing. |
| FilePath path = p2p_manager->FileGetPath(p2p_file_id_); |
| p2p_sharing_fd_ = open(path.value().c_str(), O_WRONLY); |
| if (p2p_sharing_fd_ == -1) { |
| PLOG(ERROR) << "Error opening file " << path.value(); |
| CloseP2PSharingFd(true); // Delete p2p file. |
| return false; |
| } |
| |
| // Ensure file to share is world-readable, otherwise |
| // p2p-server and p2p-http-server can't access it. |
| // |
| // (Q: Why doesn't the file have mode 0644 already? A: Because |
| // the process-wide umask is set to 0700 in main.cc.) |
| if (fchmod(p2p_sharing_fd_, 0644) != 0) { |
| PLOG(ERROR) << "Error setting mode 0644 on " << path.value(); |
| CloseP2PSharingFd(true); // Delete p2p file. |
| return false; |
| } |
| |
| // All good. |
| LOG(INFO) << "Writing payload contents to " << path.value(); |
| p2p_manager->FileGetVisible(p2p_file_id_, &p2p_visible_); |
| return true; |
| } |
| |
| void DownloadActionChromeos::WriteToP2PFile(const void* data, |
| size_t length, |
| off_t file_offset) { |
| if (p2p_sharing_fd_ == -1) { |
| return; |
| } |
| |
| // Check that the file is at least |file_offset| bytes long - if |
| // it's not something is wrong and we must immediately delete the |
| // file to avoid propagating this problem to other peers. |
| // |
| // How can this happen? It could be that we're resuming an update |
| // after a system crash... in this case, it could be that |
| // |
| // 1. the p2p file didn't get properly synced to stable storage; or |
| // 2. the file was deleted at bootup (it's in /var/cache after all); or |
| // 3. other reasons |
| off_t p2p_size = utils::FileSize(p2p_sharing_fd_); |
| if (p2p_size < 0) { |
| PLOG(ERROR) << "Error getting file status for p2p file"; |
| CloseP2PSharingFd(true); // Delete p2p file. |
| return; |
| } |
| if (p2p_size < file_offset) { |
| LOG(ERROR) << "Wanting to write to file offset " << file_offset |
| << " but existing p2p file is only " << p2p_size << " bytes."; |
| CloseP2PSharingFd(true); // Delete p2p file. |
| return; |
| } |
| |
| off_t cur_file_offset = lseek(p2p_sharing_fd_, file_offset, SEEK_SET); |
| if (cur_file_offset != static_cast<off_t>(file_offset)) { |
| PLOG(ERROR) << "Error seeking to position " << file_offset |
| << " in p2p file"; |
| CloseP2PSharingFd(true); // Delete p2p file. |
| } else { |
| // OK, seeking worked, now write the data |
| ssize_t bytes_written = write(p2p_sharing_fd_, data, length); |
| if (bytes_written != static_cast<ssize_t>(length)) { |
| PLOG(ERROR) << "Error writing " << length << " bytes at file offset " |
| << file_offset << " in p2p file"; |
| CloseP2PSharingFd(true); // Delete p2p file. |
| } |
| } |
| } |
| |
| void DownloadActionChromeos::PerformAction() { |
| http_fetcher_->set_delegate(this); |
| |
| // Get the InstallPlan and read it |
| CHECK(HasInputObject()); |
| install_plan_ = GetInputObject(); |
| install_plan_.Dump(); |
| |
| bytes_received_ = 0; |
| bytes_received_previous_payloads_ = 0; |
| bytes_total_ = 0; |
| for (const auto& payload : install_plan_.payloads) |
| bytes_total_ += payload.size; |
| |
| if (install_plan_.is_resume) { |
| int64_t payload_index = 0; |
| if (SystemState::Get()->prefs()->GetInt64(kPrefsUpdateStatePayloadIndex, |
| &payload_index) && |
| static_cast<size_t>(payload_index) < install_plan_.payloads.size()) { |
| // Save the index for the resume payload before downloading any previous |
| // payload, otherwise it will be overwritten. |
| resume_payload_index_ = payload_index; |
| for (int i = 0; i < payload_index; i++) |
| install_plan_.payloads[i].already_applied = true; |
| } |
| } |
| // TODO(senj): check that install plan has at least one payload. |
| if (!payload_) |
| payload_ = &install_plan_.payloads[0]; |
| |
| // Reset the active boot slot to the current slot before the previous slot is |
| // marked unbootable. |
| // We want to make sure the current slot is active everytime a new consecutive |
| // update starts in the inactive partition so that the active slot always has |
| // a valid image. |
| if (!SystemState::Get()->update_attempter()->ResetBootSlot()) { |
| LOG(WARNING) << "Unable to reset the active slot to the current slot. " |
| "Proceeding with the update anyway."; |
| } |
| |
| LOG(INFO) << "Marking new slot as unbootable and deleting update completed " |
| "markers and prefs from previous update."; |
| if (!SystemState::Get()->update_attempter()->ResetUpdatePrefs()) { |
| // Update completed markers are re-written to prefs after every successful |
| // update. |
| LOG(WARNING) << "Unable to delete update complete markers and prefs. " |
| "Proceeding with the update anyway."; |
| } |
| |
| if (!SystemState::Get()->boot_control()->MarkSlotUnbootable( |
| install_plan_.target_slot)) { |
| LOG(WARNING) << "Unable to mark new slot " |
| << BootControlInterface::SlotName(install_plan_.target_slot) |
| << ". Proceeding with the update anyway."; |
| } |
| |
| StartMonitoringRestrictedIntervals(); |
| StartDownloading(); |
| } |
| |
| void DownloadActionChromeos::StartDownloading() { |
| download_active_ = true; |
| http_fetcher_->ClearRanges(); |
| auto prefs = SystemState::Get()->prefs(); |
| |
| if (install_plan_.is_resume && |
| payload_ == &install_plan_.payloads[resume_payload_index_]) { |
| // Resuming an update so fetch the update manifest metadata first. |
| int64_t manifest_metadata_size = 0; |
| int64_t manifest_signature_size = 0; |
| prefs->GetInt64(kPrefsManifestMetadataSize, &manifest_metadata_size); |
| prefs->GetInt64(kPrefsManifestSignatureSize, &manifest_signature_size); |
| http_fetcher_->AddRange(base_offset_, |
| manifest_metadata_size + manifest_signature_size); |
| // If there're remaining unprocessed data blobs, fetch them. Be careful not |
| // to request data beyond the end of the payload to avoid 416 HTTP response |
| // error codes. |
| int64_t next_data_offset = 0; |
| prefs->GetInt64(kPrefsUpdateStateNextDataOffset, &next_data_offset); |
| uint64_t resume_offset = |
| manifest_metadata_size + manifest_signature_size + next_data_offset; |
| if (!payload_->size) { |
| http_fetcher_->AddRange(base_offset_ + resume_offset); |
| } else if (resume_offset < payload_->size) { |
| http_fetcher_->AddRange(base_offset_ + resume_offset, |
| payload_->size - resume_offset); |
| } |
| } else { |
| if (payload_->size) { |
| http_fetcher_->AddRange(base_offset_, payload_->size); |
| } else { |
| // If no payload size is passed we assume we read until the end of the |
| // stream. |
| http_fetcher_->AddRange(base_offset_); |
| } |
| } |
| |
| if (writer_ && writer_ != delta_performer_.get()) { |
| LOG(INFO) << "Using writer for test."; |
| } else { |
| delta_performer_.reset( |
| new DeltaPerformer(prefs, |
| SystemState::Get()->boot_control(), |
| SystemState::Get()->hardware(), |
| delegate_, |
| &install_plan_, |
| payload_, |
| interactive_)); |
| writer_ = delta_performer_.get(); |
| } |
| |
| if (SystemState::Get() != nullptr) { |
| // Close any previous P2P sharing. It will be a no-op if there were no |
| // previous file sharing. |
| CloseP2PSharingFd(false); |
| |
| const PayloadStateInterface* payload_state = |
| SystemState::Get()->payload_state(); |
| string file_id = utils::CalculateP2PFileId(payload_->hash, payload_->size); |
| if (payload_state->GetUsingP2PForSharing()) { |
| // If we're sharing the update, store the file_id to convey |
| // that we should write to the file. |
| p2p_file_id_ = file_id; |
| LOG(INFO) << "Sharing p2p file with id: " << p2p_file_id_; |
| SetupP2PSharingFd(); |
| } else { |
| // Even if we're not sharing the update, it could be that |
| // there's a partial file from a previous attempt with the same |
| // hash. If this is the case, we NEED to clean it up otherwise |
| // we're essentially timing out other peers downloading from us |
| // (since we're never going to complete the file). |
| FilePath path = SystemState::Get()->p2p_manager()->FileGetPath(file_id); |
| if (!path.empty()) { |
| if (unlink(path.value().c_str()) != 0) { |
| PLOG(ERROR) << "Error deleting p2p file " << path.value(); |
| } else { |
| LOG(INFO) << "Deleting partial p2p file " << path.value() |
| << " since we're not using p2p to share."; |
| } |
| } |
| } |
| |
| // Tweak timeouts on the HTTP fetcher if we're downloading from a |
| // local peer. |
| if (payload_state->GetUsingP2PForDownloading() && |
| payload_state->GetP2PUrl() == install_plan_.download_url) { |
| LOG(INFO) << "Tweaking HTTP fetcher since we're downloading via p2p"; |
| http_fetcher_->set_low_speed_limit(kDownloadP2PLowSpeedLimitBps, |
| kDownloadP2PLowSpeedTimeSeconds); |
| http_fetcher_->set_max_retry_count(kDownloadP2PMaxRetryCount); |
| http_fetcher_->set_connect_timeout(kDownloadP2PConnectTimeoutSeconds); |
| } |
| } |
| |
| http_fetcher_->BeginTransfer(install_plan_.download_url); |
| } |
| |
| void DownloadActionChromeos::SuspendAction() { |
| http_fetcher_->Pause(); |
| } |
| |
| void DownloadActionChromeos::ResumeAction() { |
| http_fetcher_->Unpause(); |
| } |
| |
| void DownloadActionChromeos::TerminateProcessing() { |
| if (terminate_requested_) { |
| LOG(WARNING) << "Returning as terminate processing is already requested."; |
| return; |
| } |
| terminate_requested_ = true; |
| |
| if (writer_) { |
| writer_->Close(); |
| writer_ = nullptr; |
| } |
| download_active_ = false; |
| CloseP2PSharingFd(false); // Keep p2p file. |
| // Terminates the transfer. The action is terminated, if necessary, when the |
| // TransferTerminated callback is received. |
| http_fetcher_->TerminateTransfer(); |
| } |
| |
| void DownloadActionChromeos::SeekToOffset(off_t offset) { |
| bytes_received_ = offset; |
| } |
| |
| bool DownloadActionChromeos::ReceivedBytes(HttpFetcher* fetcher, |
| const void* bytes, |
| size_t length) { |
| // Note that bytes_received_ is the current offset. |
| if (!p2p_file_id_.empty()) { |
| WriteToP2PFile(bytes, length, bytes_received_); |
| } |
| |
| bytes_received_ += length; |
| uint64_t bytes_downloaded_total = |
| bytes_received_previous_payloads_ + bytes_received_; |
| if (delegate_ && download_active_) { |
| delegate_->BytesReceived(length, bytes_downloaded_total, bytes_total_); |
| } |
| if (writer_ && !writer_->Write(bytes, length, &code_)) { |
| if (code_ != ErrorCode::kSuccess) { |
| LOG(ERROR) << "Error " << utils::ErrorCodeToString(code_) << " (" << code_ |
| << ") in DeltaPerformer's Write method when " |
| << "processing the received payload -- Terminating processing"; |
| } |
| // Delete p2p file, if applicable. |
| if (!p2p_file_id_.empty()) |
| CloseP2PSharingFd(true); |
| // Don't tell the action processor that the action is complete until we get |
| // the TransferTerminated callback. Otherwise, this and the HTTP fetcher |
| // objects may get destroyed before all callbacks are complete. |
| TerminateProcessing(); |
| return false; |
| } |
| |
| // Call p2p_manager_->FileMakeVisible() when we've successfully |
| // verified the manifest! |
| if (!p2p_visible_ && SystemState::Get() && delta_performer_.get() && |
| delta_performer_->IsManifestValid()) { |
| LOG(INFO) << "Manifest has been validated. Making p2p file visible."; |
| SystemState::Get()->p2p_manager()->FileMakeVisible(p2p_file_id_); |
| p2p_visible_ = true; |
| } |
| return true; |
| } |
| |
| void DownloadActionChromeos::TransferComplete(HttpFetcher* fetcher, |
| bool successful) { |
| if (writer_) { |
| LOG_IF(WARNING, writer_->Close() != 0) << "Error closing the writer."; |
| if (delta_performer_.get() == writer_) { |
| // no delta_performer_ in tests, so leave the test writer in place |
| writer_ = nullptr; |
| } |
| } |
| download_active_ = false; |
| ErrorCode code = |
| successful ? ErrorCode::kSuccess : ErrorCode::kDownloadTransferError; |
| if (code == ErrorCode::kSuccess) { |
| if (delta_performer_ && !payload_->already_applied) |
| code = delta_performer_->VerifyPayload(payload_->hash, payload_->size); |
| if (code == ErrorCode::kSuccess) { |
| if (payload_ < &install_plan_.payloads.back() && |
| SystemState::Get()->payload_state()->NextPayload()) { |
| LOG(INFO) << "Incrementing to next payload"; |
| // No need to reset if this payload was already applied. |
| if (delta_performer_ && !payload_->already_applied) |
| DeltaPerformer::ResetUpdateProgress(SystemState::Get()->prefs(), |
| false); |
| // Start downloading next payload. |
| bytes_received_previous_payloads_ += payload_->size; |
| payload_++; |
| install_plan_.download_url = |
| SystemState::Get()->payload_state()->GetCurrentUrl(); |
| StartDownloading(); |
| return; |
| } |
| |
| // All payloads have been applied and verified. |
| if (delegate_) |
| delegate_->DownloadComplete(); |
| |
| std::string histogram_output; |
| base::StatisticsRecorder::WriteGraph( |
| "UpdateEngine.DownloadActionChromeos.", &histogram_output); |
| LOG(INFO) << histogram_output; |
| } else { |
| LOG(ERROR) << "Download of " << install_plan_.download_url |
| << " failed due to payload verification error."; |
| // Delete p2p file, if applicable. |
| if (!p2p_file_id_.empty()) |
| CloseP2PSharingFd(true); |
| } |
| } |
| |
| // Write the path to the output pipe if we're successful. |
| if (code == ErrorCode::kSuccess && HasOutputPipe()) |
| SetOutputObject(install_plan_); |
| processor_->ActionComplete(this, code); |
| } |
| |
| void DownloadActionChromeos::TransferTerminated(HttpFetcher* fetcher) { |
| if (code_ != ErrorCode::kSuccess) { |
| processor_->ActionComplete(this, code_); |
| } else if (payload_->already_applied) { |
| LOG(INFO) << "TransferTerminated with ErrorCode::kSuccess when the current " |
| "payload has already applied, treating as TransferComplete."; |
| TransferComplete(fetcher, true); |
| } |
| } |
| |
| void DownloadActionChromeos::StartMonitoringRestrictedIntervals() { |
| update_time_restrictions_monitor_ = |
| SystemState::Get() |
| ->update_manager() |
| ->BuildUpdateTimeRestrictionsMonitorIfNeeded(install_plan_, |
| /*delegate=*/this); |
| } |
| |
| void DownloadActionChromeos::OnRestrictedIntervalStarts() { |
| LOG(INFO) << "Going inside restricted time interval. Cancelling download."; |
| code_ = ErrorCode::kDownloadCancelledPerPolicy; |
| update_time_restrictions_monitor_.reset(); |
| TerminateProcessing(); |
| } |
| |
| } // namespace chromeos_update_engine |