Make it possible for the user to select which graphical sudo application to use.

Make any external apps not installed on the system unselectable in the GUI.
Rework the app selection code in the backend to fall back to auto-selection if a requested app isn't installed.
Tweak the autoconnect attempt throttle in wicd-monitor to not be as aggressive.
Made sure the preferences dialog would reconnect to dbus when a DaemonStarting signal was sent.

data/wicd.glade

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8" standalone="no"?>
 <!DOCTYPE glade-interface SYSTEM "glade-2.0.dtd">
-<!--Generated with glade3 3.4.5 on Mon Jan 26 10:54:15 2009 -->
+<!--Generated with glade3 3.4.5 on Sun Feb  1 21:38:09 2009 -->
 <glade-interface>
   <widget class="GtkWindow" id="window1">
     <property name="width_request">450</property>
@@ -895,7 +895,7 @@ is already active.</property>
                         <child>
                           <widget class="GtkTable" id="table2">
                             <property name="visible">True</property>
-                            <property name="n_rows">6</property>
+                            <property name="n_rows">8</property>
                             <child>
                               <widget class="GtkLabel" id="route_flush_label">
                                 <property name="visible">True</property>
@@ -1125,6 +1125,92 @@ is already active.</property>
                                 <property name="y_options"></property>
                               </packing>
                             </child>
+                            <child>
+                              <widget class="GtkLabel" id="sudo_app_label">
+                                <property name="visible">True</property>
+                                <property name="xalign">0</property>
+                                <property name="label" translatable="yes">&lt;b&gt;Graphical Sudo Application&lt;/b&gt;</property>
+                                <property name="use_markup">True</property>
+                              </widget>
+                              <packing>
+                                <property name="top_attach">6</property>
+                                <property name="bottom_attach">7</property>
+                                <property name="y_options"></property>
+                              </packing>
+                            </child>
+                            <child>
+                              <widget class="GtkAlignment" id="alignment25">
+                                <property name="visible">True</property>
+                                <property name="left_padding">12</property>
+                                <child>
+                                  <widget class="GtkVBox" id="vbox1">
+                                    <property name="visible">True</property>
+                                    <child>
+                                      <widget class="GtkRadioButton" id="sudo_auto_radio">
+                                        <property name="visible">True</property>
+                                        <property name="can_focus">True</property>
+                                        <property name="label" translatable="yes">Automatic (recommended)</property>
+                                        <property name="response_id">0</property>
+                                        <property name="active">True</property>
+                                        <property name="draw_indicator">True</property>
+                                      </widget>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                      </packing>
+                                    </child>
+                                    <child>
+                                      <widget class="GtkRadioButton" id="gksudo_radio">
+                                        <property name="visible">True</property>
+                                        <property name="can_focus">True</property>
+                                        <property name="label" translatable="yes">gksudo</property>
+                                        <property name="response_id">0</property>
+                                        <property name="active">True</property>
+                                        <property name="draw_indicator">True</property>
+                                        <property name="group">sudo_auto_radio</property>
+                                      </widget>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="position">1</property>
+                                      </packing>
+                                    </child>
+                                    <child>
+                                      <widget class="GtkRadioButton" id="kdesu_radio">
+                                        <property name="visible">True</property>
+                                        <property name="can_focus">True</property>
+                                        <property name="label" translatable="yes">kdesu</property>
+                                        <property name="response_id">0</property>
+                                        <property name="active">True</property>
+                                        <property name="draw_indicator">True</property>
+                                        <property name="group">sudo_auto_radio</property>
+                                      </widget>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="position">2</property>
+                                      </packing>
+                                    </child>
+                                    <child>
+                                      <widget class="GtkRadioButton" id="ktsuss_radio">
+                                        <property name="visible">True</property>
+                                        <property name="can_focus">True</property>
+                                        <property name="label" translatable="yes">ktsuss</property>
+                                        <property name="response_id">0</property>
+                                        <property name="active">True</property>
+                                        <property name="draw_indicator">True</property>
+                                        <property name="group">sudo_auto_radio</property>
+                                      </widget>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="position">3</property>
+                                      </packing>
+                                    </child>
+                                  </widget>
+                                </child>
+                              </widget>
+                              <packing>
+                                <property name="top_attach">7</property>
+                                <property name="bottom_attach">8</property>
+                              </packing>
+                            </child>
                           </widget>
                         </child>
                       </widget>

wicd/backends/be-external.py

@@ -220,10 +220,10 @@ class WiredInterface(Interface, wnettools.BaseWiredInterface):
             except (IOError, ValueError, TypeError):
                 print 'Error checking link using /sys/class/net/%s/carrier' % self.iface
                 
-        if self.ETHTOOL_FOUND and self.link_detect != misc.MIITOOL:
-            return self._eth_get_plugged_in()
-        elif self.MIITOOL_FOUND:
+        if self.miitool_cmd and self.link_detect == misc.MIITOOL:
             return self._mii_get_plugged_in()
+        elif self.ethtool_cmd:
+            return self._eth_get_plugged_in()
         else:
             print 'Error: No way of checking for a wired connection. Make ' + \
                    'sure that either mii-tool or ethtool is installed.'
@@ -236,14 +236,15 @@ class WiredInterface(Interface, wnettools.BaseWiredInterface):
         True if a link is detected, False otherwise.
         
         """
-        link_tool = 'ethtool'
+        cmd = "%s %s" % (self.ethtool_cmd, self.iface)
         if not self.IsUp():
             print 'Wired Interface is down, putting it up'
             self.Up()
             time.sleep(6)
-        tool_data = misc.Run(link_tool + ' ' + self.iface, True)
-        if misc.RunRegex(re.compile('(Link detected: yes)', re.I | re.M  | 
-                                    re.S), tool_data) is not None:
+        if self.verbose: print cmd
+        tool_data = misc.Run(cmd, include_stderr=True)
+        if misc.RunRegex(re.compile('(Link detected: yes)', re.I | re.M  | re.S),
+                         tool_data):
             return True
         else:
             return False
@@ -255,14 +256,16 @@ class WiredInterface(Interface, wnettools.BaseWiredInterface):
         True if a link is detected, False otherwise.
         
         """
-        link_tool = 'mii-tool'
-        tool_data = misc.Run(link_tool + ' ' + self.iface, True)
+        cmd = "%s %s" % (self.miitool_cmd, self.iface)
+        if self.verbose: print cmd
+        tool_data = misc.Run(cmd, include_stderr=True)
         if misc.RunRegex(re.compile('(Invalid argument)', re.I | re.M  | re.S), 
                          tool_data) is not None:
             print 'Wired Interface is down, putting it up'
             self.Up()
             time.sleep(4)
-            tool_data = misc.Run(link_tool + ' ' + self.iface, True)
+            if self.verbose: print cmd
+            tool_data = misc.Run(cmd, include_stderr=True)
         
         if misc.RunRegex(re.compile('(link ok)', re.I | re.M | re.S),
                          tool_data) is not None:
@@ -421,14 +424,14 @@ class WirelessInterface(Interface, wnettools.BaseWirelessInterface):
 
         """
         # Right now there's no way to do this for these drivers
-        if self.wpa_driver == RALINK_DRIVER or not self.WPA_CLI_FOUND:
+        if self.wpa_driver == RALINK_DRIVER or not self.wpa_cli_cmd:
             return True
 
         MAX_TIME = 35
         MAX_DISCONNECTED_TIME = 3
         disconnected_time = 0
         while (time.time() - auth_time) < MAX_TIME:
-            cmd = 'wpa_cli -i ' + self.iface + ' status'
+            cmd = '%s -i %s status' % (self.wpa_cli_cmd, self.iface)
             output = misc.Run(cmd)
             result = misc.RunRegex(auth_pattern, output)
             if self.verbose:

wicd/backends/be-ioctl.py

@@ -215,9 +215,9 @@ class WiredInterface(Interface, wnettools.BaseWiredInterface):
         
         """
         if not self.iface: return False
-        if self.ETHTOOL_FOUND and self.link_detect != misc.MIITOOL:
+        if self.ethtool_cmd and self.link_detect != misc.MIITOOL:
             return self._eth_get_plugged_in()
-        elif self.MIITOOL_FOUND:
+        elif self.miitool_cmd:
             return self._mii_get_plugged_in()
         else:
             print 'Error: No way of checking for a wired connection. Make \

wicd/gui.py

@@ -37,6 +37,7 @@ from dbus import version as dbus_version
 from wicd import misc
 from wicd import wpath
 from wicd import dbusmanager
+from wicd import prefs
 from wicd.misc import noneToString
 from wicd.netentry import WiredNetworkEntry, WirelessNetworkEntry
 from wicd.prefs import PreferencesDialog
@@ -45,12 +46,6 @@ from wicd.guiutil import error, GreyLabel, LabelEntry, SmallLabel
 if __name__ == '__main__':
     wpath.chdir(__file__)
 
-try:
-    import pygtk
-    pygtk.require("2.0")
-except:
-    pass
-
 proxy_obj = daemon = wireless = wired = bus = None
 language = misc.get_language_list_gui()
 DBUS_AVAIL = False
@@ -71,6 +66,7 @@ def setup_dbus(force=True):
                 return False
         else:  
             return False
+    prefs.setup_dbus()
     bus = dbusmanager.get_bus()
     dbus_ifaces = dbusmanager.get_dbus_ifaces()
     daemon = dbus_ifaces['daemon']

wicd/misc.py

@@ -29,26 +29,40 @@ from commands import getoutput
 # wicd imports
 import wpath
 
-if __name__ == '__main__':
-    wpath.chdir(__file__)
-    
+# Connection state constants
 NOT_CONNECTED = 0
 CONNECTING = 1
 WIRELESS = 2
 WIRED = 3
 SUSPENDED = 4
 
+# Automatic app selection constant
 AUTO = 0
+
+# DHCP Clients
 DHCLIENT = 1
 DHCPCD = 2
 PUMP = 3
 
+# Link detection tools
 ETHTOOL = 1
 MIITOOL = 2
 
+# Route flushing tools
 IP = 1
 ROUTE = 2
 
+# Graphical sudo apps
+GKSUDO = 1
+KDESU = 2
+KTSUSS = 3
+sudo_dict = { 
+    AUTO : "",
+    GKSUDO : "gksudo",
+    KDESU : "kdesu",
+    KTSUSS: "ktsuss",
+}
+
 class WicdError(Exception):
     pass
     
@@ -375,9 +389,9 @@ def detect_desktop_environment():
             pass
     return desktop_environment
 
-def get_sudo_cmd(msg):
+def get_sudo_cmd(msg, prog_num=0):
     """ Returns a graphical sudo command for generic use. """
-    sudo_prog = choose_sudo_prog()
+    sudo_prog = choose_sudo_prog(prog_num)
     if not sudo_prog: return None
     if re.search("(ktsuss|gksu|gksudo)$", sudo_prog):
         msg_flag = "-m"
@@ -385,8 +399,10 @@ def get_sudo_cmd(msg):
         msg_flag = "--caption"
     return [sudo_prog, msg_flag, msg]
 
-def choose_sudo_prog():
+def choose_sudo_prog(prog_num=0):
     """ Try to intelligently decide which graphical sudo program to use. """
+    if prog_num:
+        return find_path(sudo_dict[prog_num])
     desktop_env = detect_desktop_environment()
     env_path = os.environ['PATH'].split(":")
     
@@ -412,7 +428,10 @@ def find_path(cmd):
     the file can not be found.
     
     """
-    paths = os.getenv("PATH", default="/usr/bin:/usr/local/bin").split(':')
+    paths = os.getenv("PATH").split(':')
+    if not paths:
+        paths = ["/usr/local/sbin", "/usr/local/bin", "/usr/sbin", "/usr/bin",
+                 "/sbin", "/bin"]
     for path in paths:
         if os.path.exists(os.path.join(path, cmd)):
             return os.path.join(path, cmd)

wicd/monitor.py

@@ -275,8 +275,9 @@ class ConnectionStatus(object):
             return
         
         # Some checks to keep reconnect retries from going crazy.
-        if self.reconnect_tries > 2 and \
-           (time.time() - self.last_reconnect_time) < 300:
+        if (self.reconnect_tries > 3 and
+           (time.time() - self.last_reconnect_time) < 200):
+            print "Throttling autoreconnect"
             return
 
         self.reconnecting = True

wicd/netentry.py

@@ -237,7 +237,8 @@ class WiredSettingsDialog(AdvancedSettingsDialog):
         profile = self.prof_name
         cmdend = [os.path.join(wpath.lib, "configscript.py"), profile, "wired"]
         if os.getuid() != 0:
-            cmdbase = misc.get_sudo_cmd(language['scripts_need_pass'])
+            cmdbase = misc.get_sudo_cmd(language['scripts_need_pass'],
+                                        prog_num=daemon.GetSudoApp())
             if not cmdbase:
                 error(None, language["no_sudo_prog"]) 
                 return
@@ -336,7 +337,8 @@ class WirelessSettingsDialog(AdvancedSettingsDialog):
         cmdend = [os.path.join(wpath.lib, "configscript.py"), 
                                 str(self.networkID), "wireless"]
         if os.getuid() != 0:
-            cmdbase = misc.get_sudo_cmd(language['scripts_need_pass'])
+            cmdbase = misc.get_sudo_cmd(language['scripts_need_pass'],
+                                        prog_num=daemon.GetSudoApp())
             if not cmdbase:
                 error(None, language["no_sudo_prog"]) 
                 return

wicd/networking.py

@@ -106,6 +106,30 @@ def get_backend_description_dict():
             d[be] = get_backend_description(be)
     return d
 
+def expand_script_macros(script, msg, bssid, essid):
+    """Expands any supported macros in a script.
+
+    Keyword arguments:
+    script -- the script to execute.
+    msg -- the name of the script, %{script} will be expanded to this.
+    bssid -- the bssid of the network we connect to, defaults to 'wired'.
+    essid -- the essid of the network we connect to, defaults to 'wired'."""
+    def repl(match):
+        macro = match.group(1).lower()
+        if macro_dict.has_key(macro):
+            return macro_dict[macro]
+        print 'Warning: found illegal macro %s in %s script' % (macro, msg)
+        return match.group()
+    
+    macro_dict = { 'script' : msg,
+             'bssid' : bssid,
+             'essid' : essid }
+    regex = re.compile(r'%\{([a-zA-Z0-9]+)\}')
+    expanded = regex.sub(repl, script)
+    print "Expanded '%s' to '%s'" % (script, expanded)
+    return expanded
+
+    
 class Controller(object):
     """ Parent class for the different interface types. """
     def __init__(self):
@@ -138,8 +162,6 @@ class Controller(object):
         self._dhcp_client = value
         if self.iface:
             self.iface.DHCP_CLIENT = value
-            self.iface.CheckDHCP()
-            
     def get_dhcp_client(self): return self._dhcp_client
     dhcp_client = property(get_dhcp_client, set_dhcp_client)
     
@@ -166,6 +188,7 @@ class Controller(object):
             return True
         
     def StopDHCP(self):
+        """ Stops all running DHCP clients. """
         return BACKEND.StopDHCP()
     
     def GetIP(self, ifconfig=""):
@@ -215,31 +238,10 @@ class Controller(object):
         """
         return self.iface.Down()
     
-def expand_script_macros(script, msg, bssid, essid):
-    """Expands any supported macros in a script.
+    def AppAvailable(self, app):
+        """ Determine if the given application is installed. """
+        return self.iface.AppAvailable(app)
     
-    Keyword arguments:
-    script -- the script to execute.
-    msg -- the name of the script, %{script} will be expanded to this.
-    bssid -- the bssid of the network we connect to, defaults to 'wired'.
-    essid -- the essid of the network we connect to, defaults to 'wired'."""
-
-    macro_dict = { 'script' : msg,
-             'bssid' : bssid,
-             'essid' : essid }
-    
-    # Define a replacement function, this is done here so that %{script} will be substituted correctly
-    def repl(match):
-        macro = match.group( 1 ).lower()
-        if macro_dict.has_key( macro ):
-            return macro_dict[macro]
-        print 'Warning: found illegal macro %s in %s script' % (macro, msg)
-        return match.group()
-
-    regex = re.compile( r'%\{([a-zA-Z0-9]+)\}' )
-    expanded = regex.sub( repl, script )
-    print "Expanded '%s' to '%s'" % (script, expanded)
-    return expanded
 
 class ConnectThread(threading.Thread):
     """ A class to perform network connections in a multi-threaded way.

wicd/prefs.py

@@ -32,6 +32,7 @@ import gtk.glade
 
 from wicd import misc
 from wicd import wpath
+from wicd import dbusmanager
 from wicd.misc import checkboxTextboxToggle, noneToBlankString
 
 daemon = None
@@ -40,17 +41,37 @@ wired = None
 
 language = misc.get_language_list_gui()
 
+def setup_dbus():
+    global daemon, wireless, wired
+    daemon = dbusmanager.get_interface('daemon')
+    wireless = dbusmanager.get_interface('wireless')
+    wired = dbusmanager.get_interface('wired')
+
 class PreferencesDialog(object):
     """ Class for handling the wicd preferences dialog window. """
     def __init__(self, wTree, dbus):
-        global daemon, wireless, wired
-        daemon = dbus['daemon']
-        wireless = dbus['wireless']
-        wired = dbus['wired']
+        setup_dbus()
         self.wTree = wTree
         self.prep_settings_diag()
         self.load_preferences_diag()
         
+    def _setup_external_app_radios(self, radio_list, get_method, set_method):
+        """ Generic function for setting up external app radios. """
+        def set_available(apps):
+            for app in apps:
+                app.set_sensitive(daemon.GetAppAvailable(app.get_label()))
+        
+        # Disable radios for apps that aren't installed.
+        set_available(radio_list[1:])
+        selected_app = get_method()
+        # Make sure the app we want to select is actually available.
+        if radio_list[selected_app].get_property("sensitive"):
+            radio_list[selected_app].set_active(True)
+        else:
+            # If it isn't, default to Automatic.
+            set_method(misc.AUTO)
+            radio_list[misc.AUTO].set_active(True)
+            
     def load_preferences_diag(self):
         """ Loads data into the preferences Dialog. """
         
@@ -62,19 +83,37 @@ class PreferencesDialog(object):
         
         dhcp_list = [self.dhcpautoradio, self.dhclientradio, self.dhcpcdradio, 
                      self.pumpradio]
-        dhcp_method = daemon.GetDHCPClient()
-        print 'DHCP method is %s' % daemon.GetDHCPClient()
-        dhcp_list[dhcp_method].set_active(True)
+        self._setup_external_app_radios(dhcp_list, daemon.GetDHCPClient,
+                                        daemon.SetDHCPClient)
+        #set_available(dhcp_list[1:])
+        #dhcp_method = daemon.GetDHCPClient()
+        #if dhcp_list[dhcp_method].get_sensitive():
+            #dhcp_list[dhcp_method].set_active(True)
+        #else:
+            #daemon.SetDHCPClient(misc.AUTO)
+            #self.dhcpautoradio.set_active(True)
         
         wired_link_list = [self.linkautoradio, self.ethtoolradio,
                            self.miitoolradio]
-        wired_link_method = daemon.GetLinkDetectionTool()
-        wired_link_list[wired_link_method].set_active(True)
+        self._setup_external_app_radios(wired_link_list,
+                                        daemon.GetLinkDetectionTool,
+                                        daemon.SetLinkDetectionTool)
+        #set_available(wired_link_list[1:])
+        #wired_link_method = daemon.GetLinkDetectionTool()
+        #if wired_link_list[wired_link_method].get_sensitive():
+            #wired_link_list[wired_link_method].set_active(True)
 
         flush_list = [self.flushautoradio, self.ipflushradio,
                       self.routeflushradio]
-        flush_method = daemon.GetFlushTool()
-        flush_list[flush_method].set_active(True)
+        self._setup_external_app_radios(flush_list, daemon.GetFlushTool,
+                                        daemon.SetFlushTool)
+        #flush_method = daemon.GetFlushTool()
+        #flush_list[flush_method].set_active(True)
+        
+        sudo_list = [self.sudoautoradio, self.gksudoradio, self.kdesuradio,
+                     self.ktsussradio]
+        self._setup_external_app_radios(sudo_list, daemon.GetSudoApp,
+                                        daemon.SetAudoApp)
         
         auto_conn_meth = daemon.GetWiredAutoConnectMethod()
         if auto_conn_meth == 1:
@@ -186,6 +225,16 @@ class PreferencesDialog(object):
             flush_tool = misc.ROUTE
         daemon.SetFlushTool(flush_tool)
         
+        if self.sudoautoradio.get_active():
+            sudo_tool = misc.AUTO
+        elif self.gksudoradio.get_active():
+            sudo_tool = misc.GKSUDO
+        elif self.kdesuradio.get_active():
+            sudo_tool = misc.KDESU
+        else:
+            sudo_tool = misc.KTSUSS
+        daemon.SetSudoApp(sudo_tool)
+
         [width, height] = self.dialog.get_size()
         daemon.WriteWindowSize(width, height, "pref")
 
@@ -290,6 +339,12 @@ class PreferencesDialog(object):
         self.ipflushradio = setup_label("ip_flush_radio")
         self.routeflushradio = setup_label("route_flush_radio")
         
+        # Graphical Sudo Apps
+        self.sudoautoradio = setup_label("sudo_auto_radio", "wicd_auto_config")
+        self.gksudoradio = setup_label("gksudo_radio")
+        self.kdesuradio = setup_label("kdesu_radio")
+        self.ktsussradio = setup_label("ktsuss_radio")
+
         # Replacement for the combo box hack
         self.wpadrivercombo = build_combobox("pref_wpa_combobox")
         self.wpadrivers = ["wext", "hostap", "madwifi", "atmel",
@@ -317,10 +372,9 @@ class PreferencesDialog(object):
         # Load backend combobox
         self.backends = daemon.GetBackendList()
         self.be_descriptions = daemon.GetBackendDescriptionDict()
-        # "" is included as a hack for DBus limitations, so we remove it.
-        self.backends.remove("")
         
         for x in self.backends:
+            if x:
                 self.backendcombo.append_text(x)
             
     def be_combo_changed(self, combo):

wicd/wicd-daemon.py

@@ -99,6 +99,7 @@ class WicdDaemon(dbus.service.Object):
         self.dhcp_client = 0
         self.link_detect_tool = 0
         self.flush_tool = 0
+        self.sudo_app = 0
         
         # This will speed up the scanning process - if a client doesn't 
         # need a fresh scan, just feed them the old one.  A fresh scan
@@ -570,6 +571,11 @@ class WicdDaemon(dbus.service.Object):
         """
         return bool(self.need_profile_chooser)
     
+    @dbus.service.method("org.wicd.daemon")
+    def GetAppAvailable(self, app):
+        """ Determine if a given  application is available."""
+        return bool(self.wifi.AppAvailable(app) or self.wired.AppAvailable(app))
+
     @dbus.service.method('org.wicd.daemon')
     def GetDHCPClient(self):
         """ Returns the current DHCP client constant.
@@ -631,6 +637,17 @@ class WicdDaemon(dbus.service.Object):
         self.wifi.flush_tool = int(flush_tool)
         self.config.set("Settings", "flush_tool", flush_tool, write=True)
 
+    @dbus.service.method('org.wicd.daemon')
+    def GetSudoApp(self):
+        """ Get the preferred sudo app. """
+        return self.sudo_app
+    
+    @dbus.service.method('org.wicd.daemon')
+    def SetSudoApp(self, sudo_app):
+        """ Set the preferred sudo app. """
+        self.sudo_app = sudo_app
+        self.config.set("Settings", "sudo_app", sudo_app, write=True)
+        
     @dbus.service.method('org.wicd.daemon')
     def WriteWindowSize(self, width, height, win_name):
         """ Write the desired default window size.
@@ -814,7 +831,6 @@ class WicdDaemon(dbus.service.Object):
         b_wired = self.wired_bus
         b_wifi = self.wireless_bus
         app_conf= self.config
-        verbose = True
         # Load the backend.
         be_def = 'external'
         self.SetBackend(app_conf.get("Settings", "backend", default=be_def))
@@ -854,6 +870,7 @@ class WicdDaemon(dbus.service.Object):
         self.SetLinkDetectionTool(app_conf.get("Settings", "link_detect_tool",
                                                default=0))
         self.SetFlushTool(app_conf.get("Settings", "flush_tool", default=0))
+        self.SetSudoApp(app_conf.get("Settings", "sudo_app", default=0))
         self.SetPreferWiredNetwork(app_conf.get("Settings", "prefer_wired", 
                                                 default=False))
         app_conf.write()

wicd/wnettools.py

@@ -38,6 +38,7 @@ from string import maketrans, translate
 
 import wpath
 import misc
+from misc import find_path
 
 RALINK_DRIVER = 'ralink legacy'
 
@@ -160,11 +161,6 @@ class BaseInterface(object):
         self.iface = _sanitize_string_strict(iface)
         self.verbose = verbose
         self.DHCP_CLIENT = None
-        self.DHCP_CMD = None
-        self.DHCP_RELEASE = None
-        self.MIITOOL_FOUND = False
-        self.ETHTOOL_FOUND = False
-        self.IP_FOUND = False
         self.flush_tool = None
         self.link_detect = None       
     
@@ -181,112 +177,82 @@ class BaseInterface(object):
         """
         self.iface = _sanitize_string_strict(str(iface))
         
-    def _find_client_path(self, client):
+    def _find_program_path(self, program):
         """ Determines the full path for the given program.
         
-        Searches a hardcoded list of paths for a given program name.
+        Searches for a given program name on the PATH.
         
         Keyword arguments:
-        client -- The name of the program to search for
+        program -- The name of the program to search for
         
         Returns:
         The full path of the program or None
         
         """
-        paths = ['/sbin/', '/usr/sbin/', '/bin/', '/usr/bin/',
-                 '/usr/local/sbin/', '/usr/local/bin/']
-        for path in paths:
-            if os.path.exists("%s%s" % (path, client)):
-                return "%s%s" % (path, client)
-        if self.verbose:
-            print "WARNING: No path found for %s"  % (client)
-        return None
+        path = find_path(program)
+        if not path and self.verbose:
+            print "WARNING: No path found for %s" % program
+        return path
 
-    def CheckDHCP(self):
-        """ Check for a valid DHCP client. 
     
-        Checks for the existence of a supported DHCP client.  If one is
-        found, the appropriate values for DHCP_CMD, DHCP_RELEASE, and
-        DHCP_CLIENT are set.  If a supported client is not found, a
-        warning is printed.
+    def _get_dhcp_command(self, flavor=None):
+        """ Returns the correct DHCP client command. 
+       
+        Given a type of DHCP request (create or release a lease),
+        this method will build a command to complete the request
+        using the correct dhcp client, and cli options.
         
         """
         def get_client_name(cl):
             """ Converts the integer value for a dhcp client to a string. """
-            if cl in [misc.DHCLIENT, "dhclient"]:
+            if (cl in [misc.DHCLIENT, "dhclient"] or 
+                (cl == misc.AUTO and self.dhclient_cmd)):
                 client = "dhclient"
-            elif cl in [misc.DHCPCD, "dhcpcd"]:
+                cmd = self.dhclient_cmd
+            elif (cl in [misc.DHCPCD, "dhcpcd"] or
+                  (cl == misc.AUTO and self.dhcpcd_cmd)):
                 client = "dhcpcd"
-            else:
+                cmd = self.dhcpcd_cmd
+            elif (cl in [misc.PUMP, "pump"] or 
+                  (cl == misc.AUTO and self.pump_cmd)):
                 client = "pump"
-            return client
-        
-        if self.DHCP_CLIENT:
-            dhcp_client = get_client_name(self.DHCP_CLIENT)
-            dhcp_path = self._find_client_path(dhcp_client)
-            if not dhcp_path:
-                print "WARNING: Could not find selected dhcp client.  Wicd " + \
-                      " will try to find another supported client."
-        if not self.DHCP_CLIENT or not dhcp_path:
-            dhcp_client = None
-            dhcp_path = None
-            dhcpclients = ["dhclient", "dhcpcd", "pump"]
-            for client in dhcpclients:
-                dhcp_path = self._find_client_path(client)
-                if dhcp_path:
-                    dhcp_client = client
-                    break
-    
-        if not dhcp_client:
-            print "WARNING: No supported DHCP Client could be found!"
-            return
-        elif dhcp_client in [misc.DHCLIENT, "dhclient"]:
-            dhcp_client = misc.DHCLIENT
-            dhcp_cmd = dhcp_path
-            dhcp_release = dhcp_cmd + " -r"
-        elif dhcp_client in [misc.PUMP, "pump"]:
-            dhcp_client = misc.PUMP
-            dhcp_cmd = dhcp_path + " -i"
-            dhcp_release = dhcp_cmd + " -r -i"
-        elif dhcp_client in [misc.DHCPCD, "dhcpcd"]:
-            dhcp_client = misc.DHCPCD
-            dhcp_cmd = dhcp_path
-            dhcp_release = dhcp_cmd + " -k"
+                cmd = self.pump_cmd
             else:
-            dhcp_client = None
-            dhcp_cmd = None
-            dhcp_release = None
+                client = None
+                cmd = ""
+            return (client, cmd)
         
-        self.DHCP_CMD = dhcp_cmd
-        self.DHCP_RELEASE = dhcp_release
-        self.DHCP_CLIENT = dhcp_client
+        connect_dict = {
+            "dhclient" : r"%s %s", 
+            "pump" : r"%s -i %s",
+            "dhcpcd" : r"%s %s",
+        }
+        release_dict = {
+            "dhclient" : r"%s -r %s",
+            "pump" : r"%s -r -i %s",
+            "dhcpcd" : r"%s -k %s",
+        }
+        (client_name, cmd) = get_client_name(self.DHCP_CLIENT)
+        if not client_name or not cmd:
+            print "WARNING: Failed to find a valid dhcp client!"
+            return ""
             
-    def CheckWiredTools(self):
-        """ Check for the existence of ethtool and mii-tool. """
-        miitool_path = self._find_client_path("mii-tool")
-        if miitool_path:
-            self.miitool_cmd = miitool_path
-            self.MIITOOL_FOUND = True
+        if flavor == "connect":
+            return connect_dict[client_name] % (cmd, self.iface)
+        elif flavor == "release":
+            return release_dict[client_name] % (cmd, self.iface)
         else:
-            self.miitool_cmd = None
-            self.MIITOOL_FOUND = False
+            return str(cmd)
     
-        ethtool_path = self._find_client_path("ethtool")
-        if ethtool_path:
-            self.ethtool_cmd = ethtool_path
-            self.ETHTOOL_FOUND = True
-        else:
-            self.ethtool_cmd = None
-            self.ETHTOOL_FOUND = False
+    def AppAvailable(self, app):
+        """ Return whether a given app is available.
         
-    def CheckWirelessTools(self):
-        """ Check for the existence of wpa_cli """
-        wpa_cli_path = self._find_client_path("wpa_cli")
-        if wpa_cli_path:
-            self.WPA_CLI_FOUND = True
-        else:
-            self.WPA_CLI_FOUND = False
-            print "wpa_cli not found.  Authentication will not be validated."
+        Given the name of an executable, determines if it is
+        available for use by checking for a defined 'app'_cmd
+        instance variable.
+        
+        """
+        return bool(self.__dict__.get("%s_cmd" % app.replace("-", "")))
         
     def Check(self):
         """ Check that all required tools are available. """
@@ -294,14 +260,43 @@ class BaseInterface(object):
         self.CheckDHCP()
         self.CheckWiredTools()
         self.CheckWirelessTools()
+        self.CheckSudoApplications()
+        self.CheckRouteFlushTool()
         
-        ip_path = self._find_client_path("ip")
-        if ip_path:
-            self.ip_cmd = ip_path
-            self.IP_FOUND = True
-        else:
-            self.ip_cmd = None
-            self.IP_FOUND = False
+    def CheckDHCP(self):
+        """ Check for the existence of valid DHCP clients. 
+        
+        Checks for the existence of a supported DHCP client.  If one is
+        found, the appropriate values for DHCP_CMD, DHCP_RELEASE, and
+        DHCP_CLIENT are set.  If a supported client is not found, a
+        warning is printed.
+        
+        """
+        
+        self.dhclient_cmd = self._find_program_path("dhclient")
+        self.dhcpcd_cmd = self._find_program_path("dhcpcd")
+        self.pump_cmd = self._find_program_path("pump")
+        
+    def CheckWiredTools(self):
+        """ Check for the existence of ethtool and mii-tool. """
+        self.miitool_cmd = self._find_program_path("mii-tool")
+        self.ethtool_cmd = self._find_program_path("ethtool")
+            
+    def CheckWirelessTools(self):
+        """ Check for the existence of wpa_cli """
+        self.wpa_cli_cmd = self._find_program_path("wpa_cli")
+        if not self.wpa_cli_cmd:
+            print "wpa_cli not found.  Authentication will not be validated."
+     
+    def CheckRouteFlushTool(self):
+        """ Check for a route flush tool. """
+        self.ip_cmd = self._find_program_path("ip")
+        self.route_cmd = self._find_program_path("route")
+            
+    def CheckSudoApplications(self):
+        self.gksudo_cmd = self._find_program_path("gksudo")
+        self.kdesu_cmd = self._find_program_path("kdesu")
+        self.ktsuss_cmd = self._find_program_path("ktsuss")
 
     def Up(self):
         """ Bring the network interface up.
@@ -461,7 +456,8 @@ class BaseInterface(object):
         """
         if not self.iface: return False
         
-        cmd = self.DHCP_CMD + " " + self.iface
+        cmd = "%s %s" % (self._get_dhcp_command('connect'), self.iface)
+        #cmd = self.DHCP_CMD + " " + self.iface
         if self.verbose: print cmd
         pipe = misc.Run(cmd, include_stderr=True, return_pipe=True)
         
@@ -476,19 +472,20 @@ class BaseInterface(object):
     def ReleaseDHCP(self):
         """ Release the DHCP lease for this interface. """
         if not self.iface: return False
-        cmd = self.DHCP_RELEASE + " " + self.iface
+        cmd = "%s %s" % (self._get_dhcp_command("release"), self.iface)
+        #cmd = self.DHCP_RELEASE + " " + self.iface
         if self.verbose: print cmd
         misc.Run(cmd)
 
     def FlushRoutes(self):
         """ Flush all network routes. """
         if not self.iface: return False
-        if self.IP_FOUND and self.flush_tool == misc.IP:
-            #cmd = "ip route flush dev " + self.iface
-            cmds = ['ip route flush all']
-        else:
-            cmds = ['route del default']
+        if self.route_cmd and self.flush_tool == misc.ROUTE:
+            cmds = ['%s del default' % self.route_cmd]
             cmds.append('route del dev %s' % self.iface)
+        elif self.ip_cmd and self.flush_tool == misc.IP:
+            #cmd = "ip route flush dev " + self.iface
+            cmds = ['%s route flush all' % self.ip_cmd]
         for cmd in cmds:
             if self.verbose: print cmd
             misc.Run(cmd)