1 // 2 // Copyright (C) 2011 The Android Open Source Project 3 // 4 // Licensed under the Apache License, Version 2.0 (the "License"); 5 // you may not use this file except in compliance with the License. 6 // You may obtain a copy of the License at 7 // 8 // http://www.apache.org/licenses/LICENSE-2.0 9 // 10 // Unless required by applicable law or agreed to in writing, software 11 // distributed under the License is distributed on an "AS IS" BASIS, 12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 // See the License for the specific language governing permissions and 14 // limitations under the License. 15 // 16 17 #ifndef UPDATE_ENGINE_COMMON_DOWNLOAD_ACTION_H_ 18 #define UPDATE_ENGINE_COMMON_DOWNLOAD_ACTION_H_ 19 20 #include <fcntl.h> 21 #include <sys/stat.h> 22 #include <sys/types.h> 23 24 #include <memory> 25 #include <string> 26 #include <utility> 27 28 #include "update_engine/common/action.h" 29 #include "update_engine/common/boot_control_interface.h" 30 #include "update_engine/common/http_fetcher.h" 31 #include "update_engine/common/multi_range_http_fetcher.h" 32 #include "update_engine/payload_consumer/delta_performer.h" 33 #include "update_engine/payload_consumer/install_plan.h" 34 35 // The Download Action downloads a specified url to disk. The url should point 36 // to an update in a delta payload format. The payload will be piped into a 37 // DeltaPerformer that will apply the delta to the disk. 38 39 namespace chromeos_update_engine { 40 41 class DownloadActionDelegate { 42 public: 43 virtual ~DownloadActionDelegate() = default; 44 45 // Called periodically after bytes are received. This method will be invoked 46 // only if the DownloadAction is running. |bytes_progressed| is the number of 47 // bytes downloaded since the last call of this method, |bytes_received| 48 // the number of bytes downloaded thus far and |total| is the number of bytes 49 // expected. 50 virtual void BytesReceived(uint64_t bytes_progressed, 51 uint64_t bytes_received, 52 uint64_t total) = 0; 53 54 // Returns whether the download should be canceled, in which case the 55 // |cancel_reason| error should be set to the reason why the download was 56 // canceled. 57 virtual bool ShouldCancel(ErrorCode* cancel_reason) = 0; 58 59 // Called once the complete payload has been downloaded. Note that any errors 60 // while applying or downloading the partial payload will result in this 61 // method not being called. 62 virtual void DownloadComplete() = 0; 63 }; 64 65 class PrefsInterface; 66 67 class DownloadAction : public InstallPlanAction, public HttpFetcherDelegate { 68 public: 69 // Debugging/logging StaticType()70 static std::string StaticType() { return "DownloadAction"; } 71 72 // Takes ownership of the passed in HttpFetcher. Useful for testing. 73 // A good calling pattern is: 74 // DownloadAction(prefs, boot_contol, hardware, 75 // new WhateverHttpFetcher, false); 76 DownloadAction( 77 PrefsInterface* prefs, 78 BootControlInterface* boot_control, 79 HardwareInterface* hardware, 80 HttpFetcher* http_fetcher, 81 bool interactive, 82 std::string update_certs_path = constants::kUpdateCertificatesPath); 83 ~DownloadAction() override; 84 85 // InstallPlanAction overrides. 86 void PerformAction() override; 87 void SuspendAction() override; 88 void ResumeAction() override; 89 void TerminateProcessing() override; Type()90 std::string Type() const override { return StaticType(); } 91 92 // Testing SetTestFileWriter(std::unique_ptr<DeltaPerformer> writer)93 void SetTestFileWriter(std::unique_ptr<DeltaPerformer> writer) { 94 delta_performer_ = std::move(writer); 95 } 96 GetHTTPResponseCode()97 int GetHTTPResponseCode() { return http_fetcher_->http_response_code(); } 98 99 // HttpFetcherDelegate methods (see http_fetcher.h) 100 bool ReceivedBytes(HttpFetcher* fetcher, 101 const void* bytes, 102 size_t length) override; 103 void SeekToOffset(off_t offset) override; 104 void TransferComplete(HttpFetcher* fetcher, bool successful) override; 105 void TransferTerminated(HttpFetcher* fetcher) override; 106 delegate()107 DownloadActionDelegate* delegate() const { return delegate_; } set_delegate(DownloadActionDelegate * delegate)108 void set_delegate(DownloadActionDelegate* delegate) { delegate_ = delegate; } 109 set_base_offset(int64_t base_offset)110 void set_base_offset(int64_t base_offset) { base_offset_ = base_offset; } 111 http_fetcher()112 HttpFetcher* http_fetcher() { return http_fetcher_.get(); } 113 114 private: 115 // Attempt to load cached manifest data from prefs 116 // return true on success, false otherwise. 117 bool LoadCachedManifest(int64_t manifest_size); 118 119 // Start downloading the current payload using delta_performer. 120 void StartDownloading(); 121 122 // Pointer to the current payload in install_plan_.payloads. 123 InstallPlan::Payload* payload_{nullptr}; 124 125 // Required pointers. 126 PrefsInterface* prefs_; 127 BootControlInterface* boot_control_; 128 HardwareInterface* hardware_; 129 130 // Pointer to the MultiRangeHttpFetcher that does the http work. 131 std::unique_ptr<MultiRangeHttpFetcher> http_fetcher_; 132 133 // If |true|, the update is user initiated (vs. periodic update checks). Hence 134 // the |delta_performer_| can decide not to use O_DSYNC flag for faster 135 // update. 136 bool interactive_; 137 138 std::unique_ptr<DeltaPerformer> delta_performer_; 139 140 // Used by TransferTerminated to figure if this action terminated itself or 141 // was terminated by the action processor. 142 ErrorCode code_; 143 144 // For reporting status to outsiders 145 DownloadActionDelegate* delegate_; 146 uint64_t bytes_received_{0}; // per file/range 147 uint64_t bytes_received_previous_payloads_{0}; 148 uint64_t bytes_total_{0}; 149 bool download_active_{false}; 150 151 // Loaded from prefs before downloading any payload. 152 size_t resume_payload_index_{0}; 153 154 // Offset of the payload in the download URL, used by UpdateAttempterAndroid. 155 int64_t base_offset_{0}; 156 157 // The path to the zip file with X509 certificates. 158 const std::string update_certificates_path_; 159 160 DISALLOW_COPY_AND_ASSIGN(DownloadAction); 161 }; 162 163 // We want to be sure that we're compiled with large file support on linux, 164 // just in case we find ourselves downloading large images. 165 static_assert(8 == sizeof(off_t), "off_t not 64 bit"); 166 167 } // namespace chromeos_update_engine 168 169 #endif // UPDATE_ENGINE_COMMON_DOWNLOAD_ACTION_H_ 170