1 // Copyright (c) 2012 The Chromium 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 5 #ifndef NET_HTTP_HTTP_NETWORK_TRANSACTION_H_ 6 #define NET_HTTP_HTTP_NETWORK_TRANSACTION_H_ 7 8 #include <string> 9 10 #include "base/basictypes.h" 11 #include "base/gtest_prod_util.h" 12 #include "base/memory/ref_counted.h" 13 #include "base/memory/scoped_ptr.h" 14 #include "base/time/time.h" 15 #include "net/base/net_log.h" 16 #include "net/base/request_priority.h" 17 #include "net/http/http_auth.h" 18 #include "net/http/http_request_headers.h" 19 #include "net/http/http_response_info.h" 20 #include "net/http/http_stream_factory.h" 21 #include "net/http/http_transaction.h" 22 #include "net/proxy/proxy_service.h" 23 #include "net/ssl/ssl_config_service.h" 24 #include "net/websockets/websocket_handshake_stream_base.h" 25 26 namespace net { 27 28 class ClientSocketHandle; 29 class HttpAuthController; 30 class HttpNetworkSession; 31 class HttpStreamBase; 32 class HttpStreamRequest; 33 class IOBuffer; 34 class ProxyInfo; 35 class SpdySession; 36 struct HttpRequestInfo; 37 38 class NET_EXPORT_PRIVATE HttpNetworkTransaction 39 : public HttpTransaction, 40 public HttpStreamRequest::Delegate { 41 public: 42 HttpNetworkTransaction(RequestPriority priority, 43 HttpNetworkSession* session); 44 45 virtual ~HttpNetworkTransaction(); 46 47 // HttpTransaction methods: 48 virtual int Start(const HttpRequestInfo* request_info, 49 const CompletionCallback& callback, 50 const BoundNetLog& net_log) OVERRIDE; 51 virtual int RestartIgnoringLastError( 52 const CompletionCallback& callback) OVERRIDE; 53 virtual int RestartWithCertificate( 54 X509Certificate* client_cert, 55 const CompletionCallback& callback) OVERRIDE; 56 virtual int RestartWithAuth(const AuthCredentials& credentials, 57 const CompletionCallback& callback) OVERRIDE; 58 virtual bool IsReadyToRestartForAuth() OVERRIDE; 59 60 virtual int Read(IOBuffer* buf, 61 int buf_len, 62 const CompletionCallback& callback) OVERRIDE; 63 virtual void StopCaching() OVERRIDE; 64 virtual bool GetFullRequestHeaders( 65 HttpRequestHeaders* headers) const OVERRIDE; 66 virtual int64 GetTotalReceivedBytes() const OVERRIDE; 67 virtual void DoneReading() OVERRIDE; 68 virtual const HttpResponseInfo* GetResponseInfo() const OVERRIDE; 69 virtual LoadState GetLoadState() const OVERRIDE; 70 virtual UploadProgress GetUploadProgress() const OVERRIDE; 71 virtual void SetQuicServerInfo(QuicServerInfo* quic_server_info) OVERRIDE; 72 virtual bool GetLoadTimingInfo( 73 LoadTimingInfo* load_timing_info) const OVERRIDE; 74 virtual void SetPriority(RequestPriority priority) OVERRIDE; 75 virtual void SetWebSocketHandshakeStreamCreateHelper( 76 WebSocketHandshakeStreamBase::CreateHelper* create_helper) OVERRIDE; 77 virtual void SetBeforeNetworkStartCallback( 78 const BeforeNetworkStartCallback& callback) OVERRIDE; 79 virtual void SetBeforeProxyHeadersSentCallback( 80 const BeforeProxyHeadersSentCallback& callback) OVERRIDE; 81 virtual int ResumeNetworkStart() OVERRIDE; 82 83 // HttpStreamRequest::Delegate methods: 84 virtual void OnStreamReady(const SSLConfig& used_ssl_config, 85 const ProxyInfo& used_proxy_info, 86 HttpStreamBase* stream) OVERRIDE; 87 virtual void OnWebSocketHandshakeStreamReady( 88 const SSLConfig& used_ssl_config, 89 const ProxyInfo& used_proxy_info, 90 WebSocketHandshakeStreamBase* stream) OVERRIDE; 91 virtual void OnStreamFailed(int status, 92 const SSLConfig& used_ssl_config) OVERRIDE; 93 virtual void OnCertificateError(int status, 94 const SSLConfig& used_ssl_config, 95 const SSLInfo& ssl_info) OVERRIDE; 96 virtual void OnNeedsProxyAuth( 97 const HttpResponseInfo& response_info, 98 const SSLConfig& used_ssl_config, 99 const ProxyInfo& used_proxy_info, 100 HttpAuthController* auth_controller) OVERRIDE; 101 virtual void OnNeedsClientAuth(const SSLConfig& used_ssl_config, 102 SSLCertRequestInfo* cert_info) OVERRIDE; 103 virtual void OnHttpsProxyTunnelResponse(const HttpResponseInfo& response_info, 104 const SSLConfig& used_ssl_config, 105 const ProxyInfo& used_proxy_info, 106 HttpStreamBase* stream) OVERRIDE; 107 108 private: 109 friend class HttpNetworkTransactionSSLTest; 110 111 FRIEND_TEST_ALL_PREFIXES(HttpNetworkTransactionTest, 112 ResetStateForRestart); 113 FRIEND_TEST_ALL_PREFIXES(SpdyNetworkTransactionTest, 114 WindowUpdateReceived); 115 FRIEND_TEST_ALL_PREFIXES(SpdyNetworkTransactionTest, 116 WindowUpdateSent); 117 FRIEND_TEST_ALL_PREFIXES(SpdyNetworkTransactionTest, 118 WindowUpdateOverflow); 119 FRIEND_TEST_ALL_PREFIXES(SpdyNetworkTransactionTest, 120 FlowControlStallResume); 121 FRIEND_TEST_ALL_PREFIXES(SpdyNetworkTransactionTest, 122 FlowControlStallResumeAfterSettings); 123 FRIEND_TEST_ALL_PREFIXES(SpdyNetworkTransactionTest, 124 FlowControlNegativeSendWindowSize); 125 126 enum State { 127 STATE_NOTIFY_BEFORE_CREATE_STREAM, 128 STATE_CREATE_STREAM, 129 STATE_CREATE_STREAM_COMPLETE, 130 STATE_INIT_STREAM, 131 STATE_INIT_STREAM_COMPLETE, 132 STATE_GENERATE_PROXY_AUTH_TOKEN, 133 STATE_GENERATE_PROXY_AUTH_TOKEN_COMPLETE, 134 STATE_GENERATE_SERVER_AUTH_TOKEN, 135 STATE_GENERATE_SERVER_AUTH_TOKEN_COMPLETE, 136 STATE_INIT_REQUEST_BODY, 137 STATE_INIT_REQUEST_BODY_COMPLETE, 138 STATE_BUILD_REQUEST, 139 STATE_BUILD_REQUEST_COMPLETE, 140 STATE_SEND_REQUEST, 141 STATE_SEND_REQUEST_COMPLETE, 142 STATE_READ_HEADERS, 143 STATE_READ_HEADERS_COMPLETE, 144 STATE_READ_BODY, 145 STATE_READ_BODY_COMPLETE, 146 STATE_DRAIN_BODY_FOR_AUTH_RESTART, 147 STATE_DRAIN_BODY_FOR_AUTH_RESTART_COMPLETE, 148 STATE_NONE 149 }; 150 151 bool is_https_request() const; 152 153 void DoCallback(int result); 154 void OnIOComplete(int result); 155 156 // Runs the state transition loop. 157 int DoLoop(int result); 158 159 // Each of these methods corresponds to a State value. Those with an input 160 // argument receive the result from the previous state. If a method returns 161 // ERR_IO_PENDING, then the result from OnIOComplete will be passed to the 162 // next state method as the result arg. 163 int DoNotifyBeforeCreateStream(); 164 int DoCreateStream(); 165 int DoCreateStreamComplete(int result); 166 int DoInitStream(); 167 int DoInitStreamComplete(int result); 168 int DoGenerateProxyAuthToken(); 169 int DoGenerateProxyAuthTokenComplete(int result); 170 int DoGenerateServerAuthToken(); 171 int DoGenerateServerAuthTokenComplete(int result); 172 int DoInitRequestBody(); 173 int DoInitRequestBodyComplete(int result); 174 int DoBuildRequest(); 175 int DoBuildRequestComplete(int result); 176 int DoSendRequest(); 177 int DoSendRequestComplete(int result); 178 int DoReadHeaders(); 179 int DoReadHeadersComplete(int result); 180 int DoReadBody(); 181 int DoReadBodyComplete(int result); 182 int DoDrainBodyForAuthRestart(); 183 int DoDrainBodyForAuthRestartComplete(int result); 184 185 void BuildRequestHeaders(bool using_proxy); 186 187 // Record histogram of time until first byte of header is received. 188 void LogTransactionConnectedMetrics(); 189 190 // Record histogram of latency (durations until last byte received). 191 void LogTransactionMetrics() const; 192 193 // Writes a log message to help debugging in the field when we block a proxy 194 // response to a CONNECT request. 195 void LogBlockedTunnelResponse(int response_code) const; 196 197 // Called to handle a client certificate request. 198 int HandleCertificateRequest(int error); 199 200 // Called to possibly handle a client authentication error. 201 void HandleClientAuthError(int error); 202 203 // Called to possibly recover from an SSL handshake error. Sets next_state_ 204 // and returns OK if recovering from the error. Otherwise, the same error 205 // code is returned. 206 int HandleSSLHandshakeError(int error); 207 208 // Called to possibly recover from the given error. Sets next_state_ and 209 // returns OK if recovering from the error. Otherwise, the same error code 210 // is returned. 211 int HandleIOError(int error); 212 213 // Gets the response headers from the HttpStream. 214 HttpResponseHeaders* GetResponseHeaders() const; 215 216 // Called when the socket is unexpectedly closed. Returns true if the request 217 // should be resent in case of a socket reuse/close race. 218 bool ShouldResendRequest() const; 219 220 // Resets the connection and the request headers for resend. Called when 221 // ShouldResendRequest() is true. 222 void ResetConnectionAndRequestForResend(); 223 224 // Sets up the state machine to restart the transaction with auth. 225 void PrepareForAuthRestart(HttpAuth::Target target); 226 227 // Called when we don't need to drain the response body or have drained it. 228 // Resets |connection_| unless |keep_alive| is true, then calls 229 // ResetStateForRestart. Sets |next_state_| appropriately. 230 void DidDrainBodyForAuthRestart(bool keep_alive); 231 232 // Resets the members of the transaction so it can be restarted. 233 void ResetStateForRestart(); 234 235 // Resets the members of the transaction, except |stream_|, which needs 236 // to be maintained for multi-round auth. 237 void ResetStateForAuthRestart(); 238 239 // Returns true if we should try to add a Proxy-Authorization header 240 bool ShouldApplyProxyAuth() const; 241 242 // Returns true if we should try to add an Authorization header. 243 bool ShouldApplyServerAuth() const; 244 245 // Handles HTTP status code 401 or 407. 246 // HandleAuthChallenge() returns a network error code, or OK on success. 247 // May update |pending_auth_target_| or |response_.auth_challenge|. 248 int HandleAuthChallenge(); 249 250 // Returns true if we have auth credentials for the given target. 251 bool HaveAuth(HttpAuth::Target target) const; 252 253 // Get the {scheme, host, path, port} for the authentication target 254 GURL AuthURL(HttpAuth::Target target) const; 255 256 // Returns true if this transaction is for a WebSocket handshake 257 bool ForWebSocketHandshake() const; 258 259 // Debug helper. 260 static std::string DescribeState(State state); 261 262 void SetStream(HttpStreamBase* stream); 263 264 scoped_refptr<HttpAuthController> 265 auth_controllers_[HttpAuth::AUTH_NUM_TARGETS]; 266 267 // Whether this transaction is waiting for proxy auth, server auth, or is 268 // not waiting for any auth at all. |pending_auth_target_| is read and 269 // cleared by RestartWithAuth(). 270 HttpAuth::Target pending_auth_target_; 271 272 CompletionCallback io_callback_; 273 CompletionCallback callback_; 274 275 HttpNetworkSession* session_; 276 277 BoundNetLog net_log_; 278 const HttpRequestInfo* request_; 279 RequestPriority priority_; 280 HttpResponseInfo response_; 281 282 // |proxy_info_| is the ProxyInfo used by the HttpStreamRequest. 283 ProxyInfo proxy_info_; 284 285 scoped_ptr<HttpStreamRequest> stream_request_; 286 scoped_ptr<HttpStreamBase> stream_; 287 288 // True if we've validated the headers that the stream parser has returned. 289 bool headers_valid_; 290 291 // True if we've logged the time of the first response byte. Used to 292 // prevent logging across authentication activity where we see multiple 293 // responses. 294 bool logged_response_time_; 295 296 SSLConfig server_ssl_config_; 297 SSLConfig proxy_ssl_config_; 298 // fallback_error_code contains the error code that caused the last TLS 299 // fallback. If the fallback connection results in 300 // ERR_SSL_INAPPROPRIATE_FALLBACK (i.e. the server indicated that the 301 // fallback should not have been needed) then we use this value to return the 302 // original error that triggered the fallback. 303 int fallback_error_code_; 304 305 HttpRequestHeaders request_headers_; 306 307 // The size in bytes of the buffer we use to drain the response body that 308 // we want to throw away. The response body is typically a small error 309 // page just a few hundred bytes long. 310 static const int kDrainBodyBufferSize = 1024; 311 312 // User buffer and length passed to the Read method. 313 scoped_refptr<IOBuffer> read_buf_; 314 int read_buf_len_; 315 316 // Total number of bytes received on streams for this transaction. 317 int64 total_received_bytes_; 318 319 // The time the Start method was called. 320 base::Time start_time_; 321 322 // When the transaction started / finished sending the request, including 323 // the body, if present. 324 base::TimeTicks send_start_time_; 325 base::TimeTicks send_end_time_; 326 327 // The next state in the state machine. 328 State next_state_; 329 330 // True when the tunnel is in the process of being established - we can't 331 // read from the socket until the tunnel is done. 332 bool establishing_tunnel_; 333 334 // The helper object to use to create WebSocketHandshakeStreamBase 335 // objects. Only relevant when establishing a WebSocket connection. 336 WebSocketHandshakeStreamBase::CreateHelper* 337 websocket_handshake_stream_base_create_helper_; 338 339 BeforeNetworkStartCallback before_network_start_callback_; 340 BeforeProxyHeadersSentCallback before_proxy_headers_sent_callback_; 341 342 DISALLOW_COPY_AND_ASSIGN(HttpNetworkTransaction); 343 }; 344 345 } // namespace net 346 347 #endif // NET_HTTP_HTTP_NETWORK_TRANSACTION_H_ 348