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.
LibcurlSockoptCallback(void *,curl_socket_t curlfd,curlsocktype)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
LibcurlCloseSocketCallback(void * clientp,curl_socket_t item)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 
LibcurlHttpFetcher(ProxyResolver * proxy_resolver,HardwareInterface * hardware)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 
~LibcurlHttpFetcher()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 
GetProxyType(const string & proxy,curl_proxytype * out_type)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 
ResumeTransfer(const string & url)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.
SetCurlOptionsForHttp()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.
SetCurlOptionsForHttps()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.
SetCurlOptionsForFile()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.
BeginTransfer(const string & url)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 
ProxiesResolved()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 
ForceTransferTermination()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 
TerminateTransfer()383 void LibcurlHttpFetcher::TerminateTransfer() {
384   if (in_write_callback_) {
385     terminate_requested_ = true;
386   } else {
387     ForceTransferTermination();
388   }
389 }
390 
SetHeader(const string & header_name,const string & header_value)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 
CurlPerformOnce()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 
LibcurlWrite(void * ptr,size_t size,size_t nmemb)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 
Pause()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 
Unpause()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.
SetupMessageLoopSources()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 
RetryTimeoutCallback()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 
TimeoutCallback()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 
CleanUp()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 
GetHttpResponseCode()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