1 // 2 // Copyright (C) 2009 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_LIBCURL_HTTP_FETCHER_H_ 18 #define UPDATE_ENGINE_LIBCURL_HTTP_FETCHER_H_ 19 20 #include <map> 21 #include <memory> 22 #include <string> 23 #include <utility> 24 25 #include <curl/curl.h> 26 27 #include <base/logging.h> 28 #include <base/macros.h> 29 #include <brillo/message_loops/message_loop.h> 30 31 #include "update_engine/certificate_checker.h" 32 #include "update_engine/common/hardware_interface.h" 33 #include "update_engine/common/http_fetcher.h" 34 35 // This is a concrete implementation of HttpFetcher that uses libcurl to do the 36 // http work. 37 38 namespace chromeos_update_engine { 39 40 class LibcurlHttpFetcher : public HttpFetcher { 41 public: 42 LibcurlHttpFetcher(ProxyResolver* proxy_resolver, 43 HardwareInterface* hardware); 44 45 // Cleans up all internal state. Does not notify delegate 46 ~LibcurlHttpFetcher() override; 47 48 void SetOffset(off_t offset) override { bytes_downloaded_ = offset; } 49 50 void SetLength(size_t length) override { download_length_ = length; } 51 void UnsetLength() override { SetLength(0); } 52 53 // Begins the transfer if it hasn't already begun. 54 void BeginTransfer(const std::string& url) override; 55 56 // If the transfer is in progress, aborts the transfer early. The transfer 57 // cannot be resumed. 58 void TerminateTransfer() override; 59 60 // Pass the headers to libcurl. 61 void SetHeader(const std::string& header_name, 62 const std::string& header_value) override; 63 64 // Suspend the transfer by calling curl_easy_pause(CURLPAUSE_ALL). 65 void Pause() override; 66 67 // Resume the transfer by calling curl_easy_pause(CURLPAUSE_CONT). 68 void Unpause() override; 69 70 // Libcurl sometimes asks to be called back after some time while 71 // leaving that time unspecified. In that case, we pick a reasonable 72 // default of one second, but it can be overridden here. This is 73 // primarily useful for testing. 74 // From http://curl.haxx.se/libcurl/c/curl_multi_timeout.html: 75 // if libcurl returns a -1 timeout here, it just means that libcurl 76 // currently has no stored timeout value. You must not wait too long 77 // (more than a few seconds perhaps) before you call 78 // curl_multi_perform() again. 79 void set_idle_seconds(int seconds) override { idle_seconds_ = seconds; } 80 81 // Sets the retry timeout. Useful for testing. 82 void set_retry_seconds(int seconds) override { retry_seconds_ = seconds; } 83 84 void set_no_network_max_retries(int retries) { 85 no_network_max_retries_ = retries; 86 } 87 88 void set_server_to_check(ServerToCheck server_to_check) { 89 server_to_check_ = server_to_check; 90 } 91 92 size_t GetBytesDownloaded() override { 93 return static_cast<size_t>(bytes_downloaded_); 94 } 95 96 void set_low_speed_limit(int low_speed_bps, int low_speed_sec) override { 97 low_speed_limit_bps_ = low_speed_bps; 98 low_speed_time_seconds_ = low_speed_sec; 99 } 100 101 void set_connect_timeout(int connect_timeout_seconds) override { 102 connect_timeout_seconds_ = connect_timeout_seconds; 103 } 104 105 void set_max_retry_count(int max_retry_count) override { 106 max_retry_count_ = max_retry_count; 107 } 108 109 private: 110 // libcurl's CURLOPT_CLOSESOCKETFUNCTION callback function. Called when 111 // closing a socket created with the CURLOPT_OPENSOCKETFUNCTION callback. 112 static int LibcurlCloseSocketCallback(void* clientp, curl_socket_t item); 113 114 // Callback for when proxy resolution has completed. This begins the 115 // transfer. 116 void ProxiesResolved(); 117 118 // Asks libcurl for the http response code and stores it in the object. 119 void GetHttpResponseCode(); 120 121 // Checks whether stored HTTP response is within the success range. 122 inline bool IsHttpResponseSuccess() { 123 return (http_response_code_ >= 200 && http_response_code_ < 300); 124 } 125 126 // Checks whether stored HTTP response is within the error range. This 127 // includes both errors with the request (4xx) and server errors (5xx). 128 inline bool IsHttpResponseError() { 129 return (http_response_code_ >= 400 && http_response_code_ < 600); 130 } 131 132 // Resumes a transfer where it left off. This will use the 133 // HTTP Range: header to make a new connection from where the last 134 // left off. 135 virtual void ResumeTransfer(const std::string& url); 136 137 void TimeoutCallback(); 138 void RetryTimeoutCallback(); 139 140 // Calls into curl_multi_perform to let libcurl do its work. Returns after 141 // curl_multi_perform is finished, which may actually be after more than 142 // one call to curl_multi_perform. This method will set up the message 143 // loop with sources for future work that libcurl will do, if any, or complete 144 // the transfer and finish the action if no work left to do. 145 // This method will not block. 146 void CurlPerformOnce(); 147 148 // Sets up message loop sources as needed by libcurl. This is generally 149 // the file descriptor of the socket and a timer in case nothing happens 150 // on the fds. 151 void SetupMessageLoopSources(); 152 153 // Callback called by libcurl when new data has arrived on the transfer 154 size_t LibcurlWrite(void* ptr, size_t size, size_t nmemb); 155 static size_t StaticLibcurlWrite(void* ptr, 156 size_t size, 157 size_t nmemb, 158 void* stream) { 159 return reinterpret_cast<LibcurlHttpFetcher*>(stream)->LibcurlWrite( 160 ptr, size, nmemb); 161 } 162 163 // Cleans up the following if they are non-null: 164 // curl(m) handles, fd_task_maps_, timeout_id_. 165 void CleanUp(); 166 167 // Force terminate the transfer. This will invoke the delegate's (if any) 168 // TransferTerminated callback so, after returning, this fetcher instance may 169 // be destroyed. 170 void ForceTransferTermination(); 171 172 // Sets the curl options for HTTP URL. 173 void SetCurlOptionsForHttp(); 174 175 // Sets the curl options for HTTPS URL. 176 void SetCurlOptionsForHttps(); 177 178 // Sets the curl options for file URI. 179 void SetCurlOptionsForFile(); 180 181 // Convert a proxy URL into a curl proxy type, if applicable. Returns true iff 182 // conversion was successful, false otherwise (in which case nothing is 183 // written to |out_type|). 184 bool GetProxyType(const std::string& proxy, curl_proxytype* out_type); 185 186 // Hardware interface used to query dev-mode and official build settings. 187 HardwareInterface* hardware_; 188 189 // Handles for the libcurl library 190 CURLM* curl_multi_handle_{nullptr}; 191 CURL* curl_handle_{nullptr}; 192 struct curl_slist* curl_http_headers_{nullptr}; 193 194 // The extra headers that will be sent on each request. 195 std::map<std::string, std::string> extra_headers_; 196 197 // Lists of all read(0)/write(1) file descriptors that we're waiting on from 198 // the message loop. libcurl may open/close descriptors and switch their 199 // directions so maintain two separate lists so that watch conditions can be 200 // set appropriately. 201 std::map<int, brillo::MessageLoop::TaskId> fd_task_maps_[2]; 202 203 // The TaskId of the timer we're waiting on. kTaskIdNull if we are not waiting 204 // on it. 205 brillo::MessageLoop::TaskId timeout_id_{brillo::MessageLoop::kTaskIdNull}; 206 207 bool transfer_in_progress_{false}; 208 bool transfer_paused_{false}; 209 210 // Whether it should ignore transfer failures for the purpose of retrying the 211 // connection. 212 bool ignore_failure_{false}; 213 214 // Whether we should restart the transfer once Unpause() is called. This can 215 // be caused because either the connection dropped while pause or the proxy 216 // was resolved and we never started the transfer in the first place. 217 bool restart_transfer_on_unpause_{false}; 218 219 // The transfer size. -1 if not known. 220 off_t transfer_size_{0}; 221 222 // How many bytes have been downloaded and sent to the delegate. 223 off_t bytes_downloaded_{0}; 224 225 // The remaining maximum number of bytes to download. Zero represents an 226 // unspecified length. 227 size_t download_length_{0}; 228 229 // If we resumed an earlier transfer, data offset that we used for the 230 // new connection. 0 otherwise. 231 // In this class, resume refers to resuming a dropped HTTP connection, 232 // not to resuming an interrupted download. 233 off_t resume_offset_{0}; 234 235 // Number of resumes performed so far and the max allowed. 236 int retry_count_{0}; 237 int max_retry_count_{kDownloadMaxRetryCount}; 238 239 // Seconds to wait before retrying a resume. 240 int retry_seconds_{20}; 241 242 // When waiting for a retry, the task id of the retry callback. 243 brillo::MessageLoop::TaskId retry_task_id_{brillo::MessageLoop::kTaskIdNull}; 244 245 // Number of resumes due to no network (e.g., HTTP response code 0). 246 int no_network_retry_count_{0}; 247 int no_network_max_retries_{0}; 248 249 // Seconds to wait before asking libcurl to "perform". 250 int idle_seconds_{1}; 251 252 // If true, we are currently performing a write callback on the delegate. 253 bool in_write_callback_{false}; 254 255 // If true, we have returned at least one byte in the write callback 256 // to the delegate. 257 bool sent_byte_{false}; 258 259 // We can't clean everything up while we're in a write callback, so 260 // if we get a terminate request, queue it until we can handle it. 261 bool terminate_requested_{false}; 262 263 // The ServerToCheck used when checking this connection's certificate. If no 264 // certificate check needs to be performed, this should be set to 265 // ServerToCheck::kNone. 266 ServerToCheck server_to_check_{ServerToCheck::kNone}; 267 268 int low_speed_limit_bps_{kDownloadLowSpeedLimitBps}; 269 int low_speed_time_seconds_{kDownloadLowSpeedTimeSeconds}; 270 int connect_timeout_seconds_{kDownloadConnectTimeoutSeconds}; 271 272 DISALLOW_COPY_AND_ASSIGN(LibcurlHttpFetcher); 273 }; 274 275 } // namespace chromeos_update_engine 276 277 #endif // UPDATE_ENGINE_LIBCURL_HTTP_FETCHER_H_ 278