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 #include "update_engine/libcurl_http_fetcher.h" 18 19 #include <sys/types.h> 20 #include <unistd.h> 21 22 #include <algorithm> 23 #include <string> 24 25 #include <base/bind.h> 26 #include <base/format_macros.h> 27 #include <base/location.h> 28 #include <base/logging.h> 29 #include <base/strings/string_util.h> 30 #include <base/strings/stringprintf.h> 31 32 #ifdef __ANDROID__ 33 #include <cutils/qtaguid.h> 34 #include <private/android_filesystem_config.h> 35 #endif // __ANDROID__ 36 37 #include "update_engine/certificate_checker.h" 38 #include "update_engine/common/hardware_interface.h" 39 #include "update_engine/common/platform_constants.h" 40 41 using base::TimeDelta; 42 using brillo::MessageLoop; 43 using std::max; 44 using std::string; 45 46 // This is a concrete implementation of HttpFetcher that uses libcurl to do the 47 // http work. 48 49 namespace chromeos_update_engine { 50 51 namespace { 52 53 const int kNoNetworkRetrySeconds = 10; 54 55 // Socket tag used by all network sockets. See qtaguid kernel module for stats. 56 const int kUpdateEngineSocketTag = 0x55417243; // "CrAU" in little-endian. 57 58 // libcurl's CURLOPT_SOCKOPTFUNCTION callback function. Called after the socket 59 // is created but before it is connected. This callback tags the created socket 60 // so the network usage can be tracked in Android. 61 int LibcurlSockoptCallback(void* /* clientp */, 62 curl_socket_t curlfd, 63 curlsocktype /* purpose */) { 64 #ifdef __ANDROID__ 65 qtaguid_tagSocket(curlfd, kUpdateEngineSocketTag, AID_OTA_UPDATE); 66 #endif // __ANDROID__ 67 return CURL_SOCKOPT_OK; 68 } 69 70 } // namespace 71 72 // static 73 int LibcurlHttpFetcher::LibcurlCloseSocketCallback(void* clientp, 74 curl_socket_t item) { 75 #ifdef __ANDROID__ 76 qtaguid_untagSocket(item); 77 #endif // __ANDROID__ 78 LibcurlHttpFetcher* fetcher = static_cast<LibcurlHttpFetcher*>(clientp); 79 // Stop watching the socket before closing it. 80 for (size_t t = 0; t < arraysize(fetcher->fd_task_maps_); ++t) { 81 const auto fd_task_pair = fetcher->fd_task_maps_[t].find(item); 82 if (fd_task_pair != fetcher->fd_task_maps_[t].end()) { 83 if (!MessageLoop::current()->CancelTask(fd_task_pair->second)) { 84 LOG(WARNING) << "Error canceling the watch task " 85 << fd_task_pair->second << " for " 86 << (t ? "writing" : "reading") << " the fd " << item; 87 } 88 fetcher->fd_task_maps_[t].erase(item); 89 } 90 } 91 92 // Documentation for this callback says to return 0 on success or 1 on error. 93 if (!IGNORE_EINTR(close(item))) 94 return 0; 95 return 1; 96 } 97 98 LibcurlHttpFetcher::LibcurlHttpFetcher(ProxyResolver* proxy_resolver, 99 HardwareInterface* hardware) 100 : HttpFetcher(proxy_resolver), hardware_(hardware) { 101 // Dev users want a longer timeout (180 seconds) because they may 102 // be waiting on the dev server to build an image. 103 if (!hardware_->IsOfficialBuild()) 104 low_speed_time_seconds_ = kDownloadDevModeLowSpeedTimeSeconds; 105 if (hardware_->IsOOBEEnabled() && !hardware_->IsOOBEComplete(nullptr)) 106 max_retry_count_ = kDownloadMaxRetryCountOobeNotComplete; 107 } 108 109 LibcurlHttpFetcher::~LibcurlHttpFetcher() { 110 LOG_IF(ERROR, transfer_in_progress_) 111 << "Destroying the fetcher while a transfer is in progress."; 112 CancelProxyResolution(); 113 CleanUp(); 114 } 115 116 bool LibcurlHttpFetcher::GetProxyType(const string& proxy, 117 curl_proxytype* out_type) { 118 if (base::StartsWith( 119 proxy, "socks5://", base::CompareCase::INSENSITIVE_ASCII) || 120 base::StartsWith( 121 proxy, "socks://", base::CompareCase::INSENSITIVE_ASCII)) { 122 *out_type = CURLPROXY_SOCKS5_HOSTNAME; 123 return true; 124 } 125 if (base::StartsWith( 126 proxy, "socks4://", base::CompareCase::INSENSITIVE_ASCII)) { 127 *out_type = CURLPROXY_SOCKS4A; 128 return true; 129 } 130 if (base::StartsWith( 131 proxy, "http://", base::CompareCase::INSENSITIVE_ASCII) || 132 base::StartsWith( 133 proxy, "https://", base::CompareCase::INSENSITIVE_ASCII)) { 134 *out_type = CURLPROXY_HTTP; 135 return true; 136 } 137 if (base::StartsWith(proxy, kNoProxy, base::CompareCase::INSENSITIVE_ASCII)) { 138 // known failure case. don't log. 139 return false; 140 } 141 LOG(INFO) << "Unknown proxy type: " << proxy; 142 return false; 143 } 144 145 void LibcurlHttpFetcher::ResumeTransfer(const string& url) { 146 LOG(INFO) << "Starting/Resuming transfer"; 147 CHECK(!transfer_in_progress_); 148 url_ = url; 149 curl_multi_handle_ = curl_multi_init(); 150 CHECK(curl_multi_handle_); 151 152 curl_handle_ = curl_easy_init(); 153 CHECK(curl_handle_); 154 ignore_failure_ = false; 155 156 // Tag and untag the socket for network usage stats. 157 curl_easy_setopt( 158 curl_handle_, CURLOPT_SOCKOPTFUNCTION, LibcurlSockoptCallback); 159 curl_easy_setopt( 160 curl_handle_, CURLOPT_CLOSESOCKETFUNCTION, LibcurlCloseSocketCallback); 161 curl_easy_setopt(curl_handle_, CURLOPT_CLOSESOCKETDATA, this); 162 163 CHECK(HasProxy()); 164 bool is_direct = (GetCurrentProxy() == kNoProxy); 165 LOG(INFO) << "Using proxy: " << (is_direct ? "no" : "yes"); 166 if (is_direct) { 167 CHECK_EQ(curl_easy_setopt(curl_handle_, 168 CURLOPT_PROXY, 169 ""), CURLE_OK); 170 } else { 171 CHECK_EQ(curl_easy_setopt(curl_handle_, 172 CURLOPT_PROXY, 173 GetCurrentProxy().c_str()), CURLE_OK); 174 // Curl seems to require us to set the protocol 175 curl_proxytype type; 176 if (GetProxyType(GetCurrentProxy(), &type)) { 177 CHECK_EQ(curl_easy_setopt(curl_handle_, 178 CURLOPT_PROXYTYPE, 179 type), CURLE_OK); 180 } 181 } 182 183 if (post_data_set_) { 184 CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_POST, 1), CURLE_OK); 185 CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_POSTFIELDS, 186 post_data_.data()), 187 CURLE_OK); 188 CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_POSTFIELDSIZE, 189 post_data_.size()), 190 CURLE_OK); 191 } 192 193 // Setup extra HTTP headers. 194 if (curl_http_headers_) { 195 curl_slist_free_all(curl_http_headers_); 196 curl_http_headers_ = nullptr; 197 } 198 for (const auto& header : extra_headers_) { 199 // curl_slist_append() copies the string. 200 curl_http_headers_ = 201 curl_slist_append(curl_http_headers_, header.second.c_str()); 202 } 203 if (post_data_set_) { 204 // Set the Content-Type HTTP header, if one was specifically set. 205 if (post_content_type_ != kHttpContentTypeUnspecified) { 206 const string content_type_attr = base::StringPrintf( 207 "Content-Type: %s", GetHttpContentTypeString(post_content_type_)); 208 curl_http_headers_ = 209 curl_slist_append(curl_http_headers_, content_type_attr.c_str()); 210 } else { 211 LOG(WARNING) << "no content type set, using libcurl default"; 212 } 213 } 214 CHECK_EQ( 215 curl_easy_setopt(curl_handle_, CURLOPT_HTTPHEADER, curl_http_headers_), 216 CURLE_OK); 217 218 if (bytes_downloaded_ > 0 || download_length_) { 219 // Resume from where we left off. 220 resume_offset_ = bytes_downloaded_; 221 CHECK_GE(resume_offset_, 0); 222 223 // Compute end offset, if one is specified. As per HTTP specification, this 224 // is an inclusive boundary. Make sure it doesn't overflow. 225 size_t end_offset = 0; 226 if (download_length_) { 227 end_offset = static_cast<size_t>(resume_offset_) + download_length_ - 1; 228 CHECK_LE((size_t) resume_offset_, end_offset); 229 } 230 231 // Create a string representation of the desired range. 232 string range_str = base::StringPrintf( 233 "%" PRIu64 "-", static_cast<uint64_t>(resume_offset_)); 234 if (end_offset) 235 range_str += std::to_string(end_offset); 236 CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_RANGE, range_str.c_str()), 237 CURLE_OK); 238 } 239 240 CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_WRITEDATA, this), CURLE_OK); 241 CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_WRITEFUNCTION, 242 StaticLibcurlWrite), CURLE_OK); 243 CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_URL, url_.c_str()), 244 CURLE_OK); 245 246 // If the connection drops under |low_speed_limit_bps_| (10 247 // bytes/sec by default) for |low_speed_time_seconds_| (90 seconds, 248 // 180 on non-official builds), reconnect. 249 CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_LOW_SPEED_LIMIT, 250 low_speed_limit_bps_), 251 CURLE_OK); 252 CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_LOW_SPEED_TIME, 253 low_speed_time_seconds_), 254 CURLE_OK); 255 CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_CONNECTTIMEOUT, 256 connect_timeout_seconds_), 257 CURLE_OK); 258 259 // By default, libcurl doesn't follow redirections. Allow up to 260 // |kDownloadMaxRedirects| redirections. 261 CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_FOLLOWLOCATION, 1), CURLE_OK); 262 CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_MAXREDIRS, 263 kDownloadMaxRedirects), 264 CURLE_OK); 265 266 // Lock down the appropriate curl options for HTTP or HTTPS depending on 267 // the url. 268 if (hardware_->IsOfficialBuild()) { 269 if (base::StartsWith( 270 url_, "http://", base::CompareCase::INSENSITIVE_ASCII)) { 271 SetCurlOptionsForHttp(); 272 } else if (base::StartsWith( 273 url_, "https://", base::CompareCase::INSENSITIVE_ASCII)) { 274 SetCurlOptionsForHttps(); 275 #if !defined(__CHROMEOS__) && !defined(__BRILLO__) 276 } else if (base::StartsWith( 277 url_, "file://", base::CompareCase::INSENSITIVE_ASCII)) { 278 SetCurlOptionsForFile(); 279 #endif 280 } else { 281 LOG(ERROR) << "Received invalid URI: " << url_; 282 // Lock down to no protocol supported for the transfer. 283 CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_PROTOCOLS, 0), CURLE_OK); 284 } 285 } else { 286 LOG(INFO) << "Not setting http(s) curl options because we are " 287 << "running a dev/test image"; 288 } 289 290 CHECK_EQ(curl_multi_add_handle(curl_multi_handle_, curl_handle_), CURLM_OK); 291 transfer_in_progress_ = true; 292 } 293 294 // Lock down only the protocol in case of HTTP. 295 void LibcurlHttpFetcher::SetCurlOptionsForHttp() { 296 LOG(INFO) << "Setting up curl options for HTTP"; 297 CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_PROTOCOLS, CURLPROTO_HTTP), 298 CURLE_OK); 299 CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_REDIR_PROTOCOLS, 300 CURLPROTO_HTTP), 301 CURLE_OK); 302 } 303 304 // Security lock-down in official builds: makes sure that peer certificate 305 // verification is enabled, restricts the set of trusted certificates, 306 // restricts protocols to HTTPS, restricts ciphers to HIGH. 307 void LibcurlHttpFetcher::SetCurlOptionsForHttps() { 308 LOG(INFO) << "Setting up curl options for HTTPS"; 309 CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_SSL_VERIFYPEER, 1), 310 CURLE_OK); 311 CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_SSL_VERIFYHOST, 2), 312 CURLE_OK); 313 CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_CAPATH, 314 constants::kCACertificatesPath), 315 CURLE_OK); 316 CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_PROTOCOLS, CURLPROTO_HTTPS), 317 CURLE_OK); 318 CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_REDIR_PROTOCOLS, 319 CURLPROTO_HTTPS), 320 CURLE_OK); 321 CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_SSL_CIPHER_LIST, "HIGH:!ADH"), 322 CURLE_OK); 323 if (server_to_check_ != ServerToCheck::kNone) { 324 CHECK_EQ( 325 curl_easy_setopt(curl_handle_, CURLOPT_SSL_CTX_DATA, &server_to_check_), 326 CURLE_OK); 327 CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_SSL_CTX_FUNCTION, 328 CertificateChecker::ProcessSSLContext), 329 CURLE_OK); 330 } 331 } 332 333 // Lock down only the protocol in case of a local file. 334 void LibcurlHttpFetcher::SetCurlOptionsForFile() { 335 LOG(INFO) << "Setting up curl options for FILE"; 336 CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_PROTOCOLS, CURLPROTO_FILE), 337 CURLE_OK); 338 CHECK_EQ( 339 curl_easy_setopt(curl_handle_, CURLOPT_REDIR_PROTOCOLS, CURLPROTO_FILE), 340 CURLE_OK); 341 } 342 343 // Begins the transfer, which must not have already been started. 344 void LibcurlHttpFetcher::BeginTransfer(const string& url) { 345 CHECK(!transfer_in_progress_); 346 url_ = url; 347 auto closure = base::Bind(&LibcurlHttpFetcher::ProxiesResolved, 348 base::Unretained(this)); 349 if (!ResolveProxiesForUrl(url_, closure)) { 350 LOG(ERROR) << "Couldn't resolve proxies"; 351 if (delegate_) 352 delegate_->TransferComplete(this, false); 353 } 354 } 355 356 void LibcurlHttpFetcher::ProxiesResolved() { 357 transfer_size_ = -1; 358 resume_offset_ = 0; 359 retry_count_ = 0; 360 no_network_retry_count_ = 0; 361 http_response_code_ = 0; 362 terminate_requested_ = false; 363 sent_byte_ = false; 364 365 // If we are paused, we delay these two operations until Unpause is called. 366 if (transfer_paused_) { 367 restart_transfer_on_unpause_ = true; 368 return; 369 } 370 ResumeTransfer(url_); 371 CurlPerformOnce(); 372 } 373 374 void LibcurlHttpFetcher::ForceTransferTermination() { 375 CancelProxyResolution(); 376 CleanUp(); 377 if (delegate_) { 378 // Note that after the callback returns this object may be destroyed. 379 delegate_->TransferTerminated(this); 380 } 381 } 382 383 void LibcurlHttpFetcher::TerminateTransfer() { 384 if (in_write_callback_) { 385 terminate_requested_ = true; 386 } else { 387 ForceTransferTermination(); 388 } 389 } 390 391 void LibcurlHttpFetcher::SetHeader(const string& header_name, 392 const string& header_value) { 393 string header_line = header_name + ": " + header_value; 394 // Avoid the space if no data on the right side of the semicolon. 395 if (header_value.empty()) 396 header_line = header_name + ":"; 397 TEST_AND_RETURN(header_line.find('\n') == string::npos); 398 TEST_AND_RETURN(header_name.find(':') == string::npos); 399 extra_headers_[base::ToLowerASCII(header_name)] = header_line; 400 } 401 402 void LibcurlHttpFetcher::CurlPerformOnce() { 403 CHECK(transfer_in_progress_); 404 int running_handles = 0; 405 CURLMcode retcode = CURLM_CALL_MULTI_PERFORM; 406 407 // libcurl may request that we immediately call curl_multi_perform after it 408 // returns, so we do. libcurl promises that curl_multi_perform will not block. 409 while (CURLM_CALL_MULTI_PERFORM == retcode) { 410 retcode = curl_multi_perform(curl_multi_handle_, &running_handles); 411 if (terminate_requested_) { 412 ForceTransferTermination(); 413 return; 414 } 415 } 416 417 // If the transfer completes while paused, we should ignore the failure once 418 // the fetcher is unpaused. 419 if (running_handles == 0 && transfer_paused_ && !ignore_failure_) { 420 LOG(INFO) << "Connection closed while paused, ignoring failure."; 421 ignore_failure_ = true; 422 } 423 424 if (running_handles != 0 || transfer_paused_) { 425 // There's either more work to do or we are paused, so we just keep the 426 // file descriptors to watch up to date and exit, until we are done with the 427 // work and we are not paused. 428 SetupMessageLoopSources(); 429 return; 430 } 431 432 // At this point, the transfer was completed in some way (error, connection 433 // closed or download finished). 434 435 GetHttpResponseCode(); 436 if (http_response_code_) { 437 LOG(INFO) << "HTTP response code: " << http_response_code_; 438 no_network_retry_count_ = 0; 439 } else { 440 LOG(ERROR) << "Unable to get http response code."; 441 } 442 443 // we're done! 444 CleanUp(); 445 446 // TODO(petkov): This temporary code tries to deal with the case where the 447 // update engine performs an update check while the network is not ready 448 // (e.g., right after resume). Longer term, we should check if the network 449 // is online/offline and return an appropriate error code. 450 if (!sent_byte_ && 451 http_response_code_ == 0 && 452 no_network_retry_count_ < no_network_max_retries_) { 453 no_network_retry_count_++; 454 retry_task_id_ = MessageLoop::current()->PostDelayedTask( 455 FROM_HERE, 456 base::Bind(&LibcurlHttpFetcher::RetryTimeoutCallback, 457 base::Unretained(this)), 458 TimeDelta::FromSeconds(kNoNetworkRetrySeconds)); 459 LOG(INFO) << "No HTTP response, retry " << no_network_retry_count_; 460 } else if ((!sent_byte_ && !IsHttpResponseSuccess()) || 461 IsHttpResponseError()) { 462 // The transfer completed w/ error and we didn't get any bytes. 463 // If we have another proxy to try, try that. 464 // 465 // TODO(garnold) in fact there are two separate cases here: one case is an 466 // other-than-success return code (including no return code) and no 467 // received bytes, which is necessary due to the way callbacks are 468 // currently processing error conditions; the second is an explicit HTTP 469 // error code, where some data may have been received (as in the case of a 470 // semi-successful multi-chunk fetch). This is a confusing behavior and 471 // should be unified into a complete, coherent interface. 472 LOG(INFO) << "Transfer resulted in an error (" << http_response_code_ 473 << "), " << bytes_downloaded_ << " bytes downloaded"; 474 475 PopProxy(); // Delete the proxy we just gave up on. 476 477 if (HasProxy()) { 478 // We have another proxy. Retry immediately. 479 LOG(INFO) << "Retrying with next proxy setting"; 480 retry_task_id_ = MessageLoop::current()->PostTask( 481 FROM_HERE, 482 base::Bind(&LibcurlHttpFetcher::RetryTimeoutCallback, 483 base::Unretained(this))); 484 } else { 485 // Out of proxies. Give up. 486 LOG(INFO) << "No further proxies, indicating transfer complete"; 487 if (delegate_) 488 delegate_->TransferComplete(this, false); // signal fail 489 return; 490 } 491 } else if ((transfer_size_ >= 0) && (bytes_downloaded_ < transfer_size_)) { 492 if (!ignore_failure_) 493 retry_count_++; 494 LOG(INFO) << "Transfer interrupted after downloading " 495 << bytes_downloaded_ << " of " << transfer_size_ << " bytes. " 496 << transfer_size_ - bytes_downloaded_ << " bytes remaining " 497 << "after " << retry_count_ << " attempt(s)"; 498 499 if (retry_count_ > max_retry_count_) { 500 LOG(INFO) << "Reached max attempts (" << retry_count_ << ")"; 501 if (delegate_) 502 delegate_->TransferComplete(this, false); // signal fail 503 return; 504 } 505 // Need to restart transfer 506 LOG(INFO) << "Restarting transfer to download the remaining bytes"; 507 retry_task_id_ = MessageLoop::current()->PostDelayedTask( 508 FROM_HERE, 509 base::Bind(&LibcurlHttpFetcher::RetryTimeoutCallback, 510 base::Unretained(this)), 511 TimeDelta::FromSeconds(retry_seconds_)); 512 } else { 513 LOG(INFO) << "Transfer completed (" << http_response_code_ 514 << "), " << bytes_downloaded_ << " bytes downloaded"; 515 if (delegate_) { 516 bool success = IsHttpResponseSuccess(); 517 delegate_->TransferComplete(this, success); 518 } 519 return; 520 } 521 // If we reach this point is because TransferComplete() was not called in any 522 // of the previous branches. The delegate is allowed to destroy the object 523 // once TransferComplete is called so this would be illegal. 524 ignore_failure_ = false; 525 } 526 527 size_t LibcurlHttpFetcher::LibcurlWrite(void *ptr, size_t size, size_t nmemb) { 528 // Update HTTP response first. 529 GetHttpResponseCode(); 530 const size_t payload_size = size * nmemb; 531 532 // Do nothing if no payload or HTTP response is an error. 533 if (payload_size == 0 || !IsHttpResponseSuccess()) { 534 LOG(INFO) << "HTTP response unsuccessful (" << http_response_code_ 535 << ") or no payload (" << payload_size << "), nothing to do"; 536 return 0; 537 } 538 539 sent_byte_ = true; 540 { 541 double transfer_size_double; 542 CHECK_EQ(curl_easy_getinfo(curl_handle_, 543 CURLINFO_CONTENT_LENGTH_DOWNLOAD, 544 &transfer_size_double), CURLE_OK); 545 off_t new_transfer_size = static_cast<off_t>(transfer_size_double); 546 if (new_transfer_size > 0) { 547 transfer_size_ = resume_offset_ + new_transfer_size; 548 } 549 } 550 bytes_downloaded_ += payload_size; 551 in_write_callback_ = true; 552 if (delegate_) 553 delegate_->ReceivedBytes(this, ptr, payload_size); 554 in_write_callback_ = false; 555 return payload_size; 556 } 557 558 void LibcurlHttpFetcher::Pause() { 559 if (transfer_paused_) { 560 LOG(ERROR) << "Fetcher already paused."; 561 return; 562 } 563 transfer_paused_ = true; 564 if (!transfer_in_progress_) { 565 // If pause before we started a connection, we don't need to notify curl 566 // about that, we will simply not start the connection later. 567 return; 568 } 569 CHECK(curl_handle_); 570 CHECK_EQ(curl_easy_pause(curl_handle_, CURLPAUSE_ALL), CURLE_OK); 571 } 572 573 void LibcurlHttpFetcher::Unpause() { 574 if (!transfer_paused_) { 575 LOG(ERROR) << "Resume attempted when fetcher not paused."; 576 return; 577 } 578 transfer_paused_ = false; 579 if (restart_transfer_on_unpause_) { 580 restart_transfer_on_unpause_ = false; 581 ResumeTransfer(url_); 582 CurlPerformOnce(); 583 return; 584 } 585 if (!transfer_in_progress_) { 586 // If resumed before starting the connection, there's no need to notify 587 // anybody. We will simply start the connection once it is time. 588 return; 589 } 590 CHECK(curl_handle_); 591 CHECK_EQ(curl_easy_pause(curl_handle_, CURLPAUSE_CONT), CURLE_OK); 592 // Since the transfer is in progress, we need to dispatch a CurlPerformOnce() 593 // now to let the connection continue, otherwise it would be called by the 594 // TimeoutCallback but with a delay. 595 CurlPerformOnce(); 596 } 597 598 // This method sets up callbacks with the MessageLoop. 599 void LibcurlHttpFetcher::SetupMessageLoopSources() { 600 fd_set fd_read; 601 fd_set fd_write; 602 fd_set fd_exc; 603 604 FD_ZERO(&fd_read); 605 FD_ZERO(&fd_write); 606 FD_ZERO(&fd_exc); 607 608 int fd_max = 0; 609 610 // Ask libcurl for the set of file descriptors we should track on its 611 // behalf. 612 CHECK_EQ(curl_multi_fdset(curl_multi_handle_, &fd_read, &fd_write, 613 &fd_exc, &fd_max), CURLM_OK); 614 615 // We should iterate through all file descriptors up to libcurl's fd_max or 616 // the highest one we're tracking, whichever is larger. 617 for (size_t t = 0; t < arraysize(fd_task_maps_); ++t) { 618 if (!fd_task_maps_[t].empty()) 619 fd_max = max(fd_max, fd_task_maps_[t].rbegin()->first); 620 } 621 622 // For each fd, if we're not tracking it, track it. If we are tracking it, but 623 // libcurl doesn't care about it anymore, stop tracking it. After this loop, 624 // there should be exactly as many tasks scheduled in fd_task_maps_[0|1] as 625 // there are read/write fds that we're tracking. 626 for (int fd = 0; fd <= fd_max; ++fd) { 627 // Note that fd_exc is unused in the current version of libcurl so is_exc 628 // should always be false. 629 bool is_exc = FD_ISSET(fd, &fd_exc) != 0; 630 bool must_track[2] = { 631 is_exc || (FD_ISSET(fd, &fd_read) != 0), // track 0 -- read 632 is_exc || (FD_ISSET(fd, &fd_write) != 0) // track 1 -- write 633 }; 634 MessageLoop::WatchMode watch_modes[2] = { 635 MessageLoop::WatchMode::kWatchRead, 636 MessageLoop::WatchMode::kWatchWrite, 637 }; 638 639 for (size_t t = 0; t < arraysize(fd_task_maps_); ++t) { 640 auto fd_task_it = fd_task_maps_[t].find(fd); 641 bool tracked = fd_task_it != fd_task_maps_[t].end(); 642 643 if (!must_track[t]) { 644 // If we have an outstanding io_channel, remove it. 645 if (tracked) { 646 MessageLoop::current()->CancelTask(fd_task_it->second); 647 fd_task_maps_[t].erase(fd_task_it); 648 } 649 continue; 650 } 651 652 // If we are already tracking this fd, continue -- nothing to do. 653 if (tracked) 654 continue; 655 656 // Track a new fd. 657 fd_task_maps_[t][fd] = MessageLoop::current()->WatchFileDescriptor( 658 FROM_HERE, 659 fd, 660 watch_modes[t], 661 true, // persistent 662 base::Bind(&LibcurlHttpFetcher::CurlPerformOnce, 663 base::Unretained(this))); 664 665 static int io_counter = 0; 666 io_counter++; 667 if (io_counter % 50 == 0) { 668 LOG(INFO) << "io_counter = " << io_counter; 669 } 670 } 671 } 672 673 // Set up a timeout callback for libcurl. 674 if (timeout_id_ == MessageLoop::kTaskIdNull) { 675 VLOG(1) << "Setting up timeout source: " << idle_seconds_ << " seconds."; 676 timeout_id_ = MessageLoop::current()->PostDelayedTask( 677 FROM_HERE, 678 base::Bind(&LibcurlHttpFetcher::TimeoutCallback, 679 base::Unretained(this)), 680 TimeDelta::FromSeconds(idle_seconds_)); 681 } 682 } 683 684 void LibcurlHttpFetcher::RetryTimeoutCallback() { 685 retry_task_id_ = MessageLoop::kTaskIdNull; 686 if (transfer_paused_) { 687 restart_transfer_on_unpause_ = true; 688 return; 689 } 690 ResumeTransfer(url_); 691 CurlPerformOnce(); 692 } 693 694 void LibcurlHttpFetcher::TimeoutCallback() { 695 // We always re-schedule the callback, even if we don't want to be called 696 // anymore. We will remove the event source separately if we don't want to 697 // be called back. 698 timeout_id_ = MessageLoop::current()->PostDelayedTask( 699 FROM_HERE, 700 base::Bind(&LibcurlHttpFetcher::TimeoutCallback, base::Unretained(this)), 701 TimeDelta::FromSeconds(idle_seconds_)); 702 703 // CurlPerformOnce() may call CleanUp(), so we need to schedule our callback 704 // first, since it could be canceled by this call. 705 if (transfer_in_progress_) 706 CurlPerformOnce(); 707 } 708 709 void LibcurlHttpFetcher::CleanUp() { 710 MessageLoop::current()->CancelTask(retry_task_id_); 711 retry_task_id_ = MessageLoop::kTaskIdNull; 712 713 MessageLoop::current()->CancelTask(timeout_id_); 714 timeout_id_ = MessageLoop::kTaskIdNull; 715 716 for (size_t t = 0; t < arraysize(fd_task_maps_); ++t) { 717 for (const auto& fd_taks_pair : fd_task_maps_[t]) { 718 if (!MessageLoop::current()->CancelTask(fd_taks_pair.second)) { 719 LOG(WARNING) << "Error canceling the watch task " 720 << fd_taks_pair.second << " for " 721 << (t ? "writing" : "reading") << " the fd " 722 << fd_taks_pair.first; 723 } 724 } 725 fd_task_maps_[t].clear(); 726 } 727 728 if (curl_http_headers_) { 729 curl_slist_free_all(curl_http_headers_); 730 curl_http_headers_ = nullptr; 731 } 732 if (curl_handle_) { 733 if (curl_multi_handle_) { 734 CHECK_EQ(curl_multi_remove_handle(curl_multi_handle_, curl_handle_), 735 CURLM_OK); 736 } 737 curl_easy_cleanup(curl_handle_); 738 curl_handle_ = nullptr; 739 } 740 if (curl_multi_handle_) { 741 CHECK_EQ(curl_multi_cleanup(curl_multi_handle_), CURLM_OK); 742 curl_multi_handle_ = nullptr; 743 } 744 transfer_in_progress_ = false; 745 transfer_paused_ = false; 746 restart_transfer_on_unpause_ = false; 747 } 748 749 void LibcurlHttpFetcher::GetHttpResponseCode() { 750 long http_response_code = 0; // NOLINT(runtime/int) - curl needs long. 751 if (base::StartsWith(url_, "file://", base::CompareCase::INSENSITIVE_ASCII)) { 752 // Fake out a valid response code for file:// URLs. 753 http_response_code_ = 299; 754 } else if (curl_easy_getinfo(curl_handle_, 755 CURLINFO_RESPONSE_CODE, 756 &http_response_code) == CURLE_OK) { 757 http_response_code_ = static_cast<int>(http_response_code); 758 } 759 } 760 761 } // namespace chromeos_update_engine 762
