Refactored to make MDnsSocketFactory return array of sockets.

net/dns/mdns_client_impl.cc

 // Copyright 2013 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/dns/mdns_client_impl.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/stl_util.h"
 #include "base/time/default_clock.h"
 #include "net/base/dns_util.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log.h"
 #include "net/base/rand_callback.h"
 #include "net/dns/dns_protocol.h"
 #include "net/dns/record_rdata.h"
 #include "net/udp/datagram_socket.h"
 
 // TODO(gene): Remove this temporary method of disabling NSEC support once it
 // becomes clear whether this feature should be
 // supported. http://crbug.com/255232
 #define ENABLE_NSEC
 
 namespace net {
 
 namespace {
+
 const unsigned MDnsTransactionTimeoutSeconds = 3;
+
+int Bind(const IPEndPoint& multicast_addr, DatagramServerSocket* socket) {
+  IPAddressNumber address_any(multicast_addr.address().size());
+  IPEndPoint bind_endpoint(address_any, multicast_addr.port());
+
+  socket->AllowAddressReuse();
+  int rv = socket->Listen(bind_endpoint);
+  if (rv < OK)
+    return rv;
+
+  socket->SetMulticastLoopbackMode(false);
+  return socket->JoinGroup(multicast_addr.address());
 }
 
+void CreateAndBindSocket(AddressFamily address_family,
+                         ScopedVector<DatagramServerSocket>* sockets) {
+  scoped_ptr<DatagramServerSocket> socket(
+      new UDPServerSocket(NULL, NetLog::Source()));
+
+  IPEndPoint multicast_addr = GetMDnsIPEndPoint(address_family);
+  int rv = Bind(multicast_addr, socket.get());
+  if (rv == OK) {
+    sockets->push_back(socket.release());
+  } else {
+    VLOG(1) << "Bind failed, endpoint=" << multicast_addr.ToStringWithoutPort()
+            << ", error=" << rv;
+  }
+}
+
+}  // namespace
+
+void MDnsSocketFactoryImpl::CreateSockets(
+    ScopedVector<DatagramServerSocket>* sockets) {
+  CreateAndBindSocket(ADDRESS_FAMILY_IPV4, sockets);
+  CreateAndBindSocket(ADDRESS_FAMILY_IPV6, sockets);
+}
+
+
+
 MDnsConnection::SocketHandler::SocketHandler(
-    MDnsConnection* connection, const IPEndPoint& multicast_addr,
-    MDnsConnection::SocketFactory* socket_factory)
-    : socket_(socket_factory->CreateSocket()), connection_(connection),
-      response_(new DnsResponse(dns_protocol::kMaxMulticastSize)),
-      multicast_addr_(multicast_addr) {
+    scoped_ptr<DatagramServerSocket> socket,
+    MDnsConnection* connection)
+    : socket_(socket.Pass()),
+      connection_(connection),
+      response_(dns_protocol::kMaxMulticastSize) {
 }
 
 MDnsConnection::SocketHandler::~SocketHandler() {
 }
 
 int MDnsConnection::SocketHandler::Start() {
+  IPEndPoint end_point;
+  int rv = socket_->GetLocalAddress(&end_point);
+  if (rv != OK)
+    return rv;
+  DCHECK(end_point.GetFamily() == ADDRESS_FAMILY_IPV4 ||
+         end_point.GetFamily() == ADDRESS_FAMILY_IPV6);
+  multicast_addr_ = GetMDnsIPEndPoint(end_point.GetFamily());
   return DoLoop(0);
 }
 
 int MDnsConnection::SocketHandler::DoLoop(int rv) {
   do {
     if (rv > 0)
-      connection_->OnDatagramReceived(response_.get(), recv_addr_, rv);
+      connection_->OnDatagramReceived(&response_, recv_addr_, rv);
 
     rv = socket_->RecvFrom(
-        response_->io_buffer(),
-        response_->io_buffer()->size(),
+        response_.io_buffer(),
+        response_.io_buffer()->size(),
         &recv_addr_,
         base::Bind(&MDnsConnection::SocketHandler::OnDatagramReceived,
                    base::Unretained(this)));
   } while (rv > 0);
 
   if (rv != ERR_IO_PENDING)
     return rv;
 
   return OK;
 }
 
 void MDnsConnection::SocketHandler::OnDatagramReceived(int rv) {
   if (rv >= OK)
     rv = DoLoop(rv);
 
   if (rv != OK)
     connection_->OnError(this, rv);
 }
 
 int MDnsConnection::SocketHandler::Send(IOBuffer* buffer, unsigned size) {
-  return socket_->SendTo(
-      buffer, size, multicast_addr_,
-      base::Bind(&MDnsConnection::SocketHandler::SendDone,
-                 base::Unretained(this) ));
+  return socket_->SendTo(buffer, size, multicast_addr_,
+                         base::Bind(&MDnsConnection::SocketHandler::SendDone,
+                                    base::Unretained(this) ));
 }
 
 void MDnsConnection::SocketHandler::SendDone(int rv) {
   // TODO(noamsml): Retry logic.
 }
 
-int MDnsConnection::SocketHandler::Bind() {
-  IPAddressNumber address_any(multicast_addr_.address().size());
-
-  IPEndPoint bind_endpoint(address_any, multicast_addr_.port());
-
-  socket_->AllowAddressReuse();
-  int rv = socket_->Listen(bind_endpoint);
-
-  if (rv < OK) return rv;
-
-  socket_->SetMulticastLoopbackMode(false);
-
-  return socket_->JoinGroup(multicast_addr_.address());
-}
-
 MDnsConnection::MDnsConnection(MDnsConnection::Delegate* delegate) :
       delegate_(delegate) {
 }
 
 MDnsConnection::~MDnsConnection() {
 }
 
-bool MDnsConnection::Init(MDnsConnection::SocketFactory* socket_factory) {
-  // TODO(vitalybuka): crbug.com/297690 Make socket_factory return list
-  // of initialized sockets.
-  socket_handlers_.push_back(
-      new SocketHandler(this, GetMDnsIPEndPoint(ADDRESS_FAMILY_IPV4),
-                        socket_factory));
-  socket_handlers_.push_back(
-      new SocketHandler(this, GetMDnsIPEndPoint(ADDRESS_FAMILY_IPV6),
-                        socket_factory));
+bool MDnsConnection::Init(MDnsSocketFactory* socket_factory) {
+  ScopedVector<DatagramServerSocket> sockets;
+  socket_factory->CreateSockets(&sockets);
 
-  for (size_t i = 0; i < socket_handlers_.size();) {
-    int rv = socket_handlers_[i]->Bind();
-    if (rv != OK) {
-      socket_handlers_.erase(socket_handlers_.begin() + i);
-      VLOG(1) << "Bind failed, socket=" << i << ", error=" << rv;
-    } else {
-      ++i;
-    }
+  for (size_t i = 0; i < sockets.size(); ++i) {
+    socket_handlers_.push_back(
+        new MDnsConnection::SocketHandler(make_scoped_ptr(sockets[i]), this));
   }
+  sockets.weak_clear();
 
   // All unbound sockets need to be bound before processing untrusted input.
   // This is done for security reasons, so that an attacker can't get an unbound
   // socket.
   for (size_t i = 0; i < socket_handlers_.size();) {
     int rv = socket_handlers_[i]->Start();
     if (rv != OK) {
       socket_handlers_.erase(socket_handlers_.begin() + i);
       VLOG(1) << "Start failed, socket=" << i << ", error=" << rv;
     } else {
@@ skipping 26 matching lines @@
 
 void MDnsConnection::OnDatagramReceived(
     DnsResponse* response,
     const IPEndPoint& recv_addr,
     int bytes_read) {
   // TODO(noamsml): More sophisticated error handling.
   DCHECK_GT(bytes_read, 0);
   delegate_->HandlePacket(response, bytes_read);
 }
 
-class MDnsConnectionSocketFactoryImpl
-    : public MDnsConnection::SocketFactory {
- public:
-  MDnsConnectionSocketFactoryImpl();
-  virtual ~MDnsConnectionSocketFactoryImpl();
-
-  virtual scoped_ptr<DatagramServerSocket> CreateSocket() OVERRIDE;
-};
-
-MDnsConnectionSocketFactoryImpl::MDnsConnectionSocketFactoryImpl() {
-}
-
-MDnsConnectionSocketFactoryImpl::~MDnsConnectionSocketFactoryImpl() {
-}
-
-scoped_ptr<DatagramServerSocket>
-MDnsConnectionSocketFactoryImpl::CreateSocket() {
-  return scoped_ptr<DatagramServerSocket>(new UDPServerSocket(
-      NULL, NetLog::Source()));
-}
-
-// static
-scoped_ptr<MDnsConnection::SocketFactory>
-MDnsConnection::SocketFactory::CreateDefault() {
-  return scoped_ptr<MDnsConnection::SocketFactory>(
-      new MDnsConnectionSocketFactoryImpl);
-}
-
 MDnsClientImpl::Core::Core(MDnsClientImpl* client)
     : client_(client), connection_(new MDnsConnection(this)) {
 }
 
 MDnsClientImpl::Core::~Core() {
   STLDeleteValues(&listeners_);
 }
 
-bool MDnsClientImpl::Core::Init(MDnsConnection::SocketFactory* socket_factory) {
+bool MDnsClientImpl::Core::Init(MDnsSocketFactory* socket_factory) {
   return connection_->Init(socket_factory);
 }
 
 bool MDnsClientImpl::Core::SendQuery(uint16 rrtype, std::string name) {
   std::string name_dns;
   if (!DNSDomainFromDot(name, &name_dns))
     return false;
 
   DnsQuery query(0, name_dns, rrtype);
   query.set_flags(0);  // Remove the RD flag from the query. It is unneeded.
@@ skipping 210 matching lines @@
   AlertListeners(MDnsListener::RECORD_REMOVED,
                  ListenerKey(record->name(), record->type()), record);
 }
 
 void MDnsClientImpl::Core::QueryCache(
     uint16 rrtype, const std::string& name,
     std::vector<const RecordParsed*>* records) const {
   cache_.FindDnsRecords(rrtype, name, records, base::Time::Now());
 }
 
-MDnsClientImpl::MDnsClientImpl(
-    scoped_ptr<MDnsConnection::SocketFactory> socket_factory)
-    : socket_factory_(socket_factory.Pass()) {
+MDnsClientImpl::MDnsClientImpl() {
 }
 
 MDnsClientImpl::~MDnsClientImpl() {
 }
 
-bool MDnsClientImpl::StartListening() {
+bool MDnsClientImpl::StartListening(MDnsSocketFactory* socket_factory) {
   DCHECK(!core_.get());
   core_.reset(new Core(this));
-  if (!core_->Init(socket_factory_.get())) {
+  if (!core_->Init(socket_factory)) {
     core_.reset();
     return false;
   }
   return true;
 }
 
 void MDnsClientImpl::StopListening() {
   core_.reset();
 }
 
@@ skipping 205 matching lines @@
 
 void MDnsTransactionImpl::OnNsecRecord(const std::string& name, unsigned type) {
   TriggerCallback(RESULT_NSEC, NULL);
 }
 
 void MDnsTransactionImpl::OnCachePurged() {
   // TODO(noamsml): Cache purge situations not yet implemented
 }
 
 }  // namespace net