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 #ifndef UPDATE_ENGINE_COMMON_HTTP_FETCHER_H_ 18 #define UPDATE_ENGINE_COMMON_HTTP_FETCHER_H_ 19 20 #include <deque> 21 #include <string> 22 #include <vector> 23 24 #include <base/callback.h> 25 #include <base/logging.h> 26 #include <base/macros.h> 27 #include <brillo/message_loops/message_loop.h> 28 29 #include "update_engine/common/http_common.h" 30 #include "update_engine/proxy_resolver.h" 31 32 // This class is a simple wrapper around an HTTP library (libcurl). We can 33 // easily mock out this interface for testing. 34 35 // Implementations of this class should use asynchronous i/o. They can access 36 // the MessageLoop to request callbacks when timers or file descriptors change. 37 38 namespace chromeos_update_engine { 39 40 class HttpFetcherDelegate; 41 42 class HttpFetcher { 43 public: 44 // |proxy_resolver| is the resolver that will be consulted for proxy 45 // settings. It may be null, in which case direct connections will 46 // be used. Does not take ownership of the resolver. 47 explicit HttpFetcher(ProxyResolver* proxy_resolver) 48 : post_data_set_(false), 49 http_response_code_(0), 50 delegate_(nullptr), 51 proxies_(1, kNoProxy), 52 proxy_resolver_(proxy_resolver), 53 callback_(nullptr) {} 54 virtual ~HttpFetcher(); 55 56 void set_delegate(HttpFetcherDelegate* delegate) { delegate_ = delegate; } 57 HttpFetcherDelegate* delegate() const { return delegate_; } 58 int http_response_code() const { return http_response_code_; } 59 60 // Optional: Post data to the server. The HttpFetcher should make a copy 61 // of this data and upload it via HTTP POST during the transfer. The type of 62 // the data is necessary for properly setting the Content-Type HTTP header. 63 void SetPostData(const void* data, size_t size, HttpContentType type); 64 65 // Same without a specified Content-Type. 66 void SetPostData(const void* data, size_t size); 67 68 // Proxy methods to set the proxies, then to pop them off. 69 void ResolveProxiesForUrl(const std::string& url, 70 const base::Closure& callback); 71 72 void SetProxies(const std::deque<std::string>& proxies) { 73 proxies_ = proxies; 74 } 75 const std::string& GetCurrentProxy() const { 76 return proxies_.front(); 77 } 78 bool HasProxy() const { return !proxies_.empty(); } 79 void PopProxy() { proxies_.pop_front(); } 80 81 // Downloading should resume from this offset 82 virtual void SetOffset(off_t offset) = 0; 83 84 // Set/unset the length of the range to be downloaded. 85 virtual void SetLength(size_t length) = 0; 86 virtual void UnsetLength() = 0; 87 88 // Begins the transfer to the specified URL. This fetcher instance should not 89 // be destroyed until either TransferComplete, or TransferTerminated is 90 // called. 91 virtual void BeginTransfer(const std::string& url) = 0; 92 93 // Aborts the transfer. The transfer may not abort right away -- delegate's 94 // TransferTerminated() will be called when the transfer is actually done. 95 virtual void TerminateTransfer() = 0; 96 97 // Add or update a custom header to be sent with every request. If the same 98 // |header_name| is passed twice, the second |header_value| would override the 99 // previous value. 100 virtual void SetHeader(const std::string& header_name, 101 const std::string& header_value) = 0; 102 103 // If data is coming in too quickly, you can call Pause() to pause the 104 // transfer. The delegate will not have ReceivedBytes() called while 105 // an HttpFetcher is paused. 106 virtual void Pause() = 0; 107 108 // Used to unpause an HttpFetcher and let the bytes stream in again. 109 // If a delegate is set, ReceivedBytes() may be called on it before 110 // Unpause() returns 111 virtual void Unpause() = 0; 112 113 // These two function are overloaded in LibcurlHttp fetcher to speed 114 // testing. 115 virtual void set_idle_seconds(int seconds) {} 116 virtual void set_retry_seconds(int seconds) {} 117 118 // Sets the values used to time out the connection if the transfer 119 // rate is less than |low_speed_bps| bytes/sec for more than 120 // |low_speed_sec| seconds. 121 virtual void set_low_speed_limit(int low_speed_bps, int low_speed_sec) = 0; 122 123 // Sets the connect timeout, e.g. the maximum amount of time willing 124 // to wait for establishing a connection to the server. 125 virtual void set_connect_timeout(int connect_timeout_seconds) = 0; 126 127 // Sets the number of allowed retries. 128 virtual void set_max_retry_count(int max_retry_count) = 0; 129 130 // Get the total number of bytes downloaded by fetcher. 131 virtual size_t GetBytesDownloaded() = 0; 132 133 ProxyResolver* proxy_resolver() const { return proxy_resolver_; } 134 135 protected: 136 // Cancels a proxy resolution in progress. The callback passed to 137 // ResolveProxiesForUrl() will not be called. Returns whether there was a 138 // pending proxy resolution to be canceled. 139 bool CancelProxyResolution(); 140 141 // The URL we're actively fetching from 142 std::string url_; 143 144 // POST data for the transfer, and whether or not it was ever set 145 bool post_data_set_; 146 brillo::Blob post_data_; 147 HttpContentType post_content_type_; 148 149 // The server's HTTP response code from the last transfer. This 150 // field should be set to 0 when a new transfer is initiated, and 151 // set to the response code when the transfer is complete. 152 int http_response_code_; 153 154 // The delegate; may be null. 155 HttpFetcherDelegate* delegate_; 156 157 // Proxy servers 158 std::deque<std::string> proxies_; 159 160 ProxyResolver* const proxy_resolver_; 161 162 // The ID of the idle callback, used when we have no proxy resolver. 163 brillo::MessageLoop::TaskId no_resolver_idle_id_{ 164 brillo::MessageLoop::kTaskIdNull}; 165 166 // Callback for when we are resolving proxies 167 std::unique_ptr<base::Closure> callback_; 168 169 private: 170 // Callback from the proxy resolver 171 void ProxiesResolved(const std::deque<std::string>& proxies); 172 173 // Callback used to run the proxy resolver callback when there is no 174 // |proxy_resolver_|. 175 void NoProxyResolverCallback(); 176 177 // Stores the ongoing proxy request id if there is one, otherwise 178 // kProxyRequestIdNull. 179 ProxyRequestId proxy_request_{kProxyRequestIdNull}; 180 181 DISALLOW_COPY_AND_ASSIGN(HttpFetcher); 182 }; 183 184 // Interface for delegates 185 class HttpFetcherDelegate { 186 public: 187 virtual ~HttpFetcherDelegate() = default; 188 189 // Called every time bytes are received. 190 virtual void ReceivedBytes(HttpFetcher* fetcher, 191 const void* bytes, 192 size_t length) = 0; 193 194 // Called if the fetcher seeks to a particular offset. 195 virtual void SeekToOffset(off_t offset) {} 196 197 // When a transfer has completed, exactly one of these two methods will be 198 // called. TransferTerminated is called when the transfer has been aborted 199 // through TerminateTransfer. TransferComplete is called in all other 200 // situations. It's OK to destroy the |fetcher| object in this callback. 201 virtual void TransferComplete(HttpFetcher* fetcher, bool successful) = 0; 202 virtual void TransferTerminated(HttpFetcher* fetcher) {} 203 }; 204 205 } // namespace chromeos_update_engine 206 207 #endif // UPDATE_ENGINE_COMMON_HTTP_FETCHER_H_ 208
