Multicast DNS implementation (initial)

net/dns/mdns_client_impl.h

Index: net/dns/mdns_client_impl.h
diff --git a/net/dns/mdns_client_impl.h b/net/dns/mdns_client_impl.h
new file mode 100644
index 0000000000000000000000000000000000000000..b64c16fdf060d0022d1293bf38a89921df88771e
--- /dev/null
+++ b/net/dns/mdns_client_impl.h
@@ -0,0 +1,292 @@
+// Copyright (c) 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.
+
+#ifndef NET_DNS_MDNS_CLIENT_IMPL_H_
+#define NET_DNS_MDNS_CLIENT_IMPL_H_
+
+#include <map>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "base/cancelable_callback.h"
+#include "base/observer_list.h"
+#include "net/base/io_buffer.h"
+#include "net/base/ip_endpoint.h"
+#include "net/dns/mdns_cache.h"
+#include "net/dns/mdns_client.h"
+#include "net/udp/datagram_server_socket.h"
+#include "net/udp/udp_server_socket.h"
+#include "net/udp/udp_socket.h"
+
+namespace net {
+
+class MDnsDatagramServerSocketFactory;
+
+// A connection to the network for multicast DNS clients. It reads data into
+// DnsResponse objects and alerts the delegate that a packet has been received.
+class MDnsConnection {
+ public:
+  class Delegate {
+   public:
+    // Handle an mDNS packet buffered in |response| with a size of |bytes_read|.
+    virtual void HandlePacket(DnsResponse* response, int bytes_read) = 0;
+    virtual void OnConnectionError(int error) = 0;
+    virtual ~Delegate() {}
+  };
+
+  explicit MDnsConnection(MDnsDatagramServerSocketFactory* socket_factory,
+                          MDnsConnection::Delegate* delegate);
+
+  virtual ~MDnsConnection();
+
+  int Init();
+  int Send(IOBuffer* buffer, unsigned size);
+
+ private:
+  class SocketHandler {
+   public:
+    SocketHandler(MDnsConnection* connection,
+                  const IPEndPoint& multicast_addr,
+                  MDnsDatagramServerSocketFactory* socket_factory);
+    ~SocketHandler();
+    int DoLoop(int rv);
+    int Start();
+
+    int Send(IOBuffer* buffer, unsigned size);
+
+   private:
+    int BindSocket();
+    void OnDatagramReceived(int rv);
+
+    // Callback for when sending a query has finished.
+    void SendDone(int sent);

[szym, 2013/06/12 21:35:41]

nit: |rv| would be better instead of |sent|.

[Noam Samuel, 2013/06/13 01:08:40]

Done.

+
+    scoped_ptr<DatagramServerSocket> socket_;
+
+    MDnsConnection* connection_;
+    IPEndPoint recv_addr_;
+    scoped_ptr<DnsResponse> response_;
+    IPEndPoint multicast_addr_;
+  };
+
+  // Callback for handling a datagram being received on either ipv4 or ipv6.
+  void OnDatagramReceived(DatagramServerSocket* socket,
+                          DnsResponse* response,
+                          IPEndPoint* recv_addr,

[szym, 2013/06/12 21:35:41]

I suggest you pass IPEndPoint by const&. Why do you need to pass the socket?

[Noam Samuel, 2013/06/13 01:08:40]

Done.

+                          int bytes_read);
+
+  void OnError(SocketHandler* loop, int error);
+
+  IPEndPoint GetMDnsIPEndPoint(const char* address);
+
+  SocketHandler socket_handler_ipv4_;
+  SocketHandler socket_handler_ipv6_;
+
+  Delegate* delegate_;
+
+  DISALLOW_COPY_AND_ASSIGN(MDnsConnection);
+};
+
+class MDnsListenerImpl;
+
+class MDnsClientImpl : public MDnsClient {
+ public:
+  // The core object exists while the MDnsClient is listening for MDnsPackets,

[szym, 2013/06/12 21:35:41]

nit: No need for "MDnsPackets". It's also not clear what it is exactly.

[Noam Samuel, 2013/06/13 01:08:40]

Done.

+  // and is deleted whenever the number of listeners reaches zero.
+  class Core : public base::SupportsWeakPtr<Core>, MDnsConnection::Delegate {
+   public:
+    Core(MDnsClientImpl* client,
+         MDnsDatagramServerSocketFactory* socket_factory);
+    virtual ~Core();
+
+    // Initialize the core. Returns true on success.
+    bool Init();
+
+    // Send a query with a specific rrtype and name. Returns true on success.
+    bool SendQuery(uint16 rrtype, std::string name);
+
+    // Add/remove a listener to the list of listener. May cause network traffic
+    // if listener is active.
+    void AddListener(MDnsListenerImpl* listener);
+    void RemoveListener(MDnsListenerImpl* listener);
+
+    // Query the cache for records of a specific type and name.
+    void QueryCache(uint16 rrtype, const std::string& name,
+                    std::vector<const RecordParsed*>* records) const;
+
+    // Parse the response and alert relevant listeners.
+    virtual void HandlePacket(DnsResponse* response, int bytes_read) OVERRIDE;
+
+    virtual void OnConnectionError(int error) OVERRIDE;
+
+   private:
+    typedef std::pair<uint16, std::string> ListenerKey;
+    typedef std::map<ListenerKey, ObserverList<MDnsListenerImpl>* >
+    ListenerMap;
+
+    // Alert listeners of an update to the cache.
+    void AlertListeners(MDnsUpdateType update_type,
+                        const ListenerKey& key, const RecordParsed* record);
+
+    // Schedule a cleanup to a specific time, cancelling other cleanups.

[szym, 2013/06/12 21:35:41]

nit: add "cache"

[Noam Samuel, 2013/06/13 01:08:40]

Done.

+    void ScheduleCleanup(base::Time cleanup);
+
+    // Clean up the cache and schedule a new cleanup.
+    void DoCleanup();
+
+    // Callback for when a record is removed from the cache.
+    void OnRecordRemoved(const RecordParsed* record);
+
+    ListenerMap listeners_;
+
+    MDnsClientImpl* client_;
+    MDnsCache cache_;
+
+    base::CancelableCallback<void()> cleanup_callback_;
+    base::Time scheduled_cleanup_;
+
+    scoped_ptr<MDnsConnection> connection_;
+
+    DISALLOW_COPY_AND_ASSIGN(Core);
+  };
+
+  explicit MDnsClientImpl(MDnsDatagramServerSocketFactory* socket_factory_);

[szym, 2013/06/12 21:35:41]

should be scoped_ptr

[Noam Samuel, 2013/06/13 01:08:40]

Done.

+  virtual ~MDnsClientImpl();
+
+  // MDnsClient implementation:
+  virtual scoped_ptr<MDnsListener> CreateListener(
+      uint16 rrtype,
+      const std::string& name,
+      MDnsListener::Delegate* delegate) OVERRIDE;
+
+  virtual scoped_ptr<MDnsTransaction> CreateTransaction(
+      uint16 rrtype,
+      const std::string& name,
+      int flags,
+      const MDnsTransaction::ResultCallback& callback) OVERRIDE;
+
+  // Functions for testing only.

[szym, 2013/06/12 21:35:41]

nit: unnecessary comment. Better to explain what "listening" means, i.e.,
"Returns true when .."

[Noam Samuel, 2013/06/13 01:08:40]

Done.

+  bool IsListeningForTests();
+
+  bool AddListenRef();
+  void SubtractListenRef();
+
+  Core* core() { return core_.get(); }
+
+ private:
+  void Shutdown();

[szym, 2013/06/12 21:35:41]

Add a comment that this is deferred shutdown after the last listener is removed
and the shutdown will be aborted if new listeners are added before it is
executed.

[Noam Samuel, 2013/06/13 01:08:40]

Done.

+
+  scoped_ptr<Core> core_;
+  int listen_refs_;
+
+  scoped_ptr<MDnsDatagramServerSocketFactory> socket_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(MDnsClientImpl);
+};
+
+class MDnsListenerImpl : public MDnsListener,
+                         public base::SupportsWeakPtr<MDnsListenerImpl> {
+ public:
+  MDnsListenerImpl(uint16 rrtype,
+                   const std::string& name,
+                   MDnsListener::Delegate* delegate,
+                   MDnsClientImpl* client);
+
+  virtual ~MDnsListenerImpl();
+
+  // MDnsListener implementation:
+  virtual bool Start() OVERRIDE;
+
+  virtual const std::string& GetName() const OVERRIDE;
+
+  virtual uint16 GetType() const OVERRIDE;
+
+  MDnsListener::Delegate* delegate() { return delegate_; }
+
+  // Alert the delegate of a record update.
+  void AlertDelegate(MDnsUpdateType update_type,
+                     const RecordParsed* record_parsed);
+ private:
+  uint16 rrtype_;
+  std::string name_;
+  MDnsClientImpl* client_;
+  MDnsListener::Delegate* delegate_;
+
+  bool started_;
+  DISALLOW_COPY_AND_ASSIGN(MDnsListenerImpl);
+};
+
+class MDnsTransactionImpl : public base::SupportsWeakPtr<MDnsTransactionImpl>,
+                            public MDnsTransaction,
+                            public MDnsListener::Delegate {
+ public:
+  MDnsTransactionImpl(uint16 rrtype,
+                      const std::string& name,
+                      int flags,
+                      const MDnsTransaction::ResultCallback& callback,
+                      MDnsClientImpl* client);
+  virtual ~MDnsTransactionImpl();
+
+  // MDnsTransaction implementation:
+  virtual bool Start() OVERRIDE;
+
+  virtual const std::string& GetName() const OVERRIDE;
+  virtual uint16 GetType() const OVERRIDE;
+
+  // MDnsListener::Delegate implementation:
+  virtual void OnRecordUpdate(MDnsUpdateType update,
+                              const RecordParsed* record) OVERRIDE;
+  virtual void OnNsecRecord(const std::string& name, unsigned type) OVERRIDE;
+
+  virtual void OnCachePurged() OVERRIDE;
+
+ private:
+  bool is_active() { return !callback_.is_null(); }
+
+  void Reset();
+
+  // Trigger the callback and reset all related variables.
+  void TriggerCallback(MDnsTransactionResult result,
+                       const RecordParsed* record);
+
+  // Internal callback for when a cache record is found.
+  void CacheRecordFound(const RecordParsed* record);
+
+  // Signal the transactionis over and release all related resources.
+  void SignalTransactionOver();
+
+  uint16 rrtype_;
+  std::string name_;
+  MDnsTransaction::ResultCallback callback_;
+
+  scoped_ptr<MDnsListener> listener_;
+  base::CancelableCallback<void()> timeout_;
+
+  MDnsClientImpl* client_;
+
+  bool started_;
+  int flags_;
+
+  DISALLOW_COPY_AND_ASSIGN(MDnsTransactionImpl);
+};
+
+class MDnsDatagramServerSocketFactory {

[szym, 2013/06/12 21:35:41]

Why not declare it first so that there's no need to forward declare?

If you want to make the name shorter, I'd be ok with DatagramServerSocketFactory
since there's nothing MDNS specific about it.

I'd also be ok with a nested MDnsConnection::SocketFactory.

[Noam Samuel, 2013/06/13 01:08:40]

Done.

+ public:
+  virtual ~MDnsDatagramServerSocketFactory() {}
+
+  virtual scoped_ptr<DatagramServerSocket> CreateSocket() = 0;
+};
+
+class MDnsDatagramServerSocketFactoryImpl

[szym, 2013/06/12 21:35:41]

I'd suggest hiding this from the header and only exposing it via static
scoped_ptr<...Factory> CreateDefault();
in the interface above.

[Noam Samuel, 2013/06/13 01:08:40]

Done.

+    : public MDnsDatagramServerSocketFactory {
+ public:
+  MDnsDatagramServerSocketFactoryImpl();
+  virtual ~MDnsDatagramServerSocketFactoryImpl();
+
+  virtual scoped_ptr<DatagramServerSocket> CreateSocket() OVERRIDE;
+};
+
+}  // namespace net
+#endif  // NET_DNS_MDNS_CLIENT_IMPL_H_