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

net/base/network_change_notifier_linux.cc

 // Copyright (c) 2011 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/base/network_change_notifier_linux.h"
 
 #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
     : public base::Thread, public MessageLoopForIO::Watcher {
  public:
   Thread();
   virtual ~Thread();
 
   // MessageLoopForIO::Watcher:
   virtual void OnFileCanReadWithoutBlocking(int fd);
   virtual void OnFileCanWriteWithoutBlocking(int /* fd */);
 
  protected:
   // base::Thread
   virtual void Init();
   virtual void CleanUp();
 
  private:
   void NotifyObserversOfIPAddressChange() {
     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();
 
   // Attempts to read from the netlink socket into |buf| of length |len|.
   // Returns the bytes read on synchronous success and ERR_IO_PENDING if the
   // recv() would block.  Otherwise, it returns a net error code.
   int ReadNotificationMessage(char* buf, size_t len);
 
   // The netlink socket descriptor.
   int netlink_fd_;
   MessageLoopForIO::FileDescriptorWatcher netlink_watcher_;
 
   // 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;
     return;
   }
   ListenForNotifications();
 }
 
 void NetworkChangeNotifierLinux::Thread::CleanUp() {
   if (netlink_fd_ != kInvalidSocket) {
@@ skipping 78 matching lines @@
   // check that the notifier thread shut down properly.
   notifier_thread_->Stop();
 }
 
 bool NetworkChangeNotifierLinux::IsCurrentlyOffline() const {
   // TODO(eroman): http://crbug.com/53473
   return false;
 }
 
 }  // namespace net