net/dns/dns_socket_pool.cc

   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 #include "net/dns/dns_socket_pool.h"
   6
   7 #include "base/logging.h"
   8 #include "base/rand_util.h"
   9 #include "base/stl_util.h"
  10 #include "net/base/address_list.h"
  11 #include "net/base/ip_endpoint.h"
  12 #include "net/base/net_errors.h"
  13 #include "net/base/rand_callback.h"
  14 #include "net/socket/client_socket_factory.h"
  15 #include "net/socket/stream_socket.h"
  16 #include "net/udp/datagram_client_socket.h"
  17
  18 namespace net {
  19
  20 namespace {
  21
  22 // When we initialize the SocketPool, we allocate kInitialPoolSize sockets.
  23 // When we allocate a socket, we ensure we have at least kAllocateMinSize
  24 // sockets to choose from.  Freed sockets are not retained.
  25
  26 // On Windows, we can't request specific (random) ports, since that will
  27 // trigger firewall prompts, so request default ones, but keep a pile of
  28 // them.  Everywhere else, request fresh, random ports each time.
  29 #if defined(OS_WIN)
  30 const DatagramSocket::BindType kBindType = DatagramSocket::DEFAULT_BIND;
  31 const unsigned kInitialPoolSize = 256;
  32 const unsigned kAllocateMinSize = 256;
  33 #else
  34 const DatagramSocket::BindType kBindType = DatagramSocket::RANDOM_BIND;
  35 const unsigned kInitialPoolSize = 0;
  36 const unsigned kAllocateMinSize = 1;
  37 #endif
  38
  39 } // namespace
  40
  41 DnsSocketPool::DnsSocketPool(ClientSocketFactory* socket_factory)
  42     : socket_factory_(socket_factory),
  43       net_log_(NULL),
  44       nameservers_(NULL),
  45       initialized_(false) {
  46 }
  47
  48 void DnsSocketPool::InitializeInternal(
  49     const std::vector<IPEndPoint>* nameservers,
  50     NetLog* net_log) {
  51   DCHECK(nameservers);
  52   DCHECK(!initialized_);
  53
  54   net_log_ = net_log;
  55   nameservers_ = nameservers;
  56   initialized_ = true;
  57 }
  58
  59 scoped_ptr<StreamSocket> DnsSocketPool::CreateTCPSocket(
  60     unsigned server_index,
  61     const NetLog::Source& source) {
  62   DCHECK_LT(server_index, nameservers_->size());
  63
  64   return scoped_ptr<StreamSocket>(
  65       socket_factory_->CreateTransportClientSocket(
  66           AddressList((*nameservers_)[server_index]), net_log_, source));
  67 }
  68
  69 scoped_ptr<DatagramClientSocket> DnsSocketPool::CreateConnectedSocket(
  70     unsigned server_index) {
  71   DCHECK_LT(server_index, nameservers_->size());
  72
  73   scoped_ptr<DatagramClientSocket> socket;
  74
  75   NetLog::Source no_source;
  76   socket = socket_factory_->CreateDatagramClientSocket(
  77       kBindType, base::Bind(&base::RandInt), net_log_, no_source);
  78
  79   if (socket.get()) {
  80     int rv = socket->Connect((*nameservers_)[server_index]);
  81     if (rv != OK) {
  82       VLOG(1) << "Failed to connect socket: " << rv;
  83       socket.reset();
  84     }
  85   } else {
  86     LOG(WARNING) << "Failed to create socket.";
  87   }
  88
  89   return socket.Pass();
  90 }
  91
  92 class NullDnsSocketPool : public DnsSocketPool {
  93  public:
  94   NullDnsSocketPool(ClientSocketFactory* factory)
  95      : DnsSocketPool(factory) {
  96   }
  97
  98   virtual void Initialize(
  99       const std::vector<IPEndPoint>* nameservers,
 100       NetLog* net_log) OVERRIDE {
 101     InitializeInternal(nameservers, net_log);
 102   }
 103
 104   virtual scoped_ptr<DatagramClientSocket> AllocateSocket(
 105       unsigned server_index) OVERRIDE {
 106     return CreateConnectedSocket(server_index);
 107   }
 108
 109   virtual void FreeSocket(
 110       unsigned server_index,
 111       scoped_ptr<DatagramClientSocket> socket) OVERRIDE {
 112   }
 113
 114  private:
 115   DISALLOW_COPY_AND_ASSIGN(NullDnsSocketPool);
 116 };
 117
 118 // static
 119 scoped_ptr<DnsSocketPool> DnsSocketPool::CreateNull(
 120     ClientSocketFactory* factory) {
 121   return scoped_ptr<DnsSocketPool>(new NullDnsSocketPool(factory));
 122 }
 123
 124 class DefaultDnsSocketPool : public DnsSocketPool {
 125  public:
 126   DefaultDnsSocketPool(ClientSocketFactory* factory)
 127      : DnsSocketPool(factory) {
 128   };
 129
 130   virtual ~DefaultDnsSocketPool();
 131
 132   virtual void Initialize(
 133       const std::vector<IPEndPoint>* nameservers,
 134       NetLog* net_log) OVERRIDE;
 135
 136   virtual scoped_ptr<DatagramClientSocket> AllocateSocket(
 137       unsigned server_index) OVERRIDE;
 138
 139   virtual void FreeSocket(
 140       unsigned server_index,
 141       scoped_ptr<DatagramClientSocket> socket) OVERRIDE;
 142
 143  private:
 144   void FillPool(unsigned server_index, unsigned size);
 145
 146   typedef std::vector<DatagramClientSocket*> SocketVector;
 147
 148   std::vector<SocketVector> pools_;
 149
 150   DISALLOW_COPY_AND_ASSIGN(DefaultDnsSocketPool);
 151 };
 152
 153 // static
 154 scoped_ptr<DnsSocketPool> DnsSocketPool::CreateDefault(
 155     ClientSocketFactory* factory) {
 156   return scoped_ptr<DnsSocketPool>(new DefaultDnsSocketPool(factory));
 157 }
 158
 159 void DefaultDnsSocketPool::Initialize(
 160     const std::vector<IPEndPoint>* nameservers,
 161     NetLog* net_log) {
 162   InitializeInternal(nameservers, net_log);
 163
 164   DCHECK(pools_.empty());
 165   const unsigned num_servers = nameservers->size();
 166   pools_.resize(num_servers);
 167   for (unsigned server_index = 0; server_index < num_servers; ++server_index)
 168     FillPool(server_index, kInitialPoolSize);
 169 }
 170
 171 DefaultDnsSocketPool::~DefaultDnsSocketPool() {
 172   unsigned num_servers = pools_.size();
 173   for (unsigned server_index = 0; server_index < num_servers; ++server_index) {
 174     SocketVector& pool = pools_[server_index];
 175     STLDeleteElements(&pool);
 176   }
 177 }
 178
 179 scoped_ptr<DatagramClientSocket> DefaultDnsSocketPool::AllocateSocket(
 180     unsigned server_index) {
 181   DCHECK_LT(server_index, pools_.size());
 182   SocketVector& pool = pools_[server_index];
 183
 184   FillPool(server_index, kAllocateMinSize);
 185   if (pool.size() == 0) {
 186     LOG(WARNING) << "No DNS sockets available in pool " << server_index << "!";
 187     return scoped_ptr<DatagramClientSocket>();
 188   }
 189
 190   if (pool.size() < kAllocateMinSize) {
 191     LOG(WARNING) << "Low DNS port entropy: wanted " << kAllocateMinSize
 192                  << " sockets to choose from, but only have " << pool.size()
 193                  << " in pool " << server_index << ".";
 194   }
 195
 196   unsigned socket_index = base::RandInt(0, pool.size() - 1);
 197   DatagramClientSocket* socket = pool[socket_index];
 198   pool[socket_index] = pool.back();
 199   pool.pop_back();
 200
 201   return scoped_ptr<DatagramClientSocket>(socket);
 202 }
 203
 204 void DefaultDnsSocketPool::FreeSocket(
 205     unsigned server_index,
 206     scoped_ptr<DatagramClientSocket> socket) {
 207   DCHECK_LT(server_index, pools_.size());
 208 }
 209
 210 void DefaultDnsSocketPool::FillPool(unsigned server_index, unsigned size) {
 211   SocketVector& pool = pools_[server_index];
 212
 213   for (unsigned pool_index = pool.size(); pool_index < size; ++pool_index) {
 214     DatagramClientSocket* socket =
 215         CreateConnectedSocket(server_index).release();
 216     if (!socket)
 217       break;
 218     pool.push_back(socket);
 219   }
 220 }
 221
 222 } // namespace net