blob: 5884e082b8f86c529d5c219d0ae1f072ee30aa0a [file] [log] [blame]
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "net/socket/client_socket_pool_manager.h"
#include <string>
#include "base/basictypes.h"
#include "base/logging.h"
#include "base/stringprintf.h"
#include "net/base/load_flags.h"
#include "net/http/http_proxy_client_socket_pool.h"
#include "net/http/http_request_info.h"
#include "net/http/http_stream_factory.h"
#include "net/proxy/proxy_info.h"
#include "net/socket/client_socket_handle.h"
#include "net/socket/socks_client_socket_pool.h"
#include "net/socket/ssl_client_socket_pool.h"
#include "net/socket/transport_client_socket_pool.h"
namespace net {
namespace {
// Limit of sockets of each socket pool.
int g_max_sockets_per_pool[] = {
256, // NORMAL_SOCKET_POOL
256 // WEBSOCKET_SOCKET_POOL
};
COMPILE_ASSERT(arraysize(g_max_sockets_per_pool) ==
HttpNetworkSession::NUM_SOCKET_POOL_TYPES,
max_sockets_per_pool_length_mismatch);
// Default to allow up to 6 connections per host. Experiment and tuning may
// try other values (greater than 0). Too large may cause many problems, such
// as home routers blocking the connections!?!? See http://crbug.com/12066.
//
// WebSocket connections are long-lived, and should be treated differently
// than normal other connections. 6 connections per group sounded too small
// for such use, thus we use a larger limit which was determined somewhat
// arbitrarily.
// TODO(yutak): Look at the usage and determine the right value after
// WebSocket protocol stack starts to work.
int g_max_sockets_per_group[] = {
6, // NORMAL_SOCKET_POOL
30 // WEBSOCKET_SOCKET_POOL
};
COMPILE_ASSERT(arraysize(g_max_sockets_per_group) ==
HttpNetworkSession::NUM_SOCKET_POOL_TYPES,
max_sockets_per_group_length_mismatch);
// The max number of sockets to allow per proxy server. This applies both to
// http and SOCKS proxies. See http://crbug.com/12066 and
// http://crbug.com/44501 for details about proxy server connection limits.
int g_max_sockets_per_proxy_server[] = {
kDefaultMaxSocketsPerProxyServer, // NORMAL_SOCKET_POOL
kDefaultMaxSocketsPerProxyServer // WEBSOCKET_SOCKET_POOL
};
COMPILE_ASSERT(arraysize(g_max_sockets_per_proxy_server) ==
HttpNetworkSession::NUM_SOCKET_POOL_TYPES,
max_sockets_per_proxy_server_length_mismatch);
// The meat of the implementation for the InitSocketHandleForHttpRequest,
// InitSocketHandleForRawConnect and PreconnectSocketsForHttpRequest methods.
int InitSocketPoolHelper(const GURL& request_url,
const HttpRequestHeaders& request_extra_headers,
int request_load_flags,
RequestPriority request_priority,
HttpNetworkSession* session,
const ProxyInfo& proxy_info,
bool force_spdy_over_ssl,
bool want_spdy_over_npn,
const SSLConfig& ssl_config_for_origin,
const SSLConfig& ssl_config_for_proxy,
bool force_tunnel,
const BoundNetLog& net_log,
int num_preconnect_streams,
ClientSocketHandle* socket_handle,
const OnHostResolutionCallback& resolution_callback,
const CompletionCallback& callback) {
scoped_refptr<TransportSocketParams> tcp_params;
scoped_refptr<HttpProxySocketParams> http_proxy_params;
scoped_refptr<SOCKSSocketParams> socks_params;
scoped_ptr<HostPortPair> proxy_host_port;
bool using_ssl = request_url.SchemeIs("https") || force_spdy_over_ssl;
HostPortPair origin_host_port =
HostPortPair(request_url.HostNoBrackets(),
request_url.EffectiveIntPort());
if (!using_ssl && session->params().testing_fixed_http_port != 0) {
origin_host_port.set_port(session->params().testing_fixed_http_port);
} else if (using_ssl && session->params().testing_fixed_https_port != 0) {
origin_host_port.set_port(session->params().testing_fixed_https_port);
}
bool disable_resolver_cache =
request_load_flags & LOAD_BYPASS_CACHE ||
request_load_flags & LOAD_VALIDATE_CACHE ||
request_load_flags & LOAD_DISABLE_CACHE;
int load_flags = request_load_flags;
if (session->params().ignore_certificate_errors)
load_flags |= LOAD_IGNORE_ALL_CERT_ERRORS;
// Build the string used to uniquely identify connections of this type.
// Determine the host and port to connect to.
std::string connection_group = origin_host_port.ToString();
DCHECK(!connection_group.empty());
if (using_ssl) {
// All connections in a group should use the same SSLConfig settings.
// Encode version_max in the connection group's name, unless it's the
// default version_max. (We want the common case to use the shortest
// encoding). A version_max of TLS 1.1 is encoded as "ssl(max:3.2)/"
// rather than "tlsv1.1/" because the actual protocol version, which
// is selected by the server, may not be TLS 1.1. Do not encode
// version_min in the connection group's name because version_min
// should be the same for all connections, whereas version_max may
// change for version fallbacks.
std::string prefix = "ssl/";
if (ssl_config_for_origin.version_max !=
SSLConfigService::default_version_max()) {
switch (ssl_config_for_origin.version_max) {
case SSL_PROTOCOL_VERSION_TLS1_2:
prefix = "ssl(max:3.3)/";
break;
case SSL_PROTOCOL_VERSION_TLS1_1:
prefix = "ssl(max:3.2)/";
break;
case SSL_PROTOCOL_VERSION_TLS1:
prefix = "ssl(max:3.1)/";
break;
case SSL_PROTOCOL_VERSION_SSL3:
prefix = "sslv3/";
break;
default:
CHECK(false);
break;
}
}
connection_group = prefix + connection_group;
}
bool ignore_limits = (request_load_flags & LOAD_IGNORE_LIMITS) != 0;
if (proxy_info.is_direct()) {
tcp_params = new TransportSocketParams(origin_host_port,
request_priority,
disable_resolver_cache,
ignore_limits,
resolution_callback);
} else {
ProxyServer proxy_server = proxy_info.proxy_server();
proxy_host_port.reset(new HostPortPair(proxy_server.host_port_pair()));
scoped_refptr<TransportSocketParams> proxy_tcp_params(
new TransportSocketParams(*proxy_host_port,
request_priority,
disable_resolver_cache,
ignore_limits,
resolution_callback));
if (proxy_info.is_http() || proxy_info.is_https()) {
std::string user_agent;
request_extra_headers.GetHeader(HttpRequestHeaders::kUserAgent,
&user_agent);
scoped_refptr<SSLSocketParams> ssl_params;
if (proxy_info.is_https()) {
// Set ssl_params, and unset proxy_tcp_params
ssl_params = new SSLSocketParams(proxy_tcp_params,
NULL,
NULL,
ProxyServer::SCHEME_DIRECT,
*proxy_host_port.get(),
ssl_config_for_proxy,
load_flags,
force_spdy_over_ssl,
want_spdy_over_npn);
proxy_tcp_params = NULL;
}
http_proxy_params =
new HttpProxySocketParams(proxy_tcp_params,
ssl_params,
request_url,
user_agent,
origin_host_port,
session->http_auth_cache(),
session->http_auth_handler_factory(),
session->spdy_session_pool(),
force_tunnel || using_ssl);
} else {
DCHECK(proxy_info.is_socks());
char socks_version;
if (proxy_server.scheme() == ProxyServer::SCHEME_SOCKS5)
socks_version = '5';
else
socks_version = '4';
connection_group = base::StringPrintf(
"socks%c/%s", socks_version, connection_group.c_str());
socks_params = new SOCKSSocketParams(proxy_tcp_params,
socks_version == '5',
origin_host_port,
request_priority);
}
}
// Deal with SSL - which layers on top of any given proxy.
if (using_ssl) {
scoped_refptr<SSLSocketParams> ssl_params =
new SSLSocketParams(tcp_params,
socks_params,
http_proxy_params,
proxy_info.proxy_server().scheme(),
origin_host_port,
ssl_config_for_origin,
load_flags,
force_spdy_over_ssl,
want_spdy_over_npn);
SSLClientSocketPool* ssl_pool = NULL;
if (proxy_info.is_direct()) {
ssl_pool = session->GetSSLSocketPool(
HttpNetworkSession::NORMAL_SOCKET_POOL);
} else {
ssl_pool = session->GetSocketPoolForSSLWithProxy(
HttpNetworkSession::NORMAL_SOCKET_POOL,
*proxy_host_port);
}
if (num_preconnect_streams) {
RequestSocketsForPool(ssl_pool, connection_group, ssl_params,
num_preconnect_streams, net_log);
return OK;
}
return socket_handle->Init(connection_group, ssl_params,
request_priority, callback, ssl_pool,
net_log);
}
// Finally, get the connection started.
if (proxy_info.is_http() || proxy_info.is_https()) {
HttpProxyClientSocketPool* pool =
session->GetSocketPoolForHTTPProxy(
HttpNetworkSession::NORMAL_SOCKET_POOL,
*proxy_host_port);
if (num_preconnect_streams) {
RequestSocketsForPool(pool, connection_group, http_proxy_params,
num_preconnect_streams, net_log);
return OK;
}
return socket_handle->Init(connection_group, http_proxy_params,
request_priority, callback,
pool, net_log);
}
if (proxy_info.is_socks()) {
SOCKSClientSocketPool* pool =
session->GetSocketPoolForSOCKSProxy(
HttpNetworkSession::NORMAL_SOCKET_POOL,
*proxy_host_port);
if (num_preconnect_streams) {
RequestSocketsForPool(pool, connection_group, socks_params,
num_preconnect_streams, net_log);
return OK;
}
return socket_handle->Init(connection_group, socks_params,
request_priority, callback, pool,
net_log);
}
DCHECK(proxy_info.is_direct());
TransportClientSocketPool* pool =
session->GetTransportSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL);
if (num_preconnect_streams) {
RequestSocketsForPool(pool, connection_group, tcp_params,
num_preconnect_streams, net_log);
return OK;
}
return socket_handle->Init(connection_group, tcp_params,
request_priority, callback,
pool, net_log);
}
} // namespace
ClientSocketPoolManager::ClientSocketPoolManager() {}
ClientSocketPoolManager::~ClientSocketPoolManager() {}
// static
int ClientSocketPoolManager::max_sockets_per_pool(
HttpNetworkSession::SocketPoolType pool_type) {
DCHECK_LT(pool_type, HttpNetworkSession::NUM_SOCKET_POOL_TYPES);
return g_max_sockets_per_pool[pool_type];
}
// static
void ClientSocketPoolManager::set_max_sockets_per_pool(
HttpNetworkSession::SocketPoolType pool_type,
int socket_count) {
DCHECK_LT(0, socket_count);
DCHECK_GT(1000, socket_count); // Sanity check.
DCHECK_LT(pool_type, HttpNetworkSession::NUM_SOCKET_POOL_TYPES);
g_max_sockets_per_pool[pool_type] = socket_count;
DCHECK_GE(g_max_sockets_per_pool[pool_type],
g_max_sockets_per_group[pool_type]);
}
// static
int ClientSocketPoolManager::max_sockets_per_group(
HttpNetworkSession::SocketPoolType pool_type) {
DCHECK_LT(pool_type, HttpNetworkSession::NUM_SOCKET_POOL_TYPES);
return g_max_sockets_per_group[pool_type];
}
// static
void ClientSocketPoolManager::set_max_sockets_per_group(
HttpNetworkSession::SocketPoolType pool_type,
int socket_count) {
DCHECK_LT(0, socket_count);
// The following is a sanity check... but we should NEVER be near this value.
DCHECK_GT(100, socket_count);
DCHECK_LT(pool_type, HttpNetworkSession::NUM_SOCKET_POOL_TYPES);
g_max_sockets_per_group[pool_type] = socket_count;
DCHECK_GE(g_max_sockets_per_pool[pool_type],
g_max_sockets_per_group[pool_type]);
DCHECK_GE(g_max_sockets_per_proxy_server[pool_type],
g_max_sockets_per_group[pool_type]);
}
// static
int ClientSocketPoolManager::max_sockets_per_proxy_server(
HttpNetworkSession::SocketPoolType pool_type) {
DCHECK_LT(pool_type, HttpNetworkSession::NUM_SOCKET_POOL_TYPES);
return g_max_sockets_per_proxy_server[pool_type];
}
// static
void ClientSocketPoolManager::set_max_sockets_per_proxy_server(
HttpNetworkSession::SocketPoolType pool_type,
int socket_count) {
DCHECK_LT(0, socket_count);
DCHECK_GT(100, socket_count); // Sanity check.
DCHECK_LT(pool_type, HttpNetworkSession::NUM_SOCKET_POOL_TYPES);
// Assert this case early on. The max number of sockets per group cannot
// exceed the max number of sockets per proxy server.
DCHECK_LE(g_max_sockets_per_group[pool_type], socket_count);
g_max_sockets_per_proxy_server[pool_type] = socket_count;
}
int InitSocketHandleForHttpRequest(
const GURL& request_url,
const HttpRequestHeaders& request_extra_headers,
int request_load_flags,
RequestPriority request_priority,
HttpNetworkSession* session,
const ProxyInfo& proxy_info,
bool force_spdy_over_ssl,
bool want_spdy_over_npn,
const SSLConfig& ssl_config_for_origin,
const SSLConfig& ssl_config_for_proxy,
const BoundNetLog& net_log,
ClientSocketHandle* socket_handle,
const OnHostResolutionCallback& resolution_callback,
const CompletionCallback& callback) {
DCHECK(socket_handle);
return InitSocketPoolHelper(
request_url, request_extra_headers, request_load_flags, request_priority,
session, proxy_info, force_spdy_over_ssl, want_spdy_over_npn,
ssl_config_for_origin, ssl_config_for_proxy, false, net_log, 0,
socket_handle, resolution_callback, callback);
}
int InitSocketHandleForRawConnect(
const HostPortPair& host_port_pair,
HttpNetworkSession* session,
const ProxyInfo& proxy_info,
const SSLConfig& ssl_config_for_origin,
const SSLConfig& ssl_config_for_proxy,
const BoundNetLog& net_log,
ClientSocketHandle* socket_handle,
const CompletionCallback& callback) {
DCHECK(socket_handle);
// Synthesize an HttpRequestInfo.
GURL request_url = GURL("http://" + host_port_pair.ToString());
HttpRequestHeaders request_extra_headers;
int request_load_flags = 0;
RequestPriority request_priority = MEDIUM;
return InitSocketPoolHelper(
request_url, request_extra_headers, request_load_flags, request_priority,
session, proxy_info, false, false, ssl_config_for_origin,
ssl_config_for_proxy, true, net_log, 0, socket_handle,
OnHostResolutionCallback(), callback);
}
int PreconnectSocketsForHttpRequest(
const GURL& request_url,
const HttpRequestHeaders& request_extra_headers,
int request_load_flags,
RequestPriority request_priority,
HttpNetworkSession* session,
const ProxyInfo& proxy_info,
bool force_spdy_over_ssl,
bool want_spdy_over_npn,
const SSLConfig& ssl_config_for_origin,
const SSLConfig& ssl_config_for_proxy,
const BoundNetLog& net_log,
int num_preconnect_streams) {
return InitSocketPoolHelper(
request_url, request_extra_headers, request_load_flags, request_priority,
session, proxy_info, force_spdy_over_ssl, want_spdy_over_npn,
ssl_config_for_origin, ssl_config_for_proxy, false, net_log,
num_preconnect_streams, NULL, OnHostResolutionCallback(),
CompletionCallback());
}
} // namespace net