blob: 900c973d4b8e004d7c4343542597d4a70f834faf [file] [log] [blame]
Alex Deymoaea4c1c2015-08-19 20:24:43 -07001//
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//
rspangler@google.com49fdf182009-10-10 00:57:34 +000016
Alex Deymo39910dc2015-11-09 17:04:30 -080017#ifndef UPDATE_ENGINE_COMMON_LIBCURL_HTTP_FETCHER_H_
18#define UPDATE_ENGINE_COMMON_LIBCURL_HTTP_FETCHER_H_
rspangler@google.com49fdf182009-10-10 00:57:34 +000019
20#include <map>
Alex Deymoc1c17b42015-11-23 03:53:15 -030021#include <memory>
rspangler@google.com49fdf182009-10-10 00:57:34 +000022#include <string>
Alex Vakulenkod2779df2014-06-16 13:19:00 -070023#include <utility>
Bruno Rocha7f9aea22011-09-12 14:31:24 -070024
rspangler@google.com49fdf182009-10-10 00:57:34 +000025#include <curl/curl.h>
Bruno Rocha7f9aea22011-09-12 14:31:24 -070026
Ben Chan05735a12014-09-03 07:48:22 -070027#include <base/logging.h>
28#include <base/macros.h>
Alex Vakulenko3f39d5c2015-10-13 09:27:13 -070029#include <brillo/message_loops/message_loop.h>
Ben Chan05735a12014-09-03 07:48:22 -070030
Alex Deymo39910dc2015-11-09 17:04:30 -080031#include "update_engine/common/certificate_checker.h"
32#include "update_engine/common/hardware_interface.h"
33#include "update_engine/common/http_fetcher.h"
Jay Srinivasan43488792012-06-19 00:25:31 -070034
rspangler@google.com49fdf182009-10-10 00:57:34 +000035// This is a concrete implementation of HttpFetcher that uses libcurl to do the
36// http work.
37
38namespace chromeos_update_engine {
39
40class LibcurlHttpFetcher : public HttpFetcher {
41 public:
Jay Srinivasan43488792012-06-19 00:25:31 -070042 LibcurlHttpFetcher(ProxyResolver* proxy_resolver,
Alex Deymo33e91e72015-12-01 18:26:08 -030043 HardwareInterface* hardware);
rspangler@google.com49fdf182009-10-10 00:57:34 +000044
45 // Cleans up all internal state. Does not notify delegate
Alex Deymo610277e2014-11-11 21:18:11 -080046 ~LibcurlHttpFetcher() override;
rspangler@google.com49fdf182009-10-10 00:57:34 +000047
Alex Deymo610277e2014-11-11 21:18:11 -080048 void SetOffset(off_t offset) override { bytes_downloaded_ = offset; }
Gilad Arnolde4ad2502011-12-29 17:08:54 -080049
Alex Deymo610277e2014-11-11 21:18:11 -080050 void SetLength(size_t length) override { download_length_ = length; }
51 void UnsetLength() override { SetLength(0); }
Andrew de los Reyes3fd5d302010-10-07 20:07:18 -070052
rspangler@google.com49fdf182009-10-10 00:57:34 +000053 // Begins the transfer if it hasn't already begun.
Alex Deymo610277e2014-11-11 21:18:11 -080054 void BeginTransfer(const std::string& url) override;
rspangler@google.com49fdf182009-10-10 00:57:34 +000055
Darin Petkov9ce452b2010-11-17 14:33:28 -080056 // If the transfer is in progress, aborts the transfer early. The transfer
57 // cannot be resumed.
Alex Deymo610277e2014-11-11 21:18:11 -080058 void TerminateTransfer() override;
rspangler@google.com49fdf182009-10-10 00:57:34 +000059
60 // Suspend the transfer by calling curl_easy_pause(CURLPAUSE_ALL).
Alex Deymo610277e2014-11-11 21:18:11 -080061 void Pause() override;
rspangler@google.com49fdf182009-10-10 00:57:34 +000062
63 // Resume the transfer by calling curl_easy_pause(CURLPAUSE_CONT).
Alex Deymo610277e2014-11-11 21:18:11 -080064 void Unpause() override;
rspangler@google.com49fdf182009-10-10 00:57:34 +000065
66 // Libcurl sometimes asks to be called back after some time while
67 // leaving that time unspecified. In that case, we pick a reasonable
68 // default of one second, but it can be overridden here. This is
69 // primarily useful for testing.
70 // From http://curl.haxx.se/libcurl/c/curl_multi_timeout.html:
71 // if libcurl returns a -1 timeout here, it just means that libcurl
72 // currently has no stored timeout value. You must not wait too long
73 // (more than a few seconds perhaps) before you call
74 // curl_multi_perform() again.
Alex Deymo610277e2014-11-11 21:18:11 -080075 void set_idle_seconds(int seconds) override { idle_seconds_ = seconds; }
Darin Petkovb83371f2010-08-17 09:34:49 -070076
77 // Sets the retry timeout. Useful for testing.
Alex Deymo610277e2014-11-11 21:18:11 -080078 void set_retry_seconds(int seconds) override { retry_seconds_ = seconds; }
Darin Petkovfc7a0ce2010-10-25 10:38:37 -070079
Darin Petkova0929552010-11-29 14:19:06 -080080 void set_no_network_max_retries(int retries) {
81 no_network_max_retries_ = retries;
82 }
83
Alex Deymo33e91e72015-12-01 18:26:08 -030084 void set_server_to_check(ServerToCheck server_to_check) {
85 server_to_check_ = server_to_check;
86 }
87
Alex Deymo610277e2014-11-11 21:18:11 -080088 size_t GetBytesDownloaded() override {
Gilad Arnold48085ba2011-11-16 09:36:08 -080089 return static_cast<size_t>(bytes_downloaded_);
90 }
91
Alex Deymo610277e2014-11-11 21:18:11 -080092 void set_low_speed_limit(int low_speed_bps, int low_speed_sec) override {
David Zeuthen34135a92013-08-06 11:16:16 -070093 low_speed_limit_bps_ = low_speed_bps;
94 low_speed_time_seconds_ = low_speed_sec;
95 }
96
Alex Deymo610277e2014-11-11 21:18:11 -080097 void set_connect_timeout(int connect_timeout_seconds) override {
David Zeuthen34135a92013-08-06 11:16:16 -070098 connect_timeout_seconds_ = connect_timeout_seconds;
99 }
100
Alex Deymo610277e2014-11-11 21:18:11 -0800101 void set_max_retry_count(int max_retry_count) override {
David Zeuthen34135a92013-08-06 11:16:16 -0700102 max_retry_count_ = max_retry_count;
103 }
104
rspangler@google.com49fdf182009-10-10 00:57:34 +0000105 private:
Andrew de los Reyesf3ed8e72011-02-16 10:35:46 -0800106 // Callback for when proxy resolution has completed. This begins the
107 // transfer.
108 void ProxiesResolved();
Jay Srinivasan43488792012-06-19 00:25:31 -0700109
Andrew de los Reyes3fd5d302010-10-07 20:07:18 -0700110 // Asks libcurl for the http response code and stores it in the object.
111 void GetHttpResponseCode();
112
Gilad Arnold9bedeb52011-11-17 16:19:57 -0800113 // Checks whether stored HTTP response is within the success range.
Gilad Arnold48085ba2011-11-16 09:36:08 -0800114 inline bool IsHttpResponseSuccess() {
115 return (http_response_code_ >= 200 && http_response_code_ < 300);
116 }
117
Gilad Arnold9bedeb52011-11-17 16:19:57 -0800118 // Checks whether stored HTTP response is within the error range. This
119 // includes both errors with the request (4xx) and server errors (5xx).
120 inline bool IsHttpResponseError() {
121 return (http_response_code_ >= 400 && http_response_code_ < 600);
122 }
123
adlr@google.comc98a7ed2009-12-04 18:54:03 +0000124 // Resumes a transfer where it left off. This will use the
125 // HTTP Range: header to make a new connection from where the last
126 // left off.
127 virtual void ResumeTransfer(const std::string& url);
rspangler@google.com49fdf182009-10-10 00:57:34 +0000128
Alex Deymo60ca1a72015-06-18 18:19:15 -0700129 void TimeoutCallback();
130 void RetryTimeoutCallback();
rspangler@google.com49fdf182009-10-10 00:57:34 +0000131
132 // Calls into curl_multi_perform to let libcurl do its work. Returns after
133 // curl_multi_perform is finished, which may actually be after more than
Alex Deymo0b3db6b2015-08-10 15:19:37 -0700134 // one call to curl_multi_perform. This method will set up the message
rspangler@google.com49fdf182009-10-10 00:57:34 +0000135 // loop with sources for future work that libcurl will do.
136 // This method will not block.
Andrew de los Reyes3270f742010-07-15 22:28:14 -0700137 // Returns true if we should resume immediately after this call.
Andrew de los Reyescb319332010-07-19 10:55:01 -0700138 void CurlPerformOnce();
rspangler@google.com49fdf182009-10-10 00:57:34 +0000139
Alex Deymo29b81532015-07-09 11:51:49 -0700140 // Sets up message loop sources as needed by libcurl. This is generally
rspangler@google.com49fdf182009-10-10 00:57:34 +0000141 // the file descriptor of the socket and a timer in case nothing happens
142 // on the fds.
Alex Deymo29b81532015-07-09 11:51:49 -0700143 void SetupMessageLoopSources();
rspangler@google.com49fdf182009-10-10 00:57:34 +0000144
145 // Callback called by libcurl when new data has arrived on the transfer
146 size_t LibcurlWrite(void *ptr, size_t size, size_t nmemb);
147 static size_t StaticLibcurlWrite(void *ptr, size_t size,
148 size_t nmemb, void *stream) {
149 return reinterpret_cast<LibcurlHttpFetcher*>(stream)->
150 LibcurlWrite(ptr, size, nmemb);
151 }
152
153 // Cleans up the following if they are non-null:
Alex Deymo29b81532015-07-09 11:51:49 -0700154 // curl(m) handles, fd_task_maps_, timeout_id_.
rspangler@google.com49fdf182009-10-10 00:57:34 +0000155 void CleanUp();
156
Darin Petkov9ce452b2010-11-17 14:33:28 -0800157 // Force terminate the transfer. This will invoke the delegate's (if any)
158 // TransferTerminated callback so, after returning, this fetcher instance may
159 // be destroyed.
160 void ForceTransferTermination();
161
Jay Srinivasanb3f55402012-12-03 18:12:04 -0800162 // Sets the curl options for HTTP URL.
163 void SetCurlOptionsForHttp();
164
165 // Sets the curl options for HTTPS URL.
166 void SetCurlOptionsForHttps();
167
Gilad Arnold59d9e012013-07-23 16:41:43 -0700168 // Convert a proxy URL into a curl proxy type, if applicable. Returns true iff
169 // conversion was successful, false otherwise (in which case nothing is
170 // written to |out_type|).
171 bool GetProxyType(const std::string& proxy, curl_proxytype* out_type);
172
Alex Deymoc1c17b42015-11-23 03:53:15 -0300173 // Hardware interface used to query dev-mode and official build settings.
174 HardwareInterface* hardware_;
175
rspangler@google.com49fdf182009-10-10 00:57:34 +0000176 // Handles for the libcurl library
Alex Deymo60ca1a72015-06-18 18:19:15 -0700177 CURLM* curl_multi_handle_{nullptr};
178 CURL* curl_handle_{nullptr};
179 struct curl_slist* curl_http_headers_{nullptr};
rspangler@google.com49fdf182009-10-10 00:57:34 +0000180
Darin Petkov60e14152010-10-27 16:57:04 -0700181 // Lists of all read(0)/write(1) file descriptors that we're waiting on from
Alex Deymo29b81532015-07-09 11:51:49 -0700182 // the message loop. libcurl may open/close descriptors and switch their
Darin Petkov60e14152010-10-27 16:57:04 -0700183 // directions so maintain two separate lists so that watch conditions can be
184 // set appropriately.
Alex Vakulenko3f39d5c2015-10-13 09:27:13 -0700185 std::map<int, brillo::MessageLoop::TaskId> fd_task_maps_[2];
rspangler@google.com49fdf182009-10-10 00:57:34 +0000186
Alex Deymo60ca1a72015-06-18 18:19:15 -0700187 // The TaskId of the timer we're waiting on. kTaskIdNull if we are not waiting
188 // on it.
Alex Vakulenko3f39d5c2015-10-13 09:27:13 -0700189 brillo::MessageLoop::TaskId timeout_id_{brillo::MessageLoop::kTaskIdNull};
rspangler@google.com49fdf182009-10-10 00:57:34 +0000190
Alex Deymo29b81532015-07-09 11:51:49 -0700191 bool transfer_in_progress_{false};
rspangler@google.com49fdf182009-10-10 00:57:34 +0000192
adlr@google.comc98a7ed2009-12-04 18:54:03 +0000193 // The transfer size. -1 if not known.
Alex Deymo60ca1a72015-06-18 18:19:15 -0700194 off_t transfer_size_{0};
adlr@google.comc98a7ed2009-12-04 18:54:03 +0000195
196 // How many bytes have been downloaded and sent to the delegate.
Alex Deymo60ca1a72015-06-18 18:19:15 -0700197 off_t bytes_downloaded_{0};
adlr@google.comc98a7ed2009-12-04 18:54:03 +0000198
Gilad Arnolde4ad2502011-12-29 17:08:54 -0800199 // The remaining maximum number of bytes to download. Zero represents an
200 // unspecified length.
Alex Deymo60ca1a72015-06-18 18:19:15 -0700201 size_t download_length_{0};
Gilad Arnolde4ad2502011-12-29 17:08:54 -0800202
adlr@google.comc98a7ed2009-12-04 18:54:03 +0000203 // If we resumed an earlier transfer, data offset that we used for the
204 // new connection. 0 otherwise.
Andrew de los Reyes3fd5d302010-10-07 20:07:18 -0700205 // In this class, resume refers to resuming a dropped HTTP connection,
206 // not to resuming an interrupted download.
Alex Deymo60ca1a72015-06-18 18:19:15 -0700207 off_t resume_offset_{0};
Darin Petkovb83371f2010-08-17 09:34:49 -0700208
Jay Srinivasan32f23572012-06-05 13:45:07 -0700209 // Number of resumes performed so far and the max allowed.
Alex Deymo60ca1a72015-06-18 18:19:15 -0700210 int retry_count_{0};
211 int max_retry_count_{kDownloadMaxRetryCount};
adlr@google.comc98a7ed2009-12-04 18:54:03 +0000212
Darin Petkovb83371f2010-08-17 09:34:49 -0700213 // Seconds to wait before retrying a resume.
Alex Deymo60ca1a72015-06-18 18:19:15 -0700214 int retry_seconds_{20};
Darin Petkovb83371f2010-08-17 09:34:49 -0700215
Darin Petkova0929552010-11-29 14:19:06 -0800216 // Number of resumes due to no network (e.g., HTTP response code 0).
Alex Deymo60ca1a72015-06-18 18:19:15 -0700217 int no_network_retry_count_{0};
218 int no_network_max_retries_{0};
Darin Petkova0929552010-11-29 14:19:06 -0800219
Darin Petkovb83371f2010-08-17 09:34:49 -0700220 // Seconds to wait before asking libcurl to "perform".
Alex Deymo60ca1a72015-06-18 18:19:15 -0700221 int idle_seconds_{1};
Darin Petkovfc7a0ce2010-10-25 10:38:37 -0700222
Andrew de los Reyes3fd5d302010-10-07 20:07:18 -0700223 // If true, we are currently performing a write callback on the delegate.
Alex Deymo60ca1a72015-06-18 18:19:15 -0700224 bool in_write_callback_{false};
Darin Petkova0929552010-11-29 14:19:06 -0800225
Andrew de los Reyes45168102010-11-22 11:13:50 -0800226 // If true, we have returned at least one byte in the write callback
227 // to the delegate.
Alex Deymo60ca1a72015-06-18 18:19:15 -0700228 bool sent_byte_{false};
Darin Petkovfc7a0ce2010-10-25 10:38:37 -0700229
Andrew de los Reyes3fd5d302010-10-07 20:07:18 -0700230 // We can't clean everything up while we're in a write callback, so
231 // if we get a terminate request, queue it until we can handle it.
Alex Deymo60ca1a72015-06-18 18:19:15 -0700232 bool terminate_requested_{false};
Andrew de los Reyes3fd5d302010-10-07 20:07:18 -0700233
Alex Deymo33e91e72015-12-01 18:26:08 -0300234 // The ServerToCheck used when checking this connection's certificate. If no
235 // certificate check needs to be performed, this should be set to
236 // ServerToCheck::kNone.
237 ServerToCheck server_to_check_{ServerToCheck::kNone};
Bruno Rocha7f9aea22011-09-12 14:31:24 -0700238
Alex Deymo60ca1a72015-06-18 18:19:15 -0700239 int low_speed_limit_bps_{kDownloadLowSpeedLimitBps};
240 int low_speed_time_seconds_{kDownloadLowSpeedTimeSeconds};
241 int connect_timeout_seconds_{kDownloadConnectTimeoutSeconds};
David Zeuthen34135a92013-08-06 11:16:16 -0700242 int num_max_retries_;
243
rspangler@google.com49fdf182009-10-10 00:57:34 +0000244 DISALLOW_COPY_AND_ASSIGN(LibcurlHttpFetcher);
245};
246
247} // namespace chromeos_update_engine
248
Alex Deymo39910dc2015-11-09 17:04:30 -0800249#endif // UPDATE_ENGINE_COMMON_LIBCURL_HTTP_FETCHER_H_