Merge nmclient and nminfo and move them in the model.

Split the gtk dialog out with the service.
I cannot test this until we build it for joyride or we support nm 0.7.

16 files changed, 1350 insertions, 1413 deletions

diff --git a/src/jarabe/Makefile.am b/src/jarabe/Makefile.am
index a2c0438..6589a17 100644
--- a/src/jarabe/Makefile.am
+++ b/src/jarabe/Makefile.am
@@ -5,6 +5,7 @@ sugar_PYTHON =			\
         __init__.py		\
 	config.py           	\
 	logsmanager.py		\
+        nmservice.py            \
 	session.py		\
 	shellservice.py
 
diff --git a/src/jarabe/controlpanel/network/model.py b/src/jarabe/controlpanel/network/model.py
index b6f71a0..101297c 100644
--- a/src/jarabe/controlpanel/network/model.py
+++ b/src/jarabe/controlpanel/network/model.py
@@ -19,7 +19,8 @@ import dbus
 from gettext import gettext as _
 
 from sugar import profile
-from jarabe.hardware import hardwaremanager
+
+from jarabe.model.network import get_manager
 
 NM_SERVICE_NAME = 'org.freedesktop.NetworkManager'
 NM_SERVICE_PATH = '/org/freedesktop/NetworkManager'
@@ -94,7 +95,7 @@ def clear_registration():
 def clear_networks():
     """Clear saved passwords and network configurations.
     """
-    network_manager = hardwaremanager.get_network_manager()
+    network_manager = get_manager()
     if not network_manager:
         return
     network_manager.nminfo.delete_all_networks()
diff --git a/src/jarabe/desktop/meshbox.py b/src/jarabe/desktop/meshbox.py
index 964bba5..4b56540 100644
--- a/src/jarabe/desktop/meshbox.py
+++ b/src/jarabe/desktop/meshbox.py
@@ -33,15 +33,14 @@ from sugar import profile
 from jarabe.model import accesspointmodel
 from jarabe.model.devices import wireless
 from jarabe.model import shellmodel
-from jarabe.hardware import hardwaremanager
-from jarabe.hardware import nmclient
+from jarabe.model import network
 from jarabe.view.buddyicon import BuddyIcon
 from jarabe.view.pulsingicon import CanvasPulsingIcon
 from jarabe.desktop.snowflakelayout import SnowflakeLayout
 from jarabe.desktop.spreadlayout import SpreadLayout
 from jarabe.view import shell
 
-from jarabe.hardware.nmclient import NM_802_11_CAP_PROTO_WEP, \
+from jarabe.model.network import NM_802_11_CAP_PROTO_WEP, \
     NM_802_11_CAP_PROTO_WPA, NM_802_11_CAP_PROTO_WPA2
 
 
@@ -112,7 +111,7 @@ class AccessPointView(CanvasPulsingIcon):
 
     def _disconnect_activate_cb(self, menuitem):
         # Disconnection for an AP means activating the default mesh device
-        network_manager = hardwaremanager.get_network_manager()
+        network_manager = network.get_manager()
         if network_manager and self._meshdev:
             network_manager.set_active_device(self._meshdev)
             self._palette.props.secondary_text = _('Disconnecting...')
@@ -129,11 +128,11 @@ class AccessPointView(CanvasPulsingIcon):
         self._update_state()
 
     def _activate_cb(self, icon):
-        network_manager = hardwaremanager.get_network_manager()
+        network_manager = network.get_manager()
         if network_manager:
             device = self._model.get_nm_device()
-            network = self._model.get_nm_network()
-            network_manager.set_active_device(device, network)
+            nm_network = self._model.get_nm_network()
+            network_manager.set_active_device(device, nm_network)
 
     def _update_name(self):
         self._palette.props.primary_text = self._model.props.name
@@ -224,17 +223,17 @@ class MeshDeviceView(CanvasPulsingIcon):
 
         state = self._nm_device.get_state()
         chan = wireless.freq_to_channel(self._nm_device.get_frequency())
-        if state == nmclient.DEVICE_STATE_ACTIVATED and chan == self.channel:
+        if state == network.DEVICE_STATE_ACTIVATED and chan == self.channel:
             self._disconnect_item.show()
         return p
 
     def _disconnect_activate_cb(self, menuitem):
-        network_manager = hardwaremanager.get_network_manager()
+        network_manager = network.get_manager()
         if network_manager:
             network_manager.set_active_device(self._nm_device)
 
     def _activate_cb(self, icon):
-        network_manager = hardwaremanager.get_network_manager()
+        network_manager = network.get_manager()
         if network_manager:
             freq = wireless.channel_to_freq(self.channel)
             network_manager.set_active_device(self._nm_device, mesh_freq=freq)
@@ -245,13 +244,13 @@ class MeshDeviceView(CanvasPulsingIcon):
     def _update_state(self):
         state = self._nm_device.get_state()
         chan = wireless.freq_to_channel(self._nm_device.get_frequency())
-        if state == nmclient.DEVICE_STATE_ACTIVATING and chan == self.channel:
+        if state == network.DEVICE_STATE_ACTIVATING and chan == self.channel:
             self._disconnect_item.hide()
             self.props.pulsing = True
-        elif state == nmclient.DEVICE_STATE_ACTIVATED and chan == self.channel:
+        elif state == network.DEVICE_STATE_ACTIVATED and chan == self.channel:
             self._disconnect_item.show()
             self.props.pulsing = False
-        elif state == nmclient.DEVICE_STATE_INACTIVE or chan != self.channel:
+        elif state == network.DEVICE_STATE_INACTIVE or chan != self.channel:
             self._disconnect_item.hide()
             self.props.pulsing = False
 
diff --git a/src/jarabe/frame/devices/mesh.py b/src/jarabe/frame/devices/mesh.py
index d6248e2..9be65eb 100644
--- a/src/jarabe/frame/devices/mesh.py
+++ b/src/jarabe/frame/devices/mesh.py
@@ -15,6 +15,7 @@
 # along with this program; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
+import logging
 from gettext import gettext as _
 
 import gtk
@@ -26,7 +27,7 @@ from sugar.graphics.palette import Palette
 
 from jarabe.model.devices import device
 from jarabe.model.devices import wireless
-from jarabe.hardware import hardwaremanager
+from jarabe.model import network
 from jarabe.frame.frameinvoker import FrameWidgetInvoker
 
 class DeviceView(TrayIcon):
@@ -99,7 +100,7 @@ class MeshPalette(Palette):
     def _disconnect_activate_cb(self, menuitem):
         # Disconnection for an mesh means activating the default mesh device
         # again without a channel
-        network_manager = hardwaremanager.get_network_manager()
+        network_manager = network.get_manager()
         nm_device = self._model.get_nm_device()
         if network_manager and nm_device:
             network_manager.set_active_device(nm_device)
@@ -125,7 +126,6 @@ class MeshPalette(Palette):
         if len(label):
             self._step_label.set_text(label)
         else:
-            import logging
             logging.debug("Unhandled mesh step %d" % step)
             self._step_label.set_text(_("Unknown Mesh"))
 
diff --git a/src/jarabe/frame/devices/wireless.py b/src/jarabe/frame/devices/wireless.py
index 6be74fb..8db1984 100644
--- a/src/jarabe/frame/devices/wireless.py
+++ b/src/jarabe/frame/devices/wireless.py
@@ -26,8 +26,7 @@ from sugar.graphics.palette import Palette
 
 from jarabe.model.devices import wireless
 from jarabe.model.devices import device
-from jarabe.hardware import hardwaremanager
-from jarabe.hardware import nmclient
+from jarabe.model import network
 from jarabe.frame.frameinvoker import FrameWidgetInvoker
 
 _ICON_NAME = 'network-wireless'
@@ -41,9 +40,9 @@ class DeviceView(TrayIcon):
         self._model = model
 
         meshdev = None
-        network_manager = hardwaremanager.get_network_manager()
+        network_manager = network.get_manager()
         for dev in network_manager.get_devices():
-            if dev.get_type() == nmclient.DEVICE_TYPE_802_11_MESH_OLPC:
+            if dev.get_type() == network.DEVICE_TYPE_802_11_MESH_OLPC:
                 meshdev = dev
                 break
 
@@ -131,7 +130,7 @@ class WirelessPalette(Palette):
 
     def _disconnect_activate_cb(self, menuitem):
         # Disconnection for an AP means activating the default mesh device
-        network_manager = hardwaremanager.get_network_manager()
+        network_manager = network.get_manager()
         if network_manager and self._meshdev:
             network_manager.set_active_device(self._meshdev)
 
diff --git a/src/jarabe/hardware/Makefile.am b/src/jarabe/hardware/Makefile.am
index 6684848..1a05c88 100644
--- a/src/jarabe/hardware/Makefile.am
+++ b/src/jarabe/hardware/Makefile.am
@@ -2,9 +2,6 @@ sugardir = $(pythondir)/jarabe/hardware
 sugar_PYTHON =				\
 	__init__.py			\
 	hardwaremanager.py		\
-	keydialog.py			\
-	nmclient.py			\
-	nminfo.py			\
 	schoolserver.py
 
 dbusservicedir = $(sysconfdir)/dbus-1/system.d/
diff --git a/src/jarabe/hardware/hardwaremanager.py b/src/jarabe/hardware/hardwaremanager.py
index 22cb1db..d43d8d6 100644
--- a/src/jarabe/hardware/hardwaremanager.py
+++ b/src/jarabe/hardware/hardwaremanager.py
@@ -19,7 +19,6 @@ import logging
 import dbus
 import gobject
 
-from jarabe.hardware.nmclient import NMClient
 from sugar.profile import get_profile
 from sugar import env
 from sugar import _sugarext
@@ -111,13 +110,4 @@ class HardwareManager(gobject.GObject):
 def get_manager():
     return _manager
 
-def get_network_manager():
-    return _network_manager
-
 _manager = HardwareManager()
-
-try:
-    _network_manager = NMClient()
-except dbus.DBusException, e:
-    _network_manager = None
-    logging.info('Network manager service not found.')
diff --git a/src/jarabe/hardware/nmclient.py b/src/jarabe/hardware/nmclient.py
deleted file mode 100644
index b1921aa..0000000
--- a/src/jarabe/hardware/nmclient.py
+++ /dev/null
@@ -1,759 +0,0 @@
-#
-# Copyright (C) 2006-2007 Red Hat, Inc.
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 2 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
-
-import logging
-
-import dbus
-import dbus.glib
-import dbus.decorators
-import gobject
-
-from jarabe.hardware import nminfo
-from sugar.graphics import xocolor
-
-IW_AUTH_ALG_OPEN_SYSTEM = 0x00000001
-IW_AUTH_ALG_SHARED_KEY  = 0x00000002
-
-NM_DEVICE_STAGE_STRINGS = ("Unknown",
-                           "Prepare",
-                           "Config",
-                           "Need Users Key",
-                           "IP Config",
-                           "IP Config Get",
-                           "IP Config Commit",
-                           "Activated",
-                           "Failed",
-                           "Canceled"
-                           )
-
-NM_SERVICE = 'org.freedesktop.NetworkManager'
-NM_IFACE = 'org.freedesktop.NetworkManager'
-NM_IFACE_DEVICES = 'org.freedesktop.NetworkManager.Devices'
-NM_PATH = '/org/freedesktop/NetworkManager'
-
-DEVICE_TYPE_UNKNOWN = 0
-DEVICE_TYPE_802_3_ETHERNET = 1
-DEVICE_TYPE_802_11_WIRELESS = 2
-DEVICE_TYPE_802_11_MESH_OLPC = 3
-
-NM_DEVICE_CAP_NONE = 0x00000000
-NM_DEVICE_CAP_NM_SUPPORTED = 0x00000001
-NM_DEVICE_CAP_CARRIER_DETECT = 0x00000002
-NM_DEVICE_CAP_WIRELESS_SCAN = 0x00000004
-
-sys_bus = dbus.SystemBus()
-
-NM_802_11_CAP_NONE            = 0x00000000
-NM_802_11_CAP_PROTO_NONE      = 0x00000001
-NM_802_11_CAP_PROTO_WEP       = 0x00000002
-NM_802_11_CAP_PROTO_WPA       = 0x00000004
-NM_802_11_CAP_PROTO_WPA2      = 0x00000008
-NM_802_11_CAP_KEY_MGMT_PSK    = 0x00000040
-NM_802_11_CAP_KEY_MGMT_802_1X = 0x00000080
-NM_802_11_CAP_CIPHER_WEP40    = 0x00001000
-NM_802_11_CAP_CIPHER_WEP104   = 0x00002000
-NM_802_11_CAP_CIPHER_TKIP     = 0x00004000
-NM_802_11_CAP_CIPHER_CCMP     = 0x00008000
-
-NETWORK_STATE_CONNECTING   = 0
-NETWORK_STATE_CONNECTED    = 1
-NETWORK_STATE_NOTCONNECTED = 2
-
-DEVICE_STATE_ACTIVATING = 0
-DEVICE_STATE_ACTIVATED  = 1
-DEVICE_STATE_INACTIVE   = 2
-
-IW_MODE_ADHOC = 1
-IW_MODE_INFRA = 2
-
-class Network(gobject.GObject):
-    __gsignals__ = {
-        'initialized'     : (gobject.SIGNAL_RUN_FIRST,
-                             gobject.TYPE_NONE, ([gobject.TYPE_BOOLEAN])),
-        'strength-changed': (gobject.SIGNAL_RUN_FIRST,
-                             gobject.TYPE_NONE, ([])),
-        'state-changed'   : (gobject.SIGNAL_RUN_FIRST,
-                             gobject.TYPE_NONE, ([]))
-    }
-
-    def __init__(self, client, op):
-        gobject.GObject.__init__(self)
-        self._client = client
-        self._op = op
-        self._ssid = None
-        self._mode = None
-        self._strength = 0
-        self._caps = 0
-        self._valid = False
-        self._favorite = False
-        self._state = NETWORK_STATE_NOTCONNECTED
-
-        obj = sys_bus.get_object(NM_SERVICE, self._op)
-        net = dbus.Interface(obj, NM_IFACE_DEVICES)
-        net.getProperties(reply_handler=self._update_reply_cb,
-                error_handler=self._update_error_cb)
-
-    def _update_reply_cb(self, *props):
-        self._ssid = props[1]
-        self._strength = props[3]
-        self._mode = props[6]
-        self._caps = props[7]
-        if self._caps & NM_802_11_CAP_PROTO_WPA or \
-                self._caps & NM_802_11_CAP_PROTO_WPA2:
-            if not (self._caps & NM_802_11_CAP_KEY_MGMT_PSK):
-                # 802.1x is not supported at this time
-                logging.debug("Net(%s): ssid '%s' dropping because 802.1x" \
-                              "is unsupported" % (self._op, self._ssid))
-                self._valid = False
-                self.emit('initialized', self._valid)
-                return
-        if self._mode != IW_MODE_INFRA:
-            # Don't show Ad-Hoc networks; they usually don't DHCP and therefore
-            # won't work well here.  This also works around the bug where
-            # we show our own mesh SSID on the Mesh view when in mesh mode
-            logging.debug("Net(%s): ssid '%s' is adhoc; not showing" %
-                          (self._op, self._ssid))
-            self._valid = False
-            self.emit('initialized', self._valid)
-            return
-
-        fav_nets = []
-        if self._client.nminfo:
-            fav_nets = self._client.nminfo.get_networks(
-                    nminfo.NETWORK_TYPE_ALLOWED)
-        if self._ssid in fav_nets:
-            self._favorite = True
-
-        self._valid = True
-        logging.debug("Net(%s): caps 0x%X" % (self._ssid, self._caps))
-        self.emit('initialized', self._valid)
-
-    def _update_error_cb(self, err):
-        logging.debug("Net(%s): failed to update. (%s)" % (self._op, err))
-        self._valid = False
-        self.emit('initialized', self._valid)
-
-    def get_colors(self):
-        import sha
-        sh = sha.new()
-        data = self._ssid + hex(self._caps) + hex(self._mode)
-        sh.update(data)
-        h = hash(sh.digest())
-        idx = h % len(xocolor.colors)
-        # stroke, fill
-        return (xocolor.colors[idx][0], xocolor.colors[idx][1])
-
-    def get_ssid(self):
-        return self._ssid
-
-    def get_caps(self):
-        return self._caps
-
-    def get_mode(self):
-        return self._mode
-
-    def get_state(self):
-        return self._state
-
-    def set_state(self, state):
-        if state == self._state:
-            return
-        self._state = state
-        if self._valid:
-            self.emit('state-changed')
-
-    def get_op(self):
-        return self._op
-
-    def get_strength(self):
-        return self._strength
-
-    def set_strength(self, strength):
-        if strength == self._strength:
-            return
-        self._strength = strength
-        if self._valid:
-            self.emit('strength-changed')
-
-    def is_valid(self):
-        return self._valid
-
-    def is_favorite(self):
-        return self._favorite
-
-class Device(gobject.GObject):
-    __gsignals__ = {
-        'initialized':              (gobject.SIGNAL_RUN_FIRST,
-                                     gobject.TYPE_NONE, ([])),
-        'init-failed':              (gobject.SIGNAL_RUN_FIRST,
-                                     gobject.TYPE_NONE, ([])),
-        'ssid-changed':             (gobject.SIGNAL_RUN_FIRST,
-                                     gobject.TYPE_NONE, ([])),
-        'strength-changed':         (gobject.SIGNAL_RUN_FIRST,
-                                     gobject.TYPE_NONE, ([])),
-        'state-changed':            (gobject.SIGNAL_RUN_FIRST,
-                                     gobject.TYPE_NONE, ([])),
-        'activation-stage-changed': (gobject.SIGNAL_RUN_FIRST,
-                                     gobject.TYPE_NONE, ([])),
-        'network-appeared':         (gobject.SIGNAL_RUN_FIRST,
-                                     gobject.TYPE_NONE,
-                                     ([gobject.TYPE_PYOBJECT])),
-        'network-disappeared':      (gobject.SIGNAL_RUN_FIRST,
-                                     gobject.TYPE_NONE,
-                                     ([gobject.TYPE_PYOBJECT]))
-    }
-
-    def __init__(self, client, op):
-        gobject.GObject.__init__(self)
-        self._client = client
-        self._op = op
-        self._iface = None
-        self._type = DEVICE_TYPE_UNKNOWN
-        self._udi = None
-        self._active = False
-        self._act_stage = 0
-        self._strength = 0
-        self._freq = 0.0
-        self._link = False
-        self._valid = False
-        self._networks = {}
-        self._caps = 0
-        self._state = DEVICE_STATE_INACTIVE
-        self._active_network = None
-        self._active_net_sigid = 0
-
-        obj = sys_bus.get_object(NM_SERVICE, self._op)
-        self.dev = dbus.Interface(obj, NM_IFACE_DEVICES)
-        self.dev.getProperties(reply_handler=self._update_reply_cb,
-                error_handler=self._update_error_cb)
-
-    def _is_activating(self):
-        if self._active and self._act_stage >= 1 and self._act_stage <= 6:
-            return True
-        return False
-
-    def _is_activated(self):
-        if self._active and self._act_stage == 7:
-            return True
-        return False
-
-    def _update_reply_cb(self, *props):
-        self._iface = props[1]
-        self._type = props[2]
-        self._udi = props[3]
-        self._active = props[4]
-        self._act_stage = props[5]
-        self._link = props[15]
-        self._caps = props[17]
-
-        if self._type == DEVICE_TYPE_802_11_WIRELESS:
-            old_strength = self._strength
-            self._strength = props[14]
-            if self._strength != old_strength:
-                if self._valid:
-                    self.emit('strength-changed')
-            self._update_networks(props[20], props[19])
-        elif self._type ==  DEVICE_TYPE_802_11_MESH_OLPC:
-            old_strength = self._strength
-            self._strength = props[14]
-            if self._strength != old_strength:
-                if self._valid:
-                    self.emit('strength-changed')
-
-        self._valid = True
-
-        if self._is_activating():
-            self.set_state(DEVICE_STATE_ACTIVATING)
-        elif self._is_activated():
-            self.set_state(DEVICE_STATE_ACTIVATED)
-        else:
-            self.set_state(DEVICE_STATE_INACTIVE)
-
-        self.emit('initialized')
-
-    def _update_networks(self, net_ops, active_op):
-        for op in net_ops:
-            net = Network(self._client, op)
-            self._networks[op] = net
-            net.connect('initialized', lambda *args:
-                        self._net_initialized_cb(active_op, *args))
-
-    def _update_error_cb(self, err):
-        logging.debug("Device(%s): failed to update. (%s)" % (self._op, err))
-        self._valid = False
-        self.emit('init-failed')
-
-    def _net_initialized_cb(self, active_op, net, valid):
-        net_op = net.get_op()
-        if not self._networks.has_key(net_op):
-            return
-
-        if not valid:
-            # init failure
-            del self._networks[net_op]
-            return
-
-        # init success
-        if self._valid:
-            self.emit('network-appeared', net)
-        if active_op and net_op == active_op:
-            self.set_active_network(net)
-
-    def get_op(self):
-        return self._op
-
-    def get_networks(self):
-        ret = []
-        for net in self._networks.values():
-            if net.is_valid():
-                ret.append(net)
-        return ret
-
-    def get_network(self, op):
-        if self._networks.has_key(op) and self._networks[op].is_valid():
-            return self._networks[op]
-        return None
-
-    def get_network_ops(self):
-        ret = []
-        for net in self._networks.values():
-            if net.is_valid():
-                ret.append(net.get_op())
-        return ret
-
-    def get_mesh_step(self):
-        if self._type !=  DEVICE_TYPE_802_11_MESH_OLPC:
-            raise RuntimeError("Only valid for mesh devices")
-        try:
-            step = self.dev.getMeshStep(timeout=3)
-        except dbus.DBusException:
-            step = 0
-        return step
-
-    def get_frequency(self):
-        try:
-            freq = self.dev.getFrequency(timeout=3)
-        except dbus.DBusException:
-            freq = 0.0
-        # Hz -> GHz
-        self._freq = freq / 1000000000.0
-        return self._freq
-
-    def get_strength(self):
-        return self._strength
-
-    def set_strength(self, strength):
-        if strength == self._strength:
-            return False
-
-        if strength >= 0 and strength <= 100:
-            self._strength = strength
-        else:
-            self._strength = 0
-
-        if self._valid:
-            self.emit('strength-changed')
-
-    def network_appeared(self, network):
-        # NM may emit NetworkAppeared messages before the initialization-time
-        # getProperties call completes. This means that we are in danger of
-        # instantiating the "appeared" network here, and then instantiating
-        # the same network later on when getProperties completes
-        # (_update_reply_cb calls _update_networks).
-        # We avoid this race by confirming that getProperties has completed
-        # before listening to any NetworkAppeared messages. We assume that
-        # any networks that get reported as appeared in this race window
-        # will be included in the getProperties response.
-        if not self._valid:
-            return
-
-        if self._networks.has_key(network):
-            return
-        net = Network(self._client, network)
-        self._networks[network] = net
-        net.connect('initialized', lambda *args:
-                    self._net_initialized_cb(None, *args))
-
-    def network_disappeared(self, network):
-        if not self._networks.has_key(network):
-            return
-
-        if self._valid:
-            self.emit('network-disappeared', self._networks[network])
-
-        del self._networks[network]
-
-    def set_active_network(self, network):
-        if self._active_network == network:
-            return
-
-        # Make sure the old one doesn't get a stuck state
-        if self._active_network:
-            self._active_network.set_state(NETWORK_STATE_NOTCONNECTED)
-            self._active_network.disconnect(self._active_net_sigid)
-
-        self._active_network = network
-
-        if self._active_network:
-            self._active_net_sigid = self._active_network.connect(
-                    "initialized", self._active_net_initialized)
-
-        # don't emit ssid-changed for networks that are not yet valid
-        if self._valid:
-            if self._active_network and self._active_network.is_valid():
-                self.emit('ssid-changed')
-            elif not self._active_network:
-                self.emit('ssid-changed')
-
-    def _active_net_initialized(self, net, user_data=None):
-        if self._active_network and self._active_network.is_valid():
-            self.emit('ssid-changed')
-
-    def _get_active_net_cb(self, state, net_op):
-        if not self._networks.has_key(net_op):
-            self.set_active_network(None)
-            return
-
-        self.set_active_network(self._networks[net_op])
-
-        _device_to_network_state = {
-            DEVICE_STATE_ACTIVATING : NETWORK_STATE_CONNECTING,
-            DEVICE_STATE_ACTIVATED  : NETWORK_STATE_CONNECTED,
-            DEVICE_STATE_INACTIVE   : NETWORK_STATE_NOTCONNECTED
-        }
-
-        network_state = _device_to_network_state[state]
-        self._active_network.set_state(network_state)
-
-    def _get_active_net_error_cb(self, err):
-        logging.debug("Couldn't get active network: %s" % err)
-        self.set_active_network(None)
-
-    def get_state(self):
-        return self._state
-
-    def set_state(self, state):
-        if state == self._state:
-            return
-
-        if state == DEVICE_STATE_INACTIVE:
-            self._act_stage = 0
-
-        self._state = state
-        if self._valid:
-            self.emit('state-changed')
-
-        if self._type == DEVICE_TYPE_802_11_WIRELESS:
-            if state == DEVICE_STATE_INACTIVE:
-                self.set_active_network(None)
-            else:
-                self.dev.getActiveNetwork(
-                    reply_handler=lambda *args:
-                    self._get_active_net_cb(state, *args),
-                    error_handler=self._get_active_net_error_cb)
-
-    def set_activation_stage(self, stage):
-        if stage == self._act_stage:
-            return
-        self._act_stage = stage
-        if self._valid:
-            self.emit('activation-stage-changed')
-
-    def get_activation_stage(self):
-        return self._act_stage
-
-    def get_ssid(self):
-        if self._active_network and self._active_network.is_valid():
-            return self._active_network.get_ssid()
-        elif not self._active_network:
-            return None
-
-    def get_active_network(self):
-        return self._active_network
-
-    def get_type(self):
-        return self._type
-
-    def is_valid(self):
-        return self._valid
-
-    def set_carrier(self, on):
-        self._link = on
-
-    def get_capabilities(self):
-        return self._caps
-
-class NMClient(gobject.GObject):
-    __gsignals__ = {
-        'device-added'     : (gobject.SIGNAL_RUN_FIRST,
-                              gobject.TYPE_NONE,
-                             ([gobject.TYPE_PYOBJECT])),
-        'device-activated' : (gobject.SIGNAL_RUN_FIRST,
-                              gobject.TYPE_NONE,
-                             ([gobject.TYPE_PYOBJECT])),
-        'device-activating': (gobject.SIGNAL_RUN_FIRST,
-                              gobject.TYPE_NONE,
-                             ([gobject.TYPE_PYOBJECT])),
-        'device-removed'   : (gobject.SIGNAL_RUN_FIRST,
-                              gobject.TYPE_NONE,
-                             ([gobject.TYPE_PYOBJECT]))
-    }
-
-    def __init__(self):
-        gobject.GObject.__init__(self)
-
-        self.nminfo = None
-        self._nm_present = False
-        self._nm_proxy = None
-        self._nm_obj = None
-        self._sig_handlers = None
-        self._update_timer = 0
-        self._devices = {}
-
-        self.nminfo = nminfo.NMInfo(self)
-        
-        self._setup_dbus()
-        if self._nm_present:
-            self._get_initial_devices()
-
-    def get_devices(self):
-        return self._devices.values()
-
-    def _get_initial_devices_reply_cb(self, ops):
-        for op in ops:
-            self._add_device(op)
-
-    def _dev_initialized_cb(self, dev):
-        self.emit('device-added', dev)
-
-    def _dev_init_failed_cb(self, dev):
-        # Device failed to initialize, likely due to dbus errors or something
-        op = dev.get_op()
-        self._remove_device(op)
-
-    def _get_initial_devices_error_cb(self, err):
-        logging.debug("Error updating devices (%s)" % err)
-
-    def _get_initial_devices(self):
-        self._nm_obj.getDevices(
-            reply_handler=self._get_initial_devices_reply_cb,
-            error_handler=self._get_initial_devices_error_cb)
-
-    def _add_device(self, dev_op):
-        if self._devices.has_key(dev_op):
-            return
-        dev = Device(self, dev_op)
-        self._devices[dev_op] = dev
-        dev.connect('init-failed', self._dev_init_failed_cb)
-        dev.connect('initialized', self._dev_initialized_cb)
-        dev.connect('state-changed', self._dev_state_changed_cb)
-
-    def _remove_device(self, dev_op):
-        if not self._devices.has_key(dev_op):
-            return
-        dev = self._devices[dev_op]
-        if dev.is_valid():
-            self.emit('device-removed', dev)
-        del self._devices[dev_op]
-
-    def _dev_state_changed_cb(self, dev):
-        op = dev.get_op()
-        if not self._devices.has_key(op) or not dev.is_valid():
-            return
-        if dev.get_state() == DEVICE_STATE_ACTIVATING:
-            self.emit('device-activating', dev)
-        elif dev.get_state() == DEVICE_STATE_ACTIVATED:
-            self.emit('device-activated', dev)
-
-    def get_device(self, dev_op):
-        if not self._devices.has_key(dev_op):
-            return None
-        return self._devices[dev_op]
-
-    def _setup_dbus(self):
-        self._sig_handlers = {
-            'StateChange': self.state_changed_sig_handler,
-            'DeviceAdded': self.device_added_sig_handler,
-            'DeviceRemoved': self.device_removed_sig_handler,
-            'DeviceActivationStage': self.device_activation_stage_sig_handler,
-            'DeviceActivating': self.device_activating_sig_handler,
-            'DeviceNowActive': self.device_now_active_sig_handler,
-            'DeviceNoLongerActive': self.device_no_longer_active_sig_handler,
-            'DeviceActivationFailed': \
-                self.device_activation_failed_sig_handler,
-            'DeviceCarrierOn': self.device_carrier_on_sig_handler,
-            'DeviceCarrierOff': self.device_carrier_off_sig_handler,
-            'DeviceStrengthChanged': \
-                self.wireless_device_strength_changed_sig_handler,
-            'WirelessNetworkAppeared': \
-                self.wireless_network_appeared_sig_handler,
-            'WirelessNetworkDisappeared': \
-                self.wireless_network_disappeared_sig_handler,
-            'WirelessNetworkStrengthChanged': \
-                self.wireless_network_strength_changed_sig_handler
-        }
-
-        try:
-            self._nm_proxy = sys_bus.get_object(NM_SERVICE, NM_PATH,
-                                                follow_name_owner_changes=True)
-            self._nm_obj = dbus.Interface(self._nm_proxy, NM_IFACE)
-        except dbus.DBusException, e:
-            logging.debug("Could not connect to NetworkManager: %s" % e)
-            self._nm_present = False
-            return
-
-        sys_bus.add_signal_receiver(self.name_owner_changed_sig_handler,
-                                         signal_name="NameOwnerChanged",
-                                         dbus_interface="org.freedesktop.DBus")
-
-        for (signal, handler) in self._sig_handlers.items():
-            sys_bus.add_signal_receiver(handler, signal_name=signal,
-                                        dbus_interface=NM_IFACE)
-
-        # Find out whether or not NMI is running
-        try:
-            bus_object = sys_bus.get_object('org.freedesktop.DBus',
-                                            '/org/freedesktop/DBus')
-            name_ = bus_object.GetNameOwner( \
-                    "org.freedesktop.NetworkManagerInfo",
-                    dbus_interface='org.freedesktop.DBus')
-            self._nm_present = True
-        except dbus.DBusException:
-            self._nm_present = False
-
-    def set_active_device(self, device, network=None,
-                          mesh_freq=None, mesh_start=None):
-        ssid = ""
-        if network:
-            ssid = network.get_ssid()
-        if device.get_type() == DEVICE_TYPE_802_11_MESH_OLPC:
-            if mesh_freq or mesh_start:
-                if mesh_freq and not mesh_start:
-                    self._nm_obj.setActiveDevice(device.get_op(),
-                                                 dbus.Double(mesh_freq))
-                elif mesh_start and not mesh_freq:
-                    self._nm_obj.setActiveDevice(device.get_op(),
-                                                 dbus.Double(0.0),
-                                                 dbus.UInt32(mesh_start))
-                else:
-                    self._nm_obj.setActiveDevice(device.get_op(),
-                                                 dbus.Double(mesh_freq),
-                                                 dbus.UInt32(mesh_start))
-            else:
-                self._nm_obj.setActiveDevice(device.get_op())
-        else:
-            self._nm_obj.setActiveDevice(device.get_op(), ssid)
-
-    def state_changed_sig_handler(self, new_state):
-        logging.debug('NM State Changed to %d' % new_state)
-
-    def device_activation_stage_sig_handler(self, device, stage):
-        logging.debug('Device Activation Stage "%s" for device %s'
-                      % (NM_DEVICE_STAGE_STRINGS[stage], device))
-        if not self._devices.has_key(device):
-            logging.debug('DeviceActivationStage, device %s does not exist'
-                          % (device))
-            return
-        self._devices[device].set_activation_stage(stage)
-
-    def device_activating_sig_handler(self, device):
-        logging.debug('DeviceActivating for %s' % (device))
-        if not self._devices.has_key(device):
-            logging.debug('DeviceActivating, device %s does not exist'
-                          % (device))
-            return
-        self._devices[device].set_state(DEVICE_STATE_ACTIVATING)
-
-    def device_now_active_sig_handler(self, device, ssid=None):
-        logging.debug('DeviceNowActive for %s' % (device))
-        if not self._devices.has_key(device):
-            logging.debug('DeviceNowActive, device %s does not exist'
-                          % (device))
-            return
-        self._devices[device].set_state(DEVICE_STATE_ACTIVATED)
-
-    def device_no_longer_active_sig_handler(self, device):
-        logging.debug('DeviceNoLongerActive for %s' % (device))
-        if not self._devices.has_key(device):
-            logging.debug('DeviceNoLongerActive, device %s does not exist'
-                          % (device))
-            return
-        self._devices[device].set_state(DEVICE_STATE_INACTIVE)
-
-    def device_activation_failed_sig_handler(self, device, ssid=None):
-        logging.debug('DeviceActivationFailed for %s' % (device))
-        if not self._devices.has_key(device):
-            logging.debug('DeviceActivationFailed, device %s does not exist'
-                          % (device))
-            return
-        self._devices[device].set_state(DEVICE_STATE_INACTIVE)
-
-    def name_owner_changed_sig_handler(self, name, old, new):
-        if name != NM_SERVICE:
-            return
-        if (old and len(old)) and (not new and not len(new)):
-            # NM went away
-            self._nm_present = False
-            devs = self._devices.keys()
-            for op in devs:
-                self._remove_device(op)
-            self._devices = {}
-        elif (not old and not len(old)) and (new and len(new)):
-            # NM started up
-            self._nm_present = True
-            self._get_initial_devices()
-
-    def device_added_sig_handler(self, device):
-        logging.debug('DeviceAdded for %s' % (device))
-        self._add_device(device)
-
-    def device_removed_sig_handler(self, device):
-        logging.debug('DeviceRemoved for %s' % (device))
-        self._remove_device(device)
-
-    def wireless_network_appeared_sig_handler(self, device, network):
-        if not self._devices.has_key(device):
-            return
-        self._devices[device].network_appeared(network)
-
-    def wireless_network_disappeared_sig_handler(self, device, network):
-        if not self._devices.has_key(device):
-            return
-        self._devices[device].network_disappeared(network)
-
-    def wireless_device_strength_changed_sig_handler(self, device, strength):
-        if not self._devices.has_key(device):
-            return
-        self._devices[device].set_strength(strength)
-
-    def wireless_network_strength_changed_sig_handler(self, device,
-                                                      network, strength):
-        if not self._devices.has_key(device):
-            return
-        net = self._devices[device].get_network(network)
-        if net:
-            net.set_strength(strength)
-
-    def device_carrier_on_sig_handler(self, device):
-        if not self._devices.has_key(device):
-            return
-        self._devices[device].set_carrier(True)
-
-    def device_carrier_off_sig_handler(self, device):
-        if not self._devices.has_key(device):
-            return
-        self._devices[device].set_carrier(False)
diff --git a/src/jarabe/hardware/nminfo.py b/src/jarabe/hardware/nminfo.py
deleted file mode 100644
index 64c5ab3..0000000
--- a/src/jarabe/hardware/nminfo.py
+++ /dev/null
@@ -1,557 +0,0 @@
-# Copyright (C) 2006-2007 Red Hat, Inc.
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 2 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
-
-import time
-import os
-import binascii
-import ConfigParser
-import logging
-
-import gtk
-import dbus
-import dbus.service
-
-from sugar import env
-
-from jarabe.hardware import keydialog
-
-IW_AUTH_KEY_MGMT_802_1X = 0x1
-IW_AUTH_KEY_MGMT_PSK = 0x2
-
-IW_AUTH_WPA_VERSION_DISABLED = 0x00000001
-IW_AUTH_WPA_VERSION_WPA      = 0x00000002
-IW_AUTH_WPA_VERSION_WPA2     = 0x00000004
-
-NM_AUTH_TYPE_WPA_PSK_AUTO = 0x00000000
-IW_AUTH_CIPHER_NONE   = 0x00000001
-IW_AUTH_CIPHER_WEP40  = 0x00000002
-IW_AUTH_CIPHER_TKIP   = 0x00000004
-IW_AUTH_CIPHER_CCMP   = 0x00000008
-IW_AUTH_CIPHER_WEP104 = 0x00000010
-
-IW_AUTH_ALG_OPEN_SYSTEM = 0x00000001
-IW_AUTH_ALG_SHARED_KEY  = 0x00000002
-
-NM_INFO_IFACE = 'org.freedesktop.NetworkManagerInfo'
-NM_INFO_PATH = '/org/freedesktop/NetworkManagerInfo'
-
-
-class NoNetworks(dbus.DBusException):
-    def __init__(self):
-        dbus.DBusException.__init__(self)
-        self._dbus_error_name = NM_INFO_IFACE + '.NoNetworks'
-
-class CanceledKeyRequestError(dbus.DBusException):
-    def __init__(self):
-        dbus.DBusException.__init__(self)
-        self._dbus_error_name = NM_INFO_IFACE + '.CanceledError'
-
-
-class NetworkInvalidError(Exception):
-    pass
-
-
-class NMConfig(ConfigParser.ConfigParser):
-    def get_bool(self, section, name):
-        opt = self.get(section, name)
-        if type(opt) == str:
-            if opt.lower() == 'yes' or opt.lower() == 'true':
-                return True
-            elif opt.lower() == 'no' or opt.lower() == 'false':
-                return False
-        raise ValueError("Invalid format for %s/%s.  Should be one of" \
-                         " [yes, no, true, false]." % (section, name))
-
-    def get_list(self, section, name):
-        opt = self.get(section, name)
-        if type(opt) != str or not len(opt):
-            return []
-        try:
-            return opt.split()
-        except Exception:
-            raise ValueError("Invalid format for %s/%s.  Should be a" \
-                             " space-separate list." % (section, name))
-
-    def get_int(self, section, name):
-        opt = self.get(section, name)
-        try:
-            return int(opt)
-        except ValueError:
-            raise ValueError("Invalid format for %s/%s.  Should be a" \
-                             " valid integer." % (section, name))
-
-    def get_float(self, section, name):
-        opt = self.get(section, name)
-        try:
-            return float(opt)
-        except ValueError:
-            raise ValueError("Invalid format for %s/%s.  Should be a" \
-                             " valid float." % (section, name))
-
-
-NETWORK_TYPE_UNKNOWN = 0
-NETWORK_TYPE_ALLOWED = 1
-NETWORK_TYPE_INVALID = 2
-
-
-class Security(object):
-    def __init__(self, we_cipher):
-        self._we_cipher = we_cipher
-        self._key = None
-        self._auth_alg = None
-
-    def read_from_config(self, cfg, name):
-        pass
-
-    def read_from_args(self, args):
-        pass
-
-    def new_from_config(cfg, name):
-        security = None
-        we_cipher = cfg.get_int(name, "we_cipher")
-        if we_cipher == IW_AUTH_CIPHER_NONE:
-            security = Security(we_cipher)
-        elif we_cipher == IW_AUTH_CIPHER_WEP40 or \
-                        we_cipher == IW_AUTH_CIPHER_WEP104:
-            security = WEPSecurity(we_cipher)
-        elif we_cipher == NM_AUTH_TYPE_WPA_PSK_AUTO or \
-                        we_cipher == IW_AUTH_CIPHER_CCMP or \
-                        we_cipher == IW_AUTH_CIPHER_TKIP:
-            security = WPASecurity(we_cipher)
-        else:
-            raise ValueError("Unsupported security combo")
-        security.read_from_config(cfg, name)
-        return security
-    new_from_config = staticmethod(new_from_config)
-
-    def new_from_args(we_cipher, args):
-        security = None
-        try:
-            if we_cipher == IW_AUTH_CIPHER_NONE:
-                security = Security(we_cipher)
-            elif we_cipher == IW_AUTH_CIPHER_WEP40 or \
-                            we_cipher == IW_AUTH_CIPHER_WEP104:
-                security = WEPSecurity(we_cipher)
-            elif we_cipher == NM_AUTH_TYPE_WPA_PSK_AUTO or \
-                            we_cipher == IW_AUTH_CIPHER_CCMP or \
-                            we_cipher == IW_AUTH_CIPHER_TKIP:
-                security = WPASecurity(we_cipher)
-            else:
-                raise ValueError("Unsupported security combo")
-            security.read_from_args(args)
-        except ValueError, e:
-            logging.debug("Error reading security information: %s" % e)
-            del security
-            return None
-        return security
-    new_from_args = staticmethod(new_from_args)
-
-    def get_properties(self):
-        return [dbus.Int32(self._we_cipher)]
-
-    def write_to_config(self, section, config):
-        config.set(section, "we_cipher", self._we_cipher)
-
-
-class WEPSecurity(Security):
-    def read_from_args(self, args):
-        if len(args) != 2:
-            raise ValueError("not enough arguments")
-        key = args[0]
-        auth_alg = args[1]
-        if isinstance(key, unicode):
-            key = key.encode()
-        if not isinstance(key, str):
-            raise ValueError("wrong argument type for key")
-        if not isinstance(auth_alg, int):
-            raise ValueError("wrong argument type for auth_alg")
-        self._key = key
-        self._auth_alg = auth_alg
-
-    def read_from_config(self, cfg, name):
-        # Key should be a hex encoded string
-        self._key = cfg.get(name, "key")
-        if self._we_cipher == IW_AUTH_CIPHER_WEP40 and len(self._key) != 10:
-            raise ValueError("Key length not right for 40-bit WEP")
-        if self._we_cipher == IW_AUTH_CIPHER_WEP104 and len(self._key) != 26:
-            raise ValueError("Key length not right for 104-bit WEP")
-
-        try:
-            binascii.a2b_hex(self._key)
-        except TypeError:
-            raise ValueError("Key was not a hexadecimal string.")
-            
-        self._auth_alg = cfg.get_int(name, "auth_alg")
-        if self._auth_alg != IW_AUTH_ALG_OPEN_SYSTEM and \
-                self._auth_alg != IW_AUTH_ALG_SHARED_KEY:
-            raise ValueError("Invalid authentication algorithm %d"
-                             % self._auth_alg)
-
-    def get_properties(self):
-        args = Security.get_properties(self)
-        args.append(dbus.String(self._key))
-        args.append(dbus.Int32(self._auth_alg))
-        return args
-
-    def write_to_config(self, section, config):
-        Security.write_to_config(self, section, config)
-        config.set(section, "key", self._key)
-        config.set(section, "auth_alg", self._auth_alg)
-
-class WPASecurity(Security):
-    def __init__(self, we_cipher):
-        Security.__init__(self, we_cipher)
-        self._wpa_ver = None
-        self._key_mgmt = None
-
-    def read_from_args(self, args):
-        if len(args) != 3:
-            raise ValueError("not enough arguments")
-        key = args[0]
-        if isinstance(key, unicode):
-            key = key.encode()
-        if not isinstance(key, str):
-            raise ValueError("wrong argument type for key")
-
-        wpa_ver = args[1]
-        if not isinstance(wpa_ver, int):
-            raise ValueError("wrong argument type for WPA version")
-
-        key_mgmt = args[2]
-        if not isinstance(key_mgmt, int):
-            raise ValueError("wrong argument type for WPA key management")
-        if not key_mgmt & IW_AUTH_KEY_MGMT_PSK:
-            raise ValueError("Key management types other than" \
-                             " PSK are not supported")
-
-        self._key = key
-        self._wpa_ver = wpa_ver
-        self._key_mgmt = key_mgmt
-
-    def read_from_config(self, cfg, name):
-        # Key should be a hex encoded string
-        self._key = cfg.get(name, "key")
-        if len(self._key) != 64:
-            raise ValueError("Key length not right for WPA-PSK")
-
-        try:
-            binascii.a2b_hex(self._key)
-        except TypeError:
-            raise ValueError("Key was not a hexadecimal string.")
-            
-        self._wpa_ver = cfg.get_int(name, "wpa_ver")
-        if self._wpa_ver != IW_AUTH_WPA_VERSION_WPA and \
-                self._wpa_ver != IW_AUTH_WPA_VERSION_WPA2:
-            raise ValueError("Invalid WPA version %d" % self._wpa_ver)
-
-        self._key_mgmt = cfg.get_int(name, "key_mgmt")
-        if not self._key_mgmt & IW_AUTH_KEY_MGMT_PSK:
-            raise ValueError("Invalid WPA key management option %d"
-                             % self._key_mgmt)
-
-    def get_properties(self):
-        args = Security.get_properties(self)
-        args.append(dbus.String(self._key))
-        args.append(dbus.Int32(self._wpa_ver))
-        args.append(dbus.Int32(self._key_mgmt))
-        return args
-
-    def write_to_config(self, section, config):
-        Security.write_to_config(self, section, config)
-        config.set(section, "key", self._key)
-        config.set(section, "wpa_ver", self._wpa_ver)
-        config.set(section, "key_mgmt", self._key_mgmt)
-
-
-class Network:
-    def __init__(self, ssid):
-        self.ssid = ssid
-        self.timestamp = int(time.time())
-        self.bssids = []
-        self.we_cipher = 0
-        self._security = None
-
-    def get_properties(self):
-        bssid_list = dbus.Array([], signature="s")
-        for item in self.bssids:
-            bssid_list.append(dbus.String(item))
-        args = [dbus.String(self.ssid), dbus.Int32(self.timestamp),
-                dbus.Boolean(True), bssid_list]
-        args += self._security.get_properties()
-        return tuple(args)
-
-    def get_security(self):
-        return self._security.get_properties()
-
-    def set_security(self, security):
-        self._security = security
-
-    def read_from_args(self, auto, bssid, we_cipher, args):
-        if auto == False:
-            self.timestamp = int(time.time())
-        if not bssid in self.bssids:
-            self.bssids.append(bssid)
-
-        self._security = Security.new_from_args(we_cipher, args)
-        if not self._security:
-            raise NetworkInvalidError("Invalid security information")
-
-    def read_from_config(self, config):
-        try:
-            self.timestamp = config.get_int(self.ssid, "timestamp")
-        except (ConfigParser.NoOptionError, ValueError), e:
-            raise NetworkInvalidError(e)
-
-        try:
-            self._security = Security.new_from_config(config, self.ssid)
-        except Exception, e:
-            raise NetworkInvalidError(e)
-
-        # The following don't need to be present
-        try:
-            self.bssids = config.get_list(self.ssid, "bssids")
-        except (ConfigParser.NoOptionError, ValueError), e:
-            logging.debug("Error reading bssids: %s" % e)
-
-    def write_to_config(self, config):
-        try:
-            config.add_section(self.ssid)
-            config.set(self.ssid, "timestamp", self.timestamp)
-            if len(self.bssids) > 0:
-                opt = " "
-                opt = opt.join(self.bssids)
-                config.set(self.ssid, "bssids", opt)
-            self._security.write_to_config(self.ssid, config)
-        except Exception, e:
-            logging.debug("Error writing '%s': %s" % (self.ssid, e))
-
-
-class NotFoundError(dbus.DBusException):
-    pass
-class UnsupportedError(dbus.DBusException):
-    pass
-
-class NMInfoDBusServiceHelper(dbus.service.Object):
-    def __init__(self, parent):
-        self._parent = parent
-        bus = dbus.SystemBus()
-
-        # If NMI is already around, don't grab the NMI service
-        bus_object = bus.get_object('org.freedesktop.DBus',
-                                    '/org/freedesktop/DBus')
-        name = None
-        try:
-            name = bus_object.GetNameOwner( \
-                    "org.freedesktop.NetworkManagerInfo",
-                    dbus_interface='org.freedesktop.DBus')
-        except dbus.DBusException:
-            logging.debug("Error getting owner of NMI")
-        if name:
-            logging.info("NMI service already owned by %s, won't claim it."
-                          % name)
-
-        bus_name = dbus.service.BusName(NM_INFO_IFACE, bus=bus)
-        dbus.service.Object.__init__(self, bus_name, NM_INFO_PATH)
-
-    @dbus.service.method(NM_INFO_IFACE, in_signature='i', out_signature='as')
-    def getNetworks(self, net_type):
-        ssids = self._parent.get_networks(net_type)
-        if len(ssids) > 0:
-            return dbus.Array(ssids)
-
-        raise NoNetworks()
-
-    @dbus.service.method(NM_INFO_IFACE, in_signature='si',
-                         async_callbacks=('async_cb', 'async_err_cb'))
-    def getNetworkProperties(self, ssid, net_type, async_cb, async_err_cb):
-        self._parent.get_network_properties(ssid, net_type,
-                                            async_cb, async_err_cb)
-
-    @dbus.service.method(NM_INFO_IFACE)
-    def updateNetworkInfo(self, ssid, bauto, bssid, cipher, *args):
-        self._parent.update_network_info(ssid, bauto, bssid, cipher, args)
-
-    @dbus.service.method(NM_INFO_IFACE,
-                         async_callbacks=('async_cb', 'async_err_cb'))
-    def getKeyForNetwork(self, dev_path, net_path, ssid, attempt,
-                         new_key, async_cb, async_err_cb):
-        self._parent.get_key_for_network(dev_path, net_path, ssid,
-                attempt, new_key, async_cb, async_err_cb)
-
-    @dbus.service.method(NM_INFO_IFACE)
-    def cancelGetKeyForNetwork(self):
-        self._parent.cancel_get_key_for_network()
-
-class NMInfo(object):
-    def __init__(self, client):
-        profile_path = env.get_profile_path()
-        self._cfg_file = os.path.join(profile_path, "nm", "networks.cfg")
-        self._nmclient = client
-        self._allowed_networks = self._read_config()
-        self._dbus_helper = NMInfoDBusServiceHelper(self)
-        self._key_dialog = None
-
-    def save_config(self):
-        self._write_config(self._allowed_networks)
-
-    def _read_config(self):
-        if not os.path.exists(os.path.dirname(self._cfg_file)):
-            os.makedirs(os.path.dirname(self._cfg_file), 0755)
-        if not os.path.exists(self._cfg_file):
-            self._write_config({})
-            return {}
-
-        config = NMConfig()
-        config.read(self._cfg_file)
-        networks = {}
-        for name in config.sections():
-            try:
-                net = Network(name)
-                net.read_from_config(config)
-                networks[name] = net
-            except Exception, e:
-                logging.error("Error when processing config for" \
-                              " the network %s: %r" % (name, e))
-
-        del config
-        return networks
-
-    def _write_config(self, networks):
-        fp = open(self._cfg_file, 'w')
-        config = NMConfig()
-        for net in networks.values():
-            net.write_to_config(config)
-        config.write(fp)
-        fp.close()
-        del config
-
-    def get_networks(self, net_type):
-        if net_type != NETWORK_TYPE_ALLOWED:
-            raise ValueError("Bad network type")
-        nets = []
-        for net in self._allowed_networks.values():
-            nets.append(net.ssid)
-        logging.debug("Returning networks: %s" % nets)
-        return nets
-
-    def get_network_properties(self, ssid, net_type, async_cb, async_err_cb):
-        if not isinstance(ssid, unicode):
-            async_err_cb(ValueError("Invalid arguments; ssid must be unicode."))
-        if net_type != NETWORK_TYPE_ALLOWED:
-            async_err_cb(ValueError("Bad network type"))
-        if not self._allowed_networks.has_key(ssid):
-            async_err_cb(NotFoundError("Network '%s' not found." % ssid))
-        network = self._allowed_networks[ssid]
-        props = network.get_properties()
-
-        # DBus workaround: the normal method return handler wraps
-        # the returned arguments in a tuple and then converts that to a
-        # struct, but NetworkManager expects a plain list of arguments.
-        # It turns out that the async callback method return code _doesn't_
-        # wrap the returned arguments in a tuple, so as a workaround use
-        # the async callback stuff here even though we're not doing it
-        # asynchronously.
-        async_cb(*props)
-
-    def update_network_info(self, ssid, auto, bssid, we_cipher, args):
-        if not isinstance(ssid, unicode):
-            raise ValueError("Invalid arguments; ssid must be unicode.")
-        if self._allowed_networks.has_key(ssid):
-            del self._allowed_networks[ssid]
-        net = Network(ssid)
-        try:
-            net.read_from_args(auto, bssid, we_cipher, args)
-            logging.debug("Updated network information for '%s'." % ssid)
-            self._allowed_networks[ssid] = net
-            self.save_config()
-        except NetworkInvalidError, e:
-            logging.debug("Error updating network information: %s" % e)
-            del net
-
-    def get_key_for_network(self, dev_op, net_op, ssid, attempt,
-                            new_key, async_cb, async_err_cb):
-        from jarabe.hardware import nmclient
-
-        if not isinstance(ssid, unicode):
-            raise ValueError("Invalid arguments; ssid must be unicode.")
-        if self._allowed_networks.has_key(ssid) and not new_key:
-            # We've got the info already
-            net = self._allowed_networks[ssid]
-            async_cb(tuple(net.get_security()))
-            return
-
-        # Otherwise, ask the user for it
-        net = None
-        dev = self._nmclient.get_device(dev_op)
-        if not dev:
-            async_err_cb(NotFoundError("Device was unknown."))
-            return
-
-        if dev.get_type() == nmclient.DEVICE_TYPE_802_3_ETHERNET:
-            # We don't support wired 802.1x yet...
-            async_err_cb(UnsupportedError("Device type is unsupported by NMI."))
-            return
-
-        net = dev.get_network(net_op)
-        if not net:
-            async_err_cb(NotFoundError("Network was unknown."))
-            return
-
-        self._key_dialog = keydialog.new_key_dialog(net, async_cb, async_err_cb)
-        self._key_dialog.connect("response", self._key_dialog_response_cb)
-        self._key_dialog.connect("destroy", self._key_dialog_destroy_cb)
-        self._key_dialog.show_all()
-
-    def _key_dialog_destroy_cb(self, widget, data=None):
-        if widget != self._key_dialog:
-            return
-        self._key_dialog_response_cb(widget, gtk.RESPONSE_CANCEL)
-
-    def _key_dialog_response_cb(self, widget, response_id):
-        if widget != self._key_dialog:
-            return
-
-        (async_cb, async_err_cb) = self._key_dialog.get_callbacks()
-        security = None
-        if response_id == gtk.RESPONSE_OK:
-            security = self._key_dialog.create_security()
-        self._key_dialog = None
-        widget.destroy()
-
-        if response_id in [gtk.RESPONSE_CANCEL, gtk.RESPONSE_NONE]:
-            # key dialog dialog was canceled; send the error back to NM
-            async_err_cb(CanceledKeyRequestError())
-        elif response_id == gtk.RESPONSE_OK:
-            if not security:
-                raise RuntimeError("Invalid security arguments.")
-            props = security.get_properties()
-            a = tuple(props)
-            async_cb(*a)
-        else:
-            raise RuntimeError("Unhandled key dialog response %d" % response_id)
-
-    def cancel_get_key_for_network(self):
-        # Close the wireless key dialog and just have it return
-        # with the 'canceled' argument set to true
-        if not self._key_dialog:
-            return
-        self._key_dialog_destroy_cb(self._key_dialog)
-
-    # this method is invoked directly in-process (not by DBus).
-    def delete_all_networks(self):
-        self._allowed_networks = {}
-        self.save_config()
-
diff --git a/src/jarabe/model/Makefile.am b/src/jarabe/model/Makefile.am
index 78d0e58..019b573 100644
--- a/src/jarabe/model/Makefile.am
+++ b/src/jarabe/model/Makefile.am
@@ -11,6 +11,7 @@ sugar_PYTHON =			\
 	invites.py		\
 	owner.py		\
 	meshmodel.py		\
+        network.py              \
 	shellmodel.py		\
 	homeactivity.py		\
 	homemodel.py
diff --git a/src/jarabe/model/accesspointmodel.py b/src/jarabe/model/accesspointmodel.py
index a4760bc..4c016b8 100644
--- a/src/jarabe/model/accesspointmodel.py
+++ b/src/jarabe/model/accesspointmodel.py
@@ -16,16 +16,16 @@
 
 import gobject
 
-from jarabe.hardware import nmclient
+from jarabe.model import network
 
 STATE_CONNECTING   = 0
 STATE_CONNECTED    = 1
 STATE_NOTCONNECTED = 2
 
 _nm_state_to_state = {
-    nmclient.NETWORK_STATE_CONNECTED    : STATE_CONNECTED,
-    nmclient.NETWORK_STATE_CONNECTING   : STATE_CONNECTING,
-    nmclient.NETWORK_STATE_NOTCONNECTED : STATE_NOTCONNECTED
+    network.NETWORK_STATE_CONNECTED    : STATE_CONNECTED,
+    network.NETWORK_STATE_CONNECTING   : STATE_CONNECTING,
+    network.NETWORK_STATE_NOTCONNECTED : STATE_NOTCONNECTED
 }
 
 class AccessPointModel(gobject.GObject):
diff --git a/src/jarabe/model/devices/device.py b/src/jarabe/model/devices/device.py
index 8d62415..014a437 100644
--- a/src/jarabe/model/devices/device.py
+++ b/src/jarabe/model/devices/device.py
@@ -16,7 +16,7 @@
 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
 import gobject
-from jarabe.hardware import nmclient
+from jarabe.model import network
 
 from sugar import util
 
@@ -25,9 +25,9 @@ STATE_ACTIVATED  = 1
 STATE_INACTIVE   = 2
 
 nm_state_to_state = {
-    nmclient.DEVICE_STATE_ACTIVATING : STATE_ACTIVATING,
-    nmclient.DEVICE_STATE_ACTIVATED  : STATE_ACTIVATED,
-    nmclient.DEVICE_STATE_INACTIVE   : STATE_INACTIVE
+    network.DEVICE_STATE_ACTIVATING : STATE_ACTIVATING,
+    network.DEVICE_STATE_ACTIVATED  : STATE_ACTIVATED,
+    network.DEVICE_STATE_INACTIVE   : STATE_INACTIVE
 }
 
 class Device(gobject.GObject):
diff --git a/src/jarabe/model/devices/devicesmodel.py b/src/jarabe/model/devices/devicesmodel.py
index b87fd0f..390199a 100644
--- a/src/jarabe/model/devices/devicesmodel.py
+++ b/src/jarabe/model/devices/devicesmodel.py
@@ -24,8 +24,7 @@ from jarabe.model.devices import wireless
 from jarabe.model.devices import mesh
 from jarabe.model.devices import battery
 from jarabe.model.devices import speaker
-from jarabe.hardware import hardwaremanager
-from jarabe.hardware import nmclient
+from jarabe.model import network
 
 class DevicesModel(gobject.GObject):
     __gsignals__ = {
@@ -62,7 +61,7 @@ class DevicesModel(gobject.GObject):
             self.add_device(battery.Device(udi))
 
     def _observe_network_manager(self):
-        network_manager = hardwaremanager.get_network_manager()
+        network_manager = network.get_manager()
         if not network_manager:
             return
 
@@ -80,8 +79,8 @@ class DevicesModel(gobject.GObject):
 
     def _network_device_added_cb(self, network_manager, nm_device):
         state = nm_device.get_state()
-        if state == nmclient.DEVICE_STATE_ACTIVATING \
-                or state == nmclient.DEVICE_STATE_ACTIVATED:
+        if state == network.DEVICE_STATE_ACTIVATING or \
+           state == network.DEVICE_STATE_ACTIVATED:
             self._check_network_device(nm_device)
 
     def _network_device_activating_cb(self, network_manager, nm_device):
@@ -100,8 +99,8 @@ class DevicesModel(gobject.GObject):
             return
 
         dtype = nm_device.get_type()
-        if dtype == nmclient.DEVICE_TYPE_802_11_WIRELESS \
-           or dtype == nmclient.DEVICE_TYPE_802_11_MESH_OLPC:
+        if dtype == network.DEVICE_TYPE_802_11_WIRELESS \
+           or dtype == network.DEVICE_TYPE_802_11_MESH_OLPC:
             self._add_network_device(nm_device)
 
     def _get_network_device(self, nm_device):
@@ -117,13 +116,13 @@ class DevicesModel(gobject.GObject):
             return
 
         dtype = nm_device.get_type()
-        if dtype == nmclient.DEVICE_TYPE_802_11_WIRELESS:
+        if dtype == network.DEVICE_TYPE_802_11_WIRELESS:
             dev = wireless.Device(nm_device)
             self.add_device(dev)
             sigid = dev.connect('notify::state',
                                 self._network_device_state_changed_cb)
             self._sigids[dev] = sigid
-        if dtype == nmclient.DEVICE_TYPE_802_11_MESH_OLPC:
+        if dtype == network.DEVICE_TYPE_802_11_MESH_OLPC:
             dev = mesh.Device(nm_device)
             self.add_device(dev)
             sigid = dev.connect('notify::state',
diff --git a/src/jarabe/model/meshmodel.py b/src/jarabe/model/meshmodel.py
index 6eb5b84..3977da4 100644
--- a/src/jarabe/model/meshmodel.py
+++ b/src/jarabe/model/meshmodel.py
@@ -22,8 +22,7 @@ from sugar import activity
 
 from jarabe.model.buddymodel import BuddyModel
 from jarabe.model.accesspointmodel import AccessPointModel
-from jarabe.hardware import hardwaremanager
-from jarabe.hardware import nmclient
+from jarabe.model import network
 
 class ActivityModel:
     def __init__(self, act, bundle):
@@ -90,7 +89,7 @@ class MeshModel(gobject.GObject):
         self._pservice.get_activities_async(
                 reply_handler=self._get_activities_cb)
 
-        network_manager = hardwaremanager.get_network_manager()
+        network_manager = network.get_manager()
         if network_manager:
             for nm_device in network_manager.get_devices():
                 self._add_network_device(nm_device)
@@ -123,7 +122,7 @@ class MeshModel(gobject.GObject):
 
     def _add_network_device(self, nm_device):
         dtype = nm_device.get_type()
-        if dtype == nmclient.DEVICE_TYPE_802_11_WIRELESS:
+        if dtype == network.DEVICE_TYPE_802_11_WIRELESS:
             for nm_network in nm_device.get_networks():
                 self._add_access_point(nm_device, nm_network)
 
@@ -131,7 +130,7 @@ class MeshModel(gobject.GObject):
                               self._nm_network_appeared_cb)
             nm_device.connect('network-disappeared',
                               self._nm_network_disappeared_cb)
-        elif dtype == nmclient.DEVICE_TYPE_802_11_MESH_OLPC:
+        elif dtype == network.DEVICE_TYPE_802_11_MESH_OLPC:
             self._mesh = nm_device
             self.emit('mesh-added', self._mesh)
 
@@ -139,7 +138,7 @@ class MeshModel(gobject.GObject):
         if nm_device == self._mesh:
             self._mesh = None
             self.emit('mesh-removed')
-        elif nm_device.get_type() == nmclient.DEVICE_TYPE_802_11_WIRELESS:
+        elif nm_device.get_type() == network.DEVICE_TYPE_802_11_WIRELESS:
             aplist = self._access_points.values()
             for ap in aplist:
                 if ap.get_nm_device() == nm_device:
diff --git a/src/jarabe/model/network.py b/src/jarabe/model/network.py
new file mode 100644
index 0000000..da5c2a7
--- /dev/null
+++ b/src/jarabe/model/network.py
@@ -0,0 +1,1159 @@
+#
+# Copyright (C) 2006-2008 Red Hat, Inc.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+import time
+import os
+import binascii
+import ConfigParser
+import logging
+
+import dbus
+import dbus.glib
+import dbus.decorators
+import gobject
+
+from sugar.graphics import xocolor
+from sugar import env
+
+IW_AUTH_ALG_OPEN_SYSTEM = 0x00000001
+IW_AUTH_ALG_SHARED_KEY  = 0x00000002
+
+NM_DEVICE_STAGE_STRINGS = ("Unknown",
+                           "Prepare",
+                           "Config",
+                           "Need Users Key",
+                           "IP Config",
+                           "IP Config Get",
+                           "IP Config Commit",
+                           "Activated",
+                           "Failed",
+                           "Canceled"
+                           )
+
+NM_SERVICE = 'org.freedesktop.NetworkManager'
+NM_IFACE = 'org.freedesktop.NetworkManager'
+NM_IFACE_DEVICES = 'org.freedesktop.NetworkManager.Devices'
+NM_PATH = '/org/freedesktop/NetworkManager'
+
+DEVICE_TYPE_UNKNOWN = 0
+DEVICE_TYPE_802_3_ETHERNET = 1
+DEVICE_TYPE_802_11_WIRELESS = 2
+DEVICE_TYPE_802_11_MESH_OLPC = 3
+
+NM_DEVICE_CAP_NONE = 0x00000000
+NM_DEVICE_CAP_NM_SUPPORTED = 0x00000001
+NM_DEVICE_CAP_CARRIER_DETECT = 0x00000002
+NM_DEVICE_CAP_WIRELESS_SCAN = 0x00000004
+
+NM_802_11_CAP_NONE            = 0x00000000
+NM_802_11_CAP_PROTO_NONE      = 0x00000001
+NM_802_11_CAP_PROTO_WEP       = 0x00000002
+NM_802_11_CAP_PROTO_WPA       = 0x00000004
+NM_802_11_CAP_PROTO_WPA2      = 0x00000008
+NM_802_11_CAP_KEY_MGMT_PSK    = 0x00000040
+NM_802_11_CAP_KEY_MGMT_802_1X = 0x00000080
+NM_802_11_CAP_CIPHER_WEP40    = 0x00001000
+NM_802_11_CAP_CIPHER_WEP104   = 0x00002000
+NM_802_11_CAP_CIPHER_TKIP     = 0x00004000
+NM_802_11_CAP_CIPHER_CCMP     = 0x00008000
+
+NETWORK_STATE_CONNECTING   = 0
+NETWORK_STATE_CONNECTED    = 1
+NETWORK_STATE_NOTCONNECTED = 2
+
+DEVICE_STATE_ACTIVATING = 0
+DEVICE_STATE_ACTIVATED  = 1
+DEVICE_STATE_INACTIVE   = 2
+
+IW_MODE_ADHOC = 1
+IW_MODE_INFRA = 2
+
+IW_AUTH_KEY_MGMT_802_1X = 0x1
+IW_AUTH_KEY_MGMT_PSK = 0x2
+
+IW_AUTH_WPA_VERSION_DISABLED = 0x00000001
+IW_AUTH_WPA_VERSION_WPA      = 0x00000002
+IW_AUTH_WPA_VERSION_WPA2     = 0x00000004
+
+NM_AUTH_TYPE_WPA_PSK_AUTO = 0x00000000
+IW_AUTH_CIPHER_NONE   = 0x00000001
+IW_AUTH_CIPHER_WEP40  = 0x00000002
+IW_AUTH_CIPHER_TKIP   = 0x00000004
+IW_AUTH_CIPHER_CCMP   = 0x00000008
+IW_AUTH_CIPHER_WEP104 = 0x00000010
+
+IW_AUTH_ALG_OPEN_SYSTEM = 0x00000001
+IW_AUTH_ALG_SHARED_KEY  = 0x00000002
+
+NETWORK_TYPE_UNKNOWN = 0
+NETWORK_TYPE_ALLOWED = 1
+NETWORK_TYPE_INVALID = 2
+
+sys_bus = dbus.SystemBus()
+
+class NetworkInvalidError(Exception):
+    pass
+
+class NotFoundError(dbus.DBusException):
+    pass
+
+class UnsupportedError(dbus.DBusException):
+    pass
+
+class NMConfig(ConfigParser.ConfigParser):
+    def get_bool(self, section, name):
+        opt = self.get(section, name)
+        if type(opt) == str:
+            if opt.lower() == 'yes' or opt.lower() == 'true':
+                return True
+            elif opt.lower() == 'no' or opt.lower() == 'false':
+                return False
+        raise ValueError("Invalid format for %s/%s.  Should be one of" \
+                         " [yes, no, true, false]." % (section, name))
+
+    def get_list(self, section, name):
+        opt = self.get(section, name)
+        if type(opt) != str or not len(opt):
+            return []
+        try:
+            return opt.split()
+        except Exception:
+            raise ValueError("Invalid format for %s/%s.  Should be a" \
+                             " space-separate list." % (section, name))
+
+    def get_int(self, section, name):
+        opt = self.get(section, name)
+        try:
+            return int(opt)
+        except ValueError:
+            raise ValueError("Invalid format for %s/%s.  Should be a" \
+                             " valid integer." % (section, name))
+
+    def get_float(self, section, name):
+        opt = self.get(section, name)
+        try:
+            return float(opt)
+        except ValueError:
+            raise ValueError("Invalid format for %s/%s.  Should be a" \
+                             " valid float." % (section, name))
+
+class Security(object):
+    def __init__(self, we_cipher):
+        self._we_cipher = we_cipher
+        self._key = None
+        self._auth_alg = None
+
+    def read_from_config(self, cfg, name):
+        pass
+
+    def read_from_args(self, args):
+        pass
+
+    def new_from_config(cfg, name):
+        security = None
+        we_cipher = cfg.get_int(name, "we_cipher")
+        if we_cipher == IW_AUTH_CIPHER_NONE:
+            security = Security(we_cipher)
+        elif we_cipher == IW_AUTH_CIPHER_WEP40 or \
+                        we_cipher == IW_AUTH_CIPHER_WEP104:
+            security = WEPSecurity(we_cipher)
+        elif we_cipher == NM_AUTH_TYPE_WPA_PSK_AUTO or \
+                        we_cipher == IW_AUTH_CIPHER_CCMP or \
+                        we_cipher == IW_AUTH_CIPHER_TKIP:
+            security = WPASecurity(we_cipher)
+        else:
+            raise ValueError("Unsupported security combo")
+        security.read_from_config(cfg, name)
+        return security
+    new_from_config = staticmethod(new_from_config)
+
+    def new_from_args(we_cipher, args):
+        security = None
+        try:
+            if we_cipher == IW_AUTH_CIPHER_NONE:
+                security = Security(we_cipher)
+            elif we_cipher == IW_AUTH_CIPHER_WEP40 or \
+                            we_cipher == IW_AUTH_CIPHER_WEP104:
+                security = WEPSecurity(we_cipher)
+            elif we_cipher == NM_AUTH_TYPE_WPA_PSK_AUTO or \
+                            we_cipher == IW_AUTH_CIPHER_CCMP or \
+                            we_cipher == IW_AUTH_CIPHER_TKIP:
+                security = WPASecurity(we_cipher)
+            else:
+                raise ValueError("Unsupported security combo")
+            security.read_from_args(args)
+        except ValueError, e:
+            logging.debug("Error reading security information: %s" % e)
+            del security
+            return None
+        return security
+    new_from_args = staticmethod(new_from_args)
+
+    def get_properties(self):
+        return [dbus.Int32(self._we_cipher)]
+
+    def write_to_config(self, section, config):
+        config.set(section, "we_cipher", self._we_cipher)
+
+
+class WEPSecurity(Security):
+    def read_from_args(self, args):
+        if len(args) != 2:
+            raise ValueError("not enough arguments")
+        key = args[0]
+        auth_alg = args[1]
+        if isinstance(key, unicode):
+            key = key.encode()
+        if not isinstance(key, str):
+            raise ValueError("wrong argument type for key")
+        if not isinstance(auth_alg, int):
+            raise ValueError("wrong argument type for auth_alg")
+        self._key = key
+        self._auth_alg = auth_alg
+
+    def read_from_config(self, cfg, name):
+        # Key should be a hex encoded string
+        self._key = cfg.get(name, "key")
+        if self._we_cipher == IW_AUTH_CIPHER_WEP40 and len(self._key) != 10:
+            raise ValueError("Key length not right for 40-bit WEP")
+        if self._we_cipher == IW_AUTH_CIPHER_WEP104 and len(self._key) != 26:
+            raise ValueError("Key length not right for 104-bit WEP")
+
+        try:
+            binascii.a2b_hex(self._key)
+        except TypeError:
+            raise ValueError("Key was not a hexadecimal string.")
+            
+        self._auth_alg = cfg.get_int(name, "auth_alg")
+        if self._auth_alg != IW_AUTH_ALG_OPEN_SYSTEM and \
+                self._auth_alg != IW_AUTH_ALG_SHARED_KEY:
+            raise ValueError("Invalid authentication algorithm %d"
+                             % self._auth_alg)
+
+    def get_properties(self):
+        args = Security.get_properties(self)
+        args.append(dbus.String(self._key))
+        args.append(dbus.Int32(self._auth_alg))
+        return args
+
+    def write_to_config(self, section, config):
+        Security.write_to_config(self, section, config)
+        config.set(section, "key", self._key)
+        config.set(section, "auth_alg", self._auth_alg)
+
+class WPASecurity(Security):
+    def __init__(self, we_cipher):
+        Security.__init__(self, we_cipher)
+        self._wpa_ver = None
+        self._key_mgmt = None
+
+    def read_from_args(self, args):
+        if len(args) != 3:
+            raise ValueError("not enough arguments")
+        key = args[0]
+        if isinstance(key, unicode):
+            key = key.encode()
+        if not isinstance(key, str):
+            raise ValueError("wrong argument type for key")
+
+        wpa_ver = args[1]
+        if not isinstance(wpa_ver, int):
+            raise ValueError("wrong argument type for WPA version")
+
+        key_mgmt = args[2]
+        if not isinstance(key_mgmt, int):
+            raise ValueError("wrong argument type for WPA key management")
+        if not key_mgmt & IW_AUTH_KEY_MGMT_PSK:
+            raise ValueError("Key management types other than" \
+                             " PSK are not supported")
+
+        self._key = key
+        self._wpa_ver = wpa_ver
+        self._key_mgmt = key_mgmt
+
+    def read_from_config(self, cfg, name):
+        # Key should be a hex encoded string
+        self._key = cfg.get(name, "key")
+        if len(self._key) != 64:
+            raise ValueError("Key length not right for WPA-PSK")
+
+        try:
+            binascii.a2b_hex(self._key)
+        except TypeError:
+            raise ValueError("Key was not a hexadecimal string.")
+            
+        self._wpa_ver = cfg.get_int(name, "wpa_ver")
+        if self._wpa_ver != IW_AUTH_WPA_VERSION_WPA and \
+                self._wpa_ver != IW_AUTH_WPA_VERSION_WPA2:
+            raise ValueError("Invalid WPA version %d" % self._wpa_ver)
+
+        self._key_mgmt = cfg.get_int(name, "key_mgmt")
+        if not self._key_mgmt & IW_AUTH_KEY_MGMT_PSK:
+            raise ValueError("Invalid WPA key management option %d"
+                             % self._key_mgmt)
+
+    def get_properties(self):
+        args = Security.get_properties(self)
+        args.append(dbus.String(self._key))
+        args.append(dbus.Int32(self._wpa_ver))
+        args.append(dbus.Int32(self._key_mgmt))
+        return args
+
+    def write_to_config(self, section, config):
+        Security.write_to_config(self, section, config)
+        config.set(section, "key", self._key)
+        config.set(section, "wpa_ver", self._wpa_ver)
+        config.set(section, "key_mgmt", self._key_mgmt)
+
+
+class NetworkInfo:
+    def __init__(self, ssid):
+        self.ssid = ssid
+        self.timestamp = int(time.time())
+        self.bssids = []
+        self.we_cipher = 0
+        self._security = None
+
+    def get_properties(self):
+        bssid_list = dbus.Array([], signature="s")
+        for item in self.bssids:
+            bssid_list.append(dbus.String(item))
+        args = [dbus.String(self.ssid), dbus.Int32(self.timestamp),
+                dbus.Boolean(True), bssid_list]
+        args += self._security.get_properties()
+        return tuple(args)
+
+    def get_security(self):
+        return self._security.get_properties()
+
+    def set_security(self, security):
+        self._security = security
+
+    def read_from_args(self, auto, bssid, we_cipher, args):
+        if auto == False:
+            self.timestamp = int(time.time())
+        if not bssid in self.bssids:
+            self.bssids.append(bssid)
+
+        self._security = Security.new_from_args(we_cipher, args)
+        if not self._security:
+            raise NetworkInvalidError("Invalid security information")
+
+    def read_from_config(self, config):
+        try:
+            self.timestamp = config.get_int(self.ssid, "timestamp")
+        except (ConfigParser.NoOptionError, ValueError), e:
+            raise NetworkInvalidError(e)
+
+        try:
+            self._security = Security.new_from_config(config, self.ssid)
+        except Exception, e:
+            raise NetworkInvalidError(e)
+
+        # The following don't need to be present
+        try:
+            self.bssids = config.get_list(self.ssid, "bssids")
+        except (ConfigParser.NoOptionError, ValueError), e:
+            logging.debug("Error reading bssids: %s" % e)
+
+    def write_to_config(self, config):
+        try:
+            config.add_section(self.ssid)
+            config.set(self.ssid, "timestamp", self.timestamp)
+            if len(self.bssids) > 0:
+                opt = " "
+                opt = opt.join(self.bssids)
+                config.set(self.ssid, "bssids", opt)
+            self._security.write_to_config(self.ssid, config)
+        except Exception, e:
+            logging.debug("Error writing '%s': %s" % (self.ssid, e))
+
+class NMInfo(object):
+    def __init__(self, client):
+        profile_path = env.get_profile_path()
+        self._cfg_file = os.path.join(profile_path, "nm", "networks.cfg")
+        self._nmclient = client
+
+        self.allowed_networks = self._read_config()
+
+    def save_config(self):
+        self._write_config(self.allowed_networks)
+
+    def _read_config(self):
+        if not os.path.exists(os.path.dirname(self._cfg_file)):
+            os.makedirs(os.path.dirname(self._cfg_file), 0755)
+        if not os.path.exists(self._cfg_file):
+            self._write_config({})
+            return {}
+
+        config = NMConfig()
+        config.read(self._cfg_file)
+        networks = {}
+        for name in config.sections():
+            try:
+                net = NetworkInfo(name)
+                net.read_from_config(config)
+                networks[name] = net
+            except Exception, e:
+                logging.error("Error when processing config for" \
+                              " the network %s: %r" % (name, e))
+
+        del config
+        return networks
+
+    def _write_config(self, networks):
+        fp = open(self._cfg_file, 'w')
+        config = NMConfig()
+        for net in networks.values():
+            net.write_to_config(config)
+        config.write(fp)
+        fp.close()
+        del config
+
+    def get_networks(self, net_type):
+        if net_type != NETWORK_TYPE_ALLOWED:
+            raise ValueError("Bad network type")
+        nets = []
+        for net in self.allowed_networks.values():
+            nets.append(net.ssid)
+        logging.debug("Returning networks: %s" % nets)
+        return nets
+
+    def get_network_properties(self, ssid, net_type, async_cb, async_err_cb):
+        if not isinstance(ssid, unicode):
+            async_err_cb(ValueError("Invalid arguments; ssid must be unicode."))
+        if net_type != NETWORK_TYPE_ALLOWED:
+            async_err_cb(ValueError("Bad network type"))
+        if not self.allowed_networks.has_key(ssid):
+            async_err_cb(NotFoundError("Network '%s' not found." % ssid))
+        network = self.allowed_networks[ssid]
+        props = network.get_properties()
+
+        # DBus workaround: the normal method return handler wraps
+        # the returned arguments in a tuple and then converts that to a
+        # struct, but NetworkManager expects a plain list of arguments.
+        # It turns out that the async callback method return code _doesn't_
+        # wrap the returned arguments in a tuple, so as a workaround use
+        # the async callback stuff here even though we're not doing it
+        # asynchronously.
+        async_cb(*props)
+
+    def update_network_info(self, ssid, auto, bssid, we_cipher, args):
+        if not isinstance(ssid, unicode):
+            raise ValueError("Invalid arguments; ssid must be unicode.")
+        if self.allowed_networks.has_key(ssid):
+            del self.allowed_networks[ssid]
+        net = Network(ssid)
+        try:
+            net.read_from_args(auto, bssid, we_cipher, args)
+            logging.debug("Updated network information for '%s'." % ssid)
+            self.allowed_networks[ssid] = net
+            self.save_config()
+        except NetworkInvalidError, e:
+            logging.debug("Error updating network information: %s" % e)
+            del net
+
+    # this method is invoked directly in-process (not by DBus).
+    def delete_all_networks(self):
+        self.allowed_networks = {}
+        self.save_config()
+
+class Network(gobject.GObject):
+    __gsignals__ = {
+        'initialized'     : (gobject.SIGNAL_RUN_FIRST,
+                             gobject.TYPE_NONE, ([gobject.TYPE_BOOLEAN])),
+        'strength-changed': (gobject.SIGNAL_RUN_FIRST,
+                             gobject.TYPE_NONE, ([])),
+        'state-changed'   : (gobject.SIGNAL_RUN_FIRST,
+                             gobject.TYPE_NONE, ([]))
+    }
+
+    def __init__(self, client, op):
+        gobject.GObject.__init__(self)
+        self._client = client
+        self._op = op
+        self._ssid = None
+        self._mode = None
+        self._strength = 0
+        self._caps = 0
+        self._valid = False
+        self._favorite = False
+        self._state = NETWORK_STATE_NOTCONNECTED
+
+        obj = sys_bus.get_object(NM_SERVICE, self._op)
+        net = dbus.Interface(obj, NM_IFACE_DEVICES)
+        net.getProperties(reply_handler=self._update_reply_cb,
+                error_handler=self._update_error_cb)
+
+    def _update_reply_cb(self, *props):
+        self._ssid = props[1]
+        self._strength = props[3]
+        self._mode = props[6]
+        self._caps = props[7]
+        if self._caps & NM_802_11_CAP_PROTO_WPA or \
+                self._caps & NM_802_11_CAP_PROTO_WPA2:
+            if not (self._caps & NM_802_11_CAP_KEY_MGMT_PSK):
+                # 802.1x is not supported at this time
+                logging.debug("Net(%s): ssid '%s' dropping because 802.1x" \
+                              "is unsupported" % (self._op, self._ssid))
+                self._valid = False
+                self.emit('initialized', self._valid)
+                return
+        if self._mode != IW_MODE_INFRA:
+            # Don't show Ad-Hoc networks; they usually don't DHCP and therefore
+            # won't work well here.  This also works around the bug where
+            # we show our own mesh SSID on the Mesh view when in mesh mode
+            logging.debug("Net(%s): ssid '%s' is adhoc; not showing" %
+                          (self._op, self._ssid))
+            self._valid = False
+            self.emit('initialized', self._valid)
+            return
+
+        fav_nets = []
+        if self._client.nminfo:
+            fav_nets = self._client.nminfo.get_networks(NETWORK_TYPE_ALLOWED)
+        if self._ssid in fav_nets:
+            self._favorite = True
+
+        self._valid = True
+        logging.debug("Net(%s): caps 0x%X" % (self._ssid, self._caps))
+        self.emit('initialized', self._valid)
+
+    def _update_error_cb(self, err):
+        logging.debug("Net(%s): failed to update. (%s)" % (self._op, err))
+        self._valid = False
+        self.emit('initialized', self._valid)
+
+    def get_colors(self):
+        import sha
+        sh = sha.new()
+        data = self._ssid + hex(self._caps) + hex(self._mode)
+        sh.update(data)
+        h = hash(sh.digest())
+        idx = h % len(xocolor.colors)
+        # stroke, fill
+        return (xocolor.colors[idx][0], xocolor.colors[idx][1])
+
+    def get_ssid(self):
+        return self._ssid
+
+    def get_caps(self):
+        return self._caps
+
+    def get_mode(self):
+        return self._mode
+
+    def get_state(self):
+        return self._state
+
+    def set_state(self, state):
+        if state == self._state:
+            return
+        self._state = state
+        if self._valid:
+            self.emit('state-changed')
+
+    def get_op(self):
+        return self._op
+
+    def get_strength(self):
+        return self._strength
+
+    def set_strength(self, strength):
+        if strength == self._strength:
+            return
+        self._strength = strength
+        if self._valid:
+            self.emit('strength-changed')
+
+    def is_valid(self):
+        return self._valid
+
+    def is_favorite(self):
+        return self._favorite
+
+class Device(gobject.GObject):
+    __gsignals__ = {
+        'initialized':              (gobject.SIGNAL_RUN_FIRST,
+                                     gobject.TYPE_NONE, ([])),
+        'init-failed':              (gobject.SIGNAL_RUN_FIRST,
+                                     gobject.TYPE_NONE, ([])),
+        'ssid-changed':             (gobject.SIGNAL_RUN_FIRST,
+                                     gobject.TYPE_NONE, ([])),
+        'strength-changed':         (gobject.SIGNAL_RUN_FIRST,
+                                     gobject.TYPE_NONE, ([])),
+        'state-changed':            (gobject.SIGNAL_RUN_FIRST,
+                                     gobject.TYPE_NONE, ([])),
+        'activation-stage-changed': (gobject.SIGNAL_RUN_FIRST,
+                                     gobject.TYPE_NONE, ([])),
+        'network-appeared':         (gobject.SIGNAL_RUN_FIRST,
+                                     gobject.TYPE_NONE,
+                                     ([gobject.TYPE_PYOBJECT])),
+        'network-disappeared':      (gobject.SIGNAL_RUN_FIRST,
+                                     gobject.TYPE_NONE,
+                                     ([gobject.TYPE_PYOBJECT]))
+    }
+
+    def __init__(self, client, op):
+        gobject.GObject.__init__(self)
+        self._client = client
+        self._op = op
+        self._iface = None
+        self._type = DEVICE_TYPE_UNKNOWN
+        self._udi = None
+        self._active = False
+        self._act_stage = 0
+        self._strength = 0
+        self._freq = 0.0
+        self._link = False
+        self._valid = False
+        self._networks = {}
+        self._caps = 0
+        self._state = DEVICE_STATE_INACTIVE
+        self._active_network = None
+        self._active_net_sigid = 0
+
+        obj = sys_bus.get_object(NM_SERVICE, self._op)
+        self.dev = dbus.Interface(obj, NM_IFACE_DEVICES)
+        self.dev.getProperties(reply_handler=self._update_reply_cb,
+                error_handler=self._update_error_cb)
+
+    def _is_activating(self):
+        if self._active and self._act_stage >= 1 and self._act_stage <= 6:
+            return True
+        return False
+
+    def _is_activated(self):
+        if self._active and self._act_stage == 7:
+            return True
+        return False
+
+    def _update_reply_cb(self, *props):
+        self._iface = props[1]
+        self._type = props[2]
+        self._udi = props[3]
+        self._active = props[4]
+        self._act_stage = props[5]
+        self._link = props[15]
+        self._caps = props[17]
+
+        if self._type == DEVICE_TYPE_802_11_WIRELESS:
+            old_strength = self._strength
+            self._strength = props[14]
+            if self._strength != old_strength:
+                if self._valid:
+                    self.emit('strength-changed')
+            self._update_networks(props[20], props[19])
+        elif self._type ==  DEVICE_TYPE_802_11_MESH_OLPC:
+            old_strength = self._strength
+            self._strength = props[14]
+            if self._strength != old_strength:
+                if self._valid:
+                    self.emit('strength-changed')
+
+        self._valid = True
+
+        if self._is_activating():
+            self.set_state(DEVICE_STATE_ACTIVATING)
+        elif self._is_activated():
+            self.set_state(DEVICE_STATE_ACTIVATED)
+        else:
+            self.set_state(DEVICE_STATE_INACTIVE)
+
+        self.emit('initialized')
+
+    def _update_networks(self, net_ops, active_op):
+        for op in net_ops:
+            net = Network(self._client, op)
+            self._networks[op] = net
+            net.connect('initialized', lambda *args:
+                        self._net_initialized_cb(active_op, *args))
+
+    def _update_error_cb(self, err):
+        logging.debug("Device(%s): failed to update. (%s)" % (self._op, err))
+        self._valid = False
+        self.emit('init-failed')
+
+    def _net_initialized_cb(self, active_op, net, valid):
+        net_op = net.get_op()
+        if not self._networks.has_key(net_op):
+            return
+
+        if not valid:
+            # init failure
+            del self._networks[net_op]
+            return
+
+        # init success
+        if self._valid:
+            self.emit('network-appeared', net)
+        if active_op and net_op == active_op:
+            self.set_active_network(net)
+
+    def get_op(self):
+        return self._op
+
+    def get_networks(self):
+        ret = []
+        for net in self._networks.values():
+            if net.is_valid():
+                ret.append(net)
+        return ret
+
+    def get_network(self, op):
+        if self._networks.has_key(op) and self._networks[op].is_valid():
+            return self._networks[op]
+        return None
+
+    def get_network_ops(self):
+        ret = []
+        for net in self._networks.values():
+            if net.is_valid():
+                ret.append(net.get_op())
+        return ret
+
+    def get_mesh_step(self):
+        if self._type !=  DEVICE_TYPE_802_11_MESH_OLPC:
+            raise RuntimeError("Only valid for mesh devices")
+        try:
+            step = self.dev.getMeshStep(timeout=3)
+        except dbus.DBusException:
+            step = 0
+        return step
+
+    def get_frequency(self):
+        try:
+            freq = self.dev.getFrequency(timeout=3)
+        except dbus.DBusException:
+            freq = 0.0
+        # Hz -> GHz
+        self._freq = freq / 1000000000.0
+        return self._freq
+
+    def get_strength(self):
+        return self._strength
+
+    def set_strength(self, strength):
+        if strength == self._strength:
+            return False
+
+        if strength >= 0 and strength <= 100:
+            self._strength = strength
+        else:
+            self._strength = 0
+
+        if self._valid:
+            self.emit('strength-changed')
+
+    def network_appeared(self, network):
+        # NM may emit NetworkAppeared messages before the initialization-time
+        # getProperties call completes. This means that we are in danger of
+        # instantiating the "appeared" network here, and then instantiating
+        # the same network later on when getProperties completes
+        # (_update_reply_cb calls _update_networks).
+        # We avoid this race by confirming that getProperties has completed
+        # before listening to any NetworkAppeared messages. We assume that
+        # any networks that get reported as appeared in this race window
+        # will be included in the getProperties response.
+        if not self._valid:
+            return
+
+        if self._networks.has_key(network):
+            return
+        net = Network(self._client, network)
+        self._networks[network] = net
+        net.connect('initialized', lambda *args:
+                    self._net_initialized_cb(None, *args))
+
+    def network_disappeared(self, network):
+        if not self._networks.has_key(network):
+            return
+
+        if self._valid:
+            self.emit('network-disappeared', self._networks[network])
+
+        del self._networks[network]
+
+    def set_active_network(self, network):
+        if self._active_network == network:
+            return
+
+        # Make sure the old one doesn't get a stuck state
+        if self._active_network:
+            self._active_network.set_state(NETWORK_STATE_NOTCONNECTED)
+            self._active_network.disconnect(self._active_net_sigid)
+
+        self._active_network = network
+
+        if self._active_network:
+            self._active_net_sigid = self._active_network.connect(
+                    "initialized", self._active_net_initialized)
+
+        # don't emit ssid-changed for networks that are not yet valid
+        if self._valid:
+            if self._active_network and self._active_network.is_valid():
+                self.emit('ssid-changed')
+            elif not self._active_network:
+                self.emit('ssid-changed')
+
+    def _active_net_initialized(self, net, user_data=None):
+        if self._active_network and self._active_network.is_valid():
+            self.emit('ssid-changed')
+
+    def _get_active_net_cb(self, state, net_op):
+        if not self._networks.has_key(net_op):
+            self.set_active_network(None)
+            return
+
+        self.set_active_network(self._networks[net_op])
+
+        _device_to_network_state = {
+            DEVICE_STATE_ACTIVATING : NETWORK_STATE_CONNECTING,
+            DEVICE_STATE_ACTIVATED  : NETWORK_STATE_CONNECTED,
+            DEVICE_STATE_INACTIVE   : NETWORK_STATE_NOTCONNECTED
+        }
+
+        network_state = _device_to_network_state[state]
+        self._active_network.set_state(network_state)
+
+    def _get_active_net_error_cb(self, err):
+        logging.debug("Couldn't get active network: %s" % err)
+        self.set_active_network(None)
+
+    def get_state(self):
+        return self._state
+
+    def set_state(self, state):
+        if state == self._state:
+            return
+
+        if state == DEVICE_STATE_INACTIVE:
+            self._act_stage = 0
+
+        self._state = state
+        if self._valid:
+            self.emit('state-changed')
+
+        if self._type == DEVICE_TYPE_802_11_WIRELESS:
+            if state == DEVICE_STATE_INACTIVE:
+                self.set_active_network(None)
+            else:
+                self.dev.getActiveNetwork(
+                    reply_handler=lambda *args:
+                    self._get_active_net_cb(state, *args),
+                    error_handler=self._get_active_net_error_cb)
+
+    def set_activation_stage(self, stage):
+        if stage == self._act_stage:
+            return
+        self._act_stage = stage
+        if self._valid:
+            self.emit('activation-stage-changed')
+
+    def get_activation_stage(self):
+        return self._act_stage
+
+    def get_ssid(self):
+        if self._active_network and self._active_network.is_valid():
+            return self._active_network.get_ssid()
+        elif not self._active_network:
+            return None
+
+    def get_active_network(self):
+        return self._active_network
+
+    def get_type(self):
+        return self._type
+
+    def is_valid(self):
+        return self._valid
+
+    def set_carrier(self, on):
+        self._link = on
+
+    def get_capabilities(self):
+        return self._caps
+
+class NMClient(gobject.GObject):
+    __gsignals__ = {
+        'device-added'     : (gobject.SIGNAL_RUN_FIRST,
+                              gobject.TYPE_NONE,
+                             ([gobject.TYPE_PYOBJECT])),
+        'device-activated' : (gobject.SIGNAL_RUN_FIRST,
+                              gobject.TYPE_NONE,
+                             ([gobject.TYPE_PYOBJECT])),
+        'device-activating': (gobject.SIGNAL_RUN_FIRST,
+                              gobject.TYPE_NONE,
+                             ([gobject.TYPE_PYOBJECT])),
+        'device-removed'   : (gobject.SIGNAL_RUN_FIRST,
+                              gobject.TYPE_NONE,
+                             ([gobject.TYPE_PYOBJECT]))
+    }
+
+    def __init__(self):
+        gobject.GObject.__init__(self)
+
+        self.nminfo = None
+        self._nm_present = False
+        self._nm_proxy = None
+        self._nm_obj = None
+        self._sig_handlers = None
+        self._update_timer = 0
+        self._devices = {}
+
+        self.nminfo = NMInfo(self)
+        
+        self._setup_dbus()
+        if self._nm_present:
+            self._get_initial_devices()
+
+    def get_devices(self):
+        return self._devices.values()
+
+    def _get_initial_devices_reply_cb(self, ops):
+        for op in ops:
+            self._add_device(op)
+
+    def _dev_initialized_cb(self, dev):
+        self.emit('device-added', dev)
+
+    def _dev_init_failed_cb(self, dev):
+        # Device failed to initialize, likely due to dbus errors or something
+        op = dev.get_op()
+        self._remove_device(op)
+
+    def _get_initial_devices_error_cb(self, err):
+        logging.debug("Error updating devices (%s)" % err)
+
+    def _get_initial_devices(self):
+        self._nm_obj.getDevices(
+            reply_handler=self._get_initial_devices_reply_cb,
+            error_handler=self._get_initial_devices_error_cb)
+
+    def _add_device(self, dev_op):
+        if self._devices.has_key(dev_op):
+            return
+        dev = Device(self, dev_op)
+        self._devices[dev_op] = dev
+        dev.connect('init-failed', self._dev_init_failed_cb)
+        dev.connect('initialized', self._dev_initialized_cb)
+        dev.connect('state-changed', self._dev_state_changed_cb)
+
+    def _remove_device(self, dev_op):
+        if not self._devices.has_key(dev_op):
+            return
+        dev = self._devices[dev_op]
+        if dev.is_valid():
+            self.emit('device-removed', dev)
+        del self._devices[dev_op]
+
+    def _dev_state_changed_cb(self, dev):
+        op = dev.get_op()
+        if not self._devices.has_key(op) or not dev.is_valid():
+            return
+        if dev.get_state() == DEVICE_STATE_ACTIVATING:
+            self.emit('device-activating', dev)
+        elif dev.get_state() == DEVICE_STATE_ACTIVATED:
+            self.emit('device-activated', dev)
+
+    def get_device(self, dev_op):
+        if not self._devices.has_key(dev_op):
+            return None
+        return self._devices[dev_op]
+
+    def _setup_dbus(self):
+        self._sig_handlers = {
+            'StateChange': self.state_changed_sig_handler,
+            'DeviceAdded': self.device_added_sig_handler,
+            'DeviceRemoved': self.device_removed_sig_handler,
+            'DeviceActivationStage': self.device_activation_stage_sig_handler,
+            'DeviceActivating': self.device_activating_sig_handler,
+            'DeviceNowActive': self.device_now_active_sig_handler,
+            'DeviceNoLongerActive': self.device_no_longer_active_sig_handler,
+            'DeviceActivationFailed': \
+                self.device_activation_failed_sig_handler,
+            'DeviceCarrierOn': self.device_carrier_on_sig_handler,
+            'DeviceCarrierOff': self.device_carrier_off_sig_handler,
+            'DeviceStrengthChanged': \
+                self.wireless_device_strength_changed_sig_handler,
+            'WirelessNetworkAppeared': \
+                self.wireless_network_appeared_sig_handler,
+            'WirelessNetworkDisappeared': \
+                self.wireless_network_disappeared_sig_handler,
+            'WirelessNetworkStrengthChanged': \
+                self.wireless_network_strength_changed_sig_handler
+        }
+
+        try:
+            self._nm_proxy = sys_bus.get_object(NM_SERVICE, NM_PATH,
+                                                follow_name_owner_changes=True)
+            self._nm_obj = dbus.Interface(self._nm_proxy, NM_IFACE)
+        except dbus.DBusException, e:
+            logging.debug("Could not connect to NetworkManager: %s" % e)
+            self._nm_present = False
+            return
+
+        sys_bus.add_signal_receiver(self.name_owner_changed_sig_handler,
+                                         signal_name="NameOwnerChanged",
+                                         dbus_interface="org.freedesktop.DBus")
+
+        for (signal, handler) in self._sig_handlers.items():
+            sys_bus.add_signal_receiver(handler, signal_name=signal,
+                                        dbus_interface=NM_IFACE)
+
+        # Find out whether or not NMI is running
+        try:
+            bus_object = sys_bus.get_object('org.freedesktop.DBus',
+                                            '/org/freedesktop/DBus')
+            name_ = bus_object.GetNameOwner( \
+                    "org.freedesktop.NetworkManagerInfo",
+                    dbus_interface='org.freedesktop.DBus')
+            self._nm_present = True
+        except dbus.DBusException:
+            self._nm_present = False
+
+    def set_active_device(self, device, network=None,
+                          mesh_freq=None, mesh_start=None):
+        ssid = ""
+        if network:
+            ssid = network.get_ssid()
+        if device.get_type() == DEVICE_TYPE_802_11_MESH_OLPC:
+            if mesh_freq or mesh_start:
+                if mesh_freq and not mesh_start:
+                    self._nm_obj.setActiveDevice(device.get_op(),
+                                                 dbus.Double(mesh_freq))
+                elif mesh_start and not mesh_freq:
+                    self._nm_obj.setActiveDevice(device.get_op(),
+                                                 dbus.Double(0.0),
+                                                 dbus.UInt32(mesh_start))
+                else:
+                    self._nm_obj.setActiveDevice(device.get_op(),
+                                                 dbus.Double(mesh_freq),
+                                                 dbus.UInt32(mesh_start))
+            else:
+                self._nm_obj.setActiveDevice(device.get_op())
+        else:
+            self._nm_obj.setActiveDevice(device.get_op(), ssid)
+
+    def state_changed_sig_handler(self, new_state):
+        logging.debug('NM State Changed to %d' % new_state)
+
+    def device_activation_stage_sig_handler(self, device, stage):
+        logging.debug('Device Activation Stage "%s" for device %s'
+                      % (NM_DEVICE_STAGE_STRINGS[stage], device))
+        if not self._devices.has_key(device):
+            logging.debug('DeviceActivationStage, device %s does not exist'
+                          % (device))
+            return
+        self._devices[device].set_activation_stage(stage)
+
+    def device_activating_sig_handler(self, device):
+        logging.debug('DeviceActivating for %s' % (device))
+        if not self._devices.has_key(device):
+            logging.debug('DeviceActivating, device %s does not exist'
+                          % (device))
+            return
+        self._devices[device].set_state(DEVICE_STATE_ACTIVATING)
+
+    def device_now_active_sig_handler(self, device, ssid=None):
+        logging.debug('DeviceNowActive for %s' % (device))
+        if not self._devices.has_key(device):
+            logging.debug('DeviceNowActive, device %s does not exist'
+                          % (device))
+            return
+        self._devices[device].set_state(DEVICE_STATE_ACTIVATED)
+
+    def device_no_longer_active_sig_handler(self, device):
+        logging.debug('DeviceNoLongerActive for %s' % (device))
+        if not self._devices.has_key(device):
+            logging.debug('DeviceNoLongerActive, device %s does not exist'
+                          % (device))
+            return
+        self._devices[device].set_state(DEVICE_STATE_INACTIVE)
+
+    def device_activation_failed_sig_handler(self, device, ssid=None):
+        logging.debug('DeviceActivationFailed for %s' % (device))
+        if not self._devices.has_key(device):
+            logging.debug('DeviceActivationFailed, device %s does not exist'
+                          % (device))
+            return
+        self._devices[device].set_state(DEVICE_STATE_INACTIVE)
+
+    def name_owner_changed_sig_handler(self, name, old, new):
+        if name != NM_SERVICE:
+            return
+        if (old and len(old)) and (not new and not len(new)):
+            # NM went away
+            self._nm_present = False
+            devs = self._devices.keys()
+            for op in devs:
+                self._remove_device(op)
+            self._devices = {}
+        elif (not old and not len(old)) and (new and len(new)):
+            # NM started up
+            self._nm_present = True
+            self._get_initial_devices()
+
+    def device_added_sig_handler(self, device):
+        logging.debug('DeviceAdded for %s' % (device))
+        self._add_device(device)
+
+    def device_removed_sig_handler(self, device):
+        logging.debug('DeviceRemoved for %s' % (device))
+        self._remove_device(device)
+
+    def wireless_network_appeared_sig_handler(self, device, network):
+        if not self._devices.has_key(device):
+            return
+        self._devices[device].network_appeared(network)
+
+    def wireless_network_disappeared_sig_handler(self, device, network):
+        if not self._devices.has_key(device):
+            return
+        self._devices[device].network_disappeared(network)
+
+    def wireless_device_strength_changed_sig_handler(self, device, strength):
+        if not self._devices.has_key(device):
+            return
+        self._devices[device].set_strength(strength)
+
+    def wireless_network_strength_changed_sig_handler(self, device,
+                                                      network, strength):
+        if not self._devices.has_key(device):
+            return
+        net = self._devices[device].get_network(network)
+        if net:
+            net.set_strength(strength)
+
+    def device_carrier_on_sig_handler(self, device):
+        if not self._devices.has_key(device):
+            return
+        self._devices[device].set_carrier(True)
+
+    def device_carrier_off_sig_handler(self, device):
+        if not self._devices.has_key(device):
+            return
+        self._devices[device].set_carrier(False)
+
+def get_manager():
+    return _manager
+
+try:
+    _manager = NMClient()
+except dbus.DBusException:
+    _manager = None
+    logging.info('Network manager service not found.')
diff --git a/src/jarabe/hardware/keydialog.py b/src/jarabe/nmservice.py
index e70e12b..f531a2d 100644
--- a/src/jarabe/hardware/keydialog.py
+++ b/src/jarabe/nmservice.py
@@ -1,6 +1,4 @@
-# vi: ts=4 ai noet
-#
-# Copyright (C) 2006-2007 Red Hat, Inc.
+# Copyright (C) 2006-2008 Red Hat, Inc.
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -16,11 +14,18 @@
 # along with this program; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
+import logging
 import md5
 from gettext import gettext as _
 
+import dbus.service
 import gtk
 
+from jarabe.model import network
+
+NM_INFO_IFACE = 'org.freedesktop.NetworkManagerInfo'
+NM_INFO_PATH = '/org/freedesktop/NetworkManagerInfo'
+
 IW_AUTH_ALG_OPEN_SYSTEM = 0x00000001
 IW_AUTH_ALG_SHARED_KEY  = 0x00000002
 
@@ -50,6 +55,141 @@ IW_AUTH_CIPHER_WEP104 = 0x00000010
 IW_AUTH_KEY_MGMT_802_1X = 0x1
 IW_AUTH_KEY_MGMT_PSK    = 0x2
 
+WEP_PASSPHRASE = 1
+WEP_HEX = 2
+WEP_ASCII = 3
+
+class NoNetworks(dbus.DBusException):
+    def __init__(self):
+        dbus.DBusException.__init__(self)
+        self._dbus_error_name = NM_INFO_IFACE + '.NoNetworks'
+
+class CanceledKeyRequestError(dbus.DBusException):
+    def __init__(self):
+        dbus.DBusException.__init__(self)
+        self._dbus_error_name = NM_INFO_IFACE + '.CanceledError'
+
+class NMService(dbus.service.Object):
+    def __init__(self):
+        self._nmclient = network.get_manager()
+        self._nminfo = self._nmclient.nminfo
+        self._key_dialog = None
+        bus = dbus.SystemBus()
+
+        # If NMI is already around, don't grab the NMI service
+        bus_object = bus.get_object('org.freedesktop.DBus',
+                                    '/org/freedesktop/DBus')
+        name = None
+        try:
+            name = bus_object.GetNameOwner( \
+                    "org.freedesktop.NetworkManagerInfo",
+                    dbus_interface='org.freedesktop.DBus')
+        except dbus.DBusException:
+            logging.debug("Error getting owner of NMI")
+        if name:
+            logging.info("NMI service already owned by %s, won't claim it."
+                          % name)
+
+        bus_name = dbus.service.BusName(NM_INFO_IFACE, bus=bus)
+        dbus.service.Object.__init__(self, bus_name, NM_INFO_PATH)
+
+    @dbus.service.method(NM_INFO_IFACE, in_signature='i', out_signature='as')
+    def getNetworks(self, net_type):
+        ssids = self._nminfo.get_networks(net_type)
+        if len(ssids) > 0:
+            return dbus.Array(ssids)
+
+        raise NoNetworks()
+
+    @dbus.service.method(NM_INFO_IFACE, in_signature='si',
+                         async_callbacks=('async_cb', 'async_err_cb'))
+    def getNetworkProperties(self, ssid, net_type, async_cb, async_err_cb):
+        self._nminfo.get_network_properties(ssid, net_type,
+                                            async_cb, async_err_cb)
+
+    @dbus.service.method(NM_INFO_IFACE)
+    def updateNetworkInfo(self, ssid, bauto, bssid, cipher, *args):
+        self._nminfo.update_network_info(ssid, bauto, bssid, cipher, args)
+
+    @dbus.service.method(NM_INFO_IFACE,
+                         async_callbacks=('async_cb', 'async_err_cb'))
+    def getKeyForNetwork(self, dev_path, net_path, ssid, attempt,
+                         new_key, async_cb, async_err_cb):
+        self._get_key_for_network(dev_path, net_path, ssid,
+                                  attempt, new_key, async_cb, async_err_cb)
+
+    @dbus.service.method(NM_INFO_IFACE)
+    def cancelGetKeyForNetwork(self):
+        self._cancel_get_key_for_network()
+
+    def _get_key_for_network(self, dev_op, net_op, ssid, attempt,
+                             new_key, async_cb, async_err_cb):
+        if not isinstance(ssid, unicode):
+            raise ValueError("Invalid arguments; ssid must be unicode.")
+        if self._nminfo.allowed_networks.has_key(ssid) and not new_key:
+            # We've got the info already
+            net = self._nminfo.allowed_networks[ssid]
+            async_cb(tuple(net.get_security()))
+            return
+
+        # Otherwise, ask the user for it
+        net = None
+        dev = self._nmclient.get_device(dev_op)
+        if not dev:
+            async_err_cb(network.NotFoundError("Device was unknown."))
+            return
+
+        if dev.get_type() == network.DEVICE_TYPE_802_3_ETHERNET:
+            # We don't support wired 802.1x yet...
+            async_err_cb(network.UnsupportedError(
+                                "Device type is unsupported by NMI."))
+            return
+
+        net = dev.get_network(net_op)
+        if not net:
+            async_err_cb(network.NotFoundError("Network was unknown."))
+            return
+
+        self._key_dialog = new_key_dialog(net, async_cb, async_err_cb)
+        self._key_dialog.connect("response", self._key_dialog_response_cb)
+        self._key_dialog.connect("destroy", self._key_dialog_destroy_cb)
+        self._key_dialog.show_all()
+
+    def _key_dialog_destroy_cb(self, widget, data=None):
+        if widget != self._key_dialog:
+            return
+        self._key_dialog_response_cb(widget, gtk.RESPONSE_CANCEL)
+
+    def _key_dialog_response_cb(self, widget, response_id):
+        if widget != self._key_dialog:
+            return
+
+        (async_cb, async_err_cb) = self._key_dialog.get_callbacks()
+        security = None
+        if response_id == gtk.RESPONSE_OK:
+            security = self._key_dialog.create_security()
+        self._key_dialog = None
+        widget.destroy()
+
+        if response_id in [gtk.RESPONSE_CANCEL, gtk.RESPONSE_NONE]:
+            # key dialog dialog was canceled; send the error back to NM
+            async_err_cb(CanceledKeyRequestError())
+        elif response_id == gtk.RESPONSE_OK:
+            if not security:
+                raise RuntimeError("Invalid security arguments.")
+            props = security.get_properties()
+            a = tuple(props)
+            async_cb(*a)
+        else:
+            raise RuntimeError("Unhandled key dialog response %d" % response_id)
+
+    def _cancel_get_key_for_network(self):
+        # Close the wireless key dialog and just have it return
+        # with the 'canceled' argument set to true
+        if not self._key_dialog:
+            return
+        self._key_dialog_destroy_cb(self._key_dialog)
+
 def string_is_hex(key):
     is_hex = True
     for c in key:
@@ -125,10 +265,6 @@ class KeyDialog(gtk.Dialog):
     def get_callbacks(self):
         return (self._async_cb, self._async_err_cb)
 
-WEP_PASSPHRASE = 1
-WEP_HEX = 2
-WEP_ASCII = 3
-
 class WEPKeyDialog(KeyDialog):
     def __init__(self, net, async_cb, async_err_cb):
         KeyDialog.__init__(self, net, async_cb, async_err_cb)
@@ -206,8 +342,7 @@ class WEPKeyDialog(KeyDialog):
 
     def create_security(self):
         (we_cipher, key, auth_alg) = self._get_security()
-        from jarabe.hardware.nminfo import Security
-        return Security.new_from_args(we_cipher, (key, auth_alg))
+        return network.Security.new_from_args(we_cipher, (key, auth_alg))
 
     def _update_response_sensitivity(self, ignored=None):
         key = self._entry.get_text()
@@ -296,9 +431,8 @@ class WPAKeyDialog(KeyDialog):
 
     def create_security(self):
         (we_cipher, key, wpa_ver) = self._get_security()
-        from jarabe.hardware.nminfo import Security
-        return Security.new_from_args(we_cipher,
-                                      (key, wpa_ver, IW_AUTH_KEY_MGMT_PSK))
+        return network.Security.new_from_args(
+                        we_cipher, (key, wpa_ver, IW_AUTH_KEY_MGMT_PSK))
 
     def _update_response_sensitivity(self, ignored=None):
         key = self._entry.get_text()
@@ -326,29 +460,3 @@ def new_key_dialog(net, async_cb, async_err_cb):
         return WEPKeyDialog(net, async_cb, async_err_cb)
     else:
         raise RuntimeError("Unhandled network capabilities %x" % caps)
-
-
-
-class FakeNet(object):
-    def get_ssid(self):
-        return "olpcwpa"
-
-    def get_caps(self):
-        return NM_802_11_CAP_CIPHER_CCMP | NM_802_11_CAP_CIPHER_TKIP | \
-                NM_802_11_CAP_PROTO_WPA
-
-def response_cb(widget, response_id):
-    if response_id == gtk.RESPONSE_OK:
-        print dialog.print_security()
-    else:
-        print "canceled"
-    widget.hide()
-    widget.destroy()
-
-
-if __name__ == "__main__":
-    fake_net = FakeNet()
-    dialog = new_key_dialog(fake_net, None, None)
-    dialog.connect("response", response_cb)
-    dialog.run()
-