Offline state detection for linux, using new D-Bus library.

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.

[satorux1, 2011/10/13 21:41:19]

BTW, this code works only if NetworkManager is running, which is always the case
on GNOME, but some users prefer simpler Linux desktop that does not run
NetworkManager. What will happen to those users?

I assume the code is not harmful for them. Would be nice to document about the
supported platforms and what would happen to unsupported platforms.

[adamk, 2011/10/24 22:37:00]

I'm not familiar with usual D-Bus practices...how will this code fail?  Clearly,
no response will ever be received.  But will the signal connection even work? 
Is there some way to fail fast?  My worry is that we'd have to wait for the
initial state request to time out before failing (and defaulting to "online").
What do you mean by "platforms" here? Distributions, or simply the dependency on
NetworkManager/DBus?

[satorux1, 2011/10/26 17:37:09]

I guess that ConnectToSignal fails fast to connect to signal, if either Network
Manager or dbus-daemon is not running, but I'm not entirely sure. It'd be great
if you could test this code on a simpler Linux desktop. You might be able to
select something simpler than GNOME from the login screen.
I meant "platforms" to be desktop environments such as GNOME, KDE, etc. but
realistically, it's not feasible to test every desktop environment. You could
ask mdm@ to test the code with KDE. It'd be nice if we could add some comment
like:


we tested this code on GNOME version blah and KDE version blah to confirm the
offline detection works, where NetworkManager D-Bus service is provided. we also
tested with SomeSimpleDesktop to confirm this code does no harm where
NetowkrManager D-Bus service is not provided.

[adamk, 2011/10/26 18:35:52]

To be honest, I haven't yet had a chance to test this (my Linux workstation is
under someone else's desk).  I'll let you know when I have.
Ok, will add a comment once I've tested it.

 
 #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/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/memory/weak_ptr.h"
+#include "base/synchronization/lock.h"
+#include "base/synchronization/waitable_event.h"
 #include "base/task.h"
+#include "base/threading/platform_thread.h"
 #include "base/threading/thread.h"
+#include "dbus/bus.h"
+#include "dbus/message.h"
+#include "dbus/object_proxy.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;
 
+const char kNetworkManagerServiceName[] = "org.freedesktop.NetworkManager";
+const char kNetworkManagerPath[] = "/org/freedesktop/NetworkManager";
+const char kNetworkManagerInterface[] = "org.freedesktop.NetworkManager";
+
+// http://projects.gnome.org/NetworkManager/developers/spec-08.html#type-NM_STATE
+enum {
+  NM_LEGACY_STATE_UNKNOWN = 0,
+  NM_LEGACY_STATE_ASLEEP = 1,
+  NM_LEGACY_STATE_CONNECTING = 2,
+  NM_LEGACY_STATE_CONNECTED = 3,
+  NM_LEGACY_STATE_DISCONNECTED = 4
+};
+
+// http://projects.gnome.org/NetworkManager/developers/migrating-to-09/spec.html#type-NM_STATE
+enum {
+  NM_STATE_UNKNOWN = 0,
+  NM_STATE_ASLEEP = 10,
+  NM_STATE_DISCONNECTED = 20,
+  NM_STATE_DISCONNECTING = 30,
+  NM_STATE_CONNECTING = 40,
+  NM_STATE_CONNECTED_LOCAL = 50,
+  NM_STATE_CONNECTED_SITE = 60,
+  NM_STATE_CONNECTED_GLOBAL = 70
+};
+
+// A wrapper around NetworkManager's D-Bus API.
+class NetworkManagerApi {
+ public:
+  typedef base::Callback<void(void)> NotificationCallback;
+
+  explicit NetworkManagerApi(NotificationCallback notification_callback)
+      : online_state_(UNINITIALIZED),
+        online_state_initialized_(false, false),
+        notification_callback_(notification_callback),
+        helper_thread_id_(base::kInvalidThreadId),
+        ALLOW_THIS_IN_INITIALIZER_LIST(ptr_factory_(this)) { }

[satorux1, 2011/10/13 21:41:19]

nit: {} is probably more common than { }.

+
+  ~NetworkManagerApi() { }
+
+  // Should be called on a helper thread which must be of type IO.
+  void Init();
+
+  // Must be called by the helper thread's CleanUp() method.
+  void CleanUp();
+
+  // Implementation of NetworkChangeNotifierLinux::IsCurrentlyOffline().
+  // Safe to call from any thread, but will block until Init() has completed.
+  bool IsCurrentlyOffline();
+
+ private:
+  enum OnlineState {
+    UNINITIALIZED = -1,
+    OFFLINE = 0,
+    ONLINE = 1
+  };
+
+  // Callbacks for D-Bus API.
+  void OnStateChanged(dbus::Signal* signal);
+  void OnConnected(const std::string&, const std::string&, bool success) {
+    LOG_IF(WARNING, !success) << "Failed to set up offline state detection";
+  }
+
+  // Synchronously gets the current state from the NetworkManager.
+  // Should be called on a helper thread.
+  uint32 GetCurrentState(dbus::ObjectProxy* proxy);
+
+  // Converts a NetworkManager state uint to our enum.
+  // Always returns either ONLINE or OFFLINE.
+  static OnlineState TranslateState(uint32 state);
+
+  OnlineState online_state_;
+  base::Lock online_state_lock_;
+  base::WaitableEvent online_state_initialized_;
+
+  NotificationCallback notification_callback_;
+
+  scoped_refptr<dbus::Bus> system_bus_;
+
+  base::PlatformThreadId helper_thread_id_;
+
+  base::WeakPtrFactory<NetworkManagerApi> ptr_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(NetworkManagerApi);
+};
+
+void NetworkManagerApi::Init() {
+  // D-Bus requires an IO MessageLoop.
+  DCHECK_EQ(MessageLoop::current()->type(), MessageLoop::TYPE_IO);
+  helper_thread_id_ = base::PlatformThread::CurrentId();
+
+  dbus::Bus::Options options;
+  options.bus_type = dbus::Bus::SYSTEM;
+  options.connection_type = dbus::Bus::PRIVATE;
+  system_bus_ = new dbus::Bus(options);
+
+  dbus::ObjectProxy* proxy =
+      system_bus_->GetObjectProxy(kNetworkManagerServiceName,
+                                  kNetworkManagerPath);
+  OnlineState initial_state = TranslateState(GetCurrentState(proxy));
+  {
+    base::AutoLock lock(online_state_lock_);
+    online_state_ = initial_state;
+  }
+  online_state_initialized_.Signal();
+
+  proxy->ConnectToSignal(
+      kNetworkManagerInterface,
+      "StateChanged",
+      base::Bind(&NetworkManagerApi::OnStateChanged, ptr_factory_.GetWeakPtr()),
+      base::Bind(&NetworkManagerApi::OnConnected, ptr_factory_.GetWeakPtr()));
+}
+
+void NetworkManagerApi::CleanUp() {
+  DCHECK_EQ(helper_thread_id_, base::PlatformThread::CurrentId());
+  ptr_factory_.InvalidateWeakPtrs();
+}
+
+void NetworkManagerApi::OnStateChanged(dbus::Signal* signal) {
+  DCHECK_EQ(helper_thread_id_, base::PlatformThread::CurrentId());
+  DCHECK(signal);
+  dbus::MessageReader reader(signal);
+  uint32 state;

[satorux1, 2011/10/13 21:41:19]

nit: I'd initialize this with 0 to avoid a possible nondeterministic behavior.

[adamk, 2011/10/24 22:37:00]

Done.  I hope there's no chance of nondeterminism in the actual code, though,
and that PopUint32 guarantees to initialize state if it returns true.

[satorux1, 2011/10/26 17:37:09]

Right. PopUint32 is guaranteed to do so, but it's good to be defensive.

+  if (!reader.PopUint32(&state)) {
+    LOG(WARNING) << "Unexpected response for NetworkManager State request: "
+                 << signal->ToString();
+    return;
+  }
+  OnlineState new_online_state = TranslateState(state);
+  {
+    base::AutoLock lock(online_state_lock_);
+    if (new_online_state != online_state_)
+      online_state_ = new_online_state;
+    else
+      return;
+  }
+  // Can't notify while we hold the lock
+  notification_callback_.Run();
+}
+
+uint32 NetworkManagerApi::GetCurrentState(dbus::ObjectProxy* proxy) {
+  DCHECK_EQ(helper_thread_id_, base::PlatformThread::CurrentId());
+  dbus::MethodCall method_call(DBUS_INTERFACE_PROPERTIES, "Get");
+  dbus::MessageWriter builder(&method_call);
+  builder.AppendString(kNetworkManagerInterface);
+  builder.AppendString("State");
+  // OK to block since we're on the helper thread.
+  scoped_ptr<dbus::Response> response(
+      proxy->CallMethodAndBlock(&method_call,
+                                dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
+  if (!response.get())
+    return NM_STATE_UNKNOWN;

[satorux1, 2011/10/13 21:41:19]

you might want to add log warning about a method call failure?

[adamk, 2011/10/24 22:37:00]

Done.

+
+  dbus::MessageReader reader(response.get());
+  uint32 state;

[satorux1, 2011/10/13 21:41:19]

nit: initialize this?

[adamk, 2011/10/24 22:37:00]

De-duped this code, so done.

+  if (!reader.PopUint32(&state)) {
+    LOG(WARNING) << "Unexpected response for NetworkManager State request: "
+                 << response->ToString();
+    return NM_STATE_UNKNOWN;
+  }
+
+  return state;
+}
+
+NetworkManagerApi::OnlineState NetworkManagerApi::TranslateState(uint32 state) {
+  switch (state) {
+    case NM_LEGACY_STATE_CONNECTED:
+    case NM_STATE_CONNECTED_SITE:
+    case NM_STATE_CONNECTED_GLOBAL:
+      // Definitely connected
+      return ONLINE;
+    case NM_LEGACY_STATE_DISCONNECTED:
+    case NM_STATE_DISCONNECTED:
+      // Definitely disconnected
+      return OFFLINE;
+    case NM_STATE_CONNECTED_LOCAL:
+      // Local networking only; I'm treating this as offline (keybuk)
+      return OFFLINE;
+    case NM_LEGACY_STATE_CONNECTING:
+    case NM_STATE_DISCONNECTING:
+    case NM_STATE_CONNECTING:
+      // In-flight change to connection status currently underway
+      return OFFLINE;
+    case NM_LEGACY_STATE_ASLEEP:
+    case NM_STATE_ASLEEP:
+      // Networking disabled or no devices on system
+      return OFFLINE;
+    default:
+      // Unknown status
+      return ONLINE;
+  }
+}
+
+bool NetworkManagerApi::IsCurrentlyOffline() {
+  online_state_initialized_.Wait();
+  base::AutoLock lock(online_state_lock_);
+  return online_state_ == OFFLINE;
+}
+
 class DNSWatchDelegate : public FilePathWatcher::Delegate {
  public:
   explicit DNSWatchDelegate(Callback0::Type* callback)
       : callback_(callback) {}
   virtual ~DNSWatchDelegate() {}
   // FilePathWatcher::Delegate interface
   virtual void OnFilePathChanged(const FilePath& path) OVERRIDE;
   virtual void OnFilePathError(const FilePath& path) OVERRIDE;
  private:
   scoped_ptr<Callback0::Type> callback_;
@@ skipping 15 matching lines @@
 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 */);
 
+  // Plumbing for NetworkChangeNotifier::IsCurrentlyOffline.
+  // Safe to call from any thread.
+  bool IsCurrentlyOffline() {
+    return network_manager_api_.IsCurrentlyOffline();
+  }
+
  protected:
   // base::Thread
   virtual void Init();
   virtual void CleanUp();
 
  private:
   void NotifyObserversOfIPAddressChange() {
     NetworkChangeNotifier::NotifyObserversOfIPAddressChange();
   }
 
   void NotifyObserversOfDNSChange() {
     NetworkChangeNotifier::NotifyObserversOfDNSChange();
   }
 
+  static void NotifyObserversOfOnlineStateChange() {
+    NetworkChangeNotifier::NotifyObserversOfOnlineStateChange();
+  }
+
   // 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_;
 
+  // Used to detect online/offline state changes.
+  NetworkManagerApi network_manager_api_;
+
   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)),
+      network_manager_api_(
+          base::Bind(&NetworkChangeNotifierLinux::Thread
+                     ::NotifyObserversOfOnlineStateChange)) {
 }
 
 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));
   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";
   }
   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();
+
+  network_manager_api_.Init();
 }
 
 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();
   }
   // Kill watchers early to make sure they won't try to call
   // into us via the delegate during destruction.
   resolv_file_watcher_.reset();
   hosts_file_watcher_.reset();
+
+  network_manager_api_.CleanUp();
 }
 
 void NetworkChangeNotifierLinux::Thread::OnFileCanReadWithoutBlocking(int fd) {
   DCHECK_EQ(fd, netlink_fd_);
   ListenForNotifications();
 }
 
 void NetworkChangeNotifierLinux::Thread::OnFileCanWriteWithoutBlocking(
     int /* fd */) {
   NOTREACHED();
@@ skipping 58 matching lines @@
   notifier_thread_->StartWithOptions(thread_options);
 }
 
 NetworkChangeNotifierLinux::~NetworkChangeNotifierLinux() {
   // We don't need to explicitly Stop(), but doing so allows us to sanity-
   // check that the notifier thread shut down properly.
   notifier_thread_->Stop();
 }
 
 bool NetworkChangeNotifierLinux::IsCurrentlyOffline() const {
-  // TODO(eroman): http://crbug.com/53473
-  return false;
+  return notifier_thread_->IsCurrentlyOffline();
 }
 
 }  // namespace net