Merged with experimental (r219).

wicd/gui.py

@@ -295,17 +295,23 @@ class appGui(object):
                         'org.wicd.daemon.wireless')
         bus.add_signal_receiver(self.update_connect_buttons, 'StatusChanged',
                         'org.wicd.daemon')
+        bus.add_signal_receiver(self.handle_connection_results,
+                                'ConnectResultsSent', 'org.wicd.daemon')
+        bus.add_signal_receiver(lambda: setup_dbus(force=False), 
+                                "DaemonStarting", "org.wicd.daemon")
         if standalone:
             bus.add_signal_receiver(handle_no_dbus, "DaemonClosing", 
                                     "org.wicd.daemon")
-            bus.add_signal_receiver(lambda: setup_dbus(force=False), 
-                                    "DaemonStarting", "org.wicd.daemon")
         try:
             gobject.timeout_add_seconds(1, self.update_statusbar)
         except:
             gobject.timeout_add(1000, self.update_statusbar)
             
         self.refresh_clicked()
+        
+    def handle_connection_results(self, results):
+        if results not in ['Success', 'aborted'] and self.is_visible:
+            error(self.window, language[results], block=False)
 
     def create_adhoc_network(self, widget=None):
         """ Shows a dialog that creates a new adhoc network. """

wicd/misc.py

@@ -504,8 +504,9 @@ def get_language_list_gui():
     language['setting_static_ip'] = _('Setting static IP addresses...')
     language['running_dhcp'] = _('Obtaining IP address...')
     language['dhcp_failed'] = _('Connection Failed: Unable to Get IP Address')
+    language['no_dhcp_offers'] = _('Connection Failed: No DHCP offers received.')
     language['aborted'] = _('Connection Cancelled')
-    language['bad_pass'] = _('Connection Failed: Bad password')
+    language['bad_pass'] = _('Connection Failed: Could not authenticate (bad password?)')
     language['done'] = _('Done connecting...')
     language['scanning'] = _('Scanning')
     language['cannot_start_daemon'] = _("Unable to connect to wicd daemon DBus interface." + \

wicd/monitor.py

@@ -146,6 +146,8 @@ class ConnectionStatus(object):
                 state = misc.CONNECTING
                 self.update_state(state)
                 return True
+            
+            daemon.SendConnectResultsIfAvail()
                 
             # Check for wired.
             wired_ip = wired.GetWiredIP("")

wicd/networking.py

@@ -57,6 +57,22 @@ if __name__ == '__main__':
 BACKEND = None
 BACKEND_MGR = BackendManager()
 
+def abortable(func):
+    """ Mark a method in a ConnectionThread as abortable. 
+    
+    This decorator runs a check that will abort the connection thread
+    if necessary before running a given method.
+    
+    """
+    def wrapper(self, *__args, **__kargs):
+        self.abort_if_needed()
+        return func(self, *__args, **__kargs)
+    
+    wrapper.__name__ = func.__name__
+    wrapper.__dict__ = func.__dict__
+    wrapper.__doc__ = func.__doc__
+    return wrapper
+
 def get_backend_list():
     if BACKEND_MGR:
         return BACKEND_MGR.get_available_backends()
@@ -83,8 +99,6 @@ class Controller(object):
         self.global_dns_2 = None
         self.global_dns_3 = None
         self.global_search_dom = None
-        self._wired_interface = None
-        self._wireless_interface = None
         self._dhcp_client = None
         self._flush_tool = None
         self._debug = None
@@ -94,50 +108,29 @@ class Controller(object):
         self.after_script = None
         self.disconnect_script = None
         self.driver = None
-        self.wiface = None
+        self.iface = None
-        self.liface = None
+        self.backend_manager = BackendManager()   
-        self.backend_manager = BackendManager()
-        
-    def set_wireless_iface(self, value):
-        self._wireless_interface = value
-        if self.wiface:
-            self.wiface.SetInterface(value)
-    def get_wireless_iface(self): return self._wireless_interface
-    wireless_interface = property(get_wireless_iface, set_wireless_iface)    
-    
-    def set_wired_iface(self, value):
-        self._wired_interface = value
-        if self.liface:
-            self.liface.SetInterface(value)            
-    def get_wired_iface(self): return self._wired_interface
-    wired_interface = property(get_wired_iface, set_wired_iface)
     
     def set_debug(self, value):
         self._debug = value
-        if self.wiface:
+        if self.iface:
-            self.wiface.SetDebugMode(value)
+            self.iface.SetDebugMode(value)
-        if self.liface:
-            self.liface.SetDebugMode(value)
     def get_debug(self): return self._debug
     debug = property(get_debug, set_debug)
     
     def set_dhcp_client(self, value):
         self._dhcp_client = value
-        if self.wiface:
+        if self.iface:
-            self.wiface.DHCP_CLIENT = value
+            self.iface.DHCP_CLIENT = value
-            self.wiface.CheckDHCP()
+            self.iface.CheckDHCP()
-        if self.liface:
+            
-            self.liface.DHCP_CLIENT = value    
-            self.liface.CheckDHCP()
     def get_dhcp_client(self): return self._dhcp_client
     dhcp_client = property(get_dhcp_client, set_dhcp_client)
     
     def set_flush_tool(self, value):
         self._flush_tool = value
-        if self.wiface:
+        if self.iface:
-            self.wiface.flush_tool = value
+            self.iface.flush_tool = value
-        if self.liface:
-            self.liface.flush_tool = value
     def get_flush_tool(self): return self._flush_tool
     flush_tool = property(get_flush_tool, set_flush_tool)
     
@@ -155,6 +148,57 @@ class Controller(object):
             return self._backend.NeedsExternalCalls()
         else:
             return True
+        
+    def StopDHCP(self):
+        return BACKEND.StopDHCP()
+    
+    def GetIP(self, ifconfig=""):
+        """ Get the IP of the interface.
+
+        Returns:
+        The IP address of the interface in dotted notation.
+
+        """
+        return self.iface.GetIP(ifconfig)
+
+    def Disconnect(self):
+        """ Disconnect from the network. """
+        iface = self.iface
+        if self.disconnect_script != None:
+            print 'Running wired disconnect script'
+            misc.Run(self.disconnect_script)
+
+        iface.ReleaseDHCP()
+        iface.SetAddress('0.0.0.0')
+        iface.Down()
+        iface.Up()
+        
+    def IsUp(self):
+        """ Calls the IsUp method for the wired interface. 
+        
+        Returns:
+        True if the interface is up, False otherwise.
+        
+        """
+        return self.iface.IsUp()
+    
+    def EnableInterface(self):
+        """ Puts the interface up.
+        
+        Returns:
+        True if the interface was put up succesfully, False otherwise.
+        
+        """
+        return self.iface.Up()
+    
+    def DisableInterface(self):
+        """ Puts the interface down.
+        
+        Returns:
+        True if the interface was put down succesfully, False otherwise.
+        
+        """
+        return self.iface.Down()
 
 
 class ConnectThread(threading.Thread):
@@ -170,9 +214,9 @@ class ConnectThread(threading.Thread):
     should_die = False
     lock = thread.allocate_lock()
 
-    def __init__(self, network, wireless, wired, before_script, after_script, 
+    def __init__(self, network, interface_name, before_script, after_script, 
                  disconnect_script, gdns1, gdns2, gdns3, gsearch_dom, 
-                 wiface, liface, debug):
+                 iface, debug):
         """ Initialise the required object variables and the thread.
 
         Keyword arguments:
@@ -190,24 +234,22 @@ class ConnectThread(threading.Thread):
         """
         threading.Thread.__init__(self)
         self.network = network
-        self.wireless_interface = wireless
-        self.wired_interface = wired
         self.is_connecting = False
         self.is_aborted = False
-        self.abort_msg = None
+        self.connect_result = None
         self.before_script = before_script
         self.after_script = after_script
         self.disconnect_script = disconnect_script
         self._should_die = False
         self.abort_reason = ""
+        self.connect_result = ""
 
         self.global_dns_1 = gdns1
         self.global_dns_2 = gdns2
         self.global_dns_3 = gdns3
         self.global_search_dom = gsearch_dom
         
-        self.wiface = wiface
+        self.iface = iface
-        self.liface = liface
 
         self.connecting_message = None
         self.debug = debug
@@ -251,7 +293,8 @@ class ConnectThread(threading.Thread):
             self.lock.release()
         return message
     
-    def reset_ip_addresses(self, wiface, liface):
+    @abortable
+    def reset_ip_addresses(self, iface):
         """ Resets the IP addresses for both wired/wireless interfaces.
         
         Sets a false ip so that when we set the real one, the correct
@@ -260,15 +303,16 @@ class ConnectThread(threading.Thread):
         """
         print 'Setting false IP...'
         self.SetStatus('resetting_ip_address')
-        wiface.SetAddress('0.0.0.0')
+        iface.SetAddress('0.0.0.0')
-        liface.SetAddress('0.0.0.0')
+    
-        
+    @abortable
     def put_iface_down(self, iface):
         """ Puts the given interface down. """
         print 'Putting interface down'
         self.SetStatus('interface_down')
         iface.Down()
         
+    @abortable
     def run_script_if_needed(self, script, msg):
         """ Execute a given script if needed.
         
@@ -280,21 +324,23 @@ class ConnectThread(threading.Thread):
         if script:
             print 'Executing %s script' % (msg)
             misc.ExecuteScript(script)
-            
+        
-    def flush_routes(self, wiface, liface):
+    @abortable
+    def flush_routes(self, iface):
         """ Flush the routes for both wired/wireless interfaces. """
         self.SetStatus('flushing_routing_table')
         print 'Flushing the routing table...'
-        wiface.FlushRoutes()
+        iface.FlushRoutes()
-        liface.FlushRoutes()
+        
-
+    @abortable
     def set_broadcast_address(self, iface):
         """ Set the broadcast address for the given interface. """
         if not self.network.get('broadcast') == None:
             self.SetStatus('setting_broadcast_address')
             print 'Setting the broadcast address...' + self.network['broadcast']
             iface.SetAddress(broadcast=self.network['broadcast'])
-            
+        
+    @abortable            
     def set_ip_address(self, iface):
         """ Set the IP address for the given interface. 
         
@@ -315,7 +361,8 @@ class ConnectThread(threading.Thread):
             if dhcp_status in ['no_dhcp_offers', 'dhcp_failed']:
                 self.abort_connection(dhcp_status)
                 return
-            
+        
+    @abortable            
     def set_dns_addresses(self):
         """ Set the DNS address(es).
 
@@ -336,6 +383,18 @@ class ConnectThread(threading.Thread):
                                  self.network.get('dns3'),
                                  self.network.get('search_domain'))
 
+    @abortable        
+    def release_dhcp_clients(self, iface):
+        """ Release all running dhcp clients. """
+        print "Releasing DHCP leases..."
+        iface.ReleaseDHCP()
+        
+    @abortable        
+    def stop_dhcp_clients(self, iface):
+        """ Stop and running DHCP clients. """
+        print 'Stopping DHCP clients'
+        BACKEND.StopDHCP()
+        
     def connect_aborted(self, reason):
         """ Sets the thread status to aborted in a thread-safe way.
         
@@ -347,7 +406,7 @@ class ConnectThread(threading.Thread):
             reason = self.abort_reason
         self.connecting_message = reason
         self.is_aborted = True
-        self.abort_msg = reason
+        self.connect_result = reason
         self.is_connecting = False
         print 'exiting connection thread'
         
@@ -356,18 +415,6 @@ class ConnectThread(threading.Thread):
         self.abort_reason = reason
         self.should_die = True
         
-    def release_dhcp_clients(self, wiface, liface):
-        """ Release all running dhcp clients. """
-        print "Releasing DHCP leases..."
-        wiface.ReleaseDHCP()
-        liface.ReleaseDHCP()
-        
-    def stop_dhcp_clients(self, iface):
-        """ Stop and running DHCP clients, as well as wpa_supplicant. """
-        print 'Stopping wpa_supplicant and any DHCP clients'
-        iface.StopWPA()
-        BACKEND.StopDHCP()
-        
     def abort_if_needed(self):
         """ Abort the thread is it has been requested. """
         self.lock.acquire()
@@ -377,7 +424,8 @@ class ConnectThread(threading.Thread):
                 thread.exit()
         finally:
             self.lock.release()
-            
+        
+    @abortable            
     def put_iface_up(self, iface):
         """ Bring up given interface. """
         print 'Putting interface up...'
@@ -392,16 +440,29 @@ class Wireless(Controller):
         """ Initialize the class. """
         Controller.__init__(self)
         self._wpa_driver = None
+        self._wireless_interface = None
+        self.wiface = None 
+        
+    def set_wireless_iface(self, value):
+        self._wireless_interface = value
+        if self.wiface:
+            self.wiface.SetInterface(value)
+    def get_wireless_iface(self): return self._wireless_interface
+    wireless_interface = property(get_wireless_iface, set_wireless_iface) 
         
     def set_wpa_driver(self, value):
         self._wpa_driver = value
         if self.wiface:
             self.SetWPADriver(value)
-    
     def get_wpa_driver(self): return self._wpa_driver
-    
     wpa_driver = property(get_wpa_driver, set_wpa_driver)
     
+    def set_iface(self, value):
+        self.wiface = value
+    def get_iface(self):
+        return self.wiface
+    iface = property(get_iface, set_iface)
+        
     def LoadBackend(self, backend):
         """ Load a given backend. 
 
@@ -440,7 +501,7 @@ class Wireless(Controller):
                 else:
                     return 0
                 
-        if not self.wireless_interface: return []
+        if not self.wiface: return []
         
         wiface = self.wiface
 
@@ -466,14 +527,13 @@ class Wireless(Controller):
         network -- network to connect to
 
         """
-        if not self.wireless_interface: return False
+        if not self.wiface: return False
         
         self.connecting_thread = WirelessConnectThread(network,
-            self.wireless_interface, self.wired_interface,
+            self.wireless_interface, self.wpa_driver, self.before_script,
-            self.wpa_driver, self.before_script, self.after_script,
+            self.after_script, self.disconnect_script, self.global_dns_1,
-            self.disconnect_script, self.global_dns_1,
             self.global_dns_2, self.global_dns_3, self.global_search_dom,
-            self.wiface, self.liface, debug)
+            self.wiface, debug)
         self.connecting_thread.setDaemon(True)
         self.connecting_thread.start()
         return True
@@ -504,15 +564,6 @@ class Wireless(Controller):
 
         """
         return self.wiface.GetCurrentNetwork(iwconfig)
-
-    def GetIP(self, ifconfig=""):
-        """ Get the IP of the interface.
-
-        Returns:
-        The IP address of the interface in dotted notation.
-
-        """
-        return self.wiface.GetIP(ifconfig)
     
     def GetBSSID(self):
         """ Get the BSSID of the current access point. 
@@ -533,17 +584,11 @@ class Wireless(Controller):
         return [driver for driver in drivers if 
                 BACKEND.IsValidWpaSuppDriver(driver)]
     
-    def IsUp(self):
+    def StopWPA(self):
-        """ Calls the IsUp method for the wireless interface.
+        return self.wiface.StopWPA()
-        
-        Returns:
-        True if the interface is up, False otherwise.
-        
-        """
-        return self.wiface.IsUp()
 
     def CreateAdHocNetwork(self, essid, channel, ip, enctype, key,
-            enc_used, ics):
+            enc_used):
         """ Create an ad-hoc wireless network.
 
         Keyword arguments:
@@ -573,34 +618,9 @@ class Wireless(Controller):
             wiface.SetKey(key)
         print 'Putting interface up'
         wiface.Up()
-        # Just assume that the netmask is 255.255.255.0, it simplifies ICS
         print 'Setting IP address'
         wiface.SetAddress(ip, '255.255.255.0')
 
-        ip_parts = misc.IsValidIP(ip)
-
-        if ics and ip_parts:
-            # Set up internet connection sharing here
-            # Flush the forward tables
-            misc.Run('iptables -F FORWARD')
-            misc.Run('iptables -N fw-interfaces')
-            misc.Run('iptables -N fw-open')
-            misc.Run('iptables -F fw-interfaces')
-            misc.Run('iptables -F fw-open')
-            misc.Run('iptables -A FORWARD -p tcp --tcp-flags SYN,RST SYN -j TCPMSS \
-                     --clamp-mss-to-pmtu')
-            misc.Run('iptables -A FORWARD -m state --state RELATED,ESTABLISHED -j ACCEPT')
-            misc.Run('iptables -A FORWARD -j fw-interfaces ')
-            misc.Run('iptables -A FORWARD -j fw-open ')
-            misc.Run('iptables -A FORWARD -j REJECT --reject-with icmp-host-unreachable')
-            misc.Run('iptables -P FORWARD DROP')
-            misc.Run('iptables -A fw-interfaces -i ' + self.wireless_interface + ' -j ACCEPT')
-            net_ip = '.'.join(ip_parts[0:3]) + '.0'
-            misc.Run('iptables -t nat -A POSTROUTING -s ' + net_ip + \
-                     '/255.255.255.0 -o ' + self.wired_interface + \
-                     ' -j MASQUERADE')
-            misc.Run('echo 1 > /proc/sys/net/ipv4/ip_forward') # Enable routing
-
     def DetectWirelessInterface(self):
         """ Detect available wireless interfaces.
 
@@ -626,23 +646,8 @@ class Wireless(Controller):
         Resets it's IP address, and puts the interface down then up.
         
         """
-        wiface = self.wiface
+        Controller.Disconnect(self)
-        if self.disconnect_script not in (None, ""):
+        self.StopWPA()
-            print 'Running wireless network disconnect script'
-            misc.ExecuteScript(self.disconnect_script)
-
-        wiface.ReleaseDHCP()
-        wiface.SetAddress('0.0.0.0')
-        wiface.Down()
-        wiface.Up()
-
-    def EnableInterface(self):
-        """ Puts the interface up. """
-        return self.wiface.Up()
-    
-    def DisableInterface(self):
-        """ Puts the interface down. """
-        return self.wiface.Down()
     
     def SetWPADriver(self, driver):
         """ Sets the wpa_supplicant driver associated with the interface. """
@@ -656,15 +661,14 @@ class WirelessConnectThread(ConnectThread):
 
     """
 
-    def __init__(self, network, wireless, wired, wpa_driver,
+    def __init__(self, network, wireless, wpa_driver, before_script,
-            before_script, after_script, disconnect_script, gdns1,
+                 after_script, disconnect_script, gdns1, gdns2, gdns3, 
-            gdns2, gdns3, gsearch_dom, wiface, liface, debug=False):
+                 gsearch_dom, wiface, debug=False):
         """ Initialise the thread with network information.
 
         Keyword arguments:
         network -- the network to connect to
         wireless -- name of the wireless interface
-        wired -- name of the wired interface
         wpa_driver -- type of wireless interface
         before_script -- script to run before bringing up the interface
         after_script -- script to run after bringing up the interface
@@ -674,9 +678,9 @@ class WirelessConnectThread(ConnectThread):
         gdns3 -- global DNS server 3
 
         """
-        ConnectThread.__init__(self, network, wireless, wired,
+        ConnectThread.__init__(self, network, wireless, before_script, 
-            before_script, after_script, disconnect_script, gdns1,
+                               after_script, disconnect_script, gdns1, gdns2, 
-            gdns2, gdns3, gsearch_dom, wiface, liface, debug)
+                               gdns3, gsearch_dom, wiface, debug)
         self.wpa_driver = wpa_driver
 
 
@@ -694,33 +698,27 @@ class WirelessConnectThread(ConnectThread):
         5. Get/set IP address and DNS servers.
 
         """
-        wiface = self.wiface
+        wiface = self.iface
-        liface = self.liface
         self.is_connecting = True
         
         # Run pre-connection script.
-        self.abort_if_needed()
         self.run_script_if_needed(self.before_script, 'pre-connection')
-        self.abort_if_needed()
         
         # Take down interface and clean up previous connections.
         self.put_iface_down(wiface)
-        self.abort_if_needed()
+        self.release_dhcp_clients(wiface)
-        self.release_dhcp_clients(wiface, liface)
+        self.reset_ip_addresses(wiface)
-        self.reset_ip_addresses(wiface, liface)
         self.stop_dhcp_clients(wiface)
-        self.abort_if_needed()
+        self.stop_wpa(wiface)
-        self.flush_routes(wiface, liface)
+        self.flush_routes(wiface)
 
         # Generate PSK and authenticate if needed.
         if self.wpa_driver != 'ralink legacy':
             self.generate_psk_and_authenticate(wiface)
 
         # Put interface up.
-        self.abort_if_needed()
         self.SetStatus('configuring_interface')
         self.put_iface_up(wiface)
-        self.abort_if_needed()
         
         # Associate.
         wiface.SetMode(self.network['mode'])
@@ -736,25 +734,31 @@ class WirelessConnectThread(ConnectThread):
         if self.network.get('enctype'):
             self.SetStatus('validating_authentication')
             if not wiface.ValidateAuthentication(time.time()):
-                self.abort_connection('bad_pass')
+                if not self.connect_result:
-        self.abort_if_needed()
+                    self.abort_connection('bad_pass')
 
         # Set up gateway, IP address, and DNS servers.
         self.set_broadcast_address(wiface)
-        self.abort_if_needed()
         self.set_ip_address(wiface)
         self.set_dns_addresses()
         
         # Run post-connection script.
-        self.abort_if_needed()
         self.run_script_if_needed(self.after_script, 'post-connection')
 
         self.SetStatus('done')
         print 'Connecting thread exiting.'
         if self.debug:
             print "IP Address is: " + str(wiface.GetIP())
+        self.connect_result = "Success"
         self.is_connecting = False
-    
+        
+    @abortable
+    def stop_wpa(self, wiface):
+        """ Stops wpa_supplicant. """
+        print 'Stopping wpa_supplicant'
+        wiface.StopWPA()
+        
+    @abortable    
     def generate_psk_and_authenticate(self, wiface):
         """ Generates a PSK and authenticates if necessary. 
         
@@ -769,7 +773,7 @@ class WirelessConnectThread(ConnectThread):
         if self.network.get('key') and 'wpa' in self.network.get('enctype'):
             self.SetStatus('generating_psk')
             print 'Generating psk...'
-            self.network['psk'] = self.wiface.GeneratePSK(self.network)
+            self.network['psk'] = wiface.GeneratePSK(self.network)
             
             if not self.network.get('psk'):
                 self.network['psk'] = self.network['key']
@@ -791,6 +795,8 @@ class Wired(Controller):
         Controller.__init__(self)
         self.wpa_driver = None
         self._link_detect = None
+        self._wired_interface = None
+        self.liface = None
         
     def set_link_detect(self, value):
         self._link_detect = value
@@ -799,6 +805,20 @@ class Wired(Controller):
     def get_link_detect(self): return self._link_detect
     link_detect = property(get_link_detect, set_link_detect)
     
+    
+    def set_wired_iface(self, value):
+        self._wired_interface = value
+        if self.liface:
+            self.liface.SetInterface(value)            
+    def get_wired_iface(self): return self._wired_interface
+    wired_interface = property(get_wired_iface, set_wired_iface)
+    
+    def set_iface(self, value):
+        self.liface = value
+    def get_iface(self):
+        return self.liface
+    iface = property(get_iface, set_iface)
+    
     def LoadBackend(self, backend):
         """ Load the backend up. """
         Controller.LoadBackend(self, backend)
@@ -822,16 +842,14 @@ class Wired(Controller):
         network -- network to connect to
 
         """
-        if not self.wired_interface: return False
+        if not self.liface: return False
         self.connecting_thread = WiredConnectThread(network,
-            self.wireless_interface, self.wired_interface,
+            self.wired_interface, self.before_script, self.after_script,
-            self.before_script, self.after_script,
+            self.disconnect_script, self.global_dns_1, self.global_dns_2, 
-            self.disconnect_script, self.global_dns_1,
+            self.global_dns_3, self.global_search_dom, self.liface, debug)
-            self.global_dns_2, self.global_dns_3, self.global_search_dom, 
-            self.wiface, self.liface, debug)
         self.connecting_thread.setDaemon(True)
         self.connecting_thread.start()
-        return True
+        return self.connecting_thread
     
     def DetectWiredInterface(self):
         """ Attempts to automatically detect a wired interface. """
@@ -840,54 +858,6 @@ class Wired(Controller):
         except IndexError:
             return None
 
-    def GetIP(self, ifconfig=""):
-        """ Get the IP of the interface.
-
-        Returns:
-        The IP address of the interface in dotted notation.
-
-        """
-        return self.liface.GetIP(ifconfig)
-
-    def Disconnect(self):
-        """ Disconnect from the network. """
-        liface = self.liface
-        if self.disconnect_script != None:
-            print 'Running wired disconnect script'
-            misc.Run(self.disconnect_script)
-
-        liface.ReleaseDHCP()
-        liface.SetAddress('0.0.0.0')
-        liface.Down()
-        liface.Up()
-        
-    def IsUp(self):
-        """ Calls the IsUp method for the wired interface. 
-        
-        Returns:
-        True if the interface is up, False otherwise.
-        
-        """
-        return self.liface.IsUp()
-    
-    def EnableInterface(self):
-        """ Puts the interface up.
-        
-        Returns:
-        True if the interface was put up succesfully, False otherwise.
-        
-        """
-        return self.liface.Up()
-    
-    def DisableInterface(self):
-        """ Puts the interface down.
-        
-        Returns:
-        True if the interface was put down succesfully, False otherwise.
-        
-        """
-        return self.liface.Down()
-
 
 class WiredConnectThread(ConnectThread):
     """ A thread class to perform the connection to a wired network.
@@ -896,9 +866,9 @@ class WiredConnectThread(ConnectThread):
     to the specified network.
 
     """
-    def __init__(self, network, wireless, wired,
+    def __init__(self, network, wired, before_script, after_script, 
-            before_script, after_script, disconnect_script, gdns1,
+                 disconnect_script, gdns1, gdns2, gdns3, gsearch_dom, liface, 
-            gdns2, gdns3, gsearch_dom, wiface, liface, debug=False):
+                 debug=False):
         """ Initialise the thread with network information.
 
         Keyword arguments:
@@ -913,9 +883,9 @@ class WiredConnectThread(ConnectThread):
         gdns3 -- global DNS server 3
 
         """
-        ConnectThread.__init__(self, network, wireless, wired,
+        ConnectThread.__init__(self, network, wired, before_script, 
-            before_script, after_script, disconnect_script, gdns1,
+                               after_script, disconnect_script, gdns1, gdns2, 
-            gdns2, gdns3, gsearch_dom, wiface, liface, debug)
+                               gdns3, gsearch_dom, liface, debug)
 
     def run(self):
         """ The main function of the connection thread.
@@ -931,34 +901,27 @@ class WiredConnectThread(ConnectThread):
         5. Run post-connection script.
 
         """
-        wiface = self.wiface
+        liface = self.iface
-        liface = self.liface
 
         self.is_connecting = True
 
         # Run pre-connection script.
-        self.abort_if_needed()
         self.run_script_if_needed(self.before_script, 'pre-connection')
-        self.abort_if_needed()
         
         # Take down interface and clean up previous connections.
         self.put_iface_down(liface)
-        self.release_dhcp_clients(wiface, liface)
+        self.release_dhcp_clients(liface)
-        self.reset_ip_addresses(wiface, liface)
+        self.reset_ip_addresses(liface)
-        self.stop_dhcp_clients(wiface)
+        self.stop_dhcp_clients(liface)
-        self.abort_if_needed()
+        self.flush_routes(liface)
-        self.flush_routes(wiface, liface)
         
         # Bring up interface.
         self.put_iface_up(liface)
-        self.abort_if_needed()
         
         # Set gateway, IP adresses, and DNS servers.
         self.set_broadcast_address(liface)
-        self.abort_if_needed()
         self.set_ip_address(liface)
         self.set_dns_addresses()
-        self.abort_if_needed()
         
         # Run post-connection script.
         self.run_script_if_needed(self.after_script, 'post-connection')
@@ -967,4 +930,6 @@ class WiredConnectThread(ConnectThread):
         print 'Connecting thread exiting.'
         if self.debug:
             print "IP Address is: " + str(liface.GetIP())
+        
+        self.connect_result = "Success"
         self.is_connecting = False

wicd/wicd-daemon.py

@@ -83,9 +83,8 @@ class WicdDaemon(dbus.service.Object):
         self.wired = networking.Wired()
         self.config = ConfigManager(os.path.join(wpath.etc,
                                                  "manager-settings.conf"))
-        self.wired_bus= WiredDaemon(bus_name, wired=self.wired, wifi=self.wifi)
+        self.wired_bus= WiredDaemon(bus_name, self, wired=self.wired)
-        self.wireless_bus = WirelessDaemon(bus_name, wired=self.wired, 
+        self.wireless_bus = WirelessDaemon(bus_name, self, wifi=self.wifi)
-                                           wifi=self.wifi)
         self.forced_disconnect = False
         self.need_profile_chooser = False
         self.current_interface = None
@@ -106,11 +105,6 @@ class WicdDaemon(dbus.service.Object):
         # need a fresh scan, just feed them the old one.  A fresh scan
         # can be done by calling Scan(fresh=True).
         self.LastScan = ''
-
-        # Kind of hackish way to set correct wnettools interfaces.
-        #TODO remove the need for this.
-        self.wifi.liface = self.wired.liface
-        self.wired.wiface = self.wifi.wiface
         
         signal.signal(signal.SIGTERM, self.DaemonClosing)
         self.DaemonStarting()
@@ -146,7 +140,6 @@ class WicdDaemon(dbus.service.Object):
         """ Sets the wired interface for the daemon to use. """
         print "setting wired interface %s" % (str(interface))
         self.wired.wired_interface = noneToBlankString(interface)
-        self.wifi.wired_interface = noneToBlankString(interface)
         self.config.set("Settings", "wired_interface", interface, True)
 
     @dbus.service.method('org.wicd.daemon')
@@ -154,7 +147,6 @@ class WicdDaemon(dbus.service.Object):
         """ Sets the wireless interface the daemon will use. """
         print "setting wireless interface %s" % (str(interface))
         self.wifi.wireless_interface = noneToBlankString(interface)
-        self.wired.wireless_interface = noneToBlankString(interface)
         self.config.set("Settings", "wireless_interface", interface, True)
 
     @dbus.service.method('org.wicd.daemon')
@@ -320,9 +312,7 @@ class WicdDaemon(dbus.service.Object):
     @dbus.service.method('org.wicd.daemon')
     def GetAutoReconnect(self):
         """ Returns the value of self.auto_reconnect. See SetAutoReconnect. """
-        do = bool(self.auto_reconnect)
+        return bool(self.auto_reconnect)
-        return self.__printReturn('returning automatically reconnect when ' \
-                                   + 'connection drops', do)
 
     @dbus.service.method('org.wicd.daemon')
     def SetAutoReconnect(self, value):
@@ -358,9 +348,13 @@ class WicdDaemon(dbus.service.Object):
         print 'canceling connection attempt'
         if self.wifi.connecting_thread:
             self.wifi.connecting_thread.should_die = True
+            self.wifi.StopDHCP()
+            self.wifi.StopWPA()
+            self.wifi.connecting_thread.connect_result = 'aborted'
         if self.wired.connecting_thread:
             self.wired.connecting_thread.should_die = True
-        misc.Run("killall dhclient dhclient3 wpa_supplicant")
+            self.wired.StopDHCP()
+            self.wired.connecting_thread.connect_result = 'aborted'
     
     @dbus.service.method('org.wicd.daemon')
     def GetCurrentInterface(self):
@@ -699,7 +693,33 @@ class WicdDaemon(dbus.service.Object):
             return False
         self.auto_connecting = False
         return False
+        
+    @dbus.service.method("org.wicd.daemon")
+    def ConnectResultsAvailable(self):
+        if ((self.wired.connecting_thread and self.wired.connecting_thread.connect_result) or 
+            (self.wifi.connecting_thread and self.wifi.connecting_thread.connect_result)):
+            return True
+        else:
+            return False
+        
+    @dbus.service.method("org.wicd.daemon")
+    def SendConnectResultsIfAvail(self):
+        if self.ConnectResultsAvailable():
+            self.SendConnectResult()
     
+    @dbus.service.method("org.wicd.daemon")
+    def SendConnectResult(self):
+        if self.wired.connecting_thread and self.wired.connecting_thread.connect_result:
+            self.ConnectResultsSent(self.wired.connecting_thread.connect_result)
+            self.wired.connecting_thread.connect_result = ""
+        elif self.wifi.connecting_thread and self.wifi.connecting_thread.connect_result:
+            self.ConnectResultsSent(self.wifi.connecting_thread.connect_result)
+            self.wifi.connecting_thread.connect_result = ""
+    
+    @dbus.service.signal(dbus_interface="org.wicd.daemon",signature='s')
+    def ConnectResultsSent(self, result):
+        print "Sending connection attempt result %s" % result
+        
     @dbus.service.signal(dbus_interface='org.wicd.daemon', signature='')
     def LaunchChooser(self):
         """ Emits the wired profile chooser dbus signal. """
@@ -731,12 +751,6 @@ class WicdDaemon(dbus.service.Object):
         """
         pass
     
-    def __printReturn(self, text, value):
-        """ Prints the specified text and value, then returns the value. """
-        if self.debug_mode:
-            print ''.join([text, " ", str(value)])
-        return value
-    
     def ReadConfig(self):
         """ Reads the manager-settings.conf file.
         
@@ -823,12 +837,12 @@ class WicdDaemon(dbus.service.Object):
  
 class WirelessDaemon(dbus.service.Object):
     """ DBus interface for wireless connection operations. """
-    def __init__(self, bus_name, wired=None, wifi=None, debug=False):
+    def __init__(self, bus_name, daemon, wifi=None, debug=False):
         """ Intitialize the wireless DBus interface. """
         dbus.service.Object.__init__(self, bus_name=bus_name,
                                      object_path='/org/wicd/daemon/wireless')
         self.hidden_essid = None
-        self.wired = wired
+        self.daemon = daemon
         self.wifi = wifi
         self.debug_mode = debug
         self.forced_disconnect = False
@@ -883,8 +897,7 @@ class WirelessDaemon(dbus.service.Object):
     def CreateAdHocNetwork(self, essid, channel, ip, enctype, key, encused,
                            ics):
         """ Creates an ad-hoc network using user inputted settings. """
-        self.wifi.CreateAdHocNetwork(essid, channel, ip, enctype, key, encused,
+        self.wifi.CreateAdHocNetwork(essid, channel, ip, enctype, key, encused)
-                                     ics)
 
     @dbus.service.method('org.wicd.daemon.wireless')
     def GetKillSwitchEnabled(self):
@@ -1012,7 +1025,7 @@ class WirelessDaemon(dbus.service.Object):
         self.wifi.disconnect_script = self.GetWirelessProperty(id,
                                                             'disconnectscript')
         print 'Connecting to wireless network ' + self.LastScan[id]['essid']
-        return self.wifi.Connect(self.LastScan[id], debug=self.debug_mode)
+        conthread = self.wifi.Connect(self.LastScan[id], debug=self.debug_mode)
 
     @dbus.service.method('org.wicd.daemon.wireless')
     def CheckIfWirelessConnecting(self):
@@ -1174,12 +1187,12 @@ class WirelessDaemon(dbus.service.Object):
         
 class WiredDaemon(dbus.service.Object):
     """ DBus interface for wired connection operations. """
-    def __init__(self, bus_name, wired=None, wifi=None, debug=False):
+    def __init__(self, bus_name, daemon, wired=None, debug=False):
         """ Intitialize the wireless DBus interface. """
         dbus.service.Object.__init__(self, bus_name=bus_name,
                                      object_path="/org/wicd/daemon/wired")
+        self.daemon = daemon
         self.wired = wired
-        self.wifi = wifi
         self.debug_mode = debug
         self.forced_disconnect = False
         self.WiredNetwork = {}
@@ -1587,4 +1600,5 @@ if __name__ == '__main__':
         print ("Root privileges are required for the daemon to run properly." +
                "  Exiting.")
         sys.exit(1)
+    gobject.threads_init()
     main(sys.argv)