Linux: Monitor resolv.conf for changes and use that to reload resolver.

net/base/network_change_notifier_linux.cc

Index: net/base/network_change_notifier_linux.cc
diff --git a/net/base/network_change_notifier_linux.cc b/net/base/network_change_notifier_linux.cc
index 3937de0ec3da8db7067c2ae07c0a3c68027d2791..20c8b0a9a4143779a28a58d63d1ee6118efea3af 100644
--- a/net/base/network_change_notifier_linux.cc
+++ b/net/base/network_change_notifier_linux.cc
@@ -7,19 +7,41 @@
 #include <errno.h>
 #include <sys/socket.h>
 
+#include "base/bind.h"
+#include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/eintr_wrapper.h"
+#include "base/files/file_path_watcher.h"
 #include "base/task.h"
 #include "base/threading/thread.h"
 #include "net/base/net_errors.h"
 #include "net/base/network_change_notifier_netlink_linux.h"
 
+using ::base::files::FilePathWatcher;
+
 namespace net {
 
 namespace {
 
 const int kInvalidSocket = -1;
 
+class DNSWatchDelegate : public FilePathWatcher::Delegate {
+ public:
+  explicit DNSWatchDelegate(const base::Callback<void(void)>& no_ref_cb)
+      : no_ref_cb_(no_ref_cb) {}
+  virtual ~DNSWatchDelegate() {}
+  // FilePathWatcher::Delegate interface
+  virtual void OnFilePathChanged(const FilePath& path);
+ private:
+  base::Callback<void(void)> no_ref_cb_;
+  DISALLOW_COPY_AND_ASSIGN(DNSWatchDelegate);
+};
+
+void DNSWatchDelegate::OnFilePathChanged(const FilePath& path) {
+    // Calls NetworkChangeNotifier::NotifyObserversOfDNSChange().
+    no_ref_cb_.Run();
+}
+
 }  // namespace
 
 class NetworkChangeNotifierLinux::Thread
@@ -42,6 +64,10 @@ class NetworkChangeNotifierLinux::Thread
     NetworkChangeNotifier::NotifyObserversOfIPAddressChange();
   }
 
+  void NotifyObserversOfDNSChange() {
+    NetworkChangeNotifier::NotifyObserversOfDNSChange();
+  }
+
   // Starts listening for netlink messages.  Also handles the messages if there
   // are any available on the netlink socket.
   void ListenForNotifications();
@@ -58,17 +84,37 @@ class NetworkChangeNotifierLinux::Thread
   // Technically only needed for ChromeOS, but it's ugly to #ifdef out.
   ScopedRunnableMethodFactory<Thread> method_factory_;
 
+  // Used to watch for changes to /etc/resolv.conf and /etc/hosts.
+  scoped_ptr<base::files::FilePathWatcher> resolv_file_watcher_;
+  scoped_ptr<base::files::FilePathWatcher> hosts_file_watcher_;
+  scoped_refptr<base::files::FilePathWatcher::Delegate> file_watcher_delegate_;
+
   DISALLOW_COPY_AND_ASSIGN(Thread);
 };
 
 NetworkChangeNotifierLinux::Thread::Thread()
     : base::Thread("NetworkChangeNotifier"),
       netlink_fd_(kInvalidSocket),
-      ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)) {}
+      ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)) {
+}
 
 NetworkChangeNotifierLinux::Thread::~Thread() {}
 
 void NetworkChangeNotifierLinux::Thread::Init() {
+  resolv_file_watcher_.reset(new FilePathWatcher);
+  hosts_file_watcher_.reset(new FilePathWatcher);
+  file_watcher_delegate_ = new DNSWatchDelegate(base::Bind(
+    &NetworkChangeNotifierLinux::Thread::NotifyObserversOfDNSChange,

[willchan no longer on Chromium, 2011/07/19 15:45:34]

Unless you *need* the new callback system, please use the old one for now. We're
still working out some critical things and want to make sure it's stable first.
In case things change, I'd like to minimize the number of existing consumers
we'd have to fix.

It looks like you might need it for base::Unretained() which is fine. Just
checking.

[Craig, 2011/08/03 19:30:58]

Converted to use callback_old.

+    base::Unretained(this)));
+  if (!resolv_file_watcher_->Watch(
+          FilePath(FILE_PATH_LITERAL("/etc/resolv.conf")),
+          file_watcher_delegate_.get())) {
+    LOG(ERROR) << "Failed to setup watch for /etc/resolv.conf";

[eroman, 2011/07/25 20:13:03]

I wander if we need to fail harder than logging an error.

Before on getaddrinfo() failures we would eventually run res_ninit(), whereas
now we will not unless we have observed a file change.

Fine for now, but we may want to follow-up with some histograms to verify people
aren't hitting this condition.

[Craig, 2011/08/03 19:30:58]

Yes, very true.
OK. I glanced at the internals of the linux file_path_watcher and it never fails
when adding watches so the LOG code here won't be triggered at the moment but
arguably it could if the implementation of FPW changes. I filed crbug.com/91132
as I initially thought returning true was wrong but have marked that as invalid
now.

This however made me think of another problem scenario - symlinks. 
FilePathWatcher doesn't seem to notice changes to symlinks if the change happens
directly to the target (crbug.com/91561) so I have normalized the path here but
I'm still a bit worried about this hack - I can imagine strange scenarios in
which the /etc/resolv.conf symlink is changed to point to some other target
rather than the (already) normalized target being updated which would cause even
the latest code here to break. The right fix IMHO would be for FilePathWatcher
to deal with symlinks correctly so I'm going to chase that around a bit as time
permits.

+  }
+  if (!hosts_file_watcher_->Watch(FilePath(FILE_PATH_LITERAL("/etc/hosts")),
+          file_watcher_delegate_.get())) {
+    LOG(ERROR) << "Failed to setup watch for /etc/hosts";
+  }
   netlink_fd_ = InitializeNetlinkSocket();
   if (netlink_fd_ < 0) {
     netlink_fd_ = kInvalidSocket;