| // Copyright (c) 2009 The Chromium OS Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #ifndef CHROMEOS_PLATFORM_UPDATE_ENGINE_LIBCURL_HTTP_FETCHER_H__ |
| #define CHROMEOS_PLATFORM_UPDATE_ENGINE_LIBCURL_HTTP_FETCHER_H__ |
| |
| #include <map> |
| #include <string> |
| |
| #include <base/basictypes.h> |
| #include <base/logging.h> |
| #include <curl/curl.h> |
| #include <glib.h> |
| |
| #include "update_engine/certificate_checker.h" |
| #include "update_engine/http_fetcher.h" |
| |
| // This is a concrete implementation of HttpFetcher that uses libcurl to do the |
| // http work. |
| |
| namespace chromeos_update_engine { |
| |
| class LibcurlHttpFetcher : public HttpFetcher { |
| public: |
| static const int kMaxRedirects = 10; |
| |
| explicit LibcurlHttpFetcher(ProxyResolver* proxy_resolver) |
| : HttpFetcher(proxy_resolver), |
| curl_multi_handle_(NULL), |
| curl_handle_(NULL), |
| timeout_source_(NULL), |
| transfer_in_progress_(false), |
| transfer_size_(0), |
| bytes_downloaded_(0), |
| download_length_(0), |
| resume_offset_(0), |
| retry_count_(0), |
| retry_seconds_(20), |
| no_network_retry_count_(0), |
| no_network_max_retries_(0), |
| idle_seconds_(1), |
| force_connection_type_(false), |
| forced_expensive_connection_(false), |
| force_build_type_(false), |
| forced_official_build_(false), |
| in_write_callback_(false), |
| sent_byte_(false), |
| terminate_requested_(false), |
| check_certificate_(CertificateChecker::kNone) {} |
| |
| // Cleans up all internal state. Does not notify delegate |
| ~LibcurlHttpFetcher(); |
| |
| virtual void SetOffset(off_t offset) { bytes_downloaded_ = offset; } |
| |
| virtual void SetLength(size_t length) { download_length_ = length; } |
| virtual void UnsetLength() { SetLength(0); } |
| |
| // Begins the transfer if it hasn't already begun. |
| virtual void BeginTransfer(const std::string& url); |
| |
| // If the transfer is in progress, aborts the transfer early. The transfer |
| // cannot be resumed. |
| virtual void TerminateTransfer(); |
| |
| // Suspend the transfer by calling curl_easy_pause(CURLPAUSE_ALL). |
| virtual void Pause(); |
| |
| // Resume the transfer by calling curl_easy_pause(CURLPAUSE_CONT). |
| virtual void Unpause(); |
| |
| // Libcurl sometimes asks to be called back after some time while |
| // leaving that time unspecified. In that case, we pick a reasonable |
| // default of one second, but it can be overridden here. This is |
| // primarily useful for testing. |
| // From http://curl.haxx.se/libcurl/c/curl_multi_timeout.html: |
| // if libcurl returns a -1 timeout here, it just means that libcurl |
| // currently has no stored timeout value. You must not wait too long |
| // (more than a few seconds perhaps) before you call |
| // curl_multi_perform() again. |
| void set_idle_seconds(int seconds) { idle_seconds_ = seconds; } |
| |
| // Sets the retry timeout. Useful for testing. |
| void set_retry_seconds(int seconds) { retry_seconds_ = seconds; } |
| |
| void set_no_network_max_retries(int retries) { |
| no_network_max_retries_ = retries; |
| } |
| |
| void SetConnectionAsExpensive(bool is_expensive) { |
| force_connection_type_ = true; |
| forced_expensive_connection_ = is_expensive; |
| } |
| |
| void SetBuildType(bool is_official) { |
| force_build_type_ = true; |
| forced_official_build_ = is_official; |
| } |
| |
| void set_check_certificate( |
| CertificateChecker::ServerToCheck check_certificate) { |
| check_certificate_ = check_certificate; |
| } |
| |
| virtual size_t GetBytesDownloaded() { |
| return static_cast<size_t>(bytes_downloaded_); |
| } |
| |
| private: |
| // Callback for when proxy resolution has completed. This begins the |
| // transfer. |
| void ProxiesResolved(); |
| |
| // Asks libcurl for the http response code and stores it in the object. |
| void GetHttpResponseCode(); |
| |
| // Checks whether stored HTTP response is within the success range. |
| inline bool IsHttpResponseSuccess() { |
| return (http_response_code_ >= 200 && http_response_code_ < 300); |
| } |
| |
| // Checks whether stored HTTP response is within the error range. This |
| // includes both errors with the request (4xx) and server errors (5xx). |
| inline bool IsHttpResponseError() { |
| return (http_response_code_ >= 400 && http_response_code_ < 600); |
| } |
| |
| // Resumes a transfer where it left off. This will use the |
| // HTTP Range: header to make a new connection from where the last |
| // left off. |
| virtual void ResumeTransfer(const std::string& url); |
| |
| // These two methods are for glib main loop callbacks. They are called |
| // when either a file descriptor is ready for work or when a timer |
| // has fired. The static versions are shims for libcurl which has a C API. |
| bool FDCallback(GIOChannel *source, GIOCondition condition); |
| static gboolean StaticFDCallback(GIOChannel *source, |
| GIOCondition condition, |
| gpointer data) { |
| return reinterpret_cast<LibcurlHttpFetcher*>(data)->FDCallback(source, |
| condition); |
| } |
| gboolean TimeoutCallback(); |
| static gboolean StaticTimeoutCallback(gpointer data) { |
| return reinterpret_cast<LibcurlHttpFetcher*>(data)->TimeoutCallback(); |
| } |
| |
| gboolean RetryTimeoutCallback(); |
| static gboolean StaticRetryTimeoutCallback(void* arg) { |
| return static_cast<LibcurlHttpFetcher*>(arg)->RetryTimeoutCallback(); |
| } |
| |
| // Calls into curl_multi_perform to let libcurl do its work. Returns after |
| // curl_multi_perform is finished, which may actually be after more than |
| // one call to curl_multi_perform. This method will set up the glib run |
| // loop with sources for future work that libcurl will do. |
| // This method will not block. |
| // Returns true if we should resume immediately after this call. |
| void CurlPerformOnce(); |
| |
| // Sets up glib main loop sources as needed by libcurl. This is generally |
| // the file descriptor of the socket and a timer in case nothing happens |
| // on the fds. |
| void SetupMainloopSources(); |
| |
| // Callback called by libcurl when new data has arrived on the transfer |
| size_t LibcurlWrite(void *ptr, size_t size, size_t nmemb); |
| static size_t StaticLibcurlWrite(void *ptr, size_t size, |
| size_t nmemb, void *stream) { |
| return reinterpret_cast<LibcurlHttpFetcher*>(stream)-> |
| LibcurlWrite(ptr, size, nmemb); |
| } |
| |
| // Cleans up the following if they are non-null: |
| // curl(m) handles, io_channels_, timeout_source_. |
| void CleanUp(); |
| |
| // Force terminate the transfer. This will invoke the delegate's (if any) |
| // TransferTerminated callback so, after returning, this fetcher instance may |
| // be destroyed. |
| void ForceTransferTermination(); |
| |
| // Returns whether or not the current network connection is considered |
| // expensive. |
| bool ConnectionIsExpensive() const; |
| |
| // Returns whether or not the current build is official. |
| bool IsOfficialBuild() const; |
| |
| // Handles for the libcurl library |
| CURLM *curl_multi_handle_; |
| CURL *curl_handle_; |
| |
| // Lists of all read(0)/write(1) file descriptors that we're waiting on from |
| // the glib main loop. libcurl may open/close descriptors and switch their |
| // directions so maintain two separate lists so that watch conditions can be |
| // set appropriately. |
| typedef std::map<int, std::pair<GIOChannel*, guint> > IOChannels; |
| IOChannels io_channels_[2]; |
| |
| // if non-NULL, a timer we're waiting on. glib main loop will call us back |
| // when it fires. |
| GSource* timeout_source_; |
| |
| bool transfer_in_progress_; |
| |
| // The transfer size. -1 if not known. |
| off_t transfer_size_; |
| |
| // How many bytes have been downloaded and sent to the delegate. |
| off_t bytes_downloaded_; |
| |
| // The remaining maximum number of bytes to download. Zero represents an |
| // unspecified length. |
| size_t download_length_; |
| |
| // If we resumed an earlier transfer, data offset that we used for the |
| // new connection. 0 otherwise. |
| // In this class, resume refers to resuming a dropped HTTP connection, |
| // not to resuming an interrupted download. |
| off_t resume_offset_; |
| |
| // Number of resumes performed. |
| int retry_count_; |
| |
| // Seconds to wait before retrying a resume. |
| int retry_seconds_; |
| |
| // Number of resumes due to no network (e.g., HTTP response code 0). |
| int no_network_retry_count_; |
| int no_network_max_retries_; |
| |
| // Seconds to wait before asking libcurl to "perform". |
| int idle_seconds_; |
| |
| // If true, assume the network is expensive or not, according to |
| // forced_expensive_connection_. (Useful for testing). |
| bool force_connection_type_; |
| bool forced_expensive_connection_; |
| |
| // If true, assume the build is official or not, according to |
| // forced_official_build_. Useful for testing. |
| bool force_build_type_; |
| bool forced_official_build_; |
| |
| // If true, we are currently performing a write callback on the delegate. |
| bool in_write_callback_; |
| |
| // If true, we have returned at least one byte in the write callback |
| // to the delegate. |
| bool sent_byte_; |
| |
| // We can't clean everything up while we're in a write callback, so |
| // if we get a terminate request, queue it until we can handle it. |
| bool terminate_requested_; |
| |
| // Represents which server certificate to be checked against this |
| // connection's certificate. If no certificate check needs to be performed, |
| // this should be kNone. |
| CertificateChecker::ServerToCheck check_certificate_; |
| |
| DISALLOW_COPY_AND_ASSIGN(LibcurlHttpFetcher); |
| }; |
| |
| } // namespace chromeos_update_engine |
| |
| #endif // CHROMEOS_PLATFORM_UPDATE_ENGINE_LIBCURL_HTTP_FETCHER_H__ |