rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 1 | // Copyright (c) 2009 The Chromium OS Authors. All rights reserved. |
| 2 | // Use of this source code is governed by a BSD-style license that can be |
| 3 | // found in the LICENSE file. |
| 4 | |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 5 | #include "update_engine/libcurl_http_fetcher.h" |
Andrew de los Reyes | d57d147 | 2010-10-21 13:34:08 -0700 | [diff] [blame] | 6 | |
adlr@google.com | c98a7ed | 2009-12-04 18:54:03 +0000 | [diff] [blame] | 7 | #include <algorithm> |
Andrew de los Reyes | d57d147 | 2010-10-21 13:34:08 -0700 | [diff] [blame] | 8 | #include <string> |
| 9 | |
| 10 | #include <base/logging.h> |
Gilad Arnold | e4ad250 | 2011-12-29 17:08:54 -0800 | [diff] [blame] | 11 | #include <base/stringprintf.h> |
Andrew de los Reyes | d57d147 | 2010-10-21 13:34:08 -0700 | [diff] [blame] | 12 | |
Bruno Rocha | 7f9aea2 | 2011-09-12 14:31:24 -0700 | [diff] [blame] | 13 | #include "update_engine/certificate_checker.h" |
Andrew de los Reyes | 4516810 | 2010-11-22 11:13:50 -0800 | [diff] [blame] | 14 | #include "update_engine/chrome_proxy_resolver.h" |
Andrew de los Reyes | d57d147 | 2010-10-21 13:34:08 -0700 | [diff] [blame] | 15 | #include "update_engine/dbus_interface.h" |
| 16 | #include "update_engine/flimflam_proxy.h" |
| 17 | #include "update_engine/utils.h" |
adlr@google.com | c98a7ed | 2009-12-04 18:54:03 +0000 | [diff] [blame] | 18 | |
Andrew de los Reyes | f3ed8e7 | 2011-02-16 10:35:46 -0800 | [diff] [blame] | 19 | using google::protobuf::NewCallback; |
adlr@google.com | c98a7ed | 2009-12-04 18:54:03 +0000 | [diff] [blame] | 20 | using std::max; |
| 21 | using std::make_pair; |
Andrew de los Reyes | d57d147 | 2010-10-21 13:34:08 -0700 | [diff] [blame] | 22 | using std::string; |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 23 | |
| 24 | // This is a concrete implementation of HttpFetcher that uses libcurl to do the |
| 25 | // http work. |
| 26 | |
| 27 | namespace chromeos_update_engine { |
| 28 | |
Andrew de los Reyes | 9bbd187 | 2010-07-16 14:52:29 -0700 | [diff] [blame] | 29 | namespace { |
Gilad Arnold | 34bf1ee | 2012-02-09 16:16:02 -0800 | [diff] [blame] | 30 | const int kMaxRetriesCount = 3; |
Andrew de los Reyes | 5d0783d | 2010-11-29 18:14:16 -0800 | [diff] [blame] | 31 | const int kNoNetworkRetrySeconds = 10; |
Ken Mixter | b2bf122 | 2010-11-18 17:29:38 -0800 | [diff] [blame] | 32 | const char kCACertificatesPath[] = "/usr/share/chromeos-ca-certificates"; |
Andrew de los Reyes | d57d147 | 2010-10-21 13:34:08 -0700 | [diff] [blame] | 33 | } // namespace {} |
Andrew de los Reyes | 9bbd187 | 2010-07-16 14:52:29 -0700 | [diff] [blame] | 34 | |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 35 | LibcurlHttpFetcher::~LibcurlHttpFetcher() { |
Darin Petkov | 9ce452b | 2010-11-17 14:33:28 -0800 | [diff] [blame] | 36 | LOG_IF(ERROR, transfer_in_progress_) |
| 37 | << "Destroying the fetcher while a transfer is in progress."; |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 38 | CleanUp(); |
| 39 | } |
| 40 | |
Andrew de los Reyes | d57d147 | 2010-10-21 13:34:08 -0700 | [diff] [blame] | 41 | // On error, returns false. |
| 42 | bool LibcurlHttpFetcher::ConnectionIsExpensive() const { |
| 43 | if (force_connection_type_) |
| 44 | return forced_expensive_connection_; |
| 45 | NetworkConnectionType type; |
| 46 | ConcreteDbusGlib dbus_iface; |
| 47 | TEST_AND_RETURN_FALSE(FlimFlamProxy::GetConnectionType(&dbus_iface, &type)); |
| 48 | LOG(INFO) << "We are connected via " |
| 49 | << FlimFlamProxy::StringForConnectionType(type); |
| 50 | return FlimFlamProxy::IsExpensiveConnectionType(type); |
| 51 | } |
| 52 | |
Darin Petkov | fc7a0ce | 2010-10-25 10:38:37 -0700 | [diff] [blame] | 53 | bool LibcurlHttpFetcher::IsOfficialBuild() const { |
| 54 | return force_build_type_ ? forced_official_build_ : utils::IsOfficialBuild(); |
| 55 | } |
| 56 | |
adlr@google.com | c98a7ed | 2009-12-04 18:54:03 +0000 | [diff] [blame] | 57 | void LibcurlHttpFetcher::ResumeTransfer(const std::string& url) { |
Andrew de los Reyes | 3270f74 | 2010-07-15 22:28:14 -0700 | [diff] [blame] | 58 | LOG(INFO) << "Starting/Resuming transfer"; |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 59 | CHECK(!transfer_in_progress_); |
| 60 | url_ = url; |
| 61 | curl_multi_handle_ = curl_multi_init(); |
| 62 | CHECK(curl_multi_handle_); |
| 63 | |
| 64 | curl_handle_ = curl_easy_init(); |
| 65 | CHECK(curl_handle_); |
| 66 | |
Andrew de los Reyes | 4516810 | 2010-11-22 11:13:50 -0800 | [diff] [blame] | 67 | CHECK(HasProxy()); |
Gilad Arnold | fbaee24 | 2012-04-04 15:59:43 -0700 | [diff] [blame] | 68 | bool is_direct = (GetCurrentProxy() == kNoProxy); |
| 69 | LOG(INFO) << "Using proxy: " << (is_direct ? "no" : "yes"); |
| 70 | if (is_direct) { |
Andrew de los Reyes | 4516810 | 2010-11-22 11:13:50 -0800 | [diff] [blame] | 71 | CHECK_EQ(curl_easy_setopt(curl_handle_, |
| 72 | CURLOPT_PROXY, |
| 73 | ""), CURLE_OK); |
| 74 | } else { |
| 75 | CHECK_EQ(curl_easy_setopt(curl_handle_, |
| 76 | CURLOPT_PROXY, |
| 77 | GetCurrentProxy().c_str()), CURLE_OK); |
| 78 | // Curl seems to require us to set the protocol |
| 79 | curl_proxytype type; |
| 80 | if (ChromeProxyResolver::GetProxyType(GetCurrentProxy(), &type)) { |
| 81 | CHECK_EQ(curl_easy_setopt(curl_handle_, |
| 82 | CURLOPT_PROXYTYPE, |
| 83 | type), CURLE_OK); |
| 84 | } |
| 85 | } |
| 86 | |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 87 | if (post_data_set_) { |
adlr@google.com | c98a7ed | 2009-12-04 18:54:03 +0000 | [diff] [blame] | 88 | CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_POST, 1), CURLE_OK); |
| 89 | CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_POSTFIELDS, |
| 90 | &post_data_[0]), |
| 91 | CURLE_OK); |
| 92 | CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_POSTFIELDSIZE, |
| 93 | post_data_.size()), |
| 94 | CURLE_OK); |
Gilad Arnold | 9dd1e7c | 2012-02-16 12:13:36 -0800 | [diff] [blame] | 95 | |
| 96 | // Set the Content-Type HTTP header, if one was specifically set. |
| 97 | CHECK(!curl_http_headers_); |
| 98 | if (post_content_type_ != kHttpContentTypeUnspecified) { |
| 99 | const string content_type_attr = |
| 100 | base::StringPrintf("Content-Type: %s", |
| 101 | GetHttpContentTypeString(post_content_type_)); |
| 102 | curl_http_headers_ = curl_slist_append(NULL, content_type_attr.c_str()); |
| 103 | CHECK(curl_http_headers_); |
| 104 | CHECK_EQ( |
| 105 | curl_easy_setopt(curl_handle_, CURLOPT_HTTPHEADER, |
| 106 | curl_http_headers_), |
| 107 | CURLE_OK); |
| 108 | } else { |
| 109 | LOG(WARNING) << "no content type set, using libcurl default"; |
| 110 | } |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 111 | } |
| 112 | |
Gilad Arnold | e4ad250 | 2011-12-29 17:08:54 -0800 | [diff] [blame] | 113 | if (bytes_downloaded_ > 0 || download_length_) { |
| 114 | // Resume from where we left off. |
adlr@google.com | c98a7ed | 2009-12-04 18:54:03 +0000 | [diff] [blame] | 115 | resume_offset_ = bytes_downloaded_; |
Gilad Arnold | e4ad250 | 2011-12-29 17:08:54 -0800 | [diff] [blame] | 116 | CHECK_GE(resume_offset_, 0); |
| 117 | |
| 118 | // Compute end offset, if one is specified. As per HTTP specification, this |
| 119 | // is an inclusive boundary. Make sure it doesn't overflow. |
| 120 | size_t end_offset = 0; |
| 121 | if (download_length_) { |
| 122 | end_offset = static_cast<size_t>(resume_offset_) + download_length_ - 1; |
| 123 | CHECK_LE((size_t) resume_offset_, end_offset); |
| 124 | } |
| 125 | |
| 126 | // Create a string representation of the desired range. |
| 127 | std::string range_str = (end_offset ? |
| 128 | StringPrintf("%jd-%zu", resume_offset_, |
| 129 | end_offset) : |
| 130 | StringPrintf("%jd-", resume_offset_)); |
| 131 | CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_RANGE, range_str.c_str()), |
| 132 | CURLE_OK); |
adlr@google.com | c98a7ed | 2009-12-04 18:54:03 +0000 | [diff] [blame] | 133 | } |
| 134 | |
| 135 | CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_WRITEDATA, this), CURLE_OK); |
| 136 | CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_WRITEFUNCTION, |
| 137 | StaticLibcurlWrite), CURLE_OK); |
Andrew de los Reyes | d57d147 | 2010-10-21 13:34:08 -0700 | [diff] [blame] | 138 | |
| 139 | string url_to_use(url_); |
| 140 | if (ConnectionIsExpensive()) { |
| 141 | LOG(INFO) << "Not initiating HTTP connection b/c we are on an expensive" |
| 142 | << " connection"; |
| 143 | url_to_use = ""; // Sabotage the URL |
| 144 | } |
| 145 | |
Darin Petkov | fc7a0ce | 2010-10-25 10:38:37 -0700 | [diff] [blame] | 146 | CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_URL, url_to_use.c_str()), |
Andrew de los Reyes | d57d147 | 2010-10-21 13:34:08 -0700 | [diff] [blame] | 147 | CURLE_OK); |
Andrew de los Reyes | 3270f74 | 2010-07-15 22:28:14 -0700 | [diff] [blame] | 148 | |
Darin Petkov | 192ced4 | 2010-07-23 16:20:24 -0700 | [diff] [blame] | 149 | // If the connection drops under 10 bytes/sec for 3 minutes, reconnect. |
Andrew de los Reyes | 3270f74 | 2010-07-15 22:28:14 -0700 | [diff] [blame] | 150 | CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_LOW_SPEED_LIMIT, 10), |
| 151 | CURLE_OK); |
Andrew de los Reyes | 2a0fd74 | 2011-04-06 11:04:53 -0700 | [diff] [blame] | 152 | // Use a smaller timeout on official builds, larger for dev. Dev users |
| 153 | // want a longer timeout b/c they may be waiting on the dev server to |
| 154 | // build an image. |
| 155 | const int kTimeout = IsOfficialBuild() ? 90 : 3 * 60; |
| 156 | CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_LOW_SPEED_TIME, kTimeout), |
Andrew de los Reyes | 3270f74 | 2010-07-15 22:28:14 -0700 | [diff] [blame] | 157 | CURLE_OK); |
Andrew de los Reyes | e72f9c0 | 2011-04-20 10:47:40 -0700 | [diff] [blame] | 158 | CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_CONNECTTIMEOUT, 30), |
| 159 | CURLE_OK); |
Andrew de los Reyes | 3270f74 | 2010-07-15 22:28:14 -0700 | [diff] [blame] | 160 | |
Darin Petkov | 41c2fcf | 2010-08-25 13:14:48 -0700 | [diff] [blame] | 161 | // By default, libcurl doesn't follow redirections. Allow up to |
| 162 | // |kMaxRedirects| redirections. |
Darin Petkov | 3a4016a | 2010-09-28 13:54:17 -0700 | [diff] [blame] | 163 | CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_FOLLOWLOCATION, 1), CURLE_OK); |
Darin Petkov | 41c2fcf | 2010-08-25 13:14:48 -0700 | [diff] [blame] | 164 | CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_MAXREDIRS, kMaxRedirects), |
| 165 | CURLE_OK); |
| 166 | |
Darin Petkov | e237d19 | 2010-11-16 10:26:08 -0800 | [diff] [blame] | 167 | // Security lock-down in official builds: makes sure that peer certificate |
| 168 | // verification is enabled, restricts the set of trusted certificates, |
| 169 | // restricts protocols to HTTPS, restricts ciphers to HIGH. |
Darin Petkov | fc7a0ce | 2010-10-25 10:38:37 -0700 | [diff] [blame] | 170 | if (IsOfficialBuild()) { |
Darin Petkov | e237d19 | 2010-11-16 10:26:08 -0800 | [diff] [blame] | 171 | CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_SSL_VERIFYPEER, 1), |
| 172 | CURLE_OK); |
| 173 | CHECK_EQ(curl_easy_setopt(curl_handle_, |
| 174 | CURLOPT_CAPATH, |
| 175 | kCACertificatesPath), |
| 176 | CURLE_OK); |
Darin Petkov | fc7a0ce | 2010-10-25 10:38:37 -0700 | [diff] [blame] | 177 | CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_PROTOCOLS, CURLPROTO_HTTPS), |
| 178 | CURLE_OK); |
| 179 | CHECK_EQ(curl_easy_setopt(curl_handle_, |
| 180 | CURLOPT_REDIR_PROTOCOLS, |
| 181 | CURLPROTO_HTTPS), |
| 182 | CURLE_OK); |
Andrew de los Reyes | 3367619 | 2010-11-29 19:41:39 -0800 | [diff] [blame] | 183 | CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_SSL_CIPHER_LIST, |
| 184 | "HIGH:!ADH"), |
Darin Petkov | e237d19 | 2010-11-16 10:26:08 -0800 | [diff] [blame] | 185 | CURLE_OK); |
Bruno Rocha | 7f9aea2 | 2011-09-12 14:31:24 -0700 | [diff] [blame] | 186 | if (check_certificate_ != CertificateChecker::kNone) { |
| 187 | CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_SSL_CTX_DATA, |
| 188 | &check_certificate_), |
| 189 | CURLE_OK); |
| 190 | CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_SSL_CTX_FUNCTION, |
| 191 | CertificateChecker::ProcessSSLContext), |
| 192 | CURLE_OK); |
| 193 | } |
Darin Petkov | fc7a0ce | 2010-10-25 10:38:37 -0700 | [diff] [blame] | 194 | } |
| 195 | |
adlr@google.com | c98a7ed | 2009-12-04 18:54:03 +0000 | [diff] [blame] | 196 | CHECK_EQ(curl_multi_add_handle(curl_multi_handle_, curl_handle_), CURLM_OK); |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 197 | transfer_in_progress_ = true; |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 198 | } |
| 199 | |
adlr@google.com | c98a7ed | 2009-12-04 18:54:03 +0000 | [diff] [blame] | 200 | // Begins the transfer, which must not have already been started. |
| 201 | void LibcurlHttpFetcher::BeginTransfer(const std::string& url) { |
Andrew de los Reyes | f3ed8e7 | 2011-02-16 10:35:46 -0800 | [diff] [blame] | 202 | CHECK(!transfer_in_progress_); |
| 203 | url_ = url; |
| 204 | if (!ResolveProxiesForUrl( |
| 205 | url_, |
| 206 | NewCallback(this, &LibcurlHttpFetcher::ProxiesResolved))) { |
| 207 | LOG(ERROR) << "Couldn't resolve proxies"; |
| 208 | if (delegate_) |
| 209 | delegate_->TransferComplete(this, false); |
| 210 | } |
| 211 | } |
| 212 | |
| 213 | void LibcurlHttpFetcher::ProxiesResolved() { |
adlr@google.com | c98a7ed | 2009-12-04 18:54:03 +0000 | [diff] [blame] | 214 | transfer_size_ = -1; |
adlr@google.com | c98a7ed | 2009-12-04 18:54:03 +0000 | [diff] [blame] | 215 | resume_offset_ = 0; |
Andrew de los Reyes | 9bbd187 | 2010-07-16 14:52:29 -0700 | [diff] [blame] | 216 | retry_count_ = 0; |
Darin Petkov | a092955 | 2010-11-29 14:19:06 -0800 | [diff] [blame] | 217 | no_network_retry_count_ = 0; |
Darin Petkov | cb46621 | 2010-08-26 09:40:11 -0700 | [diff] [blame] | 218 | http_response_code_ = 0; |
Andrew de los Reyes | 819fef2 | 2010-12-17 11:33:58 -0800 | [diff] [blame] | 219 | terminate_requested_ = false; |
Gilad Arnold | a2dee1d | 2012-04-12 11:50:37 -0700 | [diff] [blame] | 220 | sent_byte_ = false; |
Andrew de los Reyes | f3ed8e7 | 2011-02-16 10:35:46 -0800 | [diff] [blame] | 221 | ResumeTransfer(url_); |
Andrew de los Reyes | 9bbd187 | 2010-07-16 14:52:29 -0700 | [diff] [blame] | 222 | CurlPerformOnce(); |
adlr@google.com | c98a7ed | 2009-12-04 18:54:03 +0000 | [diff] [blame] | 223 | } |
| 224 | |
Darin Petkov | 9ce452b | 2010-11-17 14:33:28 -0800 | [diff] [blame] | 225 | void LibcurlHttpFetcher::ForceTransferTermination() { |
| 226 | CleanUp(); |
| 227 | if (delegate_) { |
| 228 | // Note that after the callback returns this object may be destroyed. |
| 229 | delegate_->TransferTerminated(this); |
| 230 | } |
| 231 | } |
| 232 | |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 233 | void LibcurlHttpFetcher::TerminateTransfer() { |
Darin Petkov | 9ce452b | 2010-11-17 14:33:28 -0800 | [diff] [blame] | 234 | if (in_write_callback_) { |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 235 | terminate_requested_ = true; |
Darin Petkov | 9ce452b | 2010-11-17 14:33:28 -0800 | [diff] [blame] | 236 | } else { |
| 237 | ForceTransferTermination(); |
| 238 | } |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 239 | } |
| 240 | |
Andrew de los Reyes | cb31933 | 2010-07-19 10:55:01 -0700 | [diff] [blame] | 241 | void LibcurlHttpFetcher::CurlPerformOnce() { |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 242 | CHECK(transfer_in_progress_); |
| 243 | int running_handles = 0; |
| 244 | CURLMcode retcode = CURLM_CALL_MULTI_PERFORM; |
| 245 | |
| 246 | // libcurl may request that we immediately call curl_multi_perform after it |
| 247 | // returns, so we do. libcurl promises that curl_multi_perform will not block. |
| 248 | while (CURLM_CALL_MULTI_PERFORM == retcode) { |
| 249 | retcode = curl_multi_perform(curl_multi_handle_, &running_handles); |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 250 | if (terminate_requested_) { |
Darin Petkov | 9ce452b | 2010-11-17 14:33:28 -0800 | [diff] [blame] | 251 | ForceTransferTermination(); |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 252 | return; |
| 253 | } |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 254 | } |
| 255 | if (0 == running_handles) { |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 256 | GetHttpResponseCode(); |
| 257 | if (http_response_code_) { |
| 258 | LOG(INFO) << "HTTP response code: " << http_response_code_; |
Darin Petkov | a092955 | 2010-11-29 14:19:06 -0800 | [diff] [blame] | 259 | no_network_retry_count_ = 0; |
Andrew de los Reyes | 9bbd187 | 2010-07-16 14:52:29 -0700 | [diff] [blame] | 260 | } else { |
| 261 | LOG(ERROR) << "Unable to get http response code."; |
| 262 | } |
Darin Petkov | 192ced4 | 2010-07-23 16:20:24 -0700 | [diff] [blame] | 263 | |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 264 | // we're done! |
| 265 | CleanUp(); |
adlr@google.com | c98a7ed | 2009-12-04 18:54:03 +0000 | [diff] [blame] | 266 | |
Darin Petkov | a092955 | 2010-11-29 14:19:06 -0800 | [diff] [blame] | 267 | // TODO(petkov): This temporary code tries to deal with the case where the |
| 268 | // update engine performs an update check while the network is not ready |
| 269 | // (e.g., right after resume). Longer term, we should check if the network |
| 270 | // is online/offline and return an appropriate error code. |
| 271 | if (!sent_byte_ && |
| 272 | http_response_code_ == 0 && |
| 273 | no_network_retry_count_ < no_network_max_retries_) { |
| 274 | no_network_retry_count_++; |
| 275 | g_timeout_add_seconds(kNoNetworkRetrySeconds, |
| 276 | &LibcurlHttpFetcher::StaticRetryTimeoutCallback, |
| 277 | this); |
| 278 | LOG(INFO) << "No HTTP response, retry " << no_network_retry_count_; |
| 279 | return; |
| 280 | } |
| 281 | |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 282 | if ((!sent_byte_ && !IsHttpResponseSuccess()) || IsHttpResponseError()) { |
Andrew de los Reyes | 4516810 | 2010-11-22 11:13:50 -0800 | [diff] [blame] | 283 | // The transfer completed w/ error and we didn't get any bytes. |
| 284 | // If we have another proxy to try, try that. |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 285 | // |
| 286 | // TODO(garnold) in fact there are two separate cases here: one case is an |
| 287 | // other-than-success return code (including no return code) and no |
| 288 | // received bytes, which is necessary due to the way callbacks are |
| 289 | // currently processing error conditions; the second is an explicit HTTP |
| 290 | // error code, where some data may have been received (as in the case of a |
| 291 | // semi-successful multi-chunk fetch). This is a confusing behavior and |
| 292 | // should be unified into a complete, coherent interface. |
| 293 | LOG(INFO) << "Transfer resulted in an error (" << http_response_code_ |
| 294 | << "), " << bytes_downloaded_ << " bytes downloaded"; |
Andrew de los Reyes | 4516810 | 2010-11-22 11:13:50 -0800 | [diff] [blame] | 295 | |
| 296 | PopProxy(); // Delete the proxy we just gave up on. |
| 297 | |
| 298 | if (HasProxy()) { |
| 299 | // We have another proxy. Retry immediately. |
Gilad Arnold | fbaee24 | 2012-04-04 15:59:43 -0700 | [diff] [blame] | 300 | LOG(INFO) << "Retrying with next proxy setting"; |
Andrew de los Reyes | 4516810 | 2010-11-22 11:13:50 -0800 | [diff] [blame] | 301 | g_idle_add(&LibcurlHttpFetcher::StaticRetryTimeoutCallback, this); |
| 302 | } else { |
| 303 | // Out of proxies. Give up. |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 304 | LOG(INFO) << "No further proxies, indicating transfer complete"; |
Andrew de los Reyes | 4516810 | 2010-11-22 11:13:50 -0800 | [diff] [blame] | 305 | if (delegate_) |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 306 | delegate_->TransferComplete(this, false); // signal fail |
Andrew de los Reyes | 4516810 | 2010-11-22 11:13:50 -0800 | [diff] [blame] | 307 | } |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 308 | } else if ((transfer_size_ >= 0) && (bytes_downloaded_ < transfer_size_)) { |
Andrew de los Reyes | 3270f74 | 2010-07-15 22:28:14 -0700 | [diff] [blame] | 309 | // Need to restart transfer |
Andrew de los Reyes | 9bbd187 | 2010-07-16 14:52:29 -0700 | [diff] [blame] | 310 | retry_count_++; |
| 311 | LOG(INFO) << "Restarting transfer b/c we finished, had downloaded " |
| 312 | << bytes_downloaded_ << " bytes, but transfer_size_ is " |
| 313 | << transfer_size_ << ". retry_count: " << retry_count_; |
| 314 | if (retry_count_ > kMaxRetriesCount) { |
| 315 | if (delegate_) |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 316 | delegate_->TransferComplete(this, false); // signal fail |
Andrew de los Reyes | 9bbd187 | 2010-07-16 14:52:29 -0700 | [diff] [blame] | 317 | } else { |
Darin Petkov | b83371f | 2010-08-17 09:34:49 -0700 | [diff] [blame] | 318 | g_timeout_add_seconds(retry_seconds_, |
Darin Petkov | 9b11165 | 2010-08-16 11:46:25 -0700 | [diff] [blame] | 319 | &LibcurlHttpFetcher::StaticRetryTimeoutCallback, |
| 320 | this); |
Andrew de los Reyes | 9bbd187 | 2010-07-16 14:52:29 -0700 | [diff] [blame] | 321 | } |
adlr@google.com | c98a7ed | 2009-12-04 18:54:03 +0000 | [diff] [blame] | 322 | } else { |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 323 | LOG(INFO) << "Transfer completed (" << http_response_code_ |
| 324 | << "), " << bytes_downloaded_ << " bytes downloaded"; |
adlr@google.com | c98a7ed | 2009-12-04 18:54:03 +0000 | [diff] [blame] | 325 | if (delegate_) { |
Gilad Arnold | 48085ba | 2011-11-16 09:36:08 -0800 | [diff] [blame] | 326 | bool success = IsHttpResponseSuccess(); |
Andrew de los Reyes | fb4ad7d | 2010-07-19 10:43:46 -0700 | [diff] [blame] | 327 | delegate_->TransferComplete(this, success); |
adlr@google.com | c98a7ed | 2009-12-04 18:54:03 +0000 | [diff] [blame] | 328 | } |
| 329 | } |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 330 | } else { |
| 331 | // set up callback |
| 332 | SetupMainloopSources(); |
| 333 | } |
| 334 | } |
| 335 | |
| 336 | size_t LibcurlHttpFetcher::LibcurlWrite(void *ptr, size_t size, size_t nmemb) { |
Gilad Arnold | 48085ba | 2011-11-16 09:36:08 -0800 | [diff] [blame] | 337 | // Update HTTP response first. |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 338 | GetHttpResponseCode(); |
Gilad Arnold | 48085ba | 2011-11-16 09:36:08 -0800 | [diff] [blame] | 339 | const size_t payload_size = size * nmemb; |
| 340 | |
| 341 | // Do nothing if no payload or HTTP response is an error. |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 342 | if (payload_size == 0 || !IsHttpResponseSuccess()) { |
Gilad Arnold | 48085ba | 2011-11-16 09:36:08 -0800 | [diff] [blame] | 343 | LOG(INFO) << "HTTP response unsuccessful (" << http_response_code_ |
| 344 | << ") or no payload (" << payload_size << "), nothing to do"; |
| 345 | return 0; |
| 346 | } |
| 347 | |
| 348 | sent_byte_ = true; |
adlr@google.com | c98a7ed | 2009-12-04 18:54:03 +0000 | [diff] [blame] | 349 | { |
| 350 | double transfer_size_double; |
| 351 | CHECK_EQ(curl_easy_getinfo(curl_handle_, |
| 352 | CURLINFO_CONTENT_LENGTH_DOWNLOAD, |
| 353 | &transfer_size_double), CURLE_OK); |
| 354 | off_t new_transfer_size = static_cast<off_t>(transfer_size_double); |
| 355 | if (new_transfer_size > 0) { |
| 356 | transfer_size_ = resume_offset_ + new_transfer_size; |
| 357 | } |
| 358 | } |
Gilad Arnold | 48085ba | 2011-11-16 09:36:08 -0800 | [diff] [blame] | 359 | bytes_downloaded_ += payload_size; |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 360 | in_write_callback_ = true; |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 361 | if (delegate_) |
Gilad Arnold | 48085ba | 2011-11-16 09:36:08 -0800 | [diff] [blame] | 362 | delegate_->ReceivedBytes(this, reinterpret_cast<char*>(ptr), payload_size); |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 363 | in_write_callback_ = false; |
Gilad Arnold | 48085ba | 2011-11-16 09:36:08 -0800 | [diff] [blame] | 364 | return payload_size; |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 365 | } |
| 366 | |
| 367 | void LibcurlHttpFetcher::Pause() { |
| 368 | CHECK(curl_handle_); |
| 369 | CHECK(transfer_in_progress_); |
adlr@google.com | c98a7ed | 2009-12-04 18:54:03 +0000 | [diff] [blame] | 370 | CHECK_EQ(curl_easy_pause(curl_handle_, CURLPAUSE_ALL), CURLE_OK); |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 371 | } |
| 372 | |
| 373 | void LibcurlHttpFetcher::Unpause() { |
| 374 | CHECK(curl_handle_); |
| 375 | CHECK(transfer_in_progress_); |
adlr@google.com | c98a7ed | 2009-12-04 18:54:03 +0000 | [diff] [blame] | 376 | CHECK_EQ(curl_easy_pause(curl_handle_, CURLPAUSE_CONT), CURLE_OK); |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 377 | } |
| 378 | |
| 379 | // This method sets up callbacks with the glib main loop. |
| 380 | void LibcurlHttpFetcher::SetupMainloopSources() { |
| 381 | fd_set fd_read; |
| 382 | fd_set fd_write; |
Darin Petkov | 60e1415 | 2010-10-27 16:57:04 -0700 | [diff] [blame] | 383 | fd_set fd_exc; |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 384 | |
| 385 | FD_ZERO(&fd_read); |
| 386 | FD_ZERO(&fd_write); |
Darin Petkov | 60e1415 | 2010-10-27 16:57:04 -0700 | [diff] [blame] | 387 | FD_ZERO(&fd_exc); |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 388 | |
| 389 | int fd_max = 0; |
| 390 | |
| 391 | // Ask libcurl for the set of file descriptors we should track on its |
| 392 | // behalf. |
adlr@google.com | c98a7ed | 2009-12-04 18:54:03 +0000 | [diff] [blame] | 393 | CHECK_EQ(curl_multi_fdset(curl_multi_handle_, &fd_read, &fd_write, |
Darin Petkov | 60e1415 | 2010-10-27 16:57:04 -0700 | [diff] [blame] | 394 | &fd_exc, &fd_max), CURLM_OK); |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 395 | |
| 396 | // We should iterate through all file descriptors up to libcurl's fd_max or |
Darin Petkov | 60e1415 | 2010-10-27 16:57:04 -0700 | [diff] [blame] | 397 | // the highest one we're tracking, whichever is larger. |
| 398 | for (size_t t = 0; t < arraysize(io_channels_); ++t) { |
| 399 | if (!io_channels_[t].empty()) |
| 400 | fd_max = max(fd_max, io_channels_[t].rbegin()->first); |
| 401 | } |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 402 | |
Darin Petkov | 60e1415 | 2010-10-27 16:57:04 -0700 | [diff] [blame] | 403 | // For each fd, if we're not tracking it, track it. If we are tracking it, but |
| 404 | // libcurl doesn't care about it anymore, stop tracking it. After this loop, |
| 405 | // there should be exactly as many GIOChannel objects in io_channels_[0|1] as |
| 406 | // there are read/write fds that we're tracking. |
| 407 | for (int fd = 0; fd <= fd_max; ++fd) { |
| 408 | // Note that fd_exc is unused in the current version of libcurl so is_exc |
| 409 | // should always be false. |
| 410 | bool is_exc = FD_ISSET(fd, &fd_exc) != 0; |
| 411 | bool must_track[2] = { |
| 412 | is_exc || (FD_ISSET(fd, &fd_read) != 0), // track 0 -- read |
| 413 | is_exc || (FD_ISSET(fd, &fd_write) != 0) // track 1 -- write |
| 414 | }; |
| 415 | |
| 416 | for (size_t t = 0; t < arraysize(io_channels_); ++t) { |
| 417 | bool tracked = io_channels_[t].find(fd) != io_channels_[t].end(); |
| 418 | |
| 419 | if (!must_track[t]) { |
| 420 | // If we have an outstanding io_channel, remove it. |
| 421 | if (tracked) { |
| 422 | g_source_remove(io_channels_[t][fd].second); |
| 423 | g_io_channel_unref(io_channels_[t][fd].first); |
| 424 | io_channels_[t].erase(io_channels_[t].find(fd)); |
| 425 | } |
| 426 | continue; |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 427 | } |
Darin Petkov | 60e1415 | 2010-10-27 16:57:04 -0700 | [diff] [blame] | 428 | |
| 429 | // If we are already tracking this fd, continue -- nothing to do. |
| 430 | if (tracked) |
| 431 | continue; |
| 432 | |
| 433 | // Set conditions appropriately -- read for track 0, write for track 1. |
| 434 | GIOCondition condition = static_cast<GIOCondition>( |
| 435 | ((t == 0) ? (G_IO_IN | G_IO_PRI) : G_IO_OUT) | G_IO_ERR | G_IO_HUP); |
| 436 | |
| 437 | // Track a new fd. |
| 438 | GIOChannel* io_channel = g_io_channel_unix_new(fd); |
| 439 | guint tag = |
| 440 | g_io_add_watch(io_channel, condition, &StaticFDCallback, this); |
| 441 | |
| 442 | io_channels_[t][fd] = make_pair(io_channel, tag); |
| 443 | static int io_counter = 0; |
| 444 | io_counter++; |
| 445 | if (io_counter % 50 == 0) { |
| 446 | LOG(INFO) << "io_counter = " << io_counter; |
| 447 | } |
Andrew de los Reyes | 3270f74 | 2010-07-15 22:28:14 -0700 | [diff] [blame] | 448 | } |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 449 | } |
| 450 | |
Darin Petkov | b83371f | 2010-08-17 09:34:49 -0700 | [diff] [blame] | 451 | // Set up a timeout callback for libcurl. |
Andrew de los Reyes | 3270f74 | 2010-07-15 22:28:14 -0700 | [diff] [blame] | 452 | if (!timeout_source_) { |
Darin Petkov | b83371f | 2010-08-17 09:34:49 -0700 | [diff] [blame] | 453 | LOG(INFO) << "Setting up timeout source: " << idle_seconds_ << " seconds."; |
| 454 | timeout_source_ = g_timeout_source_new_seconds(idle_seconds_); |
| 455 | g_source_set_callback(timeout_source_, StaticTimeoutCallback, this, NULL); |
Andrew de los Reyes | 3270f74 | 2010-07-15 22:28:14 -0700 | [diff] [blame] | 456 | g_source_attach(timeout_source_, NULL); |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 457 | } |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 458 | } |
| 459 | |
| 460 | bool LibcurlHttpFetcher::FDCallback(GIOChannel *source, |
| 461 | GIOCondition condition) { |
Andrew de los Reyes | 9bbd187 | 2010-07-16 14:52:29 -0700 | [diff] [blame] | 462 | CurlPerformOnce(); |
Andrew de los Reyes | 3270f74 | 2010-07-15 22:28:14 -0700 | [diff] [blame] | 463 | // We handle removing of this source elsewhere, so we always return true. |
| 464 | // The docs say, "the function should return FALSE if the event source |
| 465 | // should be removed." |
| 466 | // http://www.gtk.org/api/2.6/glib/glib-IO-Channels.html#GIOFunc |
| 467 | return true; |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 468 | } |
| 469 | |
Andrew de los Reyes | 9bbd187 | 2010-07-16 14:52:29 -0700 | [diff] [blame] | 470 | gboolean LibcurlHttpFetcher::RetryTimeoutCallback() { |
| 471 | ResumeTransfer(url_); |
| 472 | CurlPerformOnce(); |
| 473 | return FALSE; // Don't have glib auto call this callback again |
| 474 | } |
| 475 | |
Andrew de los Reyes | 3270f74 | 2010-07-15 22:28:14 -0700 | [diff] [blame] | 476 | gboolean LibcurlHttpFetcher::TimeoutCallback() { |
Andrew de los Reyes | cb31933 | 2010-07-19 10:55:01 -0700 | [diff] [blame] | 477 | // We always return true, even if we don't want glib to call us back. |
| 478 | // We will remove the event source separately if we don't want to |
| 479 | // be called back. |
Andrew de los Reyes | 3270f74 | 2010-07-15 22:28:14 -0700 | [diff] [blame] | 480 | if (!transfer_in_progress_) |
| 481 | return TRUE; |
Andrew de los Reyes | 9bbd187 | 2010-07-16 14:52:29 -0700 | [diff] [blame] | 482 | CurlPerformOnce(); |
Andrew de los Reyes | 3270f74 | 2010-07-15 22:28:14 -0700 | [diff] [blame] | 483 | return TRUE; |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 484 | } |
| 485 | |
| 486 | void LibcurlHttpFetcher::CleanUp() { |
| 487 | if (timeout_source_) { |
| 488 | g_source_destroy(timeout_source_); |
| 489 | timeout_source_ = NULL; |
| 490 | } |
| 491 | |
Darin Petkov | 60e1415 | 2010-10-27 16:57:04 -0700 | [diff] [blame] | 492 | for (size_t t = 0; t < arraysize(io_channels_); ++t) { |
| 493 | for (IOChannels::iterator it = io_channels_[t].begin(); |
| 494 | it != io_channels_[t].end(); ++it) { |
| 495 | g_source_remove(it->second.second); |
| 496 | g_io_channel_unref(it->second.first); |
| 497 | } |
| 498 | io_channels_[t].clear(); |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 499 | } |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 500 | |
Gilad Arnold | 9dd1e7c | 2012-02-16 12:13:36 -0800 | [diff] [blame] | 501 | if (curl_http_headers_) { |
| 502 | curl_slist_free_all(curl_http_headers_); |
| 503 | curl_http_headers_ = NULL; |
| 504 | } |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 505 | if (curl_handle_) { |
| 506 | if (curl_multi_handle_) { |
adlr@google.com | c98a7ed | 2009-12-04 18:54:03 +0000 | [diff] [blame] | 507 | CHECK_EQ(curl_multi_remove_handle(curl_multi_handle_, curl_handle_), |
| 508 | CURLM_OK); |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 509 | } |
| 510 | curl_easy_cleanup(curl_handle_); |
| 511 | curl_handle_ = NULL; |
| 512 | } |
| 513 | if (curl_multi_handle_) { |
adlr@google.com | c98a7ed | 2009-12-04 18:54:03 +0000 | [diff] [blame] | 514 | CHECK_EQ(curl_multi_cleanup(curl_multi_handle_), CURLM_OK); |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 515 | curl_multi_handle_ = NULL; |
| 516 | } |
| 517 | transfer_in_progress_ = false; |
| 518 | } |
| 519 | |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 520 | void LibcurlHttpFetcher::GetHttpResponseCode() { |
| 521 | long http_response_code = 0; |
| 522 | if (curl_easy_getinfo(curl_handle_, |
| 523 | CURLINFO_RESPONSE_CODE, |
| 524 | &http_response_code) == CURLE_OK) { |
| 525 | http_response_code_ = static_cast<int>(http_response_code); |
| 526 | } |
| 527 | } |
| 528 | |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 529 | } // namespace chromeos_update_engine |