gryf/wicd
1
0
Fork 0
mirror of https://github.com/gryf/wicd.git synced 2025-12-21 05:18:02 +01:00
Code Issues Projects Releases Wiki Activity

Fix some issues by pylint

Browse Source
This commit is contained in:
David Paleino
2012-11-17 01:07:08 +01:00
parent b386b37db7
commit b5a4d70ab8
19 changed files with 729 additions and 448 deletions
Download Patch File Download Diff File Expand all files Collapse all files

109
cli/wicd-cli.py
View File

@@ -1,5 +1,6 @@
#!/usr/bin/python
""" Scriptable command-line interface. """
# 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
@@ -32,20 +33,30 @@ else:
bus = dbus.SystemBus()
try:
daemon = dbus.Interface(bus.get_object('org.wicd.daemon', '/org/wicd/daemon'),
'org.wicd.daemon')
wireless = dbus.Interface(bus.get_object('org.wicd.daemon', '/org/wicd/daemon/wireless'),
'org.wicd.daemon.wireless')
wired = dbus.Interface(bus.get_object('org.wicd.daemon', '/org/wicd/daemon/wired'),
'org.wicd.daemon.wired')
config = dbus.Interface(bus.get_object('org.wicd.daemon', '/org/wicd/daemon/config'),
'org.wicd.daemon.config')
daemon = dbus.Interface(
bus.get_object('org.wicd.daemon', '/org/wicd/daemon'),
'org.wicd.daemon'
)
wireless = dbus.Interface(
bus.get_object('org.wicd.daemon', '/org/wicd/daemon/wireless'),
'org.wicd.daemon.wireless'
)
wired = dbus.Interface(
bus.get_object('org.wicd.daemon', '/org/wicd/daemon/wired'),
'org.wicd.daemon.wired'
)
config = dbus.Interface(
bus.get_object('org.wicd.daemon', '/org/wicd/daemon/config'),
'org.wicd.daemon.config'
)
except dbus.DBusException:
print 'Error: Could not connect to the daemon. Please make sure it is running.'
print 'Error: Could not connect to the daemon. ' + \
'Please make sure it is running.'
sys.exit(3)
if not daemon:
print 'Error connecting to wicd via D-Bus. Please make sure the wicd service is running.'
print 'Error connecting to wicd via D-Bus. ' + \
'Please make sure the wicd service is running.'
sys.exit(3)
parser = optparse.OptionParser()
@@ -61,12 +72,14 @@ parser.add_option('--list-networks', '-l', default=False, action='store_true')
parser.add_option('--network-details', '-d', default=False, action='store_true')
parser.add_option('--disconnect', '-x', default=False, action='store_true')
parser.add_option('--connect', '-c', default=False, action='store_true')
parser.add_option('--list-encryption-types', '-e', default=False, action='store_true')
parser.add_option('--list-encryption-types', '-e', default=False,
action='store_true')
# short options for these aren't great.
parser.add_option('--wireless', '-y', default=False, action='store_true')
parser.add_option('--wired', '-z', default=False, action='store_true')
parser.add_option('--load-profile', '-o', default=False, action='store_true')
parser.add_option('--status', '-i', default=False, action='store_true') # -i(nfo)
parser.add_option('--status', '-i', default=False,
action='store_true') # -i(nfo)
options, arguments = parser.parse_args()
@@ -114,12 +127,14 @@ if options.status:
# functions
def is_valid_wireless_network_id(network_id):
""" Check if it's a valid wireless network. '"""
if not (network_id >= 0 \
and network_id < wireless.GetNumberOfNetworks()):
print 'Invalid wireless network identifier.'
sys.exit(1)
def is_valid_wired_network_id(network_id):
""" Check if it's a valid wired network. '"""
num = len(wired.GetWiredProfileList())
if not (network_id < num and \
network_id >= 0):
@@ -127,6 +142,7 @@ def is_valid_wired_network_id(network_id):
sys.exit(4)
def is_valid_wired_network_profile(profile_name):
""" Check if it's a valid wired network profile. '"""
if not profile_name in wired.GetWiredProfileList():
print 'Profile of that name does not exist.'
sys.exit(5)
@@ -151,10 +167,10 @@ if options.list_networks:
wireless.GetWirelessProperty(network_id, 'essid'))
elif options.wired:
print '#\tProfile name'
id = 0
i = 0
for profile in wired.GetWiredProfileList():
print '%s\t%s' % (id, profile)
id += 1
print '%s\t%s' % (i, profile)
i += 1
op_performed = True
if options.network_details:
@@ -176,10 +192,14 @@ if options.network_details:
wireless.GetWirelessProperty(network_id, "encryption_method")
else:
print "Encryption: Off"
print "Quality: %s" % wireless.GetWirelessProperty(network_id, "quality")
print "Mode: %s" % wireless.GetWirelessProperty(network_id, "mode")
print "Channel: %s" % wireless.GetWirelessProperty(network_id, "channel")
print "Bit Rates: %s" % wireless.GetWirelessProperty(network_id, "bitrates")
print "Quality: %s" % \
wireless.GetWirelessProperty(network_id, "quality")
print "Mode: %s" % \
wireless.GetWirelessProperty(network_id, "mode")
print "Channel: %s" % \
wireless.GetWirelessProperty(network_id, "channel")
print "Bit Rates: %s" % \
wireless.GetWirelessProperty(network_id, "bitrates")
op_performed = True
# network properties
@@ -194,7 +214,8 @@ if options.network_property:
network_id = wireless.GetCurrentNetworkID(0)
is_valid_wireless_network_id(network_id)
if not options.set_to:
print wireless.GetWirelessProperty(network_id, options.network_property)
print wireless.GetWirelessProperty(network_id,
options.network_property)
else:
wireless.SetWirelessProperty(network_id, \
options.network_property, options.set_to)
@@ -209,11 +230,13 @@ if options.disconnect:
daemon.Disconnect()
if options.wireless:
if wireless.GetCurrentNetworkID(0) > -1:
print "Disconnecting from %s on %s" % (wireless.GetCurrentNetwork(0),
print "Disconnecting from %s on %s" % \
(wireless.GetCurrentNetwork(0),
wireless.DetectWirelessInterface())
elif options.wired:
if wired.CheckPluggedIn():
print "Disconnecting from wired connection on %s" % wired.DetectWiredInterface()
print "Disconnecting from wired connection on %s" % \
wired.DetectWiredInterface()
op_performed = True
if options.connect:
@@ -226,16 +249,17 @@ if options.connect:
wireless.DetectWirelessInterface())
wireless.ConnectWireless(options.network)
check = lambda: wireless.CheckIfWirelessConnecting()
status = lambda: wireless.CheckWirelessConnectingStatus()
message = lambda: wireless.CheckWirelessConnectingMessage()
check = wireless.CheckIfWirelessConnecting
status = wireless.CheckWirelessConnectingStatus
message = wireless.CheckWirelessConnectingMessage
elif options.wired:
print "Connecting to wired connection on %s" % wired.DetectWiredInterface()
print "Connecting to wired connection on %s" % \
wired.DetectWiredInterface()
wired.ConnectWired()
check = lambda: wired.CheckIfWiredConnecting()
status = lambda: wired.CheckWiredConnectingStatus()
message = lambda: wired.CheckWiredConnectingMessage()
check = wired.CheckIfWiredConnecting
status = wired.CheckWiredConnectingStatus
message = wired.CheckWiredConnectingMessage
else:
check = lambda: False
status = lambda: False
@@ -245,36 +269,37 @@ if options.connect:
last = None
if check:
while check():
next = status()
if next != last:
# avoid a race condition where status is updated to "done" after the
# loop check
if next == "done":
next_ = status()
if next_ != last:
# avoid a race condition where status is updated to "done" after
# the loop check
if next_ == "done":
break
print message()
last = next
last = next_
print "done!"
op_performed = True
# pretty print optional and required properties
def str_properties(prop):
""" Pretty print optional and required properties. """
if len(prop) == 0:
return "None"
else:
return ', '.join("%s (%s)" % (x[0], x[1].replace("_", " ")) for x in type['required'])
tmp = [(x[0], x[1].replace('_', ' ')) for x in type['required']]
return ', '.join("%s (%s)" % (x, y) for x, y in tmp)
if options.wireless and options.list_encryption_types:
et = misc.LoadEncryptionMethods()
# print 'Installed encryption templates:'
print '%s\t%-20s\t%s' % ('#', 'Name', 'Description')
id = 0
for type in et:
print '%s\t%-20s\t%s' % (id, type['type'], type['name'])
print ' Req: %s' % str_properties(type['required'])
i = 0
for t in et:
print '%s\t%-20s\t%s' % (i, t['type'], t['name'])
print ' Req: %s' % str_properties(t['required'])
print '---'
# don't print optionals (yet)
#print ' Opt: %s' % str_properties(type['optional'])
id += 1
i += 1
op_performed = True
if options.save and options.network > -1:

82
curses/configscript_curses.py
View File

@@ -26,26 +26,36 @@ Also recycles a lot of configscript.py, too. :-)
from wicd import misc
from wicd.translations import _
import configscript
from configscript import write_scripts,get_script_info,get_val,none_to_blank,blank_to_none
from configscript import write_scripts, get_script_info, get_val
from configscript import none_to_blank, blank_to_none
import urwid
import urwid.curses_display
import sys
import os
ui = None
frame = None
pre_entry = None
post_entry = None
pre_disconnect_entry = None
post_disconnect_entry = None
def main(argv):
global ui,frame
""" Main function. """
global ui, frame
if len(argv) < 2:
print 'Network id to configure is missing, aborting.'
sys.exit(1)
ui = urwid.curses_display.Screen()
ui.register_palette( [
('body','default','default'),
('focus','dark magenta','light gray'),
ui.register_palette([
('body', 'default', 'default'),
('focus', 'dark magenta', 'light gray'),
('editcp', 'default', 'default', 'standout'),
('editbx', 'light gray', 'dark blue'),
('editfc', 'white','dark blue', 'bold')] )
('editfc', 'white','dark blue', 'bold'),
])
network = argv[1]
network_type = argv[2]
@@ -53,34 +63,44 @@ def main(argv):
script_info = get_script_info(network, network_type)
blank = urwid.Text('')
pre_entry_t = ('body',_('Pre-connection Script')+': ')
post_entry_t = ('body',_('Post-connection Script')+': ')
pre_disconnect_entry_t = ('body',_('Pre-disconnection Script')+': ')
post_disconnect_entry_t = ('body',_('Post-disconnection Script')+': ')
pre_entry_t = ('body', _('Pre-connection Script') + ': ')
post_entry_t = ('body', _('Post-connection Script') + ': ')
pre_disconnect_entry_t = ('body', _('Pre-disconnection Script') + ': ')
post_disconnect_entry_t = ('body', _('Post-disconnection Script') + ': ')
global pre_entry,post_entry,pre_disconnect_entry,post_disconnect_entry
global pre_entry, post_entry, pre_disconnect_entry, post_disconnect_entry
pre_entry = urwid.AttrWrap(urwid.Edit(pre_entry_t,
none_to_blank(script_info.get('pre_entry'))),'editbx','editfc' )
none_to_blank(script_info.get('pre_entry'))),
'editbx', 'editfc')
post_entry = urwid.AttrWrap(urwid.Edit(post_entry_t,
none_to_blank(script_info.get('post_entry'))),'editbx','editfc' )
none_to_blank(script_info.get('post_entry'))),
'editbx','editfc')
pre_disconnect_entry = urwid.AttrWrap(urwid.Edit(pre_disconnect_entry_t,
none_to_blank(script_info.get('pre_disconnect_entry'))),'editbx','editfc' )
none_to_blank(script_info.get('pre_disconnect_entry'))),
'editbx', 'editfc')
post_disconnect_entry = urwid.AttrWrap(urwid.Edit(post_disconnect_entry_t,
none_to_blank(script_info.get('post_disconnect_entry'))),'editbx','editfc' )
none_to_blank(script_info.get('post_disconnect_entry'))),
'editbx','editfc')
# The buttons
ok_button = urwid.AttrWrap(urwid.Button(_('OK'),ok_callback),'body','focus')
cancel_button = urwid.AttrWrap(urwid.Button(_('Cancel'),cancel_callback),'body','focus')
ok_button = urwid.AttrWrap(
urwid.Button(_('OK'), ok_callback),
'body','focus'
)
cancel_button = urwid.AttrWrap(
urwid.Button(_('Cancel'), cancel_callback),
'body','focus'
)
button_cols = urwid.Columns([ok_button,cancel_button],dividechars=1)
button_cols = urwid.Columns([ok_button, cancel_button], dividechars=1)
lbox = urwid.Pile([('fixed',2,urwid.Filler(pre_entry)),
#('fixed',urwid.Filler(blank),1),
('fixed',2,urwid.Filler(post_entry)),
('fixed',2,urwid.Filler(pre_disconnect_entry)),
('fixed',2,urwid.Filler(post_disconnect_entry)),
#blank,blank,blank,blank,blank,
lbox = urwid.Pile([('fixed', 2, urwid.Filler(pre_entry)),
#('fixed', urwid.Filler(blank), 1),
('fixed', 2, urwid.Filler(post_entry)),
('fixed', 2, urwid.Filler(pre_disconnect_entry)),
('fixed', 2, urwid.Filler(post_disconnect_entry)),
#blank, blank, blank, blank, blank,
urwid.Filler(button_cols,'bottom')
])
frame = urwid.Frame(lbox)
@@ -89,16 +109,18 @@ def main(argv):
if result == True:
script_info["pre_entry"] = blank_to_none(pre_entry.get_edit_text())
script_info["post_entry"] = blank_to_none(post_entry.get_edit_text())
script_info["pre_disconnect_entry"] = blank_to_none(pre_disconnect_entry.get_edit_text())
script_info["post_disconnect_entry"] = blank_to_none(post_disconnect_entry.get_edit_text())
script_info["pre_disconnect_entry"] = \
blank_to_none(pre_disconnect_entry.get_edit_text())
script_info["post_disconnect_entry"] = \
blank_to_none(post_disconnect_entry.get_edit_text())
write_scripts(network, network_type, script_info)
OK_PRESSED = False
CANCEL_PRESSED = False
def ok_callback(button_object,user_data=None):
def ok_callback(button_object, user_data=None):
global OK_PRESSED
OK_PRESSED = True
def cancel_callback(button_object,user_data=None):
def cancel_callback(button_object, user_data=None):
global CANCEL_PRESSED
CANCEL_PRESSED = True
def run():
@@ -119,9 +141,7 @@ def run():
#Send key to underlying widget:
if urwid.is_mouse_event(k):
event, button, col, row = k
frame.mouse_event( dim,
event, button, col, row,
focus=True)
frame.mouse_event(dim, event, button, col, row, focus=True)
else:
frame.keypress(dim, k)
# Check if buttons are pressed.

297
curses/curses_misc.py
View File

@@ -27,13 +27,13 @@ import urwid
from wicd.translations import _
# Uses code that is towards the bottom
def error(ui,parent,message):
def error(ui, parent, message):
"""Shows an error dialog (or something that resembles one)"""
# /\
# /!!\
# /____\
dialog = TextDialog(message,6,40,('important',"ERROR"))
return dialog.run(ui,parent)
dialog = TextDialog(message, 6, 40, ('important', 'ERROR'))
return dialog.run(ui, parent)
class SelText(urwid.Text):
"""A selectable text widget. See urwid.Text."""
@@ -42,13 +42,12 @@ class SelText(urwid.Text):
"""Make widget selectable."""
return True
def keypress(self, size, key):
"""Don't handle any keys."""
return key
# ListBox that can't be selected.
class NSelListBox(urwid.ListBox):
""" Non-selectable ListBox. """
def selectable(self):
return False
@@ -64,8 +63,9 @@ class DynWrap(urwid.AttrWrap):
attrfoc = attributes when in focus, defaults to nothing
"""
def __init__(self,w,sensitive=True,attrs=('editbx','editnfc'),focus_attr='editfc'):
self._attrs=attrs
def __init__(self, w, sensitive=True, attrs=('editbx', 'editnfc'), \
focus_attr='editfc'):
self._attrs = attrs
self._sensitive = sensitive
if sensitive:
@@ -73,48 +73,59 @@ class DynWrap(urwid.AttrWrap):
else:
cur_attr = attrs[1]
self.__super.__init__(w,cur_attr,focus_attr)
self.__super.__init__(w, cur_attr, focus_attr)
def get_sensitive(self):
""" Getter for sensitive property. """
return self._sensitive
def set_sensitive(self,state):
def set_sensitive(self, state):
""" Setter for sensitive property. """
if state:
self.set_attr(self._attrs[0])
else:
self.set_attr(self._attrs[1])
self._sensitive = state
property(get_sensitive,set_sensitive)
property(get_sensitive, set_sensitive)
def get_attrs(self):
""" Getter for attrs property. """
return self._attrs
def set_attrs(self,attrs):
def set_attrs(self, attrs):
""" Setter for attrs property. """
self._attrs = attrs
property(get_attrs,set_attrs)
property(get_attrs, set_attrs)
def selectable(self):
return self._sensitive
# Just an Edit Dynwrapped to the most common specifications
class DynEdit(DynWrap):
def __init__(self,caption='',edit_text='',sensitive=True,attrs=('editbx','editnfc'),focus_attr='editfc'):
caption = ('editcp',caption + ': ')
edit = urwid.Edit(caption,edit_text)
self.__super.__init__(edit,sensitive,attrs,focus_attr)
""" Edit DynWrap'ed to the most common specifications. """
def __init__(self, caption='', edit_text='', sensitive=True,
attrs=('editbx', 'editnfc'), focus_attr='editfc'):
caption = ('editcp', caption + ': ')
edit = urwid.Edit(caption, edit_text)
self.__super.__init__(edit, sensitive, attrs, focus_attr)
# Just an IntEdit Dynwrapped to the most common specifications
class DynIntEdit(DynWrap):
def __init__(self,caption='',edit_text='',sensitive=True,attrs=('editbx','editnfc'),focus_attr='editfc'):
caption = ('editcp',caption + ':')
edit = urwid.IntEdit(caption,edit_text)
self.__super.__init__(edit,sensitive,attrs,focus_attr)
""" IntEdit DynWrap'ed to the most common specifications. """
def __init__(self, caption='', edit_text='', sensitive=True,
attrs=('editbx', 'editnfc'), focus_attr='editfc'):
caption = ('editcp', caption + ':')
edit = urwid.IntEdit(caption, edit_text)
self.__super.__init__(edit, sensitive, attrs, focus_attr)
class DynRadioButton(DynWrap):
def __init__(self,group,label,state='first True',on_state_change=None, user_data=None, sensitive=True, attrs=('body','editnfc'),focus_attr='body'):
#caption = ('editcp',caption + ':')
button = urwid.RadioButton(group,label,state,on_state_change,user_data)
self.__super.__init__(button,sensitive,attrs,focus_attr)
""" RadioButton DynWrap'ed to the most common specifications. """
def __init__(self, group, label, state='first True', on_state_change=None,
user_data=None, sensitive=True, attrs=('body', 'editnfc'),
focus_attr='body'):
#caption = ('editcp', caption + ':')
button = urwid.RadioButton(group, label, state, on_state_change,
user_data)
self.__super.__init__(button, sensitive, attrs, focus_attr)
class MaskingEditException(Exception):
""" Custom exception. """
pass
# Password-style edit
@@ -131,29 +142,31 @@ class MaskingEdit(urwid.Edit):
edit_pos = None, layout=None, mask_mode="always",mask_char='*'):
self.mask_mode = mask_mode
if len(mask_char) > 1:
raise MaskingEditException('Masks of more than one character are not supported!')
raise MaskingEditException('Masks of more than one character are' +\
' not supported!')
self.mask_char = mask_char
self.__super.__init__(caption,edit_text,multiline,align,wrap,allow_tab,edit_pos,layout)
self.__super.__init__(caption, edit_text, multiline, align, wrap,
allow_tab, edit_pos, layout)
def get_caption(self):
return self.caption
def get_mask_mode(self):
return self.mask_mode
def set_mask_mode(self,mode):
def set_mask_mode(self, mode):
self.mask_mode = mode
def get_masked_text(self):
return self.mask_char*len(self.get_edit_text())
def render(self,(maxcol,), focus=False):
def render(self, (maxcol, ), focus=False):
"""
Render edit widget and return canvas. Include cursor when in
focus.
"""
# If we aren't masking anything ATM, then act like an Edit.
# No problems.
if self.mask_mode == "off" or (self.mask_mode == 'no_focus' and focus == True):
canv = self.__super.render((maxcol,),focus)
if self.mask_mode == "off" or (self.mask_mode == 'no_focus' and focus):
canv = self.__super.render((maxcol, ), focus)
# The cache messes this thing up, because I am totally changing what
# is displayed.
self._invalidate()
@@ -163,49 +176,50 @@ class MaskingEdit(urwid.Edit):
self._shift_view_to_cursor = not not focus # force bool
text, attr = self.get_text()
text = text[:len(self.caption)]+self.get_masked_text()
trans = self.get_line_translation( maxcol, (text,attr) )
text = text[:len(self.caption)] + self.get_masked_text()
trans = self.get_line_translation(maxcol, (text, attr))
canv = urwid.canvas.apply_text_layout(text, attr, trans, maxcol)
if focus:
canv = urwid.CompositeCanvas(canv)
canv.cursor = self.get_cursor_coords((maxcol,))
canv.cursor = self.get_cursor_coords((maxcol, ))
return canv
# Tabbed interface, mostly for use in the Preferences Dialog
class TabColumns(urwid.WidgetWrap):
"""
Tabbed interface, mostly for use in the Preferences Dialog
titles_dict = dictionary of tab_contents (a SelText) : tab_widget (box)
attr = normal attributes
attrsel = attribute when active
"""
# FIXME Make the bottom_part optional
def __init__(self,tab_str,tab_wid,title,bottom_part=None,attr=('body','focus'),
attrsel='tab active', attrtitle='header'):
def __init__(self, tab_str, tab_wid, title, bottom_part=None,
attr=('body', 'focus'), attrsel='tab active', attrtitle='header'):
#self.bottom_part = bottom_part
#title_wid = urwid.Text((attrtitle,title),align='right')
#title_wid = urwid.Text((attrtitle, title), align='right')
column_list = []
for w in tab_str:
text,trash = w.get_text()
column_list.append(('fixed',len(text),w))
column_list.append(urwid.Text((attrtitle,title),align='right'))
text, _ = w.get_text()
column_list.append(('fixed', len(text), w))
column_list.append(urwid.Text((attrtitle, title), align='right'))
self.tab_map = dict(zip(tab_str,tab_wid))
self.tab_map = dict(zip(tab_str, tab_wid))
self.active_tab = tab_str[0]
self.columns = urwid.Columns(column_list,dividechars=1)
#walker = urwid.SimpleListWalker([self.columns,tab_wid[0]])
self.columns = urwid.Columns(column_list, dividechars=1)
#walker = urwid.SimpleListWalker([self.columns, tab_wid[0]])
#self.listbox = urwid.ListBox(walker)
self.gen_pile(tab_wid[0],True)
self.gen_pile(tab_wid[0], True)
self.frame = urwid.Frame(self.pile)
self.__super.__init__(self.frame)
# Make the pile in the middle
def gen_pile(self,lbox,firstrun=False):
def gen_pile(self, lbox, firstrun=False):
""" Make the pile in the middle. """
self.pile = urwid.Pile([
('fixed',1,urwid.Filler(self.columns,'top')),
urwid.Filler(lbox,'top',height=('relative',99)),
#('fixed',1,urwid.Filler(self.bottom_part,'bottom'))
('fixed', 1, urwid.Filler(self.columns, 'top')),
urwid.Filler(lbox, 'top', height=('relative', 99)),
#('fixed', 1, urwid.Filler(self.bottom_part, 'bottom'))
])
if not firstrun:
self.frame.set_body(self.pile)
@@ -213,9 +227,11 @@ class TabColumns(urwid.WidgetWrap):
self._invalidate()
def selectable(self):
""" Return whether the widget is selectable. """
return True
def keypress(self,size,key):
def keypress(self, size, key):
""" Handle keypresses. """
# If the key is page up or page down, move focus to the tabs and call
# left or right on the tabs.
if key == "page up" or key == "page down":
@@ -224,10 +240,10 @@ class TabColumns(urwid.WidgetWrap):
newK = 'left'
else:
newK = 'right'
self.keypress(size,newK)
self.keypress(size, newK)
self._w.get_body().set_focus(1)
else:
key = self._w.keypress(size,key)
key = self._w.keypress(size, key)
wid = self.pile.get_focus().get_body()
if wid == self.columns:
self.active_tab.set_attr('body')
@@ -237,12 +253,13 @@ class TabColumns(urwid.WidgetWrap):
return key
def mouse_event(self,size,event,button,x,y,focus):
def mouse_event(self, size, event, button, x, y, focus):
""" Handle mouse events. """
wid = self.pile.get_focus().get_body()
if wid == self.columns:
self.active_tab.set_attr('body')
self._w.mouse_event(size,event,button,x,y,focus)
self._w.mouse_event(size, event, button, x, y, focus)
if wid == self.columns:
self.active_tab.set_attr('body')
self.columns.get_focus().set_attr('tab active')
@@ -250,8 +267,8 @@ class TabColumns(urwid.WidgetWrap):
self.gen_pile(self.tab_map[self.active_tab])
### Combo box code begins here
class ComboBoxException(Exception):
""" Custom exception. """
pass
# A "combo box" of SelTexts
@@ -264,10 +281,11 @@ class ComboBox(urwid.WidgetWrap):
"""A ComboBox of text objects"""
class ComboSpace(urwid.WidgetWrap):
"""The actual menu-like space that comes down from the ComboBox"""
def __init__(self,list,body,ui,show_first,pos=(0,0),attr=('body','focus')):
def __init__(self, l, body, ui, show_first, pos=(0, 0),
attr=('body', 'focus')):
"""
body : parent widget
list : stuff to include in the combobox
l : stuff to include in the combobox
ui : the screen
show_first: index of the element in the list to pick first
pos : a tuple of (row,col) where to put the list
@@ -275,13 +293,13 @@ class ComboBox(urwid.WidgetWrap):
"""
#Calculate width and height of the menu widget:
height = len(list)
height = len(l)
width = 0
for entry in list:
for entry in l:
if len(entry) > width:
width = len(entry)
content = [urwid.AttrWrap(SelText(w), attr[0], attr[1])
for w in list]
for w in l]
self._listbox = urwid.ListBox(content)
self._listbox.set_focus(show_first)
@@ -289,8 +307,8 @@ class ComboBox(urwid.WidgetWrap):
width + 2, ('fixed top', pos[1]), height)
self.__super.__init__(overlay)
def show(self,ui,display):
def show(self, ui, display):
""" Show widget. """
dim = ui.get_cols_rows()
keys = True
@@ -306,8 +324,8 @@ class ComboBox(urwid.WidgetWrap):
if "esc" in keys:
return None
if "enter" in keys:
(wid,pos) = self._listbox.get_focus()
(text,attr) = wid.get_text()
(wid, pos) = self._listbox.get_focus()
(text, attr) = wid.get_text()
return text
for k in keys:
@@ -316,11 +334,13 @@ class ComboBox(urwid.WidgetWrap):
#def get_size(self):
def __init__(self,label='',list=[],attrs=('body','editnfc'),focus_attr='focus',use_enter=True,focus=0,callback=None,user_args=None):
def __init__(self, label='', l=[], attrs=('body', 'editnfc'),
focus_attr='focus', use_enter=True, focus=0, callback=None,
user_args=None):
"""
label : bit of text that preceeds the combobox. If it is "", then
ignore it
list : stuff to include in the combobox
l : stuff to include in the combobox
body : parent widget
ui : the screen
row : where this object is to be found onscreen
@@ -333,15 +353,19 @@ class ComboBox(urwid.WidgetWrap):
self.label = urwid.Text(label)
self.attrs = attrs
self.focus_attr = focus_attr
self.list = list
self.list = l
str,trash = self.label.get_text()
s, _ = self.label.get_text()
self.overlay = None
self.cbox = DynWrap(SelText(self.DOWN_ARROW),attrs=attrs,focus_attr=focus_attr)
self.cbox = DynWrap(SelText(self.DOWN_ARROW), attrs=attrs,
focus_attr=focus_attr)
# Unicode will kill me sooner or later.
if label != '':
w = urwid.Columns([('fixed',len(str),self.label),self.cbox],dividechars=1)
w = urwid.Columns(
[('fixed', len(s), self.label), self.cbox],
dividechars=1
)
else:
w = urwid.Columns([self.cbox])
self.__super.__init__(w)
@@ -361,10 +385,11 @@ class ComboBox(urwid.WidgetWrap):
self.parent = None
self.ui = None
self.row = None
def set_list(self,list):
self.list = list
def set_focus(self,index):
def set_list(self, l):
self.list = l
def set_focus(self, index):
if urwid.VERSION < (1, 1, 0):
self.focus = index
else:
@@ -375,33 +400,34 @@ class ComboBox(urwid.WidgetWrap):
# API changed between urwid 0.9.8.4 and 0.9.9
try:
self.cbox.set_w(SelText(self.list[index]+self.DOWN_ARROW))
self.cbox.set_w(SelText(self.list[index] + self.DOWN_ARROW))
except AttributeError:
self.cbox._w = SelText(self.list[index]+self.DOWN_ARROW)
self.cbox._w = SelText(self.list[index] + self.DOWN_ARROW)
if self.overlay:
self.overlay._listbox.set_focus(index)
def rebuild_combobox(self):
self.build_combobox(self.parent,self.ui,self.row)
def build_combobox(self,parent,ui,row):
str,trash = self.label.get_text()
self.build_combobox(self.parent, self.ui, self.row)
def build_combobox(self, parent, ui, row):
s, _ = self.label.get_text()
if urwid.VERSION < (1, 1, 0):
index = self.focus
else:
index = self._w.focus_position
self.cbox = DynWrap(SelText([self.list[index]+self.DOWN_ARROW]),
attrs=self.attrs,focus_attr=self.focus_attr)
self.cbox = DynWrap(SelText([self.list[index] + self.DOWN_ARROW]),
attrs=self.attrs, focus_attr=self.focus_attr)
if str != '':
w = urwid.Columns([('fixed',len(str),self.label),self.cbox],
w = urwid.Columns([('fixed', len(s), self.label), self.cbox],
dividechars=1)
self.overlay = self.ComboSpace(self.list,parent,ui,index,
pos=(len(str)+1,row))
self.overlay = self.ComboSpace(self.list, parent, ui, index,
pos=(len(s) + 1, row))
else:
w = urwid.Columns([self.cbox])
self.overlay = self.ComboSpace(self.list,parent,ui,index,
pos=(0,row))
self.overlay = self.ComboSpace(self.list, parent, ui, index,
pos=(0, row))
self._w = w
self._invalidate()
@@ -410,7 +436,7 @@ class ComboBox(urwid.WidgetWrap):
self.row = row
# If we press space or enter, be a combo box!
def keypress(self,size,key):
def keypress(self, size, key):
activate = key == ' '
if self.use_enter:
activate = activate or key == 'enter'
@@ -418,14 +444,14 @@ class ComboBox(urwid.WidgetWrap):
# Die if the user didn't prepare the combobox overlay
if self.overlay == None:
raise ComboBoxException('ComboBox must be built before use!')
retval = self.overlay.show(self.ui,self.parent)
retval = self.overlay.show(self.ui, self.parent)
if retval != None:
self.set_focus(self.list.index(retval))
#self.cbox.set_w(SelText(retval+' vvv'))
if self.callback != None:
self.callback(self,self.overlay._listbox.get_focus()[1],
self.callback(self, self.overlay._listbox.get_focus()[1],
self.user_args)
return self._w.keypress(size,key)
return self._w.keypress(size, key)
def selectable(self):
return self.cbox.selectable()
@@ -441,7 +467,7 @@ class ComboBox(urwid.WidgetWrap):
def get_sensitive(self):
return self.cbox.get_sensitive()
def set_sensitive(self,state):
def set_sensitive(self, state):
self.cbox.set_sensitive(state)
# This is a h4x3d copy of some of the code in Ian Ward's dialog.py example.
@@ -449,7 +475,7 @@ class DialogExit(Exception):
pass
class Dialog2(urwid.WidgetWrap):
def __init__(self, text, height,width, body=None ):
def __init__(self, text, height, width, body=None ):
self.width = int(width)
if width <= 0:
self.width = ('relative', 80)
@@ -460,12 +486,14 @@ class Dialog2(urwid.WidgetWrap):
self.body = body
if body is None:
# fill space with nothing
body = urwid.Filler(urwid.Divider(),'top')
body = urwid.Filler(urwid.Divider(), 'top')
self.frame = urwid.Frame( body, focus_part='footer')
self.frame = urwid.Frame(body, focus_part='footer')
if text is not None:
self.frame.header = urwid.Pile( [urwid.Text(text,align='right'),
urwid.Divider()] )
self.frame.header = urwid.Pile([
urwid.Text(text, align='right'),
urwid.Divider()
])
w = self.frame
self.view = w
@@ -474,29 +502,33 @@ class Dialog2(urwid.WidgetWrap):
l = []
maxlen = 0
for name, exitcode in buttons:
b = urwid.Button( name, self.button_press )
b = urwid.Button(name, self.button_press)
b.exitcode = exitcode
b = urwid.AttrWrap( b, 'body','focus' )
l.append( b )
b = urwid.AttrWrap(b, 'body', 'focus')
l.append(b)
maxlen = max(len(name), maxlen)
maxlen += 4 # because of '< ... >'
self.buttons = urwid.GridFlow(l, maxlen, 3, 1, 'center')
self.frame.footer = urwid.Pile( [ urwid.Divider(),
self.buttons ], focus_item = 1)
self.frame.footer = urwid.Pile([
urwid.Divider(),
self.buttons
], focus_item=1)
def button_press(self, button):
raise DialogExit(button.exitcode)
def run(self,ui,parent):
def run(self, ui, parent):
ui.set_mouse_tracking()
size = ui.get_cols_rows()
overlay = urwid.Overlay(urwid.LineBox(self.view),
overlay = urwid.Overlay(
urwid.LineBox(self.view),
parent, 'center', self.width,
'middle', self.height)
'middle', self.height
)
try:
while True:
canvas = overlay.render( size, focus=True )
ui.draw_screen( size, canvas )
canvas = overlay.render(size, focus=True)
ui.draw_screen(size, canvas)
keys = None
while not keys:
keys = ui.get_input()
@@ -507,19 +539,18 @@ class Dialog2(urwid.WidgetWrap):
check_mouse_event = urwid.util.is_mouse_event
if check_mouse_event(k):
event, button, col, row = k
overlay.mouse_event( size,
event, button, col, row,
overlay.mouse_event(size, event, button, col, row,
focus=True)
else:
if k == 'window resize':
size = ui.get_cols_rows()
k = self.view.keypress( size, k )
k = self.view.keypress(size, k)
if k == 'esc':
raise DialogExit(-1)
if k:
self.unhandled_key( size, k)
self.unhandled_key(size, k)
except DialogExit, e:
return self.on_exit( e.args[0] )
return self.on_exit(e.args[0])
def on_exit(self, exitcode):
return exitcode, ""
@@ -535,50 +566,50 @@ class TextDialog(Dialog2):
body = urwid.ListBox(l)
body = urwid.AttrWrap(body, 'body')
Dialog2.__init__(self, header, height+2, width+2, body)
Dialog2.__init__(self, header, height + 2, width + 2, body)
if type(buttons) == list:
self.add_buttons(buttons)
else:
self.add_buttons([buttons])
def unhandled_key(self, size, k):
if k in ('up','page up','down','page down'):
if k in ('up', 'page up', 'down', 'page down'):
self.frame.set_focus('body')
self.view.keypress( size, k )
self.frame.set_focus('footer')
class InputDialog(Dialog2):
def __init__(self, text, height, width,ok_name=_('OK'),edit_text=''):
self.edit = urwid.Edit(wrap='clip',edit_text=edit_text)
def __init__(self, text, height, width, ok_name=_('OK'), edit_text=''):
self.edit = urwid.Edit(wrap='clip', edit_text=edit_text)
body = urwid.ListBox([self.edit])
body = urwid.AttrWrap(body, 'editbx','editfc')
body = urwid.AttrWrap(body, 'editbx', 'editfc')
Dialog2.__init__(self, text, height, width, body)
self.frame.set_focus('body')
self.add_buttons([(ok_name,0),(_('Cancel'),-1)])
self.add_buttons([(ok_name, 0), (_('Cancel'), -1)])
def unhandled_key(self, size, k):
if k in ('up','page up'):
if k in ('up', 'page up'):
self.frame.set_focus('body')
if k in ('down','page down'):
if k in ('down', 'page down'):
self.frame.set_focus('footer')
if k == 'enter':
# pass enter to the "ok" button
self.frame.set_focus('footer')
self.view.keypress( size, k )
self.view.keypress(size, k)
def on_exit(self, exitcode):
return exitcode, self.edit.get_edit_text()
class ClickCols(urwid.WidgetWrap):
def __init__(self,items,callback=None,args=None):
def __init__(self, items, callback=None, args=None):
cols = urwid.Columns(items)
self.__super.__init__(cols)
self.callback = callback
self.args = args
def mouse_event(self,size,event,button,x,y,focus):
def mouse_event(self, size, event, button, x, y, focus):
if event == "mouse press":
# The keypress dealie in wicd-curses.py expects a list of keystrokes
self.callback([self.args])
@@ -589,7 +620,7 @@ class OptCols(urwid.WidgetWrap):
# attrs = (attr_key,attr_desc)
# handler = function passed the key of the "button" pressed
# mentions of 'left' and right will be converted to <- and -> respectively
def __init__(self,tuples,handler,attrs=('body','infobar'),debug=False):
def __init__(self, tuples, handler, attrs=('body', 'infobar'), debug=False):
# Find the longest string. Keys for this bar should be no greater than
# 2 characters long (e.g., -> for left)
#maxlen = 6
@@ -604,7 +635,7 @@ class OptCols(urwid.WidgetWrap):
# callbacks map the text contents to its assigned callback.
self.callbacks = []
for cmd in tuples:
key = reduce(lambda s,(f,t):s.replace(f,t), [ \
key = reduce(lambda s, (f, t): s.replace(f, t), [ \
('ctrl ', 'Ctrl+'), ('meta ', 'Alt+'), \
('left', '<-'), ('right', '->'), \
('page up', 'Page Up'), ('page down', 'Page Down'), \
@@ -618,20 +649,20 @@ class OptCols(urwid.WidgetWrap):
args = cmd[0]
#self.callbacks.append(cmd[2])
col = ClickCols([
('fixed',len(key)+1,urwid.Text((attrs[0],key+':')) ),
urwid.AttrWrap(urwid.Text(cmd[1]),attrs[1])],
callback,args)
('fixed', len(key) + 1, urwid.Text((attrs[0], key + ':'))),
urwid.AttrWrap(urwid.Text(cmd[1]), attrs[1])],
callback, args)
textList.append(col)
i+=1
i += 1
if debug:
self.debug = urwid.Text("DEBUG_MODE")
textList.append(('fixed',10,self.debug))
textList.append(('fixed', 10, self.debug))
cols = urwid.Columns(textList)
self.__super.__init__(cols)
def debugClick(self,args):
def debugClick(self, args):
self.debug.set_text(args)
def mouse_event(self,size,event,button,x,y,focus):
def mouse_event(self, size, event, button, x, y, focus):
# Widgets are evenly long (as of current), so...
return self._w.mouse_event(size,event,button,x,y,focus)
return self._w.mouse_event(size, event, button, x, y, focus)

8
in/wicd=wpath.py.in
View File

@@ -46,7 +46,7 @@ dbus_service = '%DBUS_SERVICE%'
systemd = '%SYSTEMD%'
logrotate = '%LOGROTATE%'
desktop = '%DESKTOP%'
backends= '%BACKENDS%'
backends = '%BACKENDS%'
daemon = '%DAEMON%'
curses = '%CURSES%'
gtk = '%GTK%'
@@ -88,12 +88,12 @@ no_install_ncurses = %NO_INSTALL_NCURSES%
no_install_cli = %NO_INSTALL_CLI%
no_use_notifications = %NO_USE_NOTIFICATIONS%
def chdir(file):
def chdir(f):
"""Change directory to the location of the specified file.
Keyword arguments:
file -- the file to switch to (usually __file__)
f -- the file to switch to (usually __file__)
"""
os.chdir(os.path.dirname(os.path.realpath(file)))
os.chdir(os.path.dirname(os.path.realpath(f)))

1
wicd/__init__.py
View File

@@ -0,0 +1 @@
""" WICD core module. """

12
wicd/autoconnect.py
View File

@@ -36,14 +36,16 @@ try:
daemon = dbusmanager.get_interface('daemon')
wireless = dbusmanager.get_interface('wireless')
except Exception, e:
print>>sys.stderr, "Exception caught: %s" % str(e)
print>>sys.stderr, 'Could not connect to daemon.'
print >> sys.stderr, "Exception caught: %s" % str(e)
print >> sys.stderr, 'Could not connect to daemon.'
sys.exit(1)
def handler(*args):
""" No-op handler. """
pass
def error_handler(*args):
print>>sys.stderr, 'Async error autoconnecting.'
""" Error handler. """
print >> sys.stderr, 'Async error autoconnecting.'
sys.exit(3)
if __name__ == '__main__':
@@ -54,6 +56,6 @@ if __name__ == '__main__':
daemon.AutoConnect(True, reply_handler=handler,
error_handler=error_handler)
except Exception, e:
print>>sys.stderr, "Exception caught: %s" % str(e)
print>>sys.stderr, 'Error autoconnecting.'
print >> sys.stderr, "Exception caught: %s" % str(e)
print >> sys.stderr, 'Error autoconnecting.'
sys.exit(2)

4
wicd/backend.py
View File

@@ -30,6 +30,7 @@ import os
import wicd.wpath as wpath
def fail(backend_name, reason):
""" Helper to warn the user about failure in loading backend. """
print "Failed to load backend %s: %s" % (backend_name, reason)
return True
@@ -115,7 +116,8 @@ class BackendManager(object):
"""
backend = self._load_backend(backend_name)
if not backend : return None
if not backend:
return None
failed = self._validate_backend(backend, backend_name)
if failed:

1
wicd/backends/__init__.py
View File

@@ -0,0 +1 @@
""" Backends module. """

14
wicd/backends/be-ioctl.py
View File

@@ -155,7 +155,7 @@ class Interface(BaseInterface):
return socket.inet_ntoa(raw_ip[20:24])
@neediface(False)
def IsUp(self):
def IsUp(self, ifconfig=None):
""" Determines if the interface is up.
Returns:
@@ -357,7 +357,8 @@ class WirelessInterface(Interface, BaseWirelessInterface):
print "Couldn't open ctrl_interface: %s" % e
return None
else:
print "Couldn't find a wpa_supplicant ctrl_interface for iface %s" % self.iface
print "Couldn't find a wpa_supplicant ctrl_interface for iface %s" \
% self.iface
return None
def ValidateAuthentication(self, auth_time):
@@ -402,7 +403,8 @@ class WirelessInterface(Interface, BaseWirelessInterface):
return False
if self.verbose:
print 'wpa_supplicant ctrl_interface status query is %s' % str(status)
print 'wpa_supplicant ctrl_interface status query is %s' \
% str(status)
try:
[result] = [l for l in status if l.startswith("wpa_state=")]
@@ -456,7 +458,8 @@ class WirelessInterface(Interface, BaseWirelessInterface):
print 'Setting up WEP'
cmd = ''.join(['iwconfig ', self.iface, ' key ',
network.get('key')])
if self.verbose: print cmd
if self.verbose:
print cmd
misc.Run(cmd)
else:
if info[5] == 'SHARED' and info[4] == 'WEP':
@@ -488,7 +491,8 @@ class WirelessInterface(Interface, BaseWirelessInterface):
for cmd in cmd_list:
cmd = 'iwpriv ' + self.iface + ' '
if self.verbose: print cmd
if self.verbose:
print cmd
misc.Run(cmd)
@neediface("")

20
wicd/configmanager.py
View File

@@ -35,6 +35,7 @@ from wicd.misc import Noneify, to_unicode
from dbus import Int32
def sanitize_config_file(path):
""" Remove invalid lines from config file. """
conf = open(path)
newconf = ''
for line in conf:
@@ -56,7 +57,7 @@ class ConfigManager(RawConfigParser):
sanitize_config_file(path)
try:
self.read(path)
except ParsingError, e:
except ParsingError:
self.write()
try:
self.read(path)
@@ -121,15 +122,18 @@ class ConfigManager(RawConfigParser):
if default:
if self.debug:
# mask out sensitive information
if option in ['apsk', 'password', 'identity', 'private_key', \
'private_key_passwd', 'key', 'passphrase']:
print ''.join(['found ', option, ' in configuration *****'])
if option in ['apsk', 'password', 'identity', \
'private_key', 'private_key_passwd', \
'key', 'passphrase']:
print ''.join(['found ', option, \
' in configuration *****'])
else:
print ''.join(['found ', option, ' in configuration ',
str(ret)])
else:
if default != "__None__":
print 'did not find %s in configuration, setting default %s' % (option, str(default))
print 'did not find %s in configuration, setting default %s' \
% (option, str(default))
self.set(section, option, str(default), write=True)
ret = default
else:
@@ -196,7 +200,8 @@ class ConfigManager(RawConfigParser):
p = RawConfigParser()
p.readfp(codecs.open(fname, 'r', 'utf-8'))
for section_name in p.sections():
# New files override old, so remove first to avoid DuplicateSectionError.
# New files override old, so remove first to avoid
# DuplicateSectionError.
self.remove_section(section_name)
self.add_section(section_name)
for (name, value) in p.items(section_name):
@@ -206,6 +211,7 @@ class ConfigManager(RawConfigParser):
def _copy_section(self, name):
""" Copy whole section from config file. """
p = ConfigManager("", self.debug, self.mrk_ws)
p.add_section(name)
for (iname, value) in self.items(name):
@@ -215,7 +221,7 @@ class ConfigManager(RawConfigParser):
p.remove_option(name, '_filename_')
return p
def write(self):
def write(self, fp):
""" Writes the loaded config file to disk. """
in_this_file = []
for sname in sorted(self.sections()):

17
wicd/dbusmanager.py
View File

@@ -33,21 +33,27 @@ else:
DBUS_MANAGER = None
def get_dbus_ifaces():
""" Return available DBus interfaces. """
return DBUS_MANAGER.get_dbus_ifaces()
def get_interface(iface):
""" Return specified interface. """
return DBUS_MANAGER.get_interface(iface)
def get_bus():
""" Return the loaded System Bus. """
return DBUS_MANAGER.get_bus()
def set_mainloop():
return DBUS_MANAGER.set_mainloop()
def set_mainloop(loop):
""" Set DBus main loop. """
return DBUS_MANAGER.set_mainloop(loop)
def connect_to_dbus():
""" Connect to DBus. """
return DBUS_MANAGER.connect_to_dbus()
def threads_init():
""" Init GLib threads. """
dbus.mainloop.glib.threads_init()
@@ -59,12 +65,14 @@ class DBusManager(object):
def get_dbus_ifaces(self):
""" Returns a dict of dbus interfaces. """
if not self._dbus_ifaces: connect_to_dbus()
if not self._dbus_ifaces:
connect_to_dbus()
return self._dbus_ifaces
def get_interface(self, iface):
""" Returns a DBus Interface. """
if not self._dbus_ifaces: connect_to_dbus()
if not self._dbus_ifaces:
connect_to_dbus()
return self._dbus_ifaces[iface]
def get_bus(self):
@@ -72,6 +80,7 @@ class DBusManager(object):
return self._bus
def set_mainloop(self, loop):
""" Set DBus main loop. """
dbus.set_default_main_loop(loop)
def connect_to_dbus(self):

15
wicd/logfile.py
View File

@@ -26,6 +26,7 @@ import os
import time
class SizeError(IOError):
""" Custom error class. """
pass
class LogFile(file):
@@ -48,7 +49,8 @@ class LogFile(file):
self.written += len(data)
data = data.decode('utf-8').encode('utf-8')
if len(data) <= 0: return
if len(data) <= 0:
return
if self.eol:
super(LogFile, self).write(self.get_time() + ' :: ')
self.eol = False
@@ -79,6 +81,7 @@ class LogFile(file):
str(x[4]).rjust(2, '0'), ':', str(x[5]).rjust(2, '0')])
def rotate(self):
""" Rotate logfile. """
return rotate(self)
def note(self, text):
@@ -108,21 +111,25 @@ class ManagedLog(object):
self._lf.maxsize, self.maxsave)
def write(self, data):
""" Write logfile. """
try:
self._lf.write(data)
except SizeError:
self._lf = rotate(self._lf, self.maxsave)
def note(self, data):
""" Write a note to the logfile. """
try:
self._lf.note(data)
except SizeError:
self._lf = rotate(self._lf, self.maxsave)
def written(self):
""" Return whether the logfile was written. """
return self._lf.written
def rotate(self):
""" Rotate logfile. """
self._lf = rotate(self._lf, self.maxsave)
# auto-delegate remaining methods (but you should not read or seek an open
@@ -133,7 +140,9 @@ class ManagedLog(object):
# useful for logged stdout for daemon processes
class ManagedStdio(ManagedLog):
""" Manage stdout/stderr. """
def write(self, data):
""" Write logfile to disk. """
try:
self._lf.write(data)
except SizeError:
@@ -147,6 +156,7 @@ class ManagedStdio(ManagedLog):
def rotate(fileobj, maxsave=9):
""" Rotate fileobj. """
name = fileobj.name
mode = fileobj.mode
maxsize = fileobj.maxsize
@@ -157,6 +167,7 @@ def rotate(fileobj, maxsave=9):
# assumes basename logfile is closed.
def shiftlogs(basename, maxsave):
""" Shift logfiles. """
topname = "%s.%d" % (basename, maxsave)
if os.path.isfile(topname):
os.unlink(topname)
@@ -175,9 +186,11 @@ def shiftlogs(basename, maxsave):
def open(name, maxsize=360000, maxsave=9):
""" Open logfile. """
return ManagedLog(name, maxsize, maxsave)
def writelog(logobj, data):
""" Write logfile. """
try:
logobj.write(data)
except SizeError:

30
wicd/misc.py
View File

@@ -84,7 +84,8 @@ _sudo_dict = {
_status_dict = {
'aborted': _('Connection Cancelled'),
'association_failed': _('Connection failed: Could not contact the wireless access point.'),
'association_failed': _('Connection failed: Could not contact the ' + \
'wireless access point.'),
'bad_pass': _('Connection Failed: Bad password'),
'configuring_interface': _('Configuring wireless interface...'),
'dhcp_failed': _('Connection Failed: Unable to Get IP Address'),
@@ -107,6 +108,7 @@ _status_dict = {
}
class WicdError(Exception):
""" Custom Exception type. """
pass
@@ -179,7 +181,8 @@ def LaunchAndWait(cmd):
def IsValidIP(ip):
""" Make sure an entered IP is valid. """
if not ip: return False
if not ip:
return False
if not IsValidIPv4(ip):
if not IsValidIPv6(ip):
@@ -218,9 +221,9 @@ def PromptToStartDaemon():
os.spawnvpe(os.P_WAIT, sudo_prog, sudo_args, os.environ)
return True
def RunRegex(regex, string):
def RunRegex(regex, s):
""" runs a regex search on a string """
m = regex.search(string)
m = regex.search(s)
if m:
return m.groups()[0]
else:
@@ -271,12 +274,13 @@ def to_bool(var):
var = bool(var)
return var
def Noneify(variable, to_bool=True):
def Noneify(variable, convert_to_bool=True):
""" Convert string types to either None or booleans"""
#set string Nones to real Nones
if variable in ("None", "", None):
return None
if to_bool:
if convert_to_bool:
# FIXME: should instead use above to_bool()?
if variable in ("False", "0"):
return False
if variable in ("True", "1"):
@@ -415,8 +419,10 @@ def _parse_enc_template(enctype):
print "Invalid 'optional' line found in template %s" % enctype
continue
elif line.startswith("protected"):
cur_type["protected"] = __parse_field_ent(parse_ent(line, "protected"),
field_type="protected")
cur_type["protected"] = __parse_field_ent(
parse_ent(line, "protected"),
field_type="protected"
)
if not cur_type["protected"]:
# An error occured parsing the protected line.
print "Invalid 'protected' line found in template %s" % enctype
@@ -530,7 +536,8 @@ def detect_desktop_environment():
def get_sudo_cmd(msg, prog_num=0):
""" Returns a graphical sudo command for generic use. """
sudo_prog = choose_sudo_prog(prog_num)
if not sudo_prog: return None
if not sudo_prog:
return None
if re.search("(ktsuss|gksu|gksudo)$", sudo_prog):
msg_flag = "-m"
else:
@@ -590,6 +597,8 @@ def stringToNone(text):
return str(text)
def checkboxTextboxToggle(checkbox, textboxes):
""" Manage {de,}activation of textboxes depending on checkboxes. """
# FIXME: should be moved to UI-specific files?
for textbox in textboxes:
textbox.set_sensitive(checkbox.get_active())
@@ -613,7 +622,8 @@ def timeout_add(time, func, milli=False):
if hasattr(gobject, "timeout_add_seconds") and not milli:
return gobject.timeout_add_seconds(time, func)
else:
if not milli: time = time * 1000
if not milli:
time = time * 1000
return gobject.timeout_add(time, func)
def izip_longest(*args, **kwds):

16
wicd/monitor.py
View File

@@ -47,6 +47,9 @@ wireless = dbus_dict["wireless"]
mainloop = None
def diewithdbus(func):
"""
Decorator catching DBus exceptions, making wicd quit.
"""
def wrapper(self, *__args, **__kargs):
try:
ret = func(self, *__args, **__kargs)
@@ -86,6 +89,7 @@ class ConnectionStatus(object):
self.trigger_reconnect = False
self.__lost_dbus_count = 0
self._to_time = daemon.GetBackendUpdateInterval()
self.update_callback = None
self.add_poll_callback()
bus = dbusmanager.get_bus()
@@ -310,16 +314,18 @@ class ConnectionStatus(object):
""" Get the correct signal strength format. """
try:
if daemon.GetSignalDisplayType() == 0:
wifi_signal = int(wireless.GetCurrentSignalStrength(self.iwconfig))
signal = wireless.GetCurrentSignalStrength(self.iwconfig)
wifi_signal = int(signal)
else:
signal = wireless.GetCurrentDBMStrength(self.iwconfig)
if always_positive:
# because dBm is negative, add 99 to the signal. This way, if
# the signal drops below -99, wifi_signal will == 0, and
# because dBm is negative, add 99 to the signal. This way,
# if the signal drops below -99, wifi_signal will == 0, and
# an automatic reconnect will be triggered
# this is only used in check_for_wireless_connection
wifi_signal = 99 + int(wireless.GetCurrentDBMStrength(self.iwconfig))
wifi_signal = 99 + int(signal)
else:
wifi_signal = int(wireless.GetCurrentDBMStrength(self.iwconfig))
wifi_signal = int(signal)
except TypeError:
wifi_signal = 0

73
wicd/networking.py
View File

@@ -158,25 +158,34 @@ class Controller(object):
self.driver = None
self.iface = None
def get_debug(self): return self._debug
def get_debug(self):
""" Getter for debug property. """
return self._debug
def set_debug(self, value):
""" Setter for debug property. """
self._debug = value
if self.iface:
self.iface.SetDebugMode(value)
debug = property(get_debug, set_debug)
def set_dhcp_client(self, value):
""" Setter for dhcp_client property. """
self._dhcp_client = value
if self.iface:
self.iface.DHCP_CLIENT = value
def get_dhcp_client(self): return self._dhcp_client
def get_dhcp_client(self):
""" Getter for dhcp_client property. """
return self._dhcp_client
dhcp_client = property(get_dhcp_client, set_dhcp_client)
def set_flush_tool(self, value):
""" Setter for flush_tool property. """
self._flush_tool = value
if self.iface:
self.iface.flush_tool = value
def get_flush_tool(self): return self._flush_tool
def get_flush_tool(self):
""" Getter for flush_tool property. """
return self._flush_tool
flush_tool = property(get_flush_tool, set_flush_tool)
def LoadBackend(self, backend_name):
@@ -337,6 +346,9 @@ class ConnectThread(threading.Thread):
self.SetStatus('interface_down')
def _connect(self):
raise NotImplementedError
def run(self):
self.connect_result = "failed"
try:
@@ -345,12 +357,15 @@ class ConnectThread(threading.Thread):
self.is_connecting = False
def set_should_die(self, val):
""" Setter for should_die property. """
self.lock.acquire()
try:
self._should_die = val
finally:
self.lock.release()
def get_should_die(self): return self._should_die
def get_should_die(self):
""" Getter for should_die property. """
return self._should_die
should_die = property(get_should_die, set_should_die)
def SetStatus(self, status):
@@ -401,6 +416,7 @@ class ConnectThread(threading.Thread):
@abortable
def run_global_scripts_if_needed(self, script_dir, extra_parameters=()):
""" Run global scripts if needed. '"""
misc.ExecuteScripts(script_dir, verbose=self.debug,
extra_parameters=extra_parameters)
@@ -458,7 +474,7 @@ class ConnectThread(threading.Thread):
hname = os.uname()[1]
else:
hname = self.network['dhcphostname']
print "Running DHCP with hostname",hname
print "Running DHCP with hostname", hname
dhcp_status = iface.StartDHCP(hname)
if dhcp_status in ['no_dhcp_offers', 'dhcp_failed']:
if self.connect_result != "aborted":
@@ -564,22 +580,30 @@ class Wireless(Controller):
self.should_verify_ap = True
def set_wireless_iface(self, value):
""" Setter for wireless_interface property. """
self._wireless_interface = value
if self.wiface:
self.wiface.SetInterface(value)
def get_wireless_iface(self): return self._wireless_interface
def get_wireless_iface(self):
""" Getter for wireless_interface property. """
return self._wireless_interface
wireless_interface = property(get_wireless_iface, set_wireless_iface)
def set_wpa_driver(self, value):
""" Setter for wpa_driver property. """
self._wpa_driver = value
if self.wiface:
self.SetWPADriver(value)
def get_wpa_driver(self): return self._wpa_driver
def get_wpa_driver(self):
""" Getter for wpa_driver property. """
return self._wpa_driver
wpa_driver = property(get_wpa_driver, set_wpa_driver)
def set_iface(self, value):
""" Setter for iface property. """
self.wiface = value
def get_iface(self):
""" Getter for iface property. """
return self.wiface
iface = property(get_iface, set_iface)
@@ -591,8 +615,9 @@ class Wireless(Controller):
"""
Controller.LoadBackend(self, backend)
if self._backend:
self.wiface = self._backend.WirelessInterface(self.wireless_interface,
backend = self._backend
if backend:
self.wiface = backend.WirelessInterface(self.wireless_interface,
self.debug, self.wpa_driver)
def Scan(self, essid=None):
@@ -606,13 +631,15 @@ class Wireless(Controller):
"""
def comp(x, y):
""" Custom sorting function. """
if 'quality' in x:
key = 'quality'
else:
key = 'strength'
return cmp(x[key], y[key])
if not self.wiface: return []
if not self.wiface:
return []
wiface = self.wiface
# Prepare the interface for scanning
@@ -639,7 +666,8 @@ class Wireless(Controller):
network -- network to connect to
"""
if not self.wiface: return False
if not self.wiface:
return False
self.connecting_thread = WirelessConnectThread(network,
self.wireless_interface, self.wpa_driver, self.before_script,
@@ -739,6 +767,7 @@ class Wireless(Controller):
return BACKEND.GetWpaSupplicantDrivers()
def StopWPA(self):
""" Stop wpa_supplicant. """
return self.wiface.StopWPA()
def CreateAdHocNetwork(self, essid, channel, ip, enctype, key,
@@ -821,7 +850,8 @@ class Wireless(Controller):
"""
cmd = 'rfkill list'
rfkill_out = misc.Run(cmd)
soft_blocks = filter(lambda x: x.startswith('Soft'), rfkill_out.split('\t'))
soft_blocks = filter(lambda x: x.startswith('Soft'),
rfkill_out.split('\t'))
for line in map(lambda x: x.strip(), soft_blocks):
if line.endswith('yes'):
return True
@@ -1015,7 +1045,8 @@ class WirelessConnectThread(ConnectThread):
# cards).
if self.debug:
print "enctype is %s" % self.network.get('enctype')
if self.network.get('key') and 'wpa' in str(self.network.get('enctype')):
if self.network.get('key') and \
'wpa' in str(self.network.get('enctype')):
self.SetStatus('generating_psk')
print 'Generating psk...'
self.network['psk'] = wiface.GeneratePSK(self.network)
@@ -1044,23 +1075,31 @@ class Wired(Controller):
self.liface = None
def set_link_detect(self, value):
""" Setter for link_detect property. """
self._link_detect = value
if self.liface:
self.liface.link_detect = value
def get_link_detect(self): return self._link_detect
def get_link_detect(self):
""" Getter for link_detect property. """
return self._link_detect
link_detect = property(get_link_detect, set_link_detect)
def set_wired_iface(self, value):
""" Setter for wired_interface property. """
self._wired_interface = value
if self.liface:
self.liface.SetInterface(value)
def get_wired_iface(self): return self._wired_interface
def get_wired_iface(self):
""" Getter for wired_interface property. """
return self._wired_interface
wired_interface = property(get_wired_iface, set_wired_iface)
def set_iface(self, value):
""" Setter for iface property. """
self.liface = value
def get_iface(self):
""" Getter for iface property. """
return self.liface
iface = property(get_iface, set_iface)
@@ -1087,7 +1126,8 @@ class Wired(Controller):
network -- network to connect to
"""
if not self.liface: return False
if not self.liface:
return False
self.connecting_thread = WiredConnectThread(network,
self.wired_interface, self.before_script, self.after_script,
self.pre_disconnect_script, self.post_disconnect_script,
@@ -1103,6 +1143,7 @@ class Wired(Controller):
self.StopWPA()
def StopWPA(self):
""" Stop wpa_supplicant. """
self.liface.StopWPA()
def DetectWiredInterface(self):

10
wicd/suspend.py
View File

@@ -33,19 +33,17 @@ try:
proxy_obj = bus.get_object('org.wicd.daemon', '/org/wicd/daemon')
daemon = dbus.Interface(proxy_obj, 'org.wicd.daemon')
except Exception, e:
print>>sys.stderr, "Exception caught: %s" % str(e)
print>>sys.stderr, 'Could not connect to daemon.'
print >> sys.stderr, "Exception caught: %s" % str(e)
print >> sys.stderr, 'Could not connect to daemon.'
sys.exit(1)
if __name__ == '__main__':
try:
daemon.Disconnect()
daemon.SetForcedDisconnect(False)
daemon.SetSuspend(True)
except Exception, e:
print>>sys.stderr, "Exception caught: %s" % str(e)
print>>sys.stderr, 'Error setting suspend.'
print >> sys.stderr, "Exception caught: %s" % str(e)
print >> sys.stderr, 'Error setting suspend.'
sys.exit(2)

17
wicd/translations.py
View File

@@ -52,8 +52,7 @@ def get_gettext():
langs += ["en_US"]
lang = gettext.translation('wicd', local_path, languages=langs,
fallback=True)
_ = lang.ugettext
return _
return lang.ugettext
_ = get_gettext()
@@ -67,13 +66,17 @@ language = {}
# FIXME: these were present in wicd 1.7.0, can't find where they are.
# Leaving here for future reference, they should be removed whenever
# possible.
#language['cannot_start_daemon'] = _('''Unable to connect to wicd daemon DBus interface. This typically means there was a problem starting the daemon. Check the wicd log for more information.''')
#language['backend_alert'] = _('''Changes to your backend won't occur until the daemon is restarted.''')
#language['about_help'] = _('''Stop a network connection in progress''')
#language['connect'] = _('''Connect''')
#language['cannot_start_daemon'] = _('Unable to connect to wicd daemon ' + \
# 'DBus interface. This typically means there was a problem starting ' + \
# 'the daemon. Check the wicd log for more information.')
#language['backend_alert'] = _('Changes to your backend won't occur until ' + \
# 'the daemon is restarted.')
#language['about_help'] = _('Stop a network connection in progress')
#language['connect'] = _('Connect')
# from templates, dict populated with:
# grep -R "*" encryption/templates/ | tr " " "\n" | grep "^*" | sed -e "s/*//"| sort -u | tr [A-Z] [a-z]
# grep -R "*" encryption/templates/ | tr " " "\n" | grep "^*" | \
# sed -e "s/*//" | sort -u | tr [A-Z] [a-z]
language['authentication'] = _('Authentication')
language['domain'] = _('Domain')
language['identity'] = _('Identity')

174
wicd/wicd-daemon.py
View File

@@ -71,7 +71,7 @@ wireless_conf = os.path.join(wpath.etc, "wireless-settings.conf")
wired_conf = os.path.join(wpath.etc, "wired-settings.conf")
dhclient_conf = os.path.join(wpath.etc, "dhclient.conf.template")
class WicdDaemon(dbus.service.Object):
class WicdDaemon(dbus.service.Object, object):
""" The main wicd daemon class.
This class mostly contains exported DBus methods that are not
@@ -107,6 +107,17 @@ class WicdDaemon(dbus.service.Object):
self.link_detect_tool = 0
self.flush_tool = 0
self.sudo_app = 0
self.use_global_dns = False
self.always_show_wired_interface = True
self.wired_connect_mode = 1
self.wired_bus.connect_mode = 1
self.dns_dom = None
self.signal_display_type = 0
self.dns1 = None
self.dns2 = None
self.dns3 = None
self.search_dom = None
self.auto_reconnect = True
# 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
@@ -126,8 +137,10 @@ class WicdDaemon(dbus.service.Object):
self.wireless_bus.Scan()
def get_debug_mode(self):
""" Getter for debug_mode property. """
return self._debug_mode
def set_debug_mode(self, mode):
""" Setter for debug_mode property. """
self._debug_mode = mode
self.config.debug = mode
debug_mode = property(get_debug_mode, set_debug_mode)
@@ -192,11 +205,13 @@ class WicdDaemon(dbus.service.Object):
self.dns3 = dns3
self.wifi.global_dns_3 = dns3
self.wired.global_dns_3 = dns3
self.config.set("Settings", "global_dns_dom", misc.noneToString(dns_dom))
self.config.set("Settings", "global_dns_dom",
misc.noneToString(dns_dom))
self.dns_dom = dns_dom
self.wifi.dns_dom = dns_dom
self.wired.dns_dom = dns_dom
self.config.set("Settings", "global_search_dom", misc.noneToString(search_dom))
self.config.set("Settings", "global_search_dom",
misc.noneToString(search_dom))
self.search_dom = search_dom
self.wifi.global_search_dom = search_dom
self.wired.global_search_dom = search_dom
@@ -211,7 +226,8 @@ class WicdDaemon(dbus.service.Object):
print "setting backend to %s" % backend
backends = networking.BACKEND_MGR.get_available_backends()
if backend not in backends:
print "backend %s not available, trying to fallback to another" % backend
print "backend %s not available, trying to fallback to another" \
% backend
try:
backend = backends[0]
except IndexError:
@@ -310,18 +326,18 @@ class WicdDaemon(dbus.service.Object):
self.wired.Disconnect()
@dbus.service.method('org.wicd.daemon')
def FormatSignalForPrinting(self, signal):
def FormatSignalForPrinting(self, sign):
""" Returns the suffix to display after the signal strength number. """
if self.GetSignalDisplayType() == 1:
return '%s dBm' % signal
return '%s dBm' % sign
else:
try:
if int(signal) == 101:
if int(sign) == 101:
return '??%'
else:
return '%s%%' % signal
return '%s%%' % sign
except ValueError:
return '%s%%' % signal
return '%s%%' % sign
@dbus.service.method('org.wicd.daemon')
def SetSuspend(self, val):
@@ -463,7 +479,8 @@ class WicdDaemon(dbus.service.Object):
started.
"""
if self.debug_mode and value: print "Forced disconnect on"
if self.debug_mode and value:
print "Forced disconnect on"
self.forced_disconnect = bool(value)
@dbus.service.method('org.wicd.daemon')
@@ -578,7 +595,8 @@ class WicdDaemon(dbus.service.Object):
@dbus.service.method('org.wicd.daemon')
def SetShowNeverConnect(self, value):
""" Sets the how_never_connect state. """
self.config.set("Settings", "show_never_connect", bool(value), write=True)
self.config.set("Settings", "show_never_connect", bool(value),
write=True)
self.show_never_connect = bool(value)
@dbus.service.method('org.wicd.daemon')
@@ -746,7 +764,7 @@ class WicdDaemon(dbus.service.Object):
try:
gobject.timeout_add_seconds(3, self._monitor_wired_autoconnect,
fresh)
except:
except AttributeError:
gobject.timeout_add(3000, self._monitor_wired_autoconnect, fresh)
return True
@@ -772,28 +790,36 @@ class WicdDaemon(dbus.service.Object):
@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 whether connection results are available. """
wired_thread = self.wired.connecting_thread
wifi_thread = self.wifi.connecting_thread
if ((wired_thread and wired_thread.connect_result) or
(wifi_thread and wifi_thread.connect_result)):
return True
else:
return False
@dbus.service.method("org.wicd.daemon")
def SendConnectResultsIfAvail(self):
""" Send connection results if they're available. '"""
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 = ""
""" Send connection result. """
wired_thread = self.wired.connecting_thread
wifi_thread = self.wifi.connecting_thread
if wired_thread and wired_thread.connect_result:
self.ConnectResultsSent(wired_thread.connect_result)
wired_thread.connect_result = ""
elif wifi_thread and wifi_thread.connect_result:
self.ConnectResultsSent(wifi_thread.connect_result)
wifi_thread.connect_result = ""
@dbus.service.signal(dbus_interface="org.wicd.daemon",signature='s')
def ConnectResultsSent(self, result):
""" Signal emit when connection results are sent. """
print "Sending connection attempt result %s" % result
@dbus.service.method("org.wicd.daemon")
@@ -853,15 +879,18 @@ class WicdDaemon(dbus.service.Object):
# Load network interfaces.
iface = self.wireless_bus.DetectWirelessInterface()
if not iface: iface = 'wlan0'
if not iface:
iface = 'wlan0'
self.SetWirelessInterface(app_conf.get("Settings", "wireless_interface",
default=iface))
iface = self.wired_bus.DetectWiredInterface()
if not iface: iface = 'eth0'
if not iface:
iface = 'eth0'
self.SetWiredInterface(app_conf.get("Settings", "wired_interface",
default=iface))
self.SetWPADriver(app_conf.get("Settings", "wpa_driver", default="wext"))
self.SetWPADriver(app_conf.get("Settings", "wpa_driver",
default="wext"))
self.SetAlwaysShowWiredInterface(app_conf.get("Settings",
"always_show_wired_interface",
default=False))
@@ -871,7 +900,8 @@ class WicdDaemon(dbus.service.Object):
dns2 = app_conf.get("Settings", "global_dns_2", default='None')
dns3 = app_conf.get("Settings", "global_dns_3", default='None')
dns_dom = app_conf.get("Settings", "global_dns_dom", default='None')
search_dom = app_conf.get("Settings", "global_search_dom", default='None')
search_dom = app_conf.get("Settings", "global_search_dom",
default='None')
self.SetGlobalDNS(dns1, dns2, dns3, dns_dom, search_dom)
self.SetAutoReconnect(app_conf.get("Settings", "auto_reconnect",
default=True))
@@ -933,7 +963,7 @@ class WicdDaemon(dbus.service.Object):
###### Wireless Daemon #######
##############################
class WirelessDaemon(dbus.service.Object):
class WirelessDaemon(dbus.service.Object, object):
""" DBus interface for wireless connection operations. """
def __init__(self, bus_name, daemon, wifi=None, debug=False):
""" Intitialize the wireless DBus interface. """
@@ -948,8 +978,10 @@ class WirelessDaemon(dbus.service.Object):
self.config = ConfigManager(wireless_conf, debug=debug)
def get_debug_mode(self):
""" Getter for the debug_mode property. """
return self._debug_mode
def set_debug_mode(self, mode):
""" Setter for the debug_mode property. """
self._debug_mode = mode
self.config.debug = mode
debug_mode = property(get_debug_mode, set_debug_mode)
@@ -1068,10 +1100,10 @@ class WirelessDaemon(dbus.service.Object):
return self.wifi.GetRfKillStatus()
@dbus.service.method('org.wicd.daemon.wireless')
def GetWirelessProperty(self, networkid, property):
def GetWirelessProperty(self, networkid, prop):
""" Retrieves wireless property from the network specified """
try:
value = self.LastScan[networkid].get(property)
value = self.LastScan[networkid].get(prop)
except IndexError:
return ""
value = misc.to_unicode(value)
@@ -1088,7 +1120,8 @@ class WirelessDaemon(dbus.service.Object):
return False
# whitelist some props that need different handling
if prop in ('key_index', ):
self.LastScan[netid][prop] = misc.to_unicode(misc.Noneify(value, False))
self.LastScan[netid][prop] = \
misc.to_unicode(misc.Noneify(value, False))
else:
self.LastScan[netid][prop] = misc.to_unicode(misc.Noneify(value))
@@ -1161,27 +1194,28 @@ class WirelessDaemon(dbus.service.Object):
return result
@dbus.service.method('org.wicd.daemon.wireless')
def ConnectWireless(self, id):
def ConnectWireless(self, nid):
""" Connects the the wireless network specified by i"""
self.SaveWirelessNetworkProfile(id)
self.SaveWirelessNetworkProfile(nid)
# Will returned instantly, that way we don't hold up dbus.
# CheckIfWirelessConnecting can be used to test if the connection
# is done.
self.wifi.before_script = self.GetWirelessProperty(id, 'beforescript')
self.wifi.after_script = self.GetWirelessProperty(id, 'afterscript')
self.wifi.pre_disconnect_script = self.GetWirelessProperty(id,
self.wifi.before_script = self.GetWirelessProperty(nid, 'beforescript')
self.wifi.after_script = self.GetWirelessProperty(nid, 'afterscript')
self.wifi.pre_disconnect_script = self.GetWirelessProperty(nid,
'predisconnectscript')
self.wifi.post_disconnect_script = self.GetWirelessProperty(id,
self.wifi.post_disconnect_script = self.GetWirelessProperty(nid,
'postdisconnectscript')
self.wifi.bitrate = self.GetWirelessProperty(id, 'bitrate')
self.wifi.allow_lower_bitrates = self.GetWirelessProperty(id,
self.wifi.bitrate = self.GetWirelessProperty(nid, 'bitrate')
self.wifi.allow_lower_bitrates = self.GetWirelessProperty(nid,
'allow_lower_bitrates')
print 'Connecting to wireless network ' + str(self.LastScan[id]['essid'])
print 'Connecting to wireless network ' + \
str(self.LastScan[nid]['essid'])
# disconnect to make sure that scripts are run
self.wifi.Disconnect()
self.daemon.wired_bus.wired.Disconnect()
self.daemon.SetForcedDisconnect(False)
conthread = self.wifi.Connect(self.LastScan[id], debug=self.debug_mode)
self.wifi.Connect(self.LastScan[nid], debug=self.debug_mode)
self.daemon.UpdateState()
@dbus.service.method('org.wicd.daemon.wireless')
@@ -1217,9 +1251,9 @@ class WirelessDaemon(dbus.service.Object):
return False
@dbus.service.method('org.wicd.daemon.wireless')
def ReadWirelessNetworkProfile(self, id):
def ReadWirelessNetworkProfile(self, nid):
""" Reads in wireless profile as the active network """
cur_network = self.LastScan[id]
cur_network = self.LastScan[nid]
essid_key = "essid:%s" % cur_network["essid"]
bssid_key = cur_network["bssid"]
@@ -1247,13 +1281,13 @@ class WirelessDaemon(dbus.service.Object):
cur_network['essid'] = stored_essid
@dbus.service.method('org.wicd.daemon.wireless')
def SaveWirelessNetworkProfile(self, id):
def SaveWirelessNetworkProfile(self, nid):
""" Writes a wireless profile to disk. """
def write_script_ent(prof, script):
if not self.config.has_option(prof, script):
self.config.set(prof, script, None)
cur_network = self.LastScan[id]
cur_network = self.LastScan[nid]
bssid_key = cur_network["bssid"]
essid_key = "essid:%s" % cur_network["essid"]
@@ -1287,7 +1321,7 @@ class WirelessDaemon(dbus.service.Object):
self.config.write()
@dbus.service.method('org.wicd.daemon.wireless')
def SaveWirelessNetworkProperty(self, id, option):
def SaveWirelessNetworkProperty(self, nid, option):
""" Writes a particular wireless property to disk. """
option = misc.sanitize_config(option)
if option.endswith("script"):
@@ -1295,7 +1329,7 @@ class WirelessDaemon(dbus.service.Object):
'the daemon.'
return
config = self.config
cur_network = self.LastScan[id]
cur_network = self.LastScan[nid]
essid_key = "essid:" + cur_network["essid"]
config.set(cur_network["bssid"], option, str(cur_network[option]))
@@ -1347,12 +1381,14 @@ class WirelessDaemon(dbus.service.Object):
self.config.remove_section(section)
self.config.write()
@dbus.service.signal(dbus_interface='org.wicd.daemon.wireless', signature='')
@dbus.service.signal(dbus_interface='org.wicd.daemon.wireless', \
signature='')
def SendStartScanSignal(self):
""" Emits a signal announcing a scan has started. """
self._scanning = True
@dbus.service.signal(dbus_interface='org.wicd.daemon.wireless', signature='')
@dbus.service.signal(dbus_interface='org.wicd.daemon.wireless', \
signature='')
def SendEndScanSignal(self):
""" Emits a signal announcing a scan has finished. """
self._scanning = False
@@ -1372,11 +1408,10 @@ class WirelessDaemon(dbus.service.Object):
if self.debug_mode:
print network["essid"] + ' has profile'
if bool(network.get('automatic')):
try:
if network.get('never'):
print network["essid"],'marked never connect'
continue
except:
else:
print network["essid"],'has no never connect value'
print 'trying to automatically connect to...' + \
network["essid"]
@@ -1389,7 +1424,7 @@ class WirelessDaemon(dbus.service.Object):
###### Wired Daemon #######
###########################
class WiredDaemon(dbus.service.Object):
class WiredDaemon(dbus.service.Object, object):
""" DBus interface for wired connection operations. """
def __init__(self, bus_name, daemon, wired=None, debug=False):
""" Intitialize the wireless DBus interface. """
@@ -1403,8 +1438,10 @@ class WiredDaemon(dbus.service.Object):
self.config = ConfigManager(wired_conf, debug=debug)
def get_debug_mode(self):
""" Getter for debug_mode property. """
return self._debug_mode
def set_debug_mode(self, mode):
""" Setter for debug_mode property. """
self._debug_mode = mode
self.config.debug = mode
debug_mode = property(get_debug_mode, set_debug_mode)
@@ -1465,10 +1502,10 @@ class WiredDaemon(dbus.service.Object):
return False
@dbus.service.method('org.wicd.daemon.wired')
def GetWiredProperty(self, property):
def GetWiredProperty(self, prop):
""" Returns the requested wired property. """
if self.WiredNetwork:
value = self.WiredNetwork.get(property)
value = self.WiredNetwork.get(prop)
return value
else:
print 'GetWiredProperty: WiredNetwork does not exist'
@@ -1516,8 +1553,10 @@ class WiredDaemon(dbus.service.Object):
""" Connects to a wired network. """
self.wired.before_script = self.GetWiredProperty("beforescript")
self.wired.after_script = self.GetWiredProperty("afterscript")
self.wired.pre_disconnect_script = self.GetWiredProperty("predisconnectscript")
self.wired.post_disconnect_script = self.GetWiredProperty("postdisconnectscript")
self.wired.pre_disconnect_script = \
self.GetWiredProperty("predisconnectscript")
self.wired.post_disconnect_script = \
self.GetWiredProperty("postdisconnectscript")
self.daemon.wireless_bus.wifi.Disconnect()
# make sure disconnect scripts are run
self.wired.Disconnect()
@@ -1543,7 +1582,7 @@ class WiredDaemon(dbus.service.Object):
"postdisconnectscript", "encryption_enabled"]:
self.config.set(profilename, option, None)
self.config.set(profilename, "default", default)
self.config.set(profilename,"dhcphostname",os.uname()[1])
self.config.set(profilename, "dhcphostname", os.uname()[1])
self.config.write()
return True
@@ -1628,7 +1667,8 @@ class WiredDaemon(dbus.service.Object):
profile[x] = misc.Noneify(self.config.get(profilename, x))
profile['use_global_dns'] = bool(profile.get('use_global_dns'))
profile['use_static_dns'] = bool(profile.get('use_static_dns'))
profile['encryption_enabled'] = bool(profile.get('encryption_enabled'))
profile['encryption_enabled'] = \
bool(profile.get('encryption_enabled'))
profile['profilename'] = profilename
self.WiredNetwork = profile
self._cur_wired_prof_name = profilename
@@ -1657,6 +1697,7 @@ class WiredDaemon(dbus.service.Object):
return wnettools.GetWiredInterfaces()
def usage():
""" Print help screen. """
print """
wicd %s
wireless (and wired) connection daemon.
@@ -1765,8 +1806,8 @@ def main(argv):
try:
opts, args = getopt.getopt(sys.argv[1:], 'fenoahk',
['help', 'no-daemon', 'no-poll', 'no-stderr', 'no-stdout',
'no-autoconnect', 'kill'])
['help', 'no-daemon', 'no-poll', 'no-stderr',
'no-stdout', 'no-autoconnect', 'kill'])
except getopt.GetoptError:
# Print help information and exit
usage()
@@ -1793,7 +1834,7 @@ def main(argv):
if kill:
try:
f = open(wpath.pidfile)
except:
except IOError:
#print >> sys.stderr, "No wicd instance active, aborting."
sys.exit(1)
@@ -1817,7 +1858,7 @@ def main(argv):
dbus_ifaces['daemon'].Disconnect()
pid = int(f.readline())
f.close()
os.kill(pid,signal.SIGTERM)
os.kill(pid, signal.SIGTERM)
# quit, this should be the only option specified
sys.exit(0)
@@ -1830,7 +1871,8 @@ def main(argv):
if not os.path.exists(wpath.networks):
os.makedirs(wpath.networks)
if do_daemonize: daemonize()
if do_daemonize:
daemonize()
if redirect_stderr or redirect_stdout:
logpath = os.path.join(wpath.log, 'wicd.log')
@@ -1840,8 +1882,8 @@ def main(argv):
output = ManagedStdio(logpath)
if os.path.exists(logpath):
try:
os.chmod(logpath, int(wpath.log_perms,8))
except:
os.chmod(logpath, int(wpath.log_perms, 8))
except OSError:
print 'unable to chmod log file to %s' % wpath.log_perms
try:
@@ -1849,11 +1891,13 @@ def main(argv):
import grp
group = grp.getgrnam(wpath.log_group)
os.chown(logpath, 0, group[2])
except:
except OSError:
print 'unable to chown log file to %s' % group[2]
if redirect_stdout: sys.stdout = output
if redirect_stderr: sys.stderr = output
if redirect_stdout:
sys.stdout = output
if redirect_stderr:
sys.stderr = output
print '---------------------------'
print 'wicd initializing...'

173
wicd/wnettools.py
View File

@@ -49,7 +49,8 @@ essid_pattern = re.compile('.*ESSID:"?(.*?)".*\n', _re_mode)
ap_mac_pattern = re.compile('.*Address: (.*?)\n', _re_mode)
channel_pattern = re.compile('.*Channel:?=? ?(\d+)', _re_mode)
strength_pattern = re.compile('.*Quality:?=? ?(\d+)\s*/?\s*(\d*)', _re_mode)
altstrength_pattern = re.compile('.*Signal level:?=? ?(\d+)\s*/?\s*(\d*)', _re_mode)
altstrength_pattern = re.compile('.*Signal level:?=? ?(\d+)\s*/?\s*(\d*)',
_re_mode)
signaldbm_pattern = re.compile('.*Signal level:?=? ?(-\d\d*)', _re_mode)
bitrates_pattern = re.compile('([\d\.]+)\s+\S+/s', _re_mode)
mode_pattern = re.compile('.*Mode:([A-Za-z-]*?)\n', _re_mode)
@@ -61,12 +62,15 @@ wpa2_pattern = re.compile('(WPA2)', _re_mode)
#iwconfig-only regular expressions.
ip_up = re.compile(r'flags=[0.9]*<([^>]*)>', re.S)
ip_pattern = re.compile(r'inet [Aa]d?dr[^.]*:([^.]*\.[^.]*\.[^.]*\.[0-9]*)', re.S)
ip_pattern = re.compile(r'inet [Aa]d?dr[^.]*:([^.]*\.[^.]*\.[^.]*\.[0-9]*)',
re.S)
ip_pattern1 = re.compile(r'inet ([^.]*\.[^.]*\.[^.]*\.[0-9]*)', re.S)
bssid_pattern = re.compile('.*[(Access Point)|(Cell)]: (([0-9A-Z]{2}:){5}[0-9A-Z]{2})', _re_mode)
bssid_pattern = re.compile('.*[(Access Point)|(Cell)]: ' + \
'(([0-9A-Z]{2}:){5}[0-9A-Z]{2})', _re_mode)
bitrate_pattern = re.compile('.*Bit Rate[=:](.*?/s)', _re_mode)
opmode_pattern = re.compile('.*Mode:(.*?) ', _re_mode)
authmethods_pattern = re.compile('.*Authentication capabilities :\n(.*?)Current', _re_mode)
authmethods_pattern = re.compile('.*Authentication capabilities ' + \
':\n(.*?)Current', _re_mode)
# Regular expressions for wpa_cli output
auth_pattern = re.compile('.*wpa_state=(.*?)\n', _re_mode)
@@ -79,12 +83,14 @@ blacklist_norm = ";`$!*|><&\\"
blank_trans = maketrans("", "")
def _sanitize_string(string):
""" Sanitize string. """
if string:
return translate(str(string), blank_trans, blacklist_norm)
else:
return string
def _sanitize_string_strict(string):
""" Sanitize string in a stricter way. """
if string:
return translate(str(string), blank_trans, blacklist_strict)
else:
@@ -140,7 +146,8 @@ def isWireless(devname):
in the future, if wireless.h is fully replaced.
"""
we = None
for t in [socket.AF_INET, socket.AF_INET6, socket.AF_IPX, socket.AF_AX25, socket.AF_APPLETALK]:
for t in [socket.AF_INET, socket.AF_INET6, socket.AF_IPX, socket.AF_AX25,
socket.AF_APPLETALK]:
sk = socket.socket(t, socket.SOCK_DGRAM)
if sk is None:
continue
@@ -149,7 +156,7 @@ def isWireless(devname):
#define SIOCGIWNAME 0x8b01 in linux/wireless.h
# "used to verify the presence of wireless extensions"
we = fcntl.ioctl(skfd, 0x8b01, devname)
except:
except IOError:
pass
sk.close()
return we is not None
@@ -184,7 +191,7 @@ def GetWpaSupplicantDrivers():
output = misc.Run(["wpa_supplicant", "-h"])
try:
output = output.split("drivers:")[1].split("options:")[0].strip()
except:
except KeyError:
print "Warning: Couldn't get list of valid wpa_supplicant drivers"
return [""]
patt = re.compile("(\S+)\s+=.*")
@@ -237,6 +244,23 @@ class BaseInterface(object):
self.link_detect = None
self.dhcp_object = None
self.ethtool_cmd = None
self.miitool_cmd = None
self.ip_cmd = None
self.route_cmd = None
self.wpa_cli_cmd = None
self.resolvconf_cmd = None
self.dhclient_cmd = None
self.dhclient_needs_verbose = False
self.udhcpc_cmd = None
self.dhcpcd_cmd = None
self.pump_cmd = None
self.kdesu_cmd = None
self.gksudo_cmd = None
self.ktsuss_cmd = None
def SetDebugMode(self, value):
""" If True, verbose output is enabled. """
self.verbose = value
@@ -363,7 +387,8 @@ class BaseInterface(object):
"hostname" : hostname,
'dhclientconf' : dhclient_conf_path }
elif flavor == "release":
return client_dict[client_name]['release'] % {"cmd":cmd, "iface":self.iface}
return client_dict[client_name]['release'] % \
{"cmd": cmd, "iface": self.iface}
else:
return client_dict[client_name]['id']
@@ -429,6 +454,7 @@ class BaseInterface(object):
self.route_cmd = self._find_program_path("route")
def CheckSudoApplications(self):
""" Check for available root-gaining 'sudo' applications. """
self.gksudo_cmd = self._find_program_path("gksudo")
self.kdesu_cmd = self._find_program_path("kdesu")
self.ktsuss_cmd = self._find_program_path("ktsuss")
@@ -442,7 +468,8 @@ class BaseInterface(object):
"""
cmd = 'ifconfig ' + self.iface + ' up'
if self.verbose: print cmd
if self.verbose:
print cmd
misc.Run(cmd)
return True
@@ -455,7 +482,8 @@ class BaseInterface(object):
"""
cmd = 'ifconfig ' + self.iface + ' down'
if self.verbose: print cmd
if self.verbose:
print cmd
misc.Run(cmd)
return True
@@ -464,7 +492,8 @@ class BaseInterface(object):
def GetIfconfig(self):
""" Runs ifconfig and returns the output. """
cmd = "ifconfig %s" % self.iface
if self.verbose: print cmd
if self.verbose:
print cmd
return misc.Run(cmd)
@neediface("")
@@ -491,7 +520,8 @@ class BaseInterface(object):
cmd = ''.join([cmd, 'netmask ', netmask, ' '])
if broadcast:
cmd = ''.join([cmd, 'broadcast ', broadcast, ' '])
if self.verbose: print cmd
if self.verbose:
print cmd
misc.Run(cmd)
def _parse_dhclient(self, pipe):
@@ -624,7 +654,8 @@ class BaseInterface(object):
"""
cmd = self._get_dhcp_command('connect', hostname)
if self.verbose: print cmd
if self.verbose:
print cmd
self.dhcp_object = misc.Run(cmd, include_stderr=True, return_obj=True)
pipe = self.dhcp_object.stdout
client_dict = { misc.DHCLIENT : self._parse_dhclient,
@@ -646,7 +677,8 @@ class BaseInterface(object):
def ReleaseDHCP(self):
""" Release the DHCP lease for this interface. """
cmd = self._get_dhcp_command("release")
if self.verbose: print cmd
if self.verbose:
print cmd
misc.Run(cmd)
@neediface(False)
@@ -659,7 +691,8 @@ class BaseInterface(object):
else:
print "No route manipulation command available!"
return
if self.verbose: print cmd
if self.verbose:
print cmd
misc.Run(cmd)
@neediface(False)
@@ -671,7 +704,8 @@ class BaseInterface(object):
"""
if self.resolvconf_cmd:
cmd = [self.resolvconf_cmd, '-d', self.iface + '.wicd']
if self.verbose: print cmd
if self.verbose:
print cmd
p = misc.Run(cmd, include_stderr=True, return_obj=True)
p.communicate()
@@ -711,7 +745,8 @@ class BaseInterface(object):
if self.resolvconf_cmd:
cmd = [self.resolvconf_cmd, '-a', self.iface + '.wicd']
if self.verbose: print cmd
if self.verbose:
print cmd
p = misc.Run(cmd, include_stderr=True, return_obj=True)
p.communicate(input=resolv_params)
else:
@@ -730,7 +765,8 @@ class BaseInterface(object):
print "No flush command available!"
cmds = []
for cmd in cmds:
if self.verbose: print cmd
if self.verbose:
print cmd
misc.Run(cmd)
@neediface(False)
@@ -745,7 +781,8 @@ class BaseInterface(object):
print 'WARNING: Invalid gateway found. Aborting!'
return False
cmd = 'route add default gw %s dev %s' % (gw, self.iface)
if self.verbose: print cmd
if self.verbose:
print cmd
misc.Run(cmd)
@neediface("")
@@ -763,7 +800,8 @@ class BaseInterface(object):
# check multiple ifconfig output styles
for pat in [ip_pattern, ip_pattern1]:
m = misc.RunRegex(pat, output)
if m: return m
if m:
return m
return None
@neediface(False)
@@ -784,7 +822,8 @@ class BaseInterface(object):
# timeout, while the above will wait (-w) 3 seconds at
# most.
cmd = "ping -q -c 1 %s" % gateway
if self.verbose: print cmd
if self.verbose:
print cmd
return misc.LaunchAndWait(cmd)
@neediface(False)
@@ -799,7 +838,8 @@ class BaseInterface(object):
try:
flags = open(flags_file, "r").read().strip()
except IOError:
print "Could not open %s, using ifconfig to determine status" % flags_file
print "Could not open %s, using ifconfig to determine status" \
% flags_file
return self._slow_is_up(ifconfig)
return bool(int(flags, 16) & 1)
@@ -807,7 +847,8 @@ class BaseInterface(object):
def StopWPA(self):
""" Terminates wpa using wpa_cli"""
cmd = 'wpa_cli -i %s terminate' % self.iface
if self.verbose: print cmd
if self.verbose:
print cmd
misc.Run(cmd)
@@ -866,7 +907,8 @@ class BaseWiredInterface(BaseInterface):
while True:
tries += 1
time.sleep(2)
if self.IsUp() or tries > MAX_TRIES: break
if self.IsUp() or tries > MAX_TRIES:
break
if os.path.exists(carrier_path):
carrier = open(carrier_path, 'r')
@@ -878,7 +920,8 @@ class BaseWiredInterface(BaseInterface):
elif link == 0:
return False
except (IOError, ValueError, TypeError):
print 'Error checking link using /sys/class/net/%s/carrier' % self.iface
print 'Error checking link using /sys/class/net/%s/carrier' \
% self.iface
if self.ethtool_cmd and self.link_detect in [misc.ETHTOOL, misc.AUTO]:
return self._eth_get_plugged_in()
@@ -901,10 +944,13 @@ class BaseWiredInterface(BaseInterface):
print 'Wired Interface is down, putting it up'
self.Up()
time.sleep(6)
if self.verbose: print cmd
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):
if misc.RunRegex(
re.compile('(Link detected: yes)', re.I | re.M | re.S),
tool_data
):
return True
else:
return False
@@ -917,14 +963,16 @@ class BaseWiredInterface(BaseInterface):
"""
cmd = "%s %s" % (self.miitool_cmd, self.iface)
if self.verbose: print cmd
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)
if self.verbose: print cmd
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),
@@ -934,11 +982,13 @@ class BaseWiredInterface(BaseInterface):
return False
def Authenticate(self, network):
""" Authenticate with wpa_supplicant. """
misc.ParseEncryption(network)
cmd = ['wpa_supplicant', '-B', '-i', self.iface, '-c',
os.path.join(wpath.networks, 'wired'),
'-Dwired']
if self.verbose: print cmd
if self.verbose:
print cmd
misc.Run(cmd)
class BaseWirelessInterface(BaseInterface):
@@ -968,7 +1018,8 @@ class BaseWirelessInterface(BaseInterface):
"""
cmd = ['iwconfig', self.iface, 'essid', '--', str(essid)]
if self.verbose: print str(cmd)
if self.verbose:
print str(cmd)
misc.Run(cmd)
@neediface(False)
@@ -994,7 +1045,8 @@ class BaseWirelessInterface(BaseInterface):
def GetIwconfig(self):
""" Returns the output of iwconfig for this interface. """
cmd = "iwconfig " + self.iface
if self.verbose: print cmd
if self.verbose:
print cmd
return misc.Run(cmd)
def _FreqToChannel(self, freq):
@@ -1019,7 +1071,7 @@ class BaseWirelessInterface(BaseInterface):
try:
ret = freq_dict[freq]
except KeyError:
print "Couldn't determine channel number for frequency: " + str(freq)
print "Couldn't determine channel number for frequency:", str(freq)
return ret
@@ -1040,7 +1092,7 @@ class BaseWirelessInterface(BaseInterface):
for x in lines:
ap = {}
info = x.split(" ")
info = filter(None, [x.strip() for x in info])
info = [x.strip() for x in info if x.strip()]
if len(info) < 5:
continue
if re.match(patt, info[2].upper()):
@@ -1066,7 +1118,7 @@ class BaseWirelessInterface(BaseInterface):
ap['enctype'] = info[4 + offset]
elif info[5 + offset] == 'WPA2-PSK':
ap['encryption_method'] = 'WPA2'
ap['authmode'] ="WPA2PSK"
ap['authmode'] = "WPA2PSK"
ap['keyname'] = "WPA2PSK"
ap['enctype'] = info[4 + offset]
elif info[4 + offset] == "NONE":
@@ -1075,7 +1127,8 @@ class BaseWirelessInterface(BaseInterface):
print "Unknown AuthMode, can't assign encryption_method!"
ap['encryption_method'] = 'Unknown'
aps[bssid] = ap
if self.verbose: print str(aps)
if self.verbose:
print str(aps)
return aps
def _ParseRalinkAccessPoint(self, ap, ralink_info, cell):
@@ -1090,7 +1143,6 @@ class BaseWirelessInterface(BaseInterface):
Updated array containing info about the current access point
"""
wep_pattern = re.compile('.*Encryption key:(.*?)\n', re.I | re.M | re.S)
if ralink_info.has_key(ap['bssid']):
info = ralink_info[ap['bssid']]
for key in info.keys():
@@ -1115,7 +1167,8 @@ class BaseWirelessInterface(BaseInterface):
if mode.lower() == 'master':
mode = 'managed'
cmd = 'iwconfig %s mode %s' % (self.iface, mode)
if self.verbose: print cmd
if self.verbose:
print cmd
misc.Run(cmd)
@neediface(False)
@@ -1131,7 +1184,8 @@ class BaseWirelessInterface(BaseInterface):
return False
cmd = 'iwconfig %s channel %s' % (self.iface, str(channel))
if self.verbose: print cmd
if self.verbose:
print cmd
misc.Run(cmd)
@neediface(False)
@@ -1143,7 +1197,8 @@ class BaseWirelessInterface(BaseInterface):
"""
cmd = 'iwconfig %s key %s' % (self.iface, key)
if self.verbose: print cmd
if self.verbose:
print cmd
misc.Run(cmd)
@neediface(False)
@@ -1176,11 +1231,13 @@ class BaseWirelessInterface(BaseInterface):
base = "iwconfig %s" % self.iface
if channel and str(channel).isdigit():
cmd = "%s channel %s" % (base, str(channel))
if self.verbose: print cmd
if self.verbose:
print cmd
misc.Run(cmd)
if bssid:
cmd = "%s ap %s" % (base, bssid)
if self.verbose: print cmd
if self.verbose:
print cmd
misc.Run(cmd)
def GeneratePSK(self, network):
@@ -1191,11 +1248,13 @@ class BaseWirelessInterface(BaseInterface):
"""
wpa_pass_path = misc.find_path('wpa_passphrase')
if not wpa_pass_path: return None
if not wpa_pass_path:
return None
key_pattern = re.compile('network={.*?\spsk=(.*?)\n}.*',
re.I | re.M | re.S)
cmd = [wpa_pass_path, str(network['essid']), str(network['key'])]
if self.verbose: print cmd
if self.verbose:
print cmd
return misc.RunRegex(key_pattern, misc.Run(cmd))
@neediface(False)
@@ -1218,7 +1277,8 @@ class BaseWirelessInterface(BaseInterface):
os.path.join(wpath.networks,
network['bssid'].replace(':', '').lower()),
driver]
if self.verbose: print cmd
if self.verbose:
print cmd
misc.Run(cmd)
def _AuthenticateRalinkLegacy(self, network):
@@ -1243,7 +1303,8 @@ class BaseWirelessInterface(BaseInterface):
print 'Setting up WEP'
cmd = ''.join(['iwconfig ', self.iface, ' key ',
network.get('key')])
if self.verbose: print cmd
if self.verbose:
print cmd
misc.Run(cmd)
else:
cmd_list = []
@@ -1251,13 +1312,14 @@ class BaseWirelessInterface(BaseInterface):
cmd_list.append('AuthMode=' + info['authmode'])
cmd_list.append('EncrypType=' + info['enctype'])
cmd_list.append('SSID="%s"' % network['essid'])
cmd_list.append('%s="%s"' % (network['keyname'], network['key']))
cmd_list.append('%(keyname)s="%(key)s"' % network)
if info['nettype'] == 'SHARED' and info['enctype'] == 'WEP':
cmd_list.append('DefaultKeyID=1')
for cmd in cmd_list:
cmd = ['iwpriv', self.iface, 'set', cmd]
if self.verbose: print ' '.join(cmd)
if self.verbose:
print ' '.join(cmd)
misc.Run(cmd)
@neediface([])
@@ -1269,7 +1331,8 @@ class BaseWirelessInterface(BaseInterface):
"""
cmd = 'iwlist ' + self.iface + ' scan'
if self.verbose: print cmd
if self.verbose:
print cmd
results = misc.Run(cmd)
# Split the networks apart, using Cell as our split point
# this way we can look at only one network at a time.
@@ -1501,7 +1564,8 @@ class BaseWirelessInterface(BaseInterface):
""" Get the available authentication methods for the interface. """
if not iwlistauth:
cmd = 'iwlist ' + self.iface + ' auth'
if self.verbose: print cmd
if self.verbose:
print cmd
output = misc.Run(cmd)
else:
output = iwlistauth
@@ -1515,13 +1579,14 @@ class BaseWirelessInterface(BaseInterface):
""" Get the available bitrates the wifi card can use. """
cmd = 'iwlist ' + self.iface + ' rate'
if self.verbose: print cmd
if self.verbose:
print cmd
rates = misc.Run(cmd)
# process the output
rates = rates.split('\n')
rates = filter(None, map(lambda x: x.strip().split(' ')[0], rates))
rates = filter(lambda x: x[0].isdigit(), rates)
rates = [x.strip().split(' ')[0] for x in rates]
rates = [x for x in rates if x[0].isdigit()]
return dbus.Array(rates, signature='v')
def _get_link_quality(self, output):