X-Git-Url: https://git.cweiske.de/enigma2.git/blobdiff_plain/0757605627e161bd9c666b6434ab5ace536565d1..baedb13351c92deaf80c2b1bc012054c8cc69bdc:/lib/python/Components/Network.py diff --git a/lib/python/Components/Network.py b/lib/python/Components/Network.py old mode 100644 new mode 100755 index d94fa30c..32b8bdbe --- a/lib/python/Components/Network.py +++ b/lib/python/Components/Network.py @@ -1,41 +1,57 @@ from os import system, popen, path as os_path, listdir -from re import compile as re_compile +from re import compile as re_compile, search as re_search from socket import * from enigma import eConsoleAppContainer +from Components.Console import Console +from Components.PluginComponent import plugins +from Components.About import about +from Plugins.Plugin import PluginDescriptor class Network: def __init__(self): self.ifaces = {} - self.configuredInterfaces = {} + self.configuredInterfaces = [] + self.configuredNetworkAdapters = [] + self.NetworkState = 0 + self.DnsState = 0 self.nameservers = [] - self.getInterfaces() - self.ethtool_bin = "/usr/sbin/ethtool" + self.ethtool_bin = "ethtool" self.container = eConsoleAppContainer() + self.Console = Console() + self.LinkConsole = Console() + self.restartConsole = Console() + self.deactivateInterfaceConsole = Console() + self.activateInterfaceConsole = Console() + self.resetNetworkConsole = Console() + self.DnsConsole = Console() + self.PingConsole = Console() + self.config_ready = None + self.friendlyNames = {} + self.lan_interfaces = [] + self.wlan_interfaces = [] + self.remoteRootFS = None + self.getInterfaces() - def getInterfaces(self): - devicesPattern = re_compile('[a-z]+[0-9]+') - - fp = file('/proc/net/dev', 'r') - result = fp.readlines() - fp.close() - for line in result: - try: - device = devicesPattern.search(line).group() - if device == 'wifi0': - continue - self.ifaces[device] = self.getDataForInterface(device) - # Show only UP Interfaces in E2 - #if self.getAdapterAttribute(device, 'up') is False: - # del self.ifaces[device] - except AttributeError: - pass - - print "self.ifaces:", self.ifaces - self.loadNetworkConfig() - #self.writeNetworkConfig() - #print ord(' ') - #for line in result: - # print ord(line[0]) + def onRemoteRootFS(self): + if self.remoteRootFS == None: + fp = file('/proc/mounts', 'r') + mounts = fp.readlines() + fp.close() + self.remoteRootFS = False + for line in mounts: + parts = line.strip().split() + if parts[1] == '/' and parts[2] == 'nfs': + self.remoteRootFS = True + break + return self.remoteRootFS + + def isBlacklisted(self, iface): + return iface in ('lo', 'wifi0', 'wmaster0') + + def getInterfaces(self, callback = None): + self.configuredInterfaces = [] + for device in self.getInstalledAdapters(): + self.getAddrInet(device, callback) # helper function def regExpMatch(self, pattern, string): @@ -44,64 +60,84 @@ class Network: try: return pattern.search(string).group() except AttributeError: - None + return None # helper function to convert ips from a sring to a list of ints def convertIP(self, ip): - strIP = ip.split('.') - ip = [] - for x in strIP: - ip.append(int(x)) - return ip - - def getDataForInterface(self, iface): - #ipRegexp = '[0-9]{1,2,3}\.[0-9]{1,2,3}\.[0-9]{1,2,3}\.[0-9]{1,2,3}' + return [ int(n) for n in ip.split('.') ] + + def getAddrInet(self, iface, callback): + if not self.Console: + self.Console = Console() + cmd = "ip -o addr show dev " + iface + self.Console.ePopen(cmd, self.IPaddrFinished, [iface,callback]) + + def IPaddrFinished(self, result, retval, extra_args): + (iface, callback ) = extra_args + data = { 'up': False, 'dhcp': False, 'preup' : False, 'predown' : False } + globalIPpattern = re_compile("scope global") ipRegexp = '[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}' - ipLinePattern = re_compile('inet addr:' + ipRegexp) - netmaskLinePattern = re_compile('Mask:' + ipRegexp) - bcastLinePattern = re_compile('Bcast:' + ipRegexp) + netRegexp = '[0-9]{1,2}' + macRegexp = '[0-9a-fA-F]{2}\:[0-9a-fA-F]{2}\:[0-9a-fA-F]{2}\:[0-9a-fA-F]{2}\:[0-9a-fA-F]{2}\:[0-9a-fA-F]{2}' + ipLinePattern = re_compile('inet ' + ipRegexp + '/') ipPattern = re_compile(ipRegexp) - upPattern = re_compile('UP ') - macPattern = re_compile('[0-9]{2}\:[0-9]{2}\:[0-9]{2}\:[0-9]{2}\:[0-9]{2}\:[0-9]{2}') + netmaskLinePattern = re_compile('/' + netRegexp) + netmaskPattern = re_compile(netRegexp) + bcastLinePattern = re_compile(' brd ' + ipRegexp) + upPattern = re_compile('UP') + macPattern = re_compile(macRegexp) + macLinePattern = re_compile('link/ether ' + macRegexp) - fp = popen("ifconfig " + iface) - result = fp.readlines() - fp.close() - data = { 'up': False, 'dhcp': False } - for line in result: - ip = self.regExpMatch(ipPattern, self.regExpMatch(ipLinePattern, line)) - netmask = self.regExpMatch(ipPattern, self.regExpMatch(netmaskLinePattern, line)) - bcast = self.regExpMatch(ipPattern, self.regExpMatch(bcastLinePattern, line)) - up = self.regExpMatch(upPattern, line) - mac = self.regExpMatch(macPattern, line) - if ip is not None: - data['ip'] = self.convertIP(ip) - if netmask is not None: - data['netmask'] = self.convertIP(netmask) - if bcast is not None: - data['bcast'] = self.convertIP(bcast) - if up is not None: - data['up'] = True - if mac is not None: - data['mac'] = mac + for line in result.splitlines(): + split = line.strip().split(' ',2) + if (split[1][:-1] == iface): + up = self.regExpMatch(upPattern, split[2]) + mac = self.regExpMatch(macPattern, self.regExpMatch(macLinePattern, split[2])) + if up is not None: + data['up'] = True + if iface is not 'lo': + self.configuredInterfaces.append(iface) + if mac is not None: + data['mac'] = mac + if (split[1] == iface): + if re_search(globalIPpattern, split[2]): + ip = self.regExpMatch(ipPattern, self.regExpMatch(ipLinePattern, split[2])) + netmask = self.calc_netmask(self.regExpMatch(netmaskPattern, self.regExpMatch(netmaskLinePattern, split[2]))) + bcast = self.regExpMatch(ipPattern, self.regExpMatch(bcastLinePattern, split[2])) + if ip is not None: + data['ip'] = self.convertIP(ip) + if netmask is not None: + data['netmask'] = self.convertIP(netmask) + if bcast is not None: + data['bcast'] = self.convertIP(bcast) + if not data.has_key('ip'): data['dhcp'] = True - data['ip'] = [192, 168, 1, 2] - data['netmask'] = [255, 255, 255, 0] - data['gateway'] = [192, 168, 1, 1] - - fp = popen("route -n | grep " + iface) - result = fp.readlines() - fp.close() - for line in result: + data['ip'] = [0, 0, 0, 0] + data['netmask'] = [0, 0, 0, 0] + data['gateway'] = [0, 0, 0, 0] + + cmd = "route -n | grep " + iface + self.Console.ePopen(cmd,self.routeFinished, [iface, data, callback]) + + def routeFinished(self, result, retval, extra_args): + (iface, data, callback) = extra_args + ipRegexp = '[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}' + ipPattern = re_compile(ipRegexp) + ipLinePattern = re_compile(ipRegexp) + + for line in result.splitlines(): print line[0:7] if line[0:7] == "0.0.0.0": gateway = self.regExpMatch(ipPattern, line[16:31]) - if gateway is not None: + if gateway: data['gateway'] = self.convertIP(gateway) - return data + + self.ifaces[iface] = data + self.loadNetworkConfig(iface,callback) def writeNetworkConfig(self): + self.configuredInterfaces = [] fp = file('/etc/network/interfaces', 'w') fp.write("# automatically generated by enigma 2\n# do NOT change manually!\n\n") fp.write("auto lo\n") @@ -109,20 +145,26 @@ class Network: for ifacename, iface in self.ifaces.items(): if iface['up'] == True: fp.write("auto " + ifacename + "\n") - if iface['dhcp'] == True: - fp.write("iface "+ ifacename +" inet dhcp\n") - if iface['dhcp'] == False: - fp.write("iface "+ ifacename +" inet static\n") - if iface.has_key('ip'): - print tuple(iface['ip']) - fp.write(" address %d.%d.%d.%d\n" % tuple(iface['ip'])) - fp.write(" netmask %d.%d.%d.%d\n" % tuple(iface['netmask'])) - if iface.has_key('gateway'): - fp.write(" gateway %d.%d.%d.%d\n" % tuple(iface['gateway'])) - if iface.has_key("configStrings"): - fp.write("\n" + iface["configStrings"] + "\n") - fp.write("\n") + self.configuredInterfaces.append(ifacename) + if iface['dhcp'] == True: + fp.write("iface "+ ifacename +" inet dhcp\n") + if iface['dhcp'] == False: + fp.write("iface "+ ifacename +" inet static\n") + if iface.has_key('ip'): + print tuple(iface['ip']) + fp.write(" address %d.%d.%d.%d\n" % tuple(iface['ip'])) + fp.write(" netmask %d.%d.%d.%d\n" % tuple(iface['netmask'])) + if iface.has_key('gateway'): + fp.write(" gateway %d.%d.%d.%d\n" % tuple(iface['gateway'])) + if iface.has_key("configStrings"): + fp.write(iface["configStrings"]) + if iface["preup"] is not False and not iface.has_key("configStrings"): + fp.write(iface["preup"]) + if iface["predown"] is not False and not iface.has_key("configStrings"): + fp.write(iface["predown"]) + fp.write("\n") fp.close() + self.configuredNetworkAdapters = self.configuredInterfaces self.writeNameserverConfig() def writeNameserverConfig(self): @@ -131,8 +173,7 @@ class Network: fp.write("nameserver %d.%d.%d.%d\n" % tuple(nameserver)) fp.close() - def loadNetworkConfig(self): - self.loadNameserverConfig() + def loadNetworkConfig(self,iface,callback = None): interfaces = [] # parse the interfaces-file try: @@ -153,21 +194,44 @@ class Network: ifaces[currif]["dhcp"] = True else: ifaces[currif]["dhcp"] = False - if (currif != ""): + if (currif == iface): #read information only for available interfaces if (split[0] == "address"): ifaces[currif]["address"] = map(int, split[1].split('.')) + if self.ifaces[currif].has_key("ip"): + if self.ifaces[currif]["ip"] != ifaces[currif]["address"] and ifaces[currif]["dhcp"] == False: + self.ifaces[currif]["ip"] = map(int, split[1].split('.')) if (split[0] == "netmask"): ifaces[currif]["netmask"] = map(int, split[1].split('.')) + if self.ifaces[currif].has_key("netmask"): + if self.ifaces[currif]["netmask"] != ifaces[currif]["netmask"] and ifaces[currif]["dhcp"] == False: + self.ifaces[currif]["netmask"] = map(int, split[1].split('.')) if (split[0] == "gateway"): ifaces[currif]["gateway"] = map(int, split[1].split('.')) - - self.configuredInterfaces = ifaces - print "read interfaces:", ifaces + if self.ifaces[currif].has_key("gateway"): + if self.ifaces[currif]["gateway"] != ifaces[currif]["gateway"] and ifaces[currif]["dhcp"] == False: + self.ifaces[currif]["gateway"] = map(int, split[1].split('.')) + if (split[0] == "pre-up"): + if self.ifaces[currif].has_key("preup"): + self.ifaces[currif]["preup"] = i + if (split[0] in ("pre-down","post-down")): + if self.ifaces[currif].has_key("predown"): + self.ifaces[currif]["predown"] = i + for ifacename, iface in ifaces.items(): if self.ifaces.has_key(ifacename): self.ifaces[ifacename]["dhcp"] = iface["dhcp"] - - print "self.ifaces after loading:", self.ifaces + if self.Console: + if len(self.Console.appContainers) == 0: + # save configured interfacelist + self.configuredNetworkAdapters = self.configuredInterfaces + # load ns only once + self.loadNameserverConfig() + print "read configured interface:", ifaces + print "self.ifaces after loading:", self.ifaces + self.config_ready = True + self.msgPlugins() + if callback is not None: + callback(True) def loadNameserverConfig(self): ipRegexp = "[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}" @@ -186,33 +250,61 @@ class Network: for line in resolv: if self.regExpMatch(nameserverPattern, line) is not None: ip = self.regExpMatch(ipPattern, line) - if ip is not None: + if ip: self.nameservers.append(self.convertIP(ip)) print "nameservers:", self.nameservers - def deactivateNetworkConfig(self): - for iface in self.ifaces.keys(): - system("ip addr flush " + iface) - system("/etc/init.d/networking stop") - system("killall -9 udhcpc") - system("rm /var/run/udhcpc*") + def getInstalledAdapters(self): + return [x for x in listdir('/sys/class/net') if not self.isBlacklisted(x)] - def activateNetworkConfig(self): - system("/etc/init.d/networking start") - self.getInterfaces() + def getConfiguredAdapters(self): + return self.configuredNetworkAdapters def getNumberOfAdapters(self): return len(self.ifaces) def getFriendlyAdapterName(self, x): - # maybe this needs to be replaced by an external list. - friendlyNames = { - "eth0": _("Integrated Ethernet"), - "wlan0": _("Wireless"), - "ath0": _("Integrated Wireless") - } - return friendlyNames.get(x, x) # when we have no friendly name, use adapter name + if x in self.friendlyNames.keys(): + return self.friendlyNames.get(x, x) + self.friendlyNames[x] = self.getFriendlyAdapterNaming(x) + return self.friendlyNames.get(x, x) # when we have no friendly name, use adapter name + + def getFriendlyAdapterNaming(self, iface): + name = None + if self.isWirelessInterface(iface): + if iface not in self.wlan_interfaces: + name = _("WLAN connection") + if len(self.wlan_interfaces): + name += " " + str(len(self.wlan_interfaces)+1) + self.wlan_interfaces.append(iface) + else: + if iface not in self.lan_interfaces: + name = _("LAN connection") + if len(self.lan_interfaces): + name += " " + str(len(self.lan_interfaces)+1) + self.lan_interfaces.append(iface) + return name + + def getFriendlyAdapterDescription(self, iface): + if not self.isWirelessInterface(iface): + return _('Ethernet network interface') + + moduledir = self.getWlanModuleDir(iface) + if moduledir: + name = os_path.basename(os_path.realpath(moduledir)) + if name in ('ath_pci','ath5k'): + name = 'Atheros' + elif name in ('rt73','rt73usb','rt3070sta'): + name = 'Ralink' + elif name == 'zd1211b': + name = 'Zydas' + elif name == 'r871x_usb_drv': + name = 'Realtek' + else: + name = _('Unknown') + + return name + ' ' + _('wireless network interface') def getAdapterName(self, iface): return iface @@ -259,7 +351,24 @@ class Network: if self.nameservers[i] == oldnameserver: self.nameservers[i] = newnameserver - def writeDefaultNetworkConfig(self,mode='lan'): + def resetNetworkConfig(self, mode='lan', callback = None): + self.resetNetworkConsole = Console() + self.commands = [] + self.commands.append("/etc/init.d/avahi-daemon stop") + for iface in self.ifaces.keys(): + if iface != 'eth0' or not self.onRemoteRootFS(): + self.commands.append("ip addr flush dev " + iface) + self.commands.append("/etc/init.d/networking stop") + self.commands.append("killall -9 udhcpc") + self.commands.append("rm /var/run/udhcpc*") + self.resetNetworkConsole.eBatch(self.commands, self.resetNetworkFinishedCB, [mode, callback], debug=True) + + def resetNetworkFinishedCB(self, extra_args): + (mode, callback) = extra_args + if len(self.resetNetworkConsole.appContainers) == 0: + self.writeDefaultNetworkConfig(mode, callback) + + def writeDefaultNetworkConfig(self,mode='lan', callback = None): fp = file('/etc/network/interfaces', 'w') fp.write("# automatically generated by enigma 2\n# do NOT change manually!\n\n") fp.write("auto lo\n") @@ -276,44 +385,125 @@ class Network: fp.write("\n") fp.close() - def resetNetworkConfig(self,mode='lan'): - self.deactivateNetworkConfig() - self.writeDefaultNetworkConfig(mode) + self.resetNetworkConsole = Console() + self.commands = [] if mode == 'wlan': - system("ifconfig eth0 down") - system("ifconfig ath0 down") - system("ifconfig wlan0 up") + self.commands.append("ifconfig eth0 down") + self.commands.append("ifconfig ath0 down") + self.commands.append("ifconfig wlan0 up") if mode == 'wlan-mpci': - system("ifconfig eth0 down") - system("ifconfig wlan0 down") - system("ifconfig ath0 up") + self.commands.append("ifconfig eth0 down") + self.commands.append("ifconfig wlan0 down") + self.commands.append("ifconfig ath0 up") if mode == 'lan': - system("ifconfig eth0 up") - system("ifconfig wlan0 down") - system("ifconfig ath0 down") - self.getInterfaces() - - def checkNetworkState(self): - # www.dream-multimedia-tv.de, www.heise.de, www.google.de - return system("ping -c 1 82.149.226.170") == 0 or \ - system("ping -c 1 193.99.144.85") == 0 or \ - system("ping -c 1 209.85.135.103") == 0 - - def restartNetwork(self): - iNetwork.deactivateNetworkConfig() - iNetwork.activateNetworkConfig() + self.commands.append("ifconfig eth0 up") + self.commands.append("ifconfig wlan0 down") + self.commands.append("ifconfig ath0 down") + self.commands.append("/etc/init.d/avahi-daemon start") + self.resetNetworkConsole.eBatch(self.commands, self.resetNetworkFinished, [mode,callback], debug=True) + + def resetNetworkFinished(self,extra_args): + (mode, callback) = extra_args + if len(self.resetNetworkConsole.appContainers) == 0: + if callback is not None: + callback(True,mode) + + def checkNetworkState(self,statecallback): + # www.dream-multimedia-tv.de, www.heise.de, www.google.de + self.NetworkState = 0 + cmd1 = "ping -c 1 82.149.226.170" + cmd2 = "ping -c 1 193.99.144.85" + cmd3 = "ping -c 1 209.85.135.103" + self.PingConsole = Console() + self.PingConsole.ePopen(cmd1, self.checkNetworkStateFinished,statecallback) + self.PingConsole.ePopen(cmd2, self.checkNetworkStateFinished,statecallback) + self.PingConsole.ePopen(cmd3, self.checkNetworkStateFinished,statecallback) + + def checkNetworkStateFinished(self, result, retval,extra_args): + (statecallback) = extra_args + if self.PingConsole is not None: + if retval == 0: + self.PingConsole = None + statecallback(self.NetworkState) + else: + self.NetworkState += 1 + if len(self.PingConsole.appContainers) == 0: + statecallback(self.NetworkState) + + def restartNetwork(self,callback = None): + self.restartConsole = Console() + self.config_ready = False + self.msgPlugins() + self.commands = [] + self.commands.append("/etc/init.d/avahi-daemon stop") + for iface in self.ifaces.keys(): + if iface != 'eth0' or not self.onRemoteRootFS(): + self.commands.append("ifdown " + iface) + self.commands.append("ip addr flush dev " + iface) + self.commands.append("/etc/init.d/networking stop") + self.commands.append("killall -9 udhcpc") + self.commands.append("rm /var/run/udhcpc*") + self.commands.append("/etc/init.d/networking start") + self.commands.append("/etc/init.d/avahi-daemon start") + self.restartConsole.eBatch(self.commands, self.restartNetworkFinished, callback, debug=True) + + def restartNetworkFinished(self,extra_args): + ( callback ) = extra_args + if callback is not None: + callback(True) def getLinkState(self,iface,callback): - self.dataAvail = callback cmd = self.ethtool_bin + " " + iface - self.container.appClosed.get().append(self.cmdFinished) - self.container.dataAvail.get().append(callback) - self.container.execute(cmd) + self.LinkConsole = Console() + self.LinkConsole.ePopen(cmd, self.getLinkStateFinished,callback) - def cmdFinished(self,retval): - self.container.appClosed.get().remove(self.cmdFinished) - self.container.dataAvail.get().remove(self.dataAvail) + def getLinkStateFinished(self, result, retval,extra_args): + (callback) = extra_args + if self.LinkConsole is not None: + if len(self.LinkConsole.appContainers) == 0: + callback(result) + + def stopPingConsole(self): + if self.PingConsole is not None: + if len(self.PingConsole.appContainers): + for name in self.PingConsole.appContainers.keys(): + self.PingConsole.kill(name) + + def stopLinkStateConsole(self): + if self.LinkConsole is not None: + if len(self.LinkConsole.appContainers): + for name in self.LinkConsole.appContainers.keys(): + self.LinkConsole.kill(name) + + def stopDNSConsole(self): + if self.DnsConsole is not None: + if len(self.DnsConsole.appContainers): + for name in self.DnsConsole.appContainers.keys(): + self.DnsConsole.kill(name) + + def stopRestartConsole(self): + if self.restartConsole is not None: + if len(self.restartConsole.appContainers): + for name in self.restartConsole.appContainers.keys(): + self.restartConsole.kill(name) + + def stopGetInterfacesConsole(self): + if self.Console is not None: + if len(self.Console.appContainers): + for name in self.Console.appContainers.keys(): + self.Console.kill(name) + + def stopDeactivateInterfaceConsole(self): + if self.deactivateInterfaceConsole is not None: + self.deactivateInterfaceConsole.killAll() + self.deactivateInterfaceConsole = None + + def stopActivateInterfaceConsole(self): + if self.activateInterfaceConsole is not None: + self.activateInterfaceConsole.killAll() + self.activateInterfaceConsole = None + def checkforInterface(self,iface): if self.getAdapterAttribute(iface, 'up') is True: return True @@ -325,33 +515,178 @@ class Network: else: return False - def checkDNSLookup(self): - return system("nslookup www.dream-multimedia-tv.de") == 0 or \ - system("nslookup www.heise.de") == 0 or \ - system("nslookup www.google.de") - - def deactivateInterface(self,iface): - system("ifconfig " + iface + " down") - - def detectWlanModule(self): - self.wlanmodule = None - rt73_dir = "/sys/bus/usb/drivers/rt73/" - zd1211b_dir = "/sys/bus/usb/drivers/zd1211b/" - madwifi_dir = "/sys/bus/pci/drivers/ath_pci/" - if os_path.exists(madwifi_dir): - files = listdir(madwifi_dir) - if len(files) >= 1: - self.wlanmodule = 'madwifi' - elif os_path.exists(rt73_dir): - files = listdir(rt73_dir) - if len(files) >= 1: - self.wlanmodule = 'ralink' - elif os_path.exists(zd1211b_dir): - files = listdir(zd1211b_dir) - if len(files) != 0: - self.wlanmodule = 'zydas' - return self.wlanmodule + def checkDNSLookup(self,statecallback): + cmd1 = "nslookup www.dream-multimedia-tv.de" + cmd2 = "nslookup www.heise.de" + cmd3 = "nslookup www.google.de" + self.DnsConsole = Console() + self.DnsConsole.ePopen(cmd1, self.checkDNSLookupFinished,statecallback) + self.DnsConsole.ePopen(cmd2, self.checkDNSLookupFinished,statecallback) + self.DnsConsole.ePopen(cmd3, self.checkDNSLookupFinished,statecallback) + + def checkDNSLookupFinished(self, result, retval,extra_args): + (statecallback) = extra_args + if self.DnsConsole is not None: + if retval == 0: + self.DnsConsole = None + statecallback(self.DnsState) + else: + self.DnsState += 1 + if len(self.DnsConsole.appContainers) == 0: + statecallback(self.DnsState) + + def deactivateInterface(self,ifaces,callback = None): + self.config_ready = False + self.msgPlugins() + commands = [] + def buildCommands(iface): + commands.append("ifdown " + iface) + commands.append("ip addr flush dev " + iface) + #wpa_supplicant sometimes doesn't quit properly on SIGTERM + if os_path.exists('/var/run/wpa_supplicant/'+ iface): + commands.append("wpa_cli -i" + iface + " terminate") + + if not self.deactivateInterfaceConsole: + self.deactivateInterfaceConsole = Console() + + if isinstance(ifaces, (list, tuple)): + for iface in ifaces: + if iface != 'eth0' or not self.onRemoteRootFS(): + buildCommands(iface) + else: + if ifaces == 'eth0' and self.onRemoteRootFS(): + if callback is not None: + callback(True) + return + buildCommands(ifaces) + self.deactivateInterfaceConsole.eBatch(commands, self.deactivateInterfaceFinished, [ifaces,callback], debug=True) + + def deactivateInterfaceFinished(self,extra_args): + (ifaces, callback) = extra_args + def checkCommandResult(iface): + if self.deactivateInterfaceConsole and self.deactivateInterfaceConsole.appResults.has_key("ifdown " + iface): + result = str(self.deactivateInterfaceConsole.appResults.get("ifdown " + iface)).strip("\n") + if result == "ifdown: interface " + iface + " not configured": + return False + else: + return True + #ifdown sometimes can't get the interface down. + if isinstance(ifaces, (list, tuple)): + for iface in ifaces: + if checkCommandResult(iface) is False: + Console().ePopen(("ifconfig " + iface + " down" )) + else: + if checkCommandResult(ifaces) is False: + Console().ePopen(("ifconfig " + ifaces + " down" )) + + if self.deactivateInterfaceConsole: + if len(self.deactivateInterfaceConsole.appContainers) == 0: + if callback is not None: + callback(True) + + def activateInterface(self,iface,callback = None): + if self.config_ready: + self.config_ready = False + self.msgPlugins() + if iface == 'eth0' and self.onRemoteRootFS(): + if callback is not None: + callback(True) + return + if not self.activateInterfaceConsole: + self.activateInterfaceConsole = Console() + commands = [] + commands.append("ifup " + iface) + self.activateInterfaceConsole.eBatch(commands, self.activateInterfaceFinished, callback, debug=True) + + def activateInterfaceFinished(self,extra_args): + callback = extra_args + if self.activateInterfaceConsole: + if len(self.activateInterfaceConsole.appContainers) == 0: + if callback is not None: + callback(True) + + def sysfsPath(self, iface): + return '/sys/class/net/' + iface + + def isWirelessInterface(self, iface): + if iface in self.wlan_interfaces: + return True + + if os_path.isdir(self.sysfsPath(iface) + '/wireless'): + return True + + # r871x_usb_drv on kernel 2.6.12 is not identifiable over /sys/class/net/'ifacename'/wireless so look also inside /proc/net/wireless + device = re_compile('[a-z]{2,}[0-9]*:') + ifnames = [] + fp = open('/proc/net/wireless', 'r') + for line in fp: + try: + ifnames.append(device.search(line).group()[:-1]) + except AttributeError: + pass + if iface in ifnames: + return True + + return False + + def getWlanModuleDir(self, iface = None): + devicedir = self.sysfsPath(iface) + '/device' + moduledir = devicedir + '/driver/module' + if os_path.isdir(moduledir): + return moduledir + + # identification is not possible over default moduledir + for x in listdir(devicedir): + # rt3070 on kernel 2.6.18 registers wireless devices as usb_device (e.g. 1-1.3:1.0) and identification is only possible over /sys/class/net/'ifacename'/device/1-xxx + if x.startswith("1-"): + moduledir = devicedir + '/' + x + '/driver/module' + if os_path.isdir(moduledir): + return moduledir + # rt73, zd1211b, r871x_usb_drv on kernel 2.6.12 can be identified over /sys/class/net/'ifacename'/device/driver, so look also here + moduledir = devicedir + '/driver' + if os_path.isdir(moduledir): + return moduledir + + return None + + def detectWlanModule(self, iface = None): + if not self.isWirelessInterface(iface): + return None + + devicedir = self.sysfsPath(iface) + '/device' + if os_path.isdir(devicedir + '/ieee80211'): + return 'nl80211' + + moduledir = self.getWlanModuleDir(iface) + if moduledir: + module = os_path.basename(os_path.realpath(moduledir)) + if module in ('ath_pci','ath5k'): + return 'madwifi' + if module in ('rt73','rt73'): + return 'ralink' + if module == 'zd1211b': + return 'zydas' + return 'wext' + + def calc_netmask(self,nmask): + from struct import pack, unpack + from socket import inet_ntoa, inet_aton + mask = 1L<<31 + xnet = (1L<<32)-1 + cidr_range = range(0, 32) + cidr = long(nmask) + if cidr not in cidr_range: + print 'cidr invalid: %d' % cidr + return None + else: + nm = ((1L<L', nm))) + return netmask + def msgPlugins(self): + if self.config_ready is not None: + for p in plugins.getPlugins(PluginDescriptor.WHERE_NETWORKCONFIG_READ): + p(reason=self.config_ready) iNetwork = Network()