X-Git-Url: https://git.cweiske.de/enigma2.git/blobdiff_plain/b2c9f6632fac847577a52e23aa56a1f0816b1927..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 3740e51b..32b8bdbe
--- a/lib/python/Components/Network.py
+++ b/lib/python/Components/Network.py
@@ -1,49 +1,694 @@
-from config import *
-
-import os
+from os import system, popen, path as os_path, listdir
+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):
-		pass
+		self.ifaces = {}
+		self.configuredInterfaces = []
+		self.configuredNetworkAdapters = []
+		self.NetworkState = 0
+		self.DnsState = 0
+		self.nameservers = []
+		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 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):
+		if string is None:
+			return None
+		try:
+			return pattern.search(string).group()
+		except AttributeError:
+			return None
+
+	# helper function to convert ips from a sring to a list of ints
+	def convertIP(self, ip):
+		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}'
+		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)
+		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)
 		
-	def setIPAddress(self, ip):
-		print ip
-		os.system("echo ifconfig eth0 %d.%d.%d.%d" % (ip[0], ip[1], ip[2], ip[3]))
+		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'] = [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:
+					data['gateway'] = self.convertIP(gateway)
+					
+		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")
+		fp.write("iface lo inet loopback\n\n")
+		for ifacename, iface in self.ifaces.items():
+			if iface['up'] == True:
+				fp.write("auto " + ifacename + "\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):
+		fp = file('/etc/resolv.conf', 'w')
+		for nameserver in self.nameservers:
+			fp.write("nameserver %d.%d.%d.%d\n" % tuple(nameserver))
+		fp.close()
+
+	def loadNetworkConfig(self,iface,callback = None):
+		interfaces = []
+		# parse the interfaces-file
+		try:
+			fp = file('/etc/network/interfaces', 'r')
+			interfaces = fp.readlines()
+			fp.close()
+		except:
+			print "[Network.py] interfaces - opening failed"
+
+		ifaces = {}
+		currif = ""
+		for i in interfaces:
+			split = i.strip().split(' ')
+			if (split[0] == "iface"):
+				currif = split[1]
+				ifaces[currif] = {}
+				if (len(split) == 4 and split[3] == "dhcp"):
+					ifaces[currif]["dhcp"] = True
+				else:
+					ifaces[currif]["dhcp"] = False
+			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('.'))
+					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"]
+		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}"
+		nameserverPattern = re_compile("nameserver +" + ipRegexp)
+		ipPattern = re_compile(ipRegexp)
+
+		resolv = []
+		try:
+			fp = file('/etc/resolv.conf', 'r')
+			resolv = fp.readlines()
+			fp.close()
+			self.nameservers = []
+		except:
+			print "[Network.py] resolv.conf - opening failed"
+
+		for line in resolv:
+			if self.regExpMatch(nameserverPattern, line) is not None:
+				ip = self.regExpMatch(ipPattern, line)
+				if ip:
+					self.nameservers.append(self.convertIP(ip))
+
+		print "nameservers:", self.nameservers
+
+	def getInstalledAdapters(self):
+		return [x for x in listdir('/sys/class/net') if not self.isBlacklisted(x)]
+
+	def getConfiguredAdapters(self):
+		return self.configuredNetworkAdapters
+
+	def getNumberOfAdapters(self):
+		return len(self.ifaces)
+
+	def getFriendlyAdapterName(self, x):
+		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
+
+	def getAdapterList(self):
+		return self.ifaces.keys()
+
+	def getAdapterAttribute(self, iface, attribute):
+		if self.ifaces.has_key(iface):
+			if self.ifaces[iface].has_key(attribute):
+				return self.ifaces[iface][attribute]
+		return None
+
+	def setAdapterAttribute(self, iface, attribute, value):
+		print "setting for adapter", iface, "attribute", attribute, " to value", value
+		if self.ifaces.has_key(iface):
+			self.ifaces[iface][attribute] = value
 
-	def setIPGateway(self, ip):
-		os.system("echo route add default gw %d.%d.%d.%d" % (ip[0], ip[1], ip[2], ip[3]))
+	def removeAdapterAttribute(self, iface, attribute):
+		if self.ifaces.has_key(iface):
+			if self.ifaces[iface].has_key(attribute):
+				del self.ifaces[iface][attribute]
 
-	def setIPNameserver(self, ip):
-		resolvconf = file('/etc/resolv.conf', 'w')
-		resolvconf.write("nameserver %d.%d.%d.%d" % (ip[0], ip[1], ip[2], ip[3]))
-		resolvconf.close()
+	def getNameserverList(self):
+		if len(self.nameservers) == 0:
+			return [[0, 0, 0, 0], [0, 0, 0, 0]]
+		else: 
+			return self.nameservers
+
+	def clearNameservers(self):
+		self.nameservers = []
+
+	def addNameserver(self, nameserver):
+		if nameserver not in self.nameservers:
+			self.nameservers.append(nameserver)
+
+	def removeNameserver(self, nameserver):
+		if nameserver in self.nameservers:
+			self.nameservers.remove(nameserver)
+
+	def changeNameserver(self, oldnameserver, newnameserver):
+		if oldnameserver in self.nameservers:
+			for i in range(len(self.nameservers)):
+				if self.nameservers[i] == oldnameserver:
+					self.nameservers[i] = newnameserver
+
+	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")
+		fp.write("iface lo inet loopback\n\n")
+		if mode == 'wlan':
+			fp.write("auto wlan0\n")
+			fp.write("iface wlan0 inet dhcp\n")
+		if mode == 'wlan-mpci':
+			fp.write("auto ath0\n")
+			fp.write("iface ath0 inet dhcp\n")
+		if mode == 'lan':
+			fp.write("auto eth0\n")
+			fp.write("iface eth0 inet dhcp\n")
+		fp.write("\n")
+		fp.close()
+
+		self.resetNetworkConsole = Console()
+		self.commands = []
+		if mode == 'wlan':
+			self.commands.append("ifconfig eth0 down")
+			self.commands.append("ifconfig ath0 down")
+			self.commands.append("ifconfig wlan0 up")
+		if mode == 'wlan-mpci':
+			self.commands.append("ifconfig eth0 down")
+			self.commands.append("ifconfig wlan0 down")
+			self.commands.append("ifconfig ath0 up")		
+		if mode == 'lan':			
+			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 setMACAddress(self, mac):
-		os.system("echo ifconfig eth0 %02x:%02x:%02x:%02x:%02x:%02x" % (mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]))
+	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 InitNetwork():
-	config.network = ConfigSubsection()
-	config.network.ip = configElement("config.network.ip", configSequence, [192,168,1,45], (("."), 3))
-	config.network.gateway = configElement("config.network.gateway", configSequence, [192,168,1,3], (("."), 3))
-	config.network.dns = configElement("config.network.dns", configSequence, [192,168,1,3], (("."), 3))
-	config.network.mac = configElement("config.network.mac", configSequence, [00,11,22,33,44,55], ((":"), 2))
+	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):
+		cmd = self.ethtool_bin + " " + iface
+		self.LinkConsole = Console()
+		self.LinkConsole.ePopen(cmd, self.getLinkStateFinished,callback)
 
-	iNetwork = Network()
+	def getLinkStateFinished(self, result, retval,extra_args):
+		(callback) = extra_args
 
-	def setIPAddress(configElement):
-		iNetwork.setIPAddress(configElement.value)
+		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 setIPGateway(configElement):
-		iNetwork.setIPGateway(configElement.value)
+	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
+		else:
+			ret=system("ifconfig " + iface + " up")
+			system("ifconfig " + iface + " down")
+			if ret == 0:
+				return True
+			else:
+				return False
+
+	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 setIPNameserver(configElement):
-		iNetwork.setIPNameserver(configElement.value)
+	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 setMACAddress(configElement):
-		iNetwork.setMACAddress(configElement.value)
+	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" ))
 
-	# this will call the "setup-val" initial
-	config.network.ip.addNotifier(setIPAddress)
-	config.network.gateway.addNotifier(setIPGateway)
-	config.network.dns.addNotifier(setIPNameserver)
-	config.network.mac.addNotifier(setMACAddress)
\ No newline at end of file
+		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<<cidr)-1)<<(32-cidr)
+			netmask = str(inet_ntoa(pack('>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()
+
+def InitNetwork():
+	pass