def setState(self):
"""
Build the list of devices
"""
self.li = snack.Listbox(5, returnExit=1)
l = 0
le = self.mscreen.width - 6
if le <= 0:
le = 5
for dev in getDeviceList():
if not hasattr(dev, "getDialog") or not dev.getDialog():
#li.append("No dialog for %s" % dev.Device, None)
continue
l += 1
for hw in getHardwareList():
if hw.Name == dev.Device and hw.Description:
self.li.append(
("%s (%s) - %s" %
(dev.DeviceId, dev.Device, hw.Description))[:le], dev)
break
else:
self.li.append(("%s (%s) - %s" %
(dev.DeviceId, dev.Device, dev.Type))[:le],
dev)
if not l:
return None
self.li.append(_("<New Device>"), None)
def on_configureButton_clicked(self, button): # pylint: disable-msg=W0613
device = self.clist_get_nickname()
if not device:
return
for dev in getDeviceList():
if dev.DeviceId == device:
break
else:
return
# pylint: disable-msg=W0631
(ret, msg) = dev.configure()
if not self.dialog:
return False
if ret:
errorString = _('Cannot configure network device %s')\
% (device)
generic_longinfo_dialog(errorString, msg, self.dialog)
# update dialog #83640
# Re-read the device list
self.devicelist = self.getProfDeviceList(refresh=True)
self.activedevicelist = NetworkDevice().get()
# Update the gui
self.hydrateProfiles(refresh=True)
self.hydrate()
self.oldprofile = None # forces a re-read of oldprofile
self.update_dialog()
def dehydrate(self):
DialupInterfaceDialog.dehydrate(self)
if not self.device.Device:
self.device.Device = getNewDialupDevice(getDeviceList(),
self.device)
dialup = self.device.Dialup
dialup.HangupTimeout = self.xml.get_widget(
"hangupTimeoutSB").get_value_as_int()
for attr, widget in {
'InitString': 'modemInitEntry',
'Inherits': 'modemPortEntry',
'DialMode': 'dialModeEntry',
}.items():
val = self.xml.get_widget(widget).get_text().strip()
if val:
setattr(dialup, attr, val)
else:
delattr(dialup, attr)
for attr, widget in {
'Persist': 'persistCB',
'DefRoute': 'defrouteCB',
'StupidMode': 'stupidModeCB',
}.items():
val = self.xml.get_widget(widget).get_active()
setattr(dialup, attr, val)
if dialup.DialMode == DialModes[DM_AUTO]:
dialup.DialMode = DM_AUTO
else:
dialup.DialMode = DM_MANUAL
def runIt(self, mscreen):
"""
Show and run the screen, save files if necesarry
"""
self.mscreen = mscreen
devlist = getDeviceList()
self.setState()
while True:
if devlist.modified():
self.setState()
dev = self.selectDevice(mscreen)
if dev == -1:
# we want to save
return True
elif dev == -2:
continue
elif dev == None:
return False
dialog = dev.getDialog()
if dialog.runIt(mscreen):
dev.commit()
devlist.commit()
self.plist.activateDevice(
dev.DeviceId,
self.plist.getActiveProfile().ProfileName,
state=True)
self.plist.commit()
else:
dev.rollback()
devlist.rollback()
def on_deactivateButton_clicked(self, button): # pylint: disable-msg=W0613
device = self.clist_get_nickname()
for dev in getDeviceList():
if dev.DeviceId == device:
break
else:
return
# pylint: disable-msg=W0631
if dev and device:
dev.deactivate()
self.update_dialog()
def getProfDeviceList(self, refresh=None):
profilelist = getProfileList(refresh)
prof = profilelist.getActiveProfile()
devlist = getDeviceList(refresh)
activedevlist = []
for devid in prof.ActiveDevices:
for dev in devlist:
if dev.DeviceId != devid:
continue
break
else:
continue
activedevlist.append(dev) # pylint: disable-msg=W0631
return activedevlist
def getNextAlias(self, device):
devicelist = getDeviceList()
alias = None
for dev in devicelist:
if not dev.Device == device.Device:
continue
if dev.Alias:
if alias == None:
alias = dev.Alias + 1
elif alias <= dev.Alias:
alias = dev.Alias + 1
elif alias == None:
alias = 1
return alias
def on_activateButton_clicked(self, button): # pylint: disable-msg=W0613
device = self.clist_get_device()
nickname = self.clist_get_nickname()
for dev in getDeviceList():
if dev.DeviceId == nickname:
break
else:
return
gobject.source_remove(self.tag)
if device:
dev.activate() # pylint: disable-msg=W0631
self.update_dialog()
self.tag = gobject.timeout_add(4000, self.update_dialog)
def on_generic_clist_select_row(
self,
clist,
row,
column,
event, # pylint: disable-msg=W0613
activate_button=None,
deactivate_button=None,
configure_button=None,
monitor_button=None):
if len(clist.selection) == 0:
return
status = self.clist_get_status()
devname = self.clist_get_nickname()
dev = None
for dev in getDeviceList():
if dev.DeviceId == devname:
break
else:
dev = None
# pylint: disable-msg=W0631
if dev and (dev.AllowUser or self.isRoot):
self.xml.get_widget('activateButton').set_sensitive(True)
self.xml.get_widget('deactivateButton').set_sensitive(True)
else:
self.xml.get_widget('activateButton').set_sensitive(False)
self.xml.get_widget('deactivateButton').set_sensitive(False)
if status == ACTIVE:
#self.xml.get_widget('activateButton').set_sensitive(False)
#self.xml.get_widget('deactivateButton').set_sensitive(True)
#self.xml.get_widget('configureButton').set_sensitive(False)
self.xml.get_widget('monitorButton').set_sensitive(True)
else:
#self.xml.get_widget('activateButton').set_sensitive(True)
#self.xml.get_widget('deactivateButton').set_sensitive(False)
#self.xml.get_widget('configureButton').set_sensitive(True)
self.xml.get_widget('monitorButton').set_sensitive(False)
def newDevice(self, mscreen):
"""
Displays the main screen
@screen The snack screen instance
"""
t = snack.TextboxReflowed(25,
_("Which device type do you want to add?"))
bb = snack.ButtonBar(mscreen,
((_("Add"), "add"), (_("Cancel"), "cancel")))
li = snack.Listbox(5, width=25, returnExit=1)
li.append(_("Ethernet"), ETHERNET)
machine = os.uname()[4]
if machine == 's390' or machine == 's390x':
li.append(_("QETH"), QETH)
else:
li.append(_("Modem"), MODEM)
li.append(_("ISDN"), ISDN)
g = snack.GridForm(mscreen, _("Network Configuration"), 1, 3)
g.add(t, 0, 0)
g.add(li, 0, 1)
g.add(bb, 0, 2)
res = g.run()
mscreen.popWindow()
if bb.buttonPressed(res) != 'cancel':
todo = li.current()
df = getDeviceFactory()
dev = None
devclass = df.getDeviceClass(todo)
devlist = getDeviceList()
if not devclass:
return -1
dev = devclass()
if dev:
devlist.append(dev)
return dev
return -2
def load(self, name):
conf = ConfDevice(name)
self.oldname = name
if not conf.has_key("DEVICE"):
aliaspos = name.find(':')
if aliaspos != -1:
from netconfpkg.NCDeviceList import getDeviceList
# ok, we have to inherit all other data from our master
for dev in getDeviceList():
if dev.Device == name[:aliaspos]:
self.apply(dev)
break
self.Device = name
self.DeviceId = name
for selfkey in self.__keydict.keys():
confkey = self.__keydict[selfkey]
if conf.has_key(confkey) and conf[confkey]:
setattr(self, selfkey, conf[confkey])
else:
# if confkey is for example IPADDR, we should try also IPADDR0, IPADDR1 etc.
if confkey in self.__keydictn:
for i in range(10):
confkeyn = confkey + str(i)
if conf.has_key(confkeyn) and len(conf[confkeyn]):
setattr(self, selfkey, conf[confkeyn])
break
for selfkey in self.__intkeydict.keys():
confkey = self.__intkeydict[selfkey]
if conf.has_key(confkey) and len(conf[confkey]):
setattr(self, selfkey, conf[confkey])
else:
if confkey in self.__intkeydictn:
for i in range(10):
confkeyn = confkey + str(i)
if conf.has_key(confkeyn) and len(conf[confkeyn]):
setattr(self, selfkey, conf[confkeyn])
break
for selfkey in self.__boolkeydict.keys():
confkey = self.__boolkeydict[selfkey]
if conf.has_key(confkey):
if conf[confkey] == 'yes':
setattr(self, selfkey, True)
#print >> sys.stderr, self.DeviceId, selfkey, "True"
#setattr(self, selfkey, True)
else:
setattr(self, selfkey, False)
#print >> sys.stderr, self.DeviceId, selfkey, "False"
#setattr(self, selfkey, False)
# we need to deal with options which have default value 'yes' like NM_CONTROLLED
else:
if confkey != "NM_CONTROLLED":
setattr(self, selfkey, False)
#setattr(self, selfkey, False)
# if PREFIX exists it takes preference over NETMASK
if hasattr(self, 'Prefix') and len(self.Prefix):
prefix = int(self.Prefix)
if prefix >= 0 and prefix <= 32:
netmask_str = socket.inet_ntoa(
struct.pack(">I", 0xFFFFFFFF & (0xFFFFFFFF <<
(32 - prefix))))
self.Netmask = netmask_str
if not conf.has_key("PEERDNS"):
del self.AutoDNS
if not self.Slave:
del self.Slave
if not self.Gateway:
try:
cfg = ConfShellVar.ConfShellVar(getRoot() + SYSCONFNETWORK)
if (cfg.has_key('GATEWAY')
and ((not cfg.has_key('GATEWAYDEV'))
or cfg['GATEWAYDEV'] == self.Device)):
gw = cfg['GATEWAY']
if gw and self.Netmask:
try:
network = commands.getoutput('ipcalc --network ' +
str(self.IP) + ' ' +
str(self.Netmask) +
' 2>/dev/null')
out = commands.getoutput('ipcalc --network ' +
str(gw) + ' ' +
str(self.Netmask) +
' 2>/dev/null')
if out == network:
self.Gateway = str(gw)
except:
pass
except EnvironmentError, msg:
NC_functions.generic_error_dialog(str(msg))
def init_gui(self):
# pylint: disable-msg=W0201
if self.xml:
return
glade_file = "sharedtcpip.glade"
if not os.path.exists(glade_file):
glade_file = GLADEPATH + glade_file
if not os.path.exists(glade_file):
glade_file = NETCONFDIR + glade_file
self.sharedtcpip_xml = gtk.glade.XML(glade_file, None, domain=PROGNAME)
glade_file = 'QethInterfaceDruid.glade'
if not os.path.exists(glade_file):
glade_file = GLADEPATH + glade_file
if not os.path.exists(glade_file):
glade_file = NETCONFDIR + glade_file
self.xml = gtk.glade.XML(glade_file, 'druid', domain=PROGNAME)
xml_signal_autoconnect(self.xml,
{ "on_hostname_config_page_back" : \
self.on_hostname_config_page_back,
"on_hostname_config_page_next" : \
self.on_hostname_config_page_next,
"on_hostname_config_page_prepare" : \
self.on_hostname_config_page_prepare,
"on_hw_config_page_back" : self.on_hw_config_page_back,
"on_hw_config_page_next" : self.on_hw_config_page_next,
"on_hw_config_page_prepare" : self.on_hw_config_page_prepare,
"on_finish_page_finish" : self.on_finish_page_finish,
"on_finish_page_prepare" : self.on_finish_page_prepare,
"on_finish_page_back" : self.on_finish_page_back
}
)
#print "EthernetInterface getDeviceList"
self.devicelist = getDeviceList()
df = getDeviceFactory()
devclass = df.getDeviceClass(self.connection_type)
if devclass:
self.device = devclass()
else:
self.device = NCPluginDevQeth.DevQeth()
self.device.Type = self.connection_type
self.device.OnBoot = True
self.device.AllowUser = False
self.device.IPv6Init = False
self.profilelist = NCProfileList.getProfileList()
self.hw_sel = 0
self.hwPage = False
window = self.sharedtcpip_xml.get_widget('dhcpWindow')
frame = self.sharedtcpip_xml.get_widget('dhcpFrame')
vbox = self.xml.get_widget('generalVbox')
window.remove(frame)
vbox.pack_start(frame)
sharedtcpip.dhcp_init(self.sharedtcpip_xml, self.device)
self.druids = []
self.druid = self.xml.get_widget('druid')
for i in self.druid.get_children():
self.druid.remove(i)
self.druids.append(i)
if self.connection_type == QETH:
self.hwDruid = QethHardware(self.toplevel)
self.hwDruid.has_ethernet = None
self.druids = [self.druids[0]] + self.hwDruid.druids[:]\
+ self.druids[1:]
def saveDevices(self):
if not self.do_save:
return
devicelist = getDeviceList()
devicelist.save()
def main(mcmdline):
from netconfpkg.NCDeviceList import getDeviceList
from netconfpkg.NCHardwareList import getHardwareList
from netconfpkg.NCIPsecList import getIPsecList
from netconfpkg.NCProfileList import getProfileList
from netconfpkg.NC_functions import log
signal.signal (signal.SIGINT, signal.SIG_DFL)
class BadUsage(Exception):
pass
#progname = os.path.basename(sys.argv[0])
NC_functions.setVerboseLevel(2)
NC_functions.setDebugLevel(0)
do_activate = 0
switch_profile = 0
profile = None
test = 0
EXPORT = 1
IMPORT = 2
SWITCH = 3
mode = EXPORT
filename = None
clear = 0
chroot = None
debug = None
devlists = []
try:
opts = getopt.getopt(mcmdline, "asp:?r:dhvtief:co",
[
"activate",
"profile=",
"help",
"devicelist",
"verbose",
"test",
"import",
"export",
"clear",
"root=",
"file=",
"debug",
"hardwarelist",
"ipseclist",
"profilelist"])[0]
for opt, val in opts:
if opt == '-r' or opt == '--root':
chroot = val
NC_functions.prepareRoot(chroot)
NC_functions.updateNetworkScripts()
continue
except (getopt.error, BadUsage):
pass
try:
opts = getopt.getopt(mcmdline, "asp:?r:dhvtief:co",
[
"activate",
"profile=",
"help",
"devicelist",
"verbose",
"test",
"import",
"export",
"clear",
"root=",
"file=",
"debug",
"hardwarelist",
"ipseclist",
"profilelist"])[0]
for opt, val in opts:
if opt == '-d' or opt == '--devicelist':
devlists.append(getDeviceList())
continue
if opt == '-h' or opt == '--hardwarelist':
devlists.append(getHardwareList())
continue
if opt == '-s' or opt == '--ipseclist':
devlists.append(getIPsecList())
continue
if opt == '-o' or opt == '--profilelist':
devlists.append(getProfileList())
continue
if opt == '-p' or opt == '--profile':
mode = SWITCH
switch_profile = 1
profile = val
continue
if opt == '-f' or opt == '--file':
filename = val
continue
if opt == '-r' or opt == '--root':
# already parsed
continue
if opt == '-c' or opt == '--clear':
clear = 1
continue
if opt == '-t' or opt == '--test':
test = 1
continue
if opt == '-a' or opt == '--activate':
mode = SWITCH
do_activate = 1
continue
if opt == '-i' or opt == '--import':
mode = IMPORT
continue
if opt == '-e' or opt == '--export':
mode = EXPORT
continue
if opt == '-?' or opt == '--help':
Usage()
return(0)
if opt == '-v' or opt == '--verbose':
NC_functions.setVerboseLevel(NC_functions.getVerboseLevel()+1)
continue
if opt == '--debug':
NC_functions.setDebugLevel(NC_functions.getDebugLevel()+1)
debug = 1
continue
sys.stderr.write(_("Unknown option %s\n" % opt))
raise BadUsage
except (getopt.error, BadUsage):
Usage()
return(1)
try:
if not NC_functions.getDebugLevel():
log.handler = log.syslog_handler
log.open()
else:
log.handler = log.file_handler
log.open(sys.stderr)
if not len(devlists):
devlists = [getDeviceList(), getHardwareList(),
getIPsecList(),
getProfileList()]
if clear:
for devlist in devlists:
del devlist[0:len(devlist)]
if mode == EXPORT:
for devlist in devlists:
devstr = str(devlist)
if len(devstr):
# remove the last \n
print devstr[:-1]
return(0)
elif mode == IMPORT:
devlistsdict = {
"HardwareList" : getHardwareList(),
"DeviceList" : getDeviceList(),
"IPsecList" : getIPsecList(),
"ProfileList" : getProfileList() }
if filename:
mfile = open(filename, "r")
else:
mfile = sys.stdin
lines = mfile.readlines()
for line in lines:
try:
line = line[:-1]
log.log(3, "Parsing '%s'\n" % line)
vals = line.split("=")
if len(vals) <= 1:
continue
key = vals[0]
value = "=".join(vals[1:])
vals = key.split(".")
if devlistsdict.has_key(vals[0]):
# pylint: disable-msg=W0212
devlistsdict[vals[0]].fromstr(vals, value)
else:
sys.stderr.write(_("Unknown List %s\n", vals[0]))
raise ParseError
except Exception, e:
pe = ParseError(_("Error parsing line: %s") % line)
pe.args += e.args
raise pe
for devlist in devlists:
log.log(1, "%s" % devlist)
devlist.save()
return(0)
elif test:
return(0)
elif mode == SWITCH:
ret = None
profilelist = getProfileList()
actdev = Control.NetworkDevice()
actdev.load()
aprof = profilelist.getActiveProfile()
if switch_profile and aprof.ProfileName != profile:
log.log(1, "Switching to profile %s" % profile)
if do_activate:
for p in profilelist:
if p.ProfileName == profile:
aprof = p
break
for device in getDeviceList():
if device.DeviceId not in aprof.ActiveDevices:
if actdev.find(device.Device):
(ret, msg) = device.deactivate()
if ret:
print msg
profilelist.switchToProfile(profile)
profilelist.save()
actdev.load()
if do_activate:
aprof = profilelist.getActiveProfile()
for device in getDeviceList():
if device.DeviceId in aprof.ActiveDevices:
if not actdev.find(device.Device) and \
def dehydrate(self):
DialupInterfaceDialog.dehydrate(self)
dialup = self.device.Dialup
encap_mode_old = dialup.EncapMode
if self.xml.get_widget("encapModeEntry").get_text() == _("sync PPP"):
dialup.EncapMode = "syncppp"
else:
dialup.EncapMode = "rawip"
# get free ISDN device if encap mode is changed
if encap_mode_old != dialup.EncapMode:
self.device.Device = getNewDialupDevice(\
getDeviceList(), self.device)
dialup.PhoneInNumber = self.xml.get_widget(
"dialinNumberEntry").get_text().strip()
if not dialup.PhoneInNumber:
del dialup.PhoneInNumber
dialup.Secure = self.xml.get_widget("allowDialinNumberCB").get_active()
if self.xml.get_widget("callbackCB").get_active():
dialup.createCallback()
if self.xml.get_widget('CallbackMode').get_child().get_label() == \
_('in'):
dialup.Callback.Type = 'in'
else:
dialup.Callback.Type = 'out'
dialup.Callback.Delay = self.xml.get_widget(\
"callbackDelaySB").get_value_as_int()
dialup.Callback.Hup = False
dialup.Callback.Compression = self.xml.get_widget(\
"cbcpCB").get_active()
dialup.Callback.MSN = self.xml.get_widget(\
"cbcpMSNEntry").get_text().strip()
if not dialup.Callback.MSN:
del dialup.Callback.MSN
else:
if dialup.Callback:
dialup.Callback.Type = "off"
dialup.HangupTimeout = self.xml.get_widget(\
"hangupTimeoutISDNSB").get_value_as_int()
dialup.DialMode = self.xml.get_widget("dialModeISDNEntry").get_text()
if dialup.DialMode == DialModes[DM_AUTO]:
dialup.DialMode = DM_AUTO
dialup.DefRoute = True
else:
dialup.DialMode = DM_MANUAL
dialup.DefRoute = False
dialup.MSN = self.xml.get_widget("msnEntry").get_text().strip()
if not dialup.MSN:
del dialup.MSN
dialup.ChannelBundling = self.xml.get_widget(\
"channelBundlingCB").get_active()
if dialup.ChannelBundling:
dialup.SlaveDevice = getNewDialupDevice(\
getDeviceList(), self.device)
else:
dialup.SlaveDevice = None
dialup.DefRoute = self.xml.get_widget("defrouteISDNCB").get_active()
auth = self.xml.get_widget("authEntry").get_text()
if auth == _('pap'):
dialup.Authentication = '+pap -chap'
elif auth == _('chap'):
dialup.Authentication = '-pap +chap'
elif auth == _('chap+pap'):
dialup.Authentication = '+chap +pap'
else:
dialup.Authentication = 'noauth'
