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_old.h"
 #include "base/compiler_specific.h"
 #include "base/eintr_wrapper.h"
+#include "base/file_util.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(Callback0::Type* callback)
+      : callback_enabled(true) {
+    callback_.reset(callback);

[eroman, 2011/08/11 01:57:55]

nit: I suggest moving this into the initializer list.

[Craig, 2011/08/15 17:10:56]

Done.

+  }
+  virtual ~DNSWatchDelegate() {}
+  void DisableCallback() {
+    callback_enabled = false;

[eroman, 2011/08/11 01:57:55]

Not sure the bool is necessary, could do callback_.reset(), and test for if
(callback_.get() when running.

[Craig, 2011/08/15 17:10:56]

Done.

+  }
+  // FilePathWatcher::Delegate interface
+  virtual void OnFilePathChanged(const FilePath& path);

[eroman, 2011/08/11 01:57:55]

nit: Can you add OVERRIDE annotation?

[Craig, 2011/08/15 17:10:56]

Done.

+ private:

[eroman, 2011/08/11 01:57:55]

[optional]: I suggest hooking OnFilePathError() and printing an error message
(could help with debugging should the watching go awry).

[Craig, 2011/08/15 17:10:56]

Done. At the moment FilePathWatcher on linux won't actually ever call
OnFilePathError btw.

+  scoped_ptr<Callback0::Type> callback_;
+  bool callback_enabled;
+  DISALLOW_COPY_AND_ASSIGN(DNSWatchDelegate);
+};
+
+void DNSWatchDelegate::OnFilePathChanged(const FilePath& path) {
+    // Calls NetworkChangeNotifier::NotifyObserversOfDNSChange().
+    if (callback_enabled)
+      callback_->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<DNSWatchDelegate> 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(NewCallback(this,
+      &NetworkChangeNotifierLinux::Thread::NotifyObserversOfDNSChange));
+  FilePath resolver(FILE_PATH_LITERAL("/etc/resolv.conf"));
+  FilePath tmppath;
+  // On systems where /etc/resolv.conf is a symlink, we have to normalize
+  // the path and watch that until FilePathWatcher copes with this. See
+  // crbug.com/91561. Note that there are some corner cases this workaround
+  // won't catch.
+  if (file_util::NormalizeFilePath(resolver, &tmppath))
+    resolver = tmppath;
+  else
+    LOG(ERROR) << "Cannot normalize /etc/resolv.conf";
+  if (!resolv_file_watcher_->Watch(resolver, file_watcher_delegate_.get())) {
+    LOG(ERROR) << "Failed to setup watch for /etc/resolv.conf";
+  }
+  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) {
     if (HANDLE_EINTR(close(netlink_fd_)) != 0)
       PLOG(ERROR) << "Failed to close socket";
     netlink_fd_ = kInvalidSocket;
     netlink_watcher_.StopWatchingFileDescriptor();
   }
+  // If DNSWatchDelegate outlives us, make sure it won't
+  // try to call into us during destruction.
+  file_watcher_delegate_->DisableCallback();

[eroman, 2011/08/11 01:57:55]

I think it would be sufficient to reset the file watchers instead (since they
cleanup on destruction).

  resolve_file_watcher_.reset();
  hosts_file_watcher_.reset();

[Craig, 2011/08/15 17:10:56]

Done. Much cleaner. I've killed the DisableCallback stuff.

 }
 
 void NetworkChangeNotifierLinux::Thread::OnFileCanReadWithoutBlocking(int fd) {
   DCHECK_EQ(fd, netlink_fd_);
   ListenForNotifications();
 }
 
 void NetworkChangeNotifierLinux::Thread::OnFileCanWriteWithoutBlocking(
     int /* fd */) {
   NOTREACHED();
@@ skipping 63 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