X-Git-Url: https://git.cweiske.de/enigma2.git/blobdiff_plain/67b53c1cb06988394c35a6e965c99b72b67fe1be..63473fb658a8a70a67d4c68eba2deb7850739f2e:/lib/python/Screens/NetworkSetup.py diff --git a/lib/python/Screens/NetworkSetup.py b/lib/python/Screens/NetworkSetup.py old mode 100644 new mode 100755 index 9514e7fd..c0037f81 --- a/lib/python/Screens/NetworkSetup.py +++ b/lib/python/Screens/NetworkSetup.py @@ -1,70 +1,271 @@ from Screen import Screen -from Components.ActionMap import ActionMap -from Components.ConfigList import ConfigListScreen -from Components.config import config, getConfigListEntry +from Screens.MessageBox import MessageBox +from Screens.InputBox import InputBox +from Screens.Standby import * +from Screens.VirtualKeyBoard import VirtualKeyBoard +from Screens.HelpMenu import HelpableScreen from Components.Network import iNetwork -from Components.Label import Label +from Components.Sources.StaticText import StaticText +from Components.Sources.Boolean import Boolean +from Components.Label import Label,MultiColorLabel +from Components.Pixmap import Pixmap,MultiPixmap from Components.MenuList import MenuList -from Components.config import config, ConfigYesNo, ConfigIP, NoSave, ConfigNothing +from Components.config import config, ConfigYesNo, ConfigIP, NoSave, ConfigText, ConfigPassword, ConfigSelection, getConfigListEntry, ConfigNothing +from Components.ConfigList import ConfigListScreen from Components.PluginComponent import plugins +from Components.MultiContent import MultiContentEntryText, MultiContentEntryPixmapAlphaTest +from Components.ActionMap import ActionMap, NumberActionMap, HelpableActionMap +from Tools.Directories import resolveFilename, SCOPE_PLUGINS, SCOPE_CURRENT_SKIN +from Tools.LoadPixmap import LoadPixmap from Plugins.Plugin import PluginDescriptor +from enigma import eTimer, ePoint, eSize, RT_HALIGN_LEFT, eListboxPythonMultiContent, gFont +from os import path as os_path, system as os_system, unlink +from re import compile as re_compile, search as re_search + + +class InterfaceList(MenuList): + def __init__(self, list, enableWrapAround=False): + MenuList.__init__(self, list, enableWrapAround, eListboxPythonMultiContent) + self.l.setFont(0, gFont("Regular", 20)) + self.l.setItemHeight(30) + +def InterfaceEntryComponent(index,name,default,active ): + res = [ + (index), + MultiContentEntryText(pos=(80, 5), size=(430, 25), font=0, text=name) + ] + num_configured_if = len(iNetwork.getConfiguredAdapters()) + if num_configured_if >= 2: + if default is True: + png = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/buttons/button_blue.png")) + if default is False: + png = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/buttons/button_blue_off.png")) + res.append(MultiContentEntryPixmapAlphaTest(pos=(10, 5), size=(25, 25), png = png)) + if active is True: + png2 = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/icons/lock_on.png")) + if active is False: + png2 = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/icons/lock_error.png")) + res.append(MultiContentEntryPixmapAlphaTest(pos=(40, 1), size=(25, 25), png = png2)) + return res -class NetworkAdapterSelection(Screen): +class NetworkAdapterSelection(Screen,HelpableScreen): def __init__(self, session): Screen.__init__(self, session) + HelpableScreen.__init__(self) - self["adapterlist"] = MenuList(iNetwork.getAdapterList()) + self.wlan_errortext = _("No working wireless network adapter found.\nPlease verify that you have attached a compatible WLAN device and your network is configured correctly.") + self.lan_errortext = _("No working local network adapter found.\nPlease verify that you have attached a network cable and your network is configured correctly.") + self.oktext = _("Press OK on your remote control to continue.") + self.edittext = _("Press OK to edit the settings.") + self.defaulttext = _("Press yellow to set this interface as default interface.") + self.restartLanRef = None - self["actions"] = ActionMap(["OkCancelActions"], - { - "ok": self.okbuttonClick , - "cancel": self.close - }) + self["key_red"] = StaticText(_("Close")) + self["key_green"] = StaticText(_("Select")) + self["key_yellow"] = StaticText("") + self["key_blue"] = StaticText("") + self["introduction"] = StaticText(self.edittext) + + self.adapters = [(iNetwork.getFriendlyAdapterName(x),x) for x in iNetwork.getAdapterList()] + + if not self.adapters: + self.onFirstExecBegin.append(self.NetworkFallback) + + self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions", + { + "cancel": (self.close, _("exit network interface list")), + "ok": (self.okbuttonClick, _("select interface")), + }) + + self["ColorActions"] = HelpableActionMap(self, "ColorActions", + { + "red": (self.close, _("exit network interface list")), + "green": (self.okbuttonClick, _("select interface")), + "blue": (self.openNetworkWizard, _("Use the Networkwizard to configure selected network adapter")), + }) + + self["DefaultInterfaceAction"] = HelpableActionMap(self, "ColorActions", + { + "yellow": (self.setDefaultInterface, [_("Set interface as default Interface"),_("* Only available if more than one interface is active.")] ), + }) + + self.list = [] + self["list"] = InterfaceList(self.list) + self.updateList() + + if len(self.adapters) == 1: + self.onFirstExecBegin.append(self.okbuttonClick) + self.onClose.append(self.cleanup) + + + def updateList(self): + self.list = [] + default_gw = None + num_configured_if = len(iNetwork.getConfiguredAdapters()) + if num_configured_if >= 2: + self["key_yellow"].setText(_("Default")) + self["introduction"].setText(self.defaulttext) + self["DefaultInterfaceAction"].setEnabled(True) + else: + self["key_yellow"].setText("") + self["introduction"].setText(self.edittext) + self["DefaultInterfaceAction"].setEnabled(False) + + if num_configured_if < 2 and os_path.exists("/etc/default_gw"): + unlink("/etc/default_gw") + + if os_path.exists("/etc/default_gw"): + fp = file('/etc/default_gw', 'r') + result = fp.read() + fp.close() + default_gw = result + + if len(self.adapters) == 0: # no interface available => display only eth0 + self.list.append(InterfaceEntryComponent("eth0",iNetwork.getFriendlyAdapterName('eth0'),True,True )) + else: + for x in self.adapters: + if x[1] == default_gw: + default_int = True + else: + default_int = False + if iNetwork.getAdapterAttribute(x[1], 'up') is True: + active_int = True + else: + active_int = False + self.list.append(InterfaceEntryComponent(index = x[1],name = _(x[0]),default=default_int,active=active_int )) + + if os_path.exists(resolveFilename(SCOPE_PLUGINS, "SystemPlugins/NetworkWizard/networkwizard.xml")): + self["key_blue"].setText(_("NetworkWizard")) + self["list"].l.setList(self.list) + + def setDefaultInterface(self): + selection = self["list"].getCurrent() + num_if = len(self.list) + old_default_gw = None + num_configured_if = len(iNetwork.getConfiguredAdapters()) + if os_path.exists("/etc/default_gw"): + fp = open('/etc/default_gw', 'r') + old_default_gw = fp.read() + fp.close() + if num_configured_if > 1 and (not old_default_gw or old_default_gw != selection[0]): + fp = open('/etc/default_gw', 'w+') + fp.write(selection[0]) + fp.close() + self.restartLan() + elif old_default_gw and num_configured_if < 2: + unlink("/etc/default_gw") + self.restartLan() def okbuttonClick(self): - selection = self["adapterlist"].getCurrent() - print "selection:", selection + selection = self["list"].getCurrent() if selection is not None: - self.session.open(AdapterSetup, selection) + self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetupConfiguration, selection[0]) + + def AdapterSetupClosed(self, *ret): + if len(self.adapters) == 1: + self.close() + else: + self.updateList() + + def NetworkFallback(self): + if iNetwork.configuredNetworkAdapters.has_key('wlan0') is True: + self.session.openWithCallback(self.ErrorMessageClosed, MessageBox, self.wlan_errortext, type = MessageBox.TYPE_INFO,timeout = 10) + if iNetwork.configuredNetworkAdapters.has_key('ath0') is True: + self.session.openWithCallback(self.ErrorMessageClosed, MessageBox, self.wlan_errortext, type = MessageBox.TYPE_INFO,timeout = 10) + else: + self.session.openWithCallback(self.ErrorMessageClosed, MessageBox, self.lan_errortext, type = MessageBox.TYPE_INFO,timeout = 10) + + def ErrorMessageClosed(self, *ret): + if iNetwork.configuredNetworkAdapters.has_key('wlan0') is True: + self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetupConfiguration, 'wlan0') + elif iNetwork.configuredNetworkAdapters.has_key('ath0') is True: + self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetupConfiguration, 'ath0') + else: + self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetupConfiguration, 'eth0') + + def cleanup(self): + iNetwork.stopLinkStateConsole() + iNetwork.stopRestartConsole() + iNetwork.stopGetInterfacesConsole() + + def restartLan(self): + iNetwork.restartNetwork(self.restartLanDataAvail) + self.restartLanRef = self.session.openWithCallback(self.restartfinishedCB, MessageBox, _("Please wait while we configure your network..."), type = MessageBox.TYPE_INFO, enable_input = False) -class NameserverSetup(Screen, ConfigListScreen): + def restartLanDataAvail(self, data): + if data is True: + iNetwork.getInterfaces(self.getInterfacesDataAvail) + + def getInterfacesDataAvail(self, data): + if data is True: + self.restartLanRef.close(True) + + def restartfinishedCB(self,data): + if data is True: + self.updateList() + self.session.open(MessageBox, _("Finished configuring your network"), type = MessageBox.TYPE_INFO, timeout = 10, default = False) + + def openNetworkWizard(self): + if os_path.exists(resolveFilename(SCOPE_PLUGINS, "SystemPlugins/NetworkWizard/networkwizard.xml")): + try: + from Plugins.SystemPlugins.NetworkWizard.NetworkWizard import NetworkWizard + except ImportError: + self.session.open(MessageBox, _("The NetworkWizard extension is not installed!\nPlease install it."), type = MessageBox.TYPE_INFO,timeout = 10 ) + else: + selection = self["list"].getCurrent() + if selection is not None: + self.session.openWithCallback(self.AdapterSetupClosed, NetworkWizard, selection[0]) + + +class NameserverSetup(Screen, ConfigListScreen, HelpableScreen): def __init__(self, session): Screen.__init__(self, session) + HelpableScreen.__init__(self) self.backupNameserverList = iNetwork.getNameserverList()[:] print "backup-list:", self.backupNameserverList - self["red"] = Label(_("Delete")) - self["green"] = Label(_("Add")) - + self["key_red"] = StaticText(_("Cancel")) + self["key_green"] = StaticText(_("Add")) + self["key_yellow"] = StaticText(_("Delete")) + + self["introduction"] = StaticText(_("Press OK to activate the settings.")) self.createConfig() - - self["actions"] = ActionMap(["OkCancelActions", "ColorActions"], + + self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions", + { + "cancel": (self.cancel, _("exit nameserver configuration")), + "ok": (self.ok, _("activate current configuration")), + }) + + self["ColorActions"] = HelpableActionMap(self, "ColorActions", + { + "red": (self.cancel, _("exit nameserver configuration")), + "green": (self.add, _("add a nameserver entry")), + "yellow": (self.remove, _("remove a nameserver entry")), + }) + + self["actions"] = NumberActionMap(["SetupActions"], { "ok": self.ok, - "cancel": self.cancel, - "green": self.add, - "red": self.remove }, -2) self.list = [] ConfigListScreen.__init__(self, self.list) self.createSetup() - + def createConfig(self): self.nameservers = iNetwork.getNameserverList() - self.nameserverEntries = [] - - for nameserver in self.nameservers: - self.nameserverEntries.append(NoSave(ConfigIP(default=nameserver))) - + self.nameserverEntries = [ NoSave(ConfigIP(default=nameserver)) for nameserver in self.nameservers] + def createSetup(self): self.list = [] - #self.nameserverConfigEntries = [] - for i in range(len(self.nameserverEntries)): - self.list.append(getConfigListEntry(_("Nameserver %d") % (i + 1), self.nameserverEntries[i])) - + i = 1 + for x in self.nameserverEntries: + self.list.append(getConfigListEntry(_("Nameserver %d") % (i), x)) + i += 1 + self["config"].list = self.list self["config"].l.setList(self.list) @@ -74,108 +275,320 @@ class NameserverSetup(Screen, ConfigListScreen): iNetwork.addNameserver(nameserver.value) iNetwork.writeNameserverConfig() self.close() - + + def run(self): + self.ok() + def cancel(self): iNetwork.clearNameservers() print "backup-list:", self.backupNameserverList for nameserver in self.backupNameserverList: iNetwork.addNameserver(nameserver) self.close() - + def add(self): iNetwork.addNameserver([0,0,0,0]) self.createConfig() self.createSetup() - + def remove(self): print "currentIndex:", self["config"].getCurrentIndex() - index = self["config"].getCurrentIndex() if index < len(self.nameservers): iNetwork.removeNameserver(self.nameservers[index]) self.createConfig() self.createSetup() - -class AdapterSetup(Screen, ConfigListScreen): - def __init__(self, session, iface): + +class AdapterSetup(Screen, ConfigListScreen, HelpableScreen): + def __init__(self, session, networkinfo, essid=None, aplist=None): Screen.__init__(self, session) - - self.iface = iface + HelpableScreen.__init__(self) + self.session = session + if isinstance(networkinfo, (list, tuple)): + self.iface = networkinfo[0] + self.essid = networkinfo[1] + self.aplist = networkinfo[2] + else: + self.iface = networkinfo + self.essid = essid + self.aplist = aplist + self.extended = None + self.applyConfigRef = None + self.finished_cb = None + self.oktext = _("Press OK on your remote control to continue.") + self.oldInterfaceState = iNetwork.getAdapterAttribute(self.iface, "up") + + self.createConfig() + + self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions", + { + "cancel": (self.keyCancel, _("exit network adapter configuration")), + "ok": (self.keySave, _("activate network adapter configuration")), + }) - print iNetwork.getAdapterAttribute(self.iface, "dhcp") - self.dhcpConfigEntry = NoSave(ConfigYesNo(default=iNetwork.getAdapterAttribute(self.iface, "dhcp"))) - self.hasGatewayConfigEntry = NoSave(ConfigYesNo(default=True)) - self.ipConfigEntry = NoSave(ConfigIP(default=iNetwork.getAdapterAttribute(self.iface, "ip"))) - self.netmaskConfigEntry = NoSave(ConfigIP(default=iNetwork.getAdapterAttribute(self.iface, "netmask"))) - self.gatewayConfigEntry = NoSave(ConfigIP(default=iNetwork.getAdapterAttribute(self.iface, "gateway"))) - - self["iface"] = Label(iNetwork.getAdapterName(self.iface)) - - self["actions"] = ActionMap(["SetupActions"], + self["ColorActions"] = HelpableActionMap(self, "ColorActions", + { + "red": (self.keyCancel, _("exit network adapter configuration")), + "blue": (self.KeyBlue, _("open nameserver configuration")), + }) + + self["actions"] = NumberActionMap(["SetupActions"], { - "ok": self.ok, - "cancel": self.cancel, + "ok": self.keySave, }, -2) self.list = [] - ConfigListScreen.__init__(self, self.list) + ConfigListScreen.__init__(self, self.list,session = self.session) self.createSetup() + self.onLayoutFinish.append(self.layoutFinished) + self.onClose.append(self.cleanup) + + self["DNS1text"] = StaticText(_("Primary DNS")) + self["DNS2text"] = StaticText(_("Secondary DNS")) + self["DNS1"] = StaticText() + self["DNS2"] = StaticText() + self["introduction"] = StaticText(_("Current settings:")) - self["introduction"] = Label(_("Press OK to activate the settings.")) + self["IPtext"] = StaticText(_("IP Address")) + self["Netmasktext"] = StaticText(_("Netmask")) + self["Gatewaytext"] = StaticText(_("Gateway")) + + self["IP"] = StaticText() + self["Mask"] = StaticText() + self["Gateway"] = StaticText() + + self["Adaptertext"] = StaticText(_("Network:")) + self["Adapter"] = StaticText() + self["introduction2"] = StaticText(_("Press OK to activate the settings.")) + self["key_red"] = StaticText(_("Cancel")) + self["key_blue"] = StaticText(_("Edit DNS")) + + self["VKeyIcon"] = Boolean(False) + self["HelpWindow"] = Pixmap() + self["HelpWindow"].hide() + + def layoutFinished(self): + self["DNS1"].setText(self.primaryDNS.getText()) + self["DNS2"].setText(self.secondaryDNS.getText()) + if self.ipConfigEntry.getText() is not None: + if self.ipConfigEntry.getText() == "0.0.0.0": + self["IP"].setText(_("N/A")) + else: + self["IP"].setText(self.ipConfigEntry.getText()) + else: + self["IP"].setText(_("N/A")) + if self.netmaskConfigEntry.getText() is not None: + if self.netmaskConfigEntry.getText() == "0.0.0.0": + self["Mask"].setText(_("N/A")) + else: + self["Mask"].setText(self.netmaskConfigEntry.getText()) + else: + self["IP"].setText(_("N/A")) + if iNetwork.getAdapterAttribute(self.iface, "gateway"): + if self.gatewayConfigEntry.getText() == "0.0.0.0": + self["Gatewaytext"].setText(_("Gateway")) + self["Gateway"].setText(_("N/A")) + else: + self["Gatewaytext"].setText(_("Gateway")) + self["Gateway"].setText(self.gatewayConfigEntry.getText()) + else: + self["Gateway"].setText("") + self["Gatewaytext"].setText("") + self["Adapter"].setText(iNetwork.getFriendlyAdapterName(self.iface)) + + def createConfig(self): + self.InterfaceEntry = None + self.dhcpEntry = None + self.gatewayEntry = None + self.hiddenSSID = None + self.wlanSSID = None + self.encryptionEnabled = None + self.encryptionKey = None + self.encryptionType = None + self.nwlist = None + self.encryptionlist = None + self.weplist = None + self.wsconfig = None + self.default = None + + if self.iface == "wlan0" or self.iface == "ath0" : + from Plugins.SystemPlugins.WirelessLan.Wlan import wpaSupplicant,Wlan + self.w = Wlan(self.iface) + self.ws = wpaSupplicant() + self.encryptionlist = [] + self.encryptionlist.append(("WEP", _("WEP"))) + self.encryptionlist.append(("WPA", _("WPA"))) + self.encryptionlist.append(("WPA2", _("WPA2"))) + self.encryptionlist.append(("WPA/WPA2", _("WPA or WPA2"))) + self.weplist = [] + self.weplist.append("ASCII") + self.weplist.append("HEX") + if self.aplist is not None: + self.nwlist = self.aplist + self.nwlist.sort(key = lambda x: x[0]) + else: + self.nwlist = [] + self.aps = None + try: + self.aps = self.w.getNetworkList() + if self.aps is not None: + for ap in self.aps: + a = self.aps[ap] + if a['active']: + if a['essid'] != '': + self.nwlist.append((a['essid'],a['essid'])) + self.nwlist.sort(key = lambda x: x[0]) + except: + self.nwlist.append(("No Networks found",_("No Networks found"))) + + self.wsconfig = self.ws.loadConfig() + if self.essid is not None: # ssid from wlan scan + self.default = self.essid + else: + self.default = self.wsconfig['ssid'] + + if "hidden..." not in self.nwlist: + self.nwlist.append(("hidden...",_("enter hidden network SSID"))) + if self.default not in self.nwlist: + self.nwlist.append((self.default,self.default)) + config.plugins.wlan.essid = NoSave(ConfigSelection(self.nwlist, default = self.default )) + config.plugins.wlan.hiddenessid = NoSave(ConfigText(default = self.wsconfig['hiddenessid'], visible_width = 50, fixed_size = False)) + + config.plugins.wlan.encryption.enabled = NoSave(ConfigYesNo(default = self.wsconfig['encryption'] )) + config.plugins.wlan.encryption.type = NoSave(ConfigSelection(self.encryptionlist, default = self.wsconfig['encryption_type'] )) + config.plugins.wlan.encryption.wepkeytype = NoSave(ConfigSelection(self.weplist, default = self.wsconfig['encryption_wepkeytype'] )) + config.plugins.wlan.encryption.psk = NoSave(ConfigPassword(default = self.wsconfig['key'], visible_width = 50, fixed_size = False)) + + self.activateInterfaceEntry = NoSave(ConfigYesNo(default=iNetwork.getAdapterAttribute(self.iface, "up") or False)) + self.dhcpConfigEntry = NoSave(ConfigYesNo(default=iNetwork.getAdapterAttribute(self.iface, "dhcp") or False)) + self.ipConfigEntry = NoSave(ConfigIP(default=iNetwork.getAdapterAttribute(self.iface, "ip")) or [0,0,0,0]) + self.netmaskConfigEntry = NoSave(ConfigIP(default=iNetwork.getAdapterAttribute(self.iface, "netmask") or [255,0,0,0])) + if iNetwork.getAdapterAttribute(self.iface, "gateway"): + self.dhcpdefault=True + else: + self.dhcpdefault=False + self.hasGatewayConfigEntry = NoSave(ConfigYesNo(default=self.dhcpdefault or False)) + self.gatewayConfigEntry = NoSave(ConfigIP(default=iNetwork.getAdapterAttribute(self.iface, "gateway") or [0,0,0,0])) + nameserver = (iNetwork.getNameserverList() + [[0,0,0,0]] * 2)[0:2] + self.primaryDNS = NoSave(ConfigIP(default=nameserver[0])) + self.secondaryDNS = NoSave(ConfigIP(default=nameserver[1])) def createSetup(self): self.list = [] + self.InterfaceEntry = getConfigListEntry(_("Use Interface"), self.activateInterfaceEntry) - self.dhcpEntry = getConfigListEntry(_("Use DHCP"), self.dhcpConfigEntry) - self.list.append(self.dhcpEntry) - if not self.dhcpConfigEntry.value: - self.list.append(getConfigListEntry(_('IP Address'), self.ipConfigEntry)) - self.list.append(getConfigListEntry(_('Netmask'), self.netmaskConfigEntry)) - self.list.append(getConfigListEntry(_('Use a gateway'), self.hasGatewayConfigEntry)) - if self.hasGatewayConfigEntry.value: - self.list.append(getConfigListEntry(_('Gateway'), self.gatewayConfigEntry)) - - self.extended = None - self.extendedSetup = None - for p in plugins.getPlugins(PluginDescriptor.WHERE_NETWORKSETUP): - callFnc = p.__call__["ifaceSupported"](self.iface) - if callFnc is not None: - self.extended = callFnc - print p.__call__ - if p.__call__.has_key("configStrings"): - self.configStrings = p.__call__["configStrings"] - else: - self.configStrings = None - - if p.__call__.has_key("menuEntryName"): - menuEntryName = p.__call__["menuEntryName"](self.iface) - else: - menuEntryName = _('Extended Setup...') - self.extendedSetup = getConfigListEntry(menuEntryName, NoSave(ConfigNothing())) - self.list.append(self.extendedSetup) + self.list.append(self.InterfaceEntry) + if self.activateInterfaceEntry.value: + self.dhcpEntry = getConfigListEntry(_("Use DHCP"), self.dhcpConfigEntry) + self.list.append(self.dhcpEntry) + if not self.dhcpConfigEntry.value: + self.list.append(getConfigListEntry(_('IP Address'), self.ipConfigEntry)) + self.list.append(getConfigListEntry(_('Netmask'), self.netmaskConfigEntry)) + self.gatewayEntry = getConfigListEntry(_('Use a gateway'), self.hasGatewayConfigEntry) + self.list.append(self.gatewayEntry) + if self.hasGatewayConfigEntry.value: + self.list.append(getConfigListEntry(_('Gateway'), self.gatewayConfigEntry)) + + self.extended = None + for p in plugins.getPlugins(PluginDescriptor.WHERE_NETWORKSETUP): + callFnc = p.__call__["ifaceSupported"](self.iface) + if callFnc is not None: + if p.__call__.has_key("WlanPluginEntry"): # internally used only for WLAN Plugin + self.extended = callFnc + if p.__call__.has_key("configStrings"): + self.configStrings = p.__call__["configStrings"] + else: + self.configStrings = None + if config.plugins.wlan.essid.value == 'hidden...': + self.wlanSSID = getConfigListEntry(_("Network SSID"), config.plugins.wlan.essid) + self.list.append(self.wlanSSID) + self.hiddenSSID = getConfigListEntry(_("Hidden network SSID"), config.plugins.wlan.hiddenessid) + self.list.append(self.hiddenSSID) + else: + self.wlanSSID = getConfigListEntry(_("Network SSID"), config.plugins.wlan.essid) + self.list.append(self.wlanSSID) + self.encryptionEnabled = getConfigListEntry(_("Encryption"), config.plugins.wlan.encryption.enabled) + self.list.append(self.encryptionEnabled) + + if config.plugins.wlan.encryption.enabled.value: + self.encryptionType = getConfigListEntry(_("Encryption Type"), config.plugins.wlan.encryption.type) + self.list.append(self.encryptionType) + if config.plugins.wlan.encryption.type.value == 'WEP': + self.list.append(getConfigListEntry(_("Encryption Keytype"), config.plugins.wlan.encryption.wepkeytype)) + self.encryptionKey = getConfigListEntry(_("Encryption Key"), config.plugins.wlan.encryption.psk) + self.list.append(self.encryptionKey) + else: + self.encryptionKey = getConfigListEntry(_("Encryption Key"), config.plugins.wlan.encryption.psk) + self.list.append(self.encryptionKey) self["config"].list = self.list self["config"].l.setList(self.list) + def KeyBlue(self): + self.session.openWithCallback(self.NameserverSetupClosed, NameserverSetup) + def newConfig(self): - print self["config"].getCurrent() + if self["config"].getCurrent() == self.InterfaceEntry: + self.createSetup() if self["config"].getCurrent() == self.dhcpEntry: self.createSetup() + if self["config"].getCurrent() == self.gatewayEntry: + self.createSetup() + if self.iface == "wlan0" or self.iface == "ath0" : + if self["config"].getCurrent() == self.wlanSSID: + self.createSetup() + if self["config"].getCurrent() == self.encryptionEnabled: + self.createSetup() + if self["config"].getCurrent() == self.encryptionType: + self.createSetup() def keyLeft(self): ConfigListScreen.keyLeft(self) - self.createSetup() + self.newConfig() def keyRight(self): ConfigListScreen.keyRight(self) - self.createSetup() + self.newConfig() + + def keySave(self): + self.hideInputHelp() + if self["config"].isChanged(): + self.session.openWithCallback(self.keySaveConfirm, MessageBox, (_("Are you sure you want to activate this network configuration?\n\n") + self.oktext ) ) + else: + if self.finished_cb: + self.finished_cb() + else: + self.close('cancel') - def ok(self): - selection = self["config"].getCurrent() - if selection == self.extendedSetup: - self.extended(self.session, self.iface) + def keySaveConfirm(self, ret = False): + if (ret == True): + num_configured_if = len(iNetwork.getConfiguredAdapters()) + if num_configured_if >= 1: + if num_configured_if == 1 and self.iface in iNetwork.getConfiguredAdapters(): + self.applyConfig(True) + else: + self.session.openWithCallback(self.secondIfaceFoundCB, MessageBox, _("A second configured interface has been found.\n\nDo you want to disable the second network interface?"), default = True) + else: + self.applyConfig(True) else: + self.keyCancel() + + def secondIfaceFoundCB(self,data): + if data is False: + self.applyConfig(True) + else: + configuredInterfaces = iNetwork.getConfiguredAdapters() + for interface in configuredInterfaces: + if interface == self.iface: + continue + iNetwork.setAdapterAttribute(interface, "up", False) + iNetwork.deactivateInterface(interface) + self.applyConfig(True) + + def applyConfig(self, ret = False): + if (ret == True): + iNetwork.setAdapterAttribute(self.iface, "up", self.activateInterfaceEntry.value) iNetwork.setAdapterAttribute(self.iface, "dhcp", self.dhcpConfigEntry.value) iNetwork.setAdapterAttribute(self.iface, "ip", self.ipConfigEntry.value) iNetwork.setAdapterAttribute(self.iface, "netmask", self.netmaskConfigEntry.value) @@ -183,15 +596,818 @@ class AdapterSetup(Screen, ConfigListScreen): iNetwork.setAdapterAttribute(self.iface, "gateway", self.gatewayConfigEntry.value) else: iNetwork.removeAdapterAttribute(self.iface, "gateway") - if self.extended is not None and self.configStrings is not None: iNetwork.setAdapterAttribute(self.iface, "configStrings", self.configStrings(self.iface)) + self.ws.writeConfig() + if self.activateInterfaceEntry.value is False: + iNetwork.deactivateInterface(self.iface) + iNetwork.writeNetworkConfig() + iNetwork.restartNetwork(self.applyConfigDataAvail) + self.applyConfigRef = self.session.openWithCallback(self.applyConfigfinishedCB, MessageBox, _("Please wait for activation of your network configuration..."), type = MessageBox.TYPE_INFO, enable_input = False) + else: + self.keyCancel() - iNetwork.deactivateNetworkConfig() - iNetwork.writeNetworkConfig() - iNetwork.activateNetworkConfig() - self.close() + def applyConfigDataAvail(self, data): + if data is True: + iNetwork.getInterfaces(self.getInterfacesDataAvail) + + def getInterfacesDataAvail(self, data): + if data is True: + self.applyConfigRef.close(True) + + def applyConfigfinishedCB(self,data): + if data is True: + if self.finished_cb: + self.session.openWithCallback(lambda x : self.finished_cb(), MessageBox, _("Your network configuration has been activated."), type = MessageBox.TYPE_INFO, timeout = 10) + else: + self.session.openWithCallback(self.ConfigfinishedCB, MessageBox, _("Your network configuration has been activated."), type = MessageBox.TYPE_INFO, timeout = 10) + + def ConfigfinishedCB(self,data): + if data is not None: + if data is True: + self.close('ok') + + def keyCancelConfirm(self, result): + if not result: + return + if self.oldInterfaceState is False: + iNetwork.deactivateInterface(self.iface,self.keyCancelCB) + else: + self.close('cancel') + + def keyCancel(self): + self.hideInputHelp() + if self["config"].isChanged(): + self.session.openWithCallback(self.keyCancelConfirm, MessageBox, _("Really close without saving settings?")) + else: + self.close('cancel') + + def keyCancelCB(self,data): + if data is not None: + if data is True: + self.close('cancel') + + def runAsync(self, finished_cb): + self.finished_cb = finished_cb + self.keySave() + + def NameserverSetupClosed(self, *ret): + iNetwork.loadNameserverConfig() + nameserver = (iNetwork.getNameserverList() + [[0,0,0,0]] * 2)[0:2] + self.primaryDNS = NoSave(ConfigIP(default=nameserver[0])) + self.secondaryDNS = NoSave(ConfigIP(default=nameserver[1])) + self.createSetup() + self.layoutFinished() + + def cleanup(self): + iNetwork.stopLinkStateConsole() + + def hideInputHelp(self): + current = self["config"].getCurrent() + if current == self.hiddenSSID and config.plugins.wlan.essid.value == 'hidden...': + if current[1].help_window.instance is not None: + current[1].help_window.instance.hide() + elif current == self.encryptionKey and config.plugins.wlan.encryption.enabled.value: + if current[1].help_window.instance is not None: + current[1].help_window.instance.hide() + + +class AdapterSetupConfiguration(Screen, HelpableScreen): + def __init__(self, session,iface): + Screen.__init__(self, session) + HelpableScreen.__init__(self) + self.session = session + self.iface = iface + self.restartLanRef = None + self.LinkState = None + self.mainmenu = self.genMainMenu() + self["menulist"] = MenuList(self.mainmenu) + self["key_red"] = StaticText(_("Close")) + self["description"] = StaticText() + self["IFtext"] = StaticText() + self["IF"] = StaticText() + self["Statustext"] = StaticText() + self["statuspic"] = MultiPixmap() + self["statuspic"].hide() + + self.oktext = _("Press OK on your remote control to continue.") + self.reboottext = _("Your Dreambox will restart after pressing OK on your remote control.") + self.errortext = _("No working wireless network interface found.\n Please verify that you have attached a compatible WLAN device or enable your local network interface.") + + self["WizardActions"] = HelpableActionMap(self, "WizardActions", + { + "up": (self.up, _("move up to previous entry")), + "down": (self.down, _("move down to next entry")), + "left": (self.left, _("move up to first entry")), + "right": (self.right, _("move down to last entry")), + }) + + self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions", + { + "cancel": (self.close, _("exit networkadapter setup menu")), + "ok": (self.ok, _("select menu entry")), + }) + + self["ColorActions"] = HelpableActionMap(self, "ColorActions", + { + "red": (self.close, _("exit networkadapter setup menu")), + }) + + self["actions"] = NumberActionMap(["WizardActions","ShortcutActions"], + { + "ok": self.ok, + "back": self.close, + "up": self.up, + "down": self.down, + "red": self.close, + "left": self.left, + "right": self.right, + }, -2) + + self.updateStatusbar() + self.onLayoutFinish.append(self.layoutFinished) + self.onClose.append(self.cleanup) + + def ok(self): + self.cleanup() + if self["menulist"].getCurrent()[1] == 'edit': + if self.iface == 'wlan0' or self.iface == 'ath0': + try: + from Plugins.SystemPlugins.WirelessLan.plugin import WlanScan + from Plugins.SystemPlugins.WirelessLan.iwlibs import Wireless + except ImportError: + self.session.open(MessageBox, _("The wireless LAN plugin is not installed!\nPlease install it."), type = MessageBox.TYPE_INFO,timeout = 10 ) + else: + ifobj = Wireless(self.iface) # a Wireless NIC Object + self.wlanresponse = ifobj.getStatistics() + if self.wlanresponse[0] != 19: # Wlan Interface found. + self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetup,self.iface) + else: + # Display Wlan not available Message + self.showErrorMessage() + else: + self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetup,self.iface) + if self["menulist"].getCurrent()[1] == 'test': + self.session.open(NetworkAdapterTest,self.iface) + if self["menulist"].getCurrent()[1] == 'dns': + self.session.open(NameserverSetup) + if self["menulist"].getCurrent()[1] == 'scanwlan': + try: + from Plugins.SystemPlugins.WirelessLan.plugin import WlanScan + from Plugins.SystemPlugins.WirelessLan.iwlibs import Wireless + except ImportError: + self.session.open(MessageBox, _("The wireless LAN plugin is not installed!\nPlease install it."), type = MessageBox.TYPE_INFO,timeout = 10 ) + else: + ifobj = Wireless(self.iface) # a Wireless NIC Object + self.wlanresponse = ifobj.getStatistics() + if self.wlanresponse[0] != 19: + self.session.openWithCallback(self.WlanScanClosed, WlanScan, self.iface) + else: + # Display Wlan not available Message + self.showErrorMessage() + if self["menulist"].getCurrent()[1] == 'wlanstatus': + try: + from Plugins.SystemPlugins.WirelessLan.plugin import WlanStatus + from Plugins.SystemPlugins.WirelessLan.iwlibs import Wireless + except ImportError: + self.session.open(MessageBox, _("The wireless LAN plugin is not installed!\nPlease install it."), type = MessageBox.TYPE_INFO,timeout = 10 ) + else: + ifobj = Wireless(self.iface) # a Wireless NIC Object + self.wlanresponse = ifobj.getStatistics() + if self.wlanresponse[0] != 19: + self.session.openWithCallback(self.WlanStatusClosed, WlanStatus,self.iface) + else: + # Display Wlan not available Message + self.showErrorMessage() + if self["menulist"].getCurrent()[1] == 'lanrestart': + self.session.openWithCallback(self.restartLan, MessageBox, (_("Are you sure you want to restart your network interfaces?\n\n") + self.oktext ) ) + if self["menulist"].getCurrent()[1] == 'openwizard': + from Plugins.SystemPlugins.NetworkWizard.NetworkWizard import NetworkWizard + self.session.openWithCallback(self.AdapterSetupClosed, NetworkWizard, self.iface) + if self["menulist"].getCurrent()[1][0] == 'extendedSetup': + self.extended = self["menulist"].getCurrent()[1][2] + self.extended(self.session, self.iface) + + def up(self): + self["menulist"].up() + self.loadDescription() + + def down(self): + self["menulist"].down() + self.loadDescription() + + def left(self): + self["menulist"].pageUp() + self.loadDescription() + + def right(self): + self["menulist"].pageDown() + self.loadDescription() + + def layoutFinished(self): + idx = 0 + self["menulist"].moveToIndex(idx) + self.loadDescription() + + def loadDescription(self): + if self["menulist"].getCurrent()[1] == 'edit': + self["description"].setText(_("Edit the network configuration of your Dreambox.\n" ) + self.oktext ) + if self["menulist"].getCurrent()[1] == 'test': + self["description"].setText(_("Test the network configuration of your Dreambox.\n" ) + self.oktext ) + if self["menulist"].getCurrent()[1] == 'dns': + self["description"].setText(_("Edit the Nameserver configuration of your Dreambox.\n" ) + self.oktext ) + if self["menulist"].getCurrent()[1] == 'scanwlan': + self["description"].setText(_("Scan your network for wireless Access Points and connect to them using your selected wireless device.\n" ) + self.oktext ) + if self["menulist"].getCurrent()[1] == 'wlanstatus': + self["description"].setText(_("Shows the state of your wireless LAN connection.\n" ) + self.oktext ) + if self["menulist"].getCurrent()[1] == 'lanrestart': + self["description"].setText(_("Restart your network connection and interfaces.\n" ) + self.oktext ) + if self["menulist"].getCurrent()[1] == 'openwizard': + self["description"].setText(_("Use the Networkwizard to configure your Network\n" ) + self.oktext ) + if self["menulist"].getCurrent()[1][0] == 'extendedSetup': + self["description"].setText(_(self["menulist"].getCurrent()[1][1]) + self.oktext ) + + def updateStatusbar(self, data = None): + self.mainmenu = self.genMainMenu() + self["menulist"].l.setList(self.mainmenu) + self["IFtext"].setText(_("Network:")) + self["IF"].setText(iNetwork.getFriendlyAdapterName(self.iface)) + self["Statustext"].setText(_("Link:")) + + if self.iface == 'wlan0' or self.iface == 'ath0': + try: + from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus + except: + self["statuspic"].setPixmapNum(1) + self["statuspic"].show() + else: + iStatus.getDataForInterface(self.iface,self.getInfoCB) + else: + iNetwork.getLinkState(self.iface,self.dataAvail) + + def doNothing(self): + pass + + def genMainMenu(self): + menu = [] + menu.append((_("Adapter settings"), "edit")) + menu.append((_("Nameserver settings"), "dns")) + menu.append((_("Network test"), "test")) + menu.append((_("Restart network"), "lanrestart")) + + self.extended = None + self.extendedSetup = None + for p in plugins.getPlugins(PluginDescriptor.WHERE_NETWORKSETUP): + callFnc = p.__call__["ifaceSupported"](self.iface) + if callFnc is not None: + self.extended = callFnc + if p.__call__.has_key("WlanPluginEntry"): # internally used only for WLAN Plugin + menu.append((_("Scan Wireless Networks"), "scanwlan")) + if iNetwork.getAdapterAttribute(self.iface, "up"): + menu.append((_("Show WLAN Status"), "wlanstatus")) + else: + if p.__call__.has_key("menuEntryName"): + menuEntryName = p.__call__["menuEntryName"](self.iface) + else: + menuEntryName = _('Extended Setup...') + if p.__call__.has_key("menuEntryDescription"): + menuEntryDescription = p.__call__["menuEntryDescription"](self.iface) + else: + menuEntryDescription = _('Extended Networksetup Plugin...') + self.extendedSetup = ('extendedSetup',menuEntryDescription, self.extended) + menu.append((menuEntryName,self.extendedSetup)) + + if os_path.exists(resolveFilename(SCOPE_PLUGINS, "SystemPlugins/NetworkWizard/networkwizard.xml")): + menu.append((_("NetworkWizard"), "openwizard")) + + return menu + + def AdapterSetupClosed(self, *ret): + if ret is not None and len(ret): + if ret[0] == 'ok' and (self.iface == 'wlan0' or self.iface == 'ath0') and iNetwork.getAdapterAttribute(self.iface, "up") is True: + try: + from Plugins.SystemPlugins.WirelessLan.plugin import WlanStatus + from Plugins.SystemPlugins.WirelessLan.iwlibs import Wireless + except ImportError: + self.session.open(MessageBox, _("The wireless LAN plugin is not installed!\nPlease install it."), type = MessageBox.TYPE_INFO,timeout = 10 ) + else: + ifobj = Wireless(self.iface) # a Wireless NIC Object + self.wlanresponse = ifobj.getStatistics() + if self.wlanresponse[0] != 19: + self.session.openWithCallback(self.WlanStatusClosed, WlanStatus,self.iface) + else: + # Display Wlan not available Message + self.showErrorMessage() + else: + self.updateStatusbar() + else: + self.updateStatusbar() + + def WlanStatusClosed(self, *ret): + if ret is not None and len(ret): + from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus,Status + iStatus.stopWlanConsole() + self.updateStatusbar() + + def WlanScanClosed(self,*ret): + if ret[0] is not None: + self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetup, self.iface,ret[0],ret[1]) + else: + from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus,Status + iStatus.stopWlanConsole() + self.updateStatusbar() + + def restartLan(self, ret = False): + if (ret == True): + iNetwork.restartNetwork(self.restartLanDataAvail) + self.restartLanRef = self.session.openWithCallback(self.restartfinishedCB, MessageBox, _("Please wait while your network is restarting..."), type = MessageBox.TYPE_INFO, enable_input = False) + + def restartLanDataAvail(self, data): + if data is True: + iNetwork.getInterfaces(self.getInterfacesDataAvail) + + def getInterfacesDataAvail(self, data): + if data is True: + self.restartLanRef.close(True) + + def restartfinishedCB(self,data): + if data is True: + self.updateStatusbar() + self.session.open(MessageBox, _("Finished restarting your network"), type = MessageBox.TYPE_INFO, timeout = 10, default = False) + + def dataAvail(self,data): + self.LinkState = None + for line in data.splitlines(): + line = line.strip() + if 'Link detected:' in line: + if "yes" in line: + self.LinkState = True + else: + self.LinkState = False + if self.LinkState == True: + iNetwork.checkNetworkState(self.checkNetworkCB) + else: + self["statuspic"].setPixmapNum(1) + self["statuspic"].show() + + def showErrorMessage(self): + self.session.open(MessageBox, self.errortext, type = MessageBox.TYPE_INFO,timeout = 10 ) + + def cleanup(self): + iNetwork.stopLinkStateConsole() + iNetwork.stopDeactivateInterfaceConsole() + iNetwork.stopPingConsole() + try: + from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus + except ImportError: + pass + else: + iStatus.stopWlanConsole() + + def getInfoCB(self,data,status): + self.LinkState = None + if data is not None: + if data is True: + if status is not None: + if status[self.iface]["acesspoint"] == "No Connection" or status[self.iface]["acesspoint"] == "Not-Associated" or status[self.iface]["acesspoint"] == False: + self.LinkState = False + self["statuspic"].setPixmapNum(1) + self["statuspic"].show() + else: + self.LinkState = True + iNetwork.checkNetworkState(self.checkNetworkCB) + + def checkNetworkCB(self,data): + if iNetwork.getAdapterAttribute(self.iface, "up") is True: + if self.LinkState is True: + if data <= 2: + self["statuspic"].setPixmapNum(0) + else: + self["statuspic"].setPixmapNum(1) + self["statuspic"].show() + else: + self["statuspic"].setPixmapNum(1) + self["statuspic"].show() + else: + self["statuspic"].setPixmapNum(1) + self["statuspic"].show() + + +class NetworkAdapterTest(Screen): + def __init__(self, session,iface): + Screen.__init__(self, session) + self.iface = iface + self.oldInterfaceState = iNetwork.getAdapterAttribute(self.iface, "up") + self.setLabels() + self.onClose.append(self.cleanup) + self.onHide.append(self.cleanup) + + self["updown_actions"] = NumberActionMap(["WizardActions","ShortcutActions"], + { + "ok": self.KeyOK, + "blue": self.KeyOK, + "up": lambda: self.updownhandler('up'), + "down": lambda: self.updownhandler('down'), + + }, -2) + + self["shortcuts"] = ActionMap(["ShortcutActions","WizardActions"], + { + "red": self.cancel, + "back": self.cancel, + }, -2) + self["infoshortcuts"] = ActionMap(["ShortcutActions","WizardActions"], + { + "red": self.closeInfo, + "back": self.closeInfo, + }, -2) + self["shortcutsgreen"] = ActionMap(["ShortcutActions"], + { + "green": self.KeyGreen, + }, -2) + self["shortcutsgreen_restart"] = ActionMap(["ShortcutActions"], + { + "green": self.KeyGreenRestart, + }, -2) + self["shortcutsyellow"] = ActionMap(["ShortcutActions"], + { + "yellow": self.KeyYellow, + }, -2) + + self["shortcutsgreen_restart"].setEnabled(False) + self["updown_actions"].setEnabled(False) + self["infoshortcuts"].setEnabled(False) + self.onClose.append(self.delTimer) + self.onLayoutFinish.append(self.layoutFinished) + self.steptimer = False + self.nextstep = 0 + self.activebutton = 0 + self.nextStepTimer = eTimer() + self.nextStepTimer.callback.append(self.nextStepTimerFire) def cancel(self): - iNetwork.getInterfaces() + if self.oldInterfaceState is False: + iNetwork.setAdapterAttribute(self.iface, "up", self.oldInterfaceState) + iNetwork.deactivateInterface(self.iface) self.close() + + def closeInfo(self): + self["shortcuts"].setEnabled(True) + self["infoshortcuts"].setEnabled(False) + self["InfoText"].hide() + self["InfoTextBorder"].hide() + self["key_red"].setText(_("Close")) + + def delTimer(self): + del self.steptimer + del self.nextStepTimer + + def nextStepTimerFire(self): + self.nextStepTimer.stop() + self.steptimer = False + self.runTest() + + def updownhandler(self,direction): + if direction == 'up': + if self.activebutton >=2: + self.activebutton -= 1 + else: + self.activebutton = 6 + self.setActiveButton(self.activebutton) + if direction == 'down': + if self.activebutton <=5: + self.activebutton += 1 + else: + self.activebutton = 1 + self.setActiveButton(self.activebutton) + + def setActiveButton(self,button): + if button == 1: + self["EditSettingsButton"].setPixmapNum(0) + self["EditSettings_Text"].setForegroundColorNum(0) + self["NetworkInfo"].setPixmapNum(0) + self["NetworkInfo_Text"].setForegroundColorNum(1) + self["AdapterInfo"].setPixmapNum(1) # active + self["AdapterInfo_Text"].setForegroundColorNum(2) # active + if button == 2: + self["AdapterInfo_Text"].setForegroundColorNum(1) + self["AdapterInfo"].setPixmapNum(0) + self["DhcpInfo"].setPixmapNum(0) + self["DhcpInfo_Text"].setForegroundColorNum(1) + self["NetworkInfo"].setPixmapNum(1) # active + self["NetworkInfo_Text"].setForegroundColorNum(2) # active + if button == 3: + self["NetworkInfo"].setPixmapNum(0) + self["NetworkInfo_Text"].setForegroundColorNum(1) + self["IPInfo"].setPixmapNum(0) + self["IPInfo_Text"].setForegroundColorNum(1) + self["DhcpInfo"].setPixmapNum(1) # active + self["DhcpInfo_Text"].setForegroundColorNum(2) # active + if button == 4: + self["DhcpInfo"].setPixmapNum(0) + self["DhcpInfo_Text"].setForegroundColorNum(1) + self["DNSInfo"].setPixmapNum(0) + self["DNSInfo_Text"].setForegroundColorNum(1) + self["IPInfo"].setPixmapNum(1) # active + self["IPInfo_Text"].setForegroundColorNum(2) # active + if button == 5: + self["IPInfo"].setPixmapNum(0) + self["IPInfo_Text"].setForegroundColorNum(1) + self["EditSettingsButton"].setPixmapNum(0) + self["EditSettings_Text"].setForegroundColorNum(0) + self["DNSInfo"].setPixmapNum(1) # active + self["DNSInfo_Text"].setForegroundColorNum(2) # active + if button == 6: + self["DNSInfo"].setPixmapNum(0) + self["DNSInfo_Text"].setForegroundColorNum(1) + self["EditSettingsButton"].setPixmapNum(1) # active + self["EditSettings_Text"].setForegroundColorNum(2) # active + self["AdapterInfo"].setPixmapNum(0) + self["AdapterInfo_Text"].setForegroundColorNum(1) + + def runTest(self): + next = self.nextstep + if next == 0: + self.doStep1() + elif next == 1: + self.doStep2() + elif next == 2: + self.doStep3() + elif next == 3: + self.doStep4() + elif next == 4: + self.doStep5() + elif next == 5: + self.doStep6() + self.nextstep += 1 + + def doStep1(self): + self.steptimer = True + self.nextStepTimer.start(3000) + self["key_yellow"].setText(_("Stop test")) + + def doStep2(self): + self["Adapter"].setText(iNetwork.getFriendlyAdapterName(self.iface)) + self["Adapter"].setForegroundColorNum(2) + self["Adaptertext"].setForegroundColorNum(1) + self["AdapterInfo_Text"].setForegroundColorNum(1) + self["AdapterInfo_OK"].show() + self.steptimer = True + self.nextStepTimer.start(3000) + + def doStep3(self): + self["Networktext"].setForegroundColorNum(1) + self["Network"].setText(_("Please wait...")) + self.getLinkState(self.iface) + self["NetworkInfo_Text"].setForegroundColorNum(1) + self.steptimer = True + self.nextStepTimer.start(3000) + + def doStep4(self): + self["Dhcptext"].setForegroundColorNum(1) + if iNetwork.getAdapterAttribute(self.iface, 'dhcp') is True: + self["Dhcp"].setForegroundColorNum(2) + self["Dhcp"].setText(_("enabled")) + self["DhcpInfo_Check"].setPixmapNum(0) + else: + self["Dhcp"].setForegroundColorNum(1) + self["Dhcp"].setText(_("disabled")) + self["DhcpInfo_Check"].setPixmapNum(1) + self["DhcpInfo_Check"].show() + self["DhcpInfo_Text"].setForegroundColorNum(1) + self.steptimer = True + self.nextStepTimer.start(3000) + + def doStep5(self): + self["IPtext"].setForegroundColorNum(1) + self["IP"].setText(_("Please wait...")) + iNetwork.checkNetworkState(self.NetworkStatedataAvail) + + def doStep6(self): + self.steptimer = False + self.nextStepTimer.stop() + self["DNStext"].setForegroundColorNum(1) + self["DNS"].setText(_("Please wait...")) + iNetwork.checkDNSLookup(self.DNSLookupdataAvail) + + def KeyGreen(self): + self["shortcutsgreen"].setEnabled(False) + self["shortcutsyellow"].setEnabled(True) + self["updown_actions"].setEnabled(False) + self["key_yellow"].setText("") + self["key_green"].setText("") + self.steptimer = True + self.nextStepTimer.start(1000) + + def KeyGreenRestart(self): + self.nextstep = 0 + self.layoutFinished() + self["Adapter"].setText(("")) + self["Network"].setText(("")) + self["Dhcp"].setText(("")) + self["IP"].setText(("")) + self["DNS"].setText(("")) + self["AdapterInfo_Text"].setForegroundColorNum(0) + self["NetworkInfo_Text"].setForegroundColorNum(0) + self["DhcpInfo_Text"].setForegroundColorNum(0) + self["IPInfo_Text"].setForegroundColorNum(0) + self["DNSInfo_Text"].setForegroundColorNum(0) + self["shortcutsgreen_restart"].setEnabled(False) + self["shortcutsgreen"].setEnabled(False) + self["shortcutsyellow"].setEnabled(True) + self["updown_actions"].setEnabled(False) + self["key_yellow"].setText("") + self["key_green"].setText("") + self.steptimer = True + self.nextStepTimer.start(1000) + + def KeyOK(self): + self["infoshortcuts"].setEnabled(True) + self["shortcuts"].setEnabled(False) + if self.activebutton == 1: # Adapter Check + self["InfoText"].setText(_("This test detects your configured LAN-Adapter.")) + self["InfoTextBorder"].show() + self["InfoText"].show() + self["key_red"].setText(_("Back")) + if self.activebutton == 2: #LAN Check + self["InfoText"].setText(_("This test checks whether a network cable is connected to your LAN-Adapter.\nIf you get a \"disconnected\" message:\n- verify that a network cable is attached\n- verify that the cable is not broken")) + self["InfoTextBorder"].show() + self["InfoText"].show() + self["key_red"].setText(_("Back")) + if self.activebutton == 3: #DHCP Check + self["InfoText"].setText(_("This test checks whether your LAN Adapter is set up for automatic IP Address configuration with DHCP.\nIf you get a \"disabled\" message:\n - then your LAN Adapter is configured for manual IP Setup\n- verify thay you have entered correct IP informations in the AdapterSetup dialog.\nIf you get an \"enabeld\" message:\n-verify that you have a configured and working DHCP Server in your network.")) + self["InfoTextBorder"].show() + self["InfoText"].show() + self["key_red"].setText(_("Back")) + if self.activebutton == 4: # IP Check + self["InfoText"].setText(_("This test checks whether a valid IP Address is found for your LAN Adapter.\nIf you get a \"unconfirmed\" message:\n- no valid IP Address was found\n- please check your DHCP, cabling and adapter setup")) + self["InfoTextBorder"].show() + self["InfoText"].show() + self["key_red"].setText(_("Back")) + if self.activebutton == 5: # DNS Check + self["InfoText"].setText(_("This test checks for configured Nameservers.\nIf you get a \"unconfirmed\" message:\n- please check your DHCP, cabling and Adapter setup\n- if you configured your Nameservers manually please verify your entries in the \"Nameserver\" Configuration")) + self["InfoTextBorder"].show() + self["InfoText"].show() + self["key_red"].setText(_("Back")) + if self.activebutton == 6: # Edit Settings + self.session.open(AdapterSetup,self.iface) + + def KeyYellow(self): + self.nextstep = 0 + self["shortcutsgreen_restart"].setEnabled(True) + self["shortcutsgreen"].setEnabled(False) + self["shortcutsyellow"].setEnabled(False) + self["key_green"].setText(_("Restart test")) + self["key_yellow"].setText("") + self.steptimer = False + self.nextStepTimer.stop() + + def layoutFinished(self): + self["shortcutsyellow"].setEnabled(False) + self["AdapterInfo_OK"].hide() + self["NetworkInfo_Check"].hide() + self["DhcpInfo_Check"].hide() + self["IPInfo_Check"].hide() + self["DNSInfo_Check"].hide() + self["EditSettings_Text"].hide() + self["EditSettingsButton"].hide() + self["InfoText"].hide() + self["InfoTextBorder"].hide() + self["key_yellow"].setText("") + + def setLabels(self): + self["Adaptertext"] = MultiColorLabel(_("LAN Adapter")) + self["Adapter"] = MultiColorLabel() + self["AdapterInfo"] = MultiPixmap() + self["AdapterInfo_Text"] = MultiColorLabel(_("Show Info")) + self["AdapterInfo_OK"] = Pixmap() + + if self.iface == 'wlan0' or self.iface == 'ath0': + self["Networktext"] = MultiColorLabel(_("Wireless Network")) + else: + self["Networktext"] = MultiColorLabel(_("Local Network")) + + self["Network"] = MultiColorLabel() + self["NetworkInfo"] = MultiPixmap() + self["NetworkInfo_Text"] = MultiColorLabel(_("Show Info")) + self["NetworkInfo_Check"] = MultiPixmap() + + self["Dhcptext"] = MultiColorLabel(_("DHCP")) + self["Dhcp"] = MultiColorLabel() + self["DhcpInfo"] = MultiPixmap() + self["DhcpInfo_Text"] = MultiColorLabel(_("Show Info")) + self["DhcpInfo_Check"] = MultiPixmap() + + self["IPtext"] = MultiColorLabel(_("IP Address")) + self["IP"] = MultiColorLabel() + self["IPInfo"] = MultiPixmap() + self["IPInfo_Text"] = MultiColorLabel(_("Show Info")) + self["IPInfo_Check"] = MultiPixmap() + + self["DNStext"] = MultiColorLabel(_("Nameserver")) + self["DNS"] = MultiColorLabel() + self["DNSInfo"] = MultiPixmap() + self["DNSInfo_Text"] = MultiColorLabel(_("Show Info")) + self["DNSInfo_Check"] = MultiPixmap() + + self["EditSettings_Text"] = MultiColorLabel(_("Edit settings")) + self["EditSettingsButton"] = MultiPixmap() + + self["key_red"] = StaticText(_("Close")) + self["key_green"] = StaticText(_("Start test")) + self["key_yellow"] = StaticText(_("Stop test")) + + self["InfoTextBorder"] = Pixmap() + self["InfoText"] = Label() + + def getLinkState(self,iface): + if iface == 'wlan0' or iface == 'ath0': + try: + from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus,Status + except: + self["Network"].setForegroundColorNum(1) + self["Network"].setText(_("disconnected")) + self["NetworkInfo_Check"].setPixmapNum(1) + self["NetworkInfo_Check"].show() + else: + iStatus.getDataForInterface(self.iface,self.getInfoCB) + else: + iNetwork.getLinkState(iface,self.LinkStatedataAvail) + + def LinkStatedataAvail(self,data): + self.output = data.strip() + result = self.output.split('\n') + pattern = re_compile("Link detected: yes") + for item in result: + if re_search(pattern, item): + self["Network"].setForegroundColorNum(2) + self["Network"].setText(_("connected")) + self["NetworkInfo_Check"].setPixmapNum(0) + else: + self["Network"].setForegroundColorNum(1) + self["Network"].setText(_("disconnected")) + self["NetworkInfo_Check"].setPixmapNum(1) + self["NetworkInfo_Check"].show() + + def NetworkStatedataAvail(self,data): + if data <= 2: + self["IP"].setForegroundColorNum(2) + self["IP"].setText(_("confirmed")) + self["IPInfo_Check"].setPixmapNum(0) + else: + self["IP"].setForegroundColorNum(1) + self["IP"].setText(_("unconfirmed")) + self["IPInfo_Check"].setPixmapNum(1) + self["IPInfo_Check"].show() + self["IPInfo_Text"].setForegroundColorNum(1) + self.steptimer = True + self.nextStepTimer.start(3000) + + def DNSLookupdataAvail(self,data): + if data <= 2: + self["DNS"].setForegroundColorNum(2) + self["DNS"].setText(_("confirmed")) + self["DNSInfo_Check"].setPixmapNum(0) + else: + self["DNS"].setForegroundColorNum(1) + self["DNS"].setText(_("unconfirmed")) + self["DNSInfo_Check"].setPixmapNum(1) + self["DNSInfo_Check"].show() + self["DNSInfo_Text"].setForegroundColorNum(1) + self["EditSettings_Text"].show() + self["EditSettingsButton"].setPixmapNum(1) + self["EditSettings_Text"].setForegroundColorNum(2) # active + self["EditSettingsButton"].show() + self["key_yellow"].setText("") + self["key_green"].setText(_("Restart test")) + self["shortcutsgreen"].setEnabled(False) + self["shortcutsgreen_restart"].setEnabled(True) + self["shortcutsyellow"].setEnabled(False) + self["updown_actions"].setEnabled(True) + self.activebutton = 6 + + def getInfoCB(self,data,status): + if data is not None: + if data is True: + if status is not None: + if status[self.iface]["acesspoint"] == "No Connection" or status[self.iface]["acesspoint"] == "Not-Associated" or status[self.iface]["acesspoint"] == False: + self["Network"].setForegroundColorNum(1) + self["Network"].setText(_("disconnected")) + self["NetworkInfo_Check"].setPixmapNum(1) + self["NetworkInfo_Check"].show() + else: + self["Network"].setForegroundColorNum(2) + self["Network"].setText(_("connected")) + self["NetworkInfo_Check"].setPixmapNum(0) + self["NetworkInfo_Check"].show() + + def cleanup(self): + iNetwork.stopLinkStateConsole() + iNetwork.stopDNSConsole() + try: + from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus,Status + except ImportError: + pass + else: + iStatus.stopWlanConsole() +