lib/python/Components/VolumeControl.py: make the VolumeControl instance global access...

[enigma2.git] / lib / python / Components / Network.py

diff --git a/lib/python/Components/Network.py b/lib/python/Components/Network.py
old mode 100644 (file)
new mode 100755 (executable)
index 7d6c5e1..b9da48d
--- a/lib/python/Components/Network.py
+++ b/lib/python/Components/Network.py
@@ -1,187 +1,614 @@
-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 socket import *

+from enigma import eConsoleAppContainer
+from Components.Console import Console
+from Components.PluginComponent import plugins
+from Plugins.Plugin import PluginDescriptor

 
 class Network:
        def __init__(self):
 
 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.deactivateConsole = Console()
+               self.deactivateInterfaceConsole = Console()
+               self.activateConsole = Console()
+               self.resetNetworkConsole = Console()
+               self.DnsConsole = Console()
+               self.PingConsole = Console()
+               self.config_ready = None
+               self.getInterfaces()
+
+       def onRemoteRootFS(self):
+               fp = file('/proc/mounts', 'r')
+               mounts = fp.readlines()
+               fp.close()
+               for line in mounts:
+                       parts = line.strip().split(' ')
+                       if parts[1] == '/' and (parts[2] == 'nfs' or parts[2] == 'smbfs'):
+                               return True
+               return False
+
+       def getInterfaces(self, callback = None):
+               devicesPattern = re_compile('[a-z]+[0-9]+')
+               self.configuredInterfaces = []
+               fp = file('/proc/net/dev', 'r')
+               result = fp.readlines()
+               fp.close()
+               for line in result:
+                       try:
+                               device = devicesPattern.search(line).group()
+                               if device in ('wifi0', 'wmaster0'):
+                                       continue
+                               self.getDataForInterface(device, callback)
+                       except AttributeError:
+                               pass
+               #print "self.ifaces:", self.ifaces
+               #self.writeNetworkConfig()
+               #print ord(' ')
+               #for line in result:
+               #       print ord(line[0])
+
+       # helper function
+       def regExpMatch(self, pattern, string):
+               if string is None:
+                       return None
+               try:
+                       return pattern.search(string).group()
+               except AttributeError:
+                       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,callback):
+               #get ip out of ip addr, as avahi sometimes overrides it in ifconfig.
+               if not self.Console:
+                       self.Console = Console()
+               cmd = "ip -o addr"
+               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, 'postdown' : 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-9]{2}\:[0-9]{2}\:[0-9]{2}\:[a-z0-9]{2}\:[a-z0-9]{2}\:[a-z0-9]{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('[0-9]{2}\:[0-9]{2}\:[0-9]{2}\:[a-z0-9]{2}\:[a-z0-9]{2}\:[a-z0-9]{2}')
+               macLinePattern = re_compile('link/ether ' + macRegexp)

                
                

+               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 is not None:
+                                       data['gateway'] = self.convertIP(gateway)
+                                       
+               self.ifaces[iface] = data
+               self.loadNetworkConfig(iface,callback)
+

        def writeNetworkConfig(self):
        def writeNetworkConfig(self):

-               # fixme restarting and updating the network too often. possible fix: check current config and execute only if changed :/
-               # fixme using interfaces.tmp instead of interfaces for now
+               self.configuredInterfaces = []

                fp = file('/etc/network/interfaces', 'w')
                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")
                fp.write("auto lo\n")
                fp.write("iface lo inet loopback\n\n")

-               fp.write("auto eth0\n")
-               if (currentConfigSelectionElement(config.network.dhcp) == "yes"):
-                       fp.write("iface eth0 inet dhcp\n")
-               else:
-                       fp.write("iface eth0 inet static\n")
-                       fp.write("      address %d.%d.%d.%d\n" % tuple(config.network.ip.value))
-                       fp.write("      netmask %d.%d.%d.%d\n" % tuple(config.network.netmask.value))
-                       fp.write("      gateway %d.%d.%d.%d\n" % tuple(config.network.gateway.value))
-                       fp2 = file('/etc/resolv.conf', 'w')
-                       fp2.write("nameserver %d.%d.%d.%d\n" % tuple(config.network.dns.value))
-                       fp2.close()
+               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("\n" + iface["configStrings"] + "\n")
+                       if iface["preup"] is not False and not iface.has_key("configStrings"):
+                               fp.write(iface["preup"])
+                               fp.write(iface["postdown"])
+                       fp.write("\n")                          
+               fp.close()
+               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()
 
                fp.close()
 

-       def loadNetworkConfig(self):
+       def loadNetworkConfig(self,iface,callback = None):
+               interfaces = []
+               # parse the interfaces-file

                try:
                try:

-                       # parse the interfaces-file

                        fp = file('/etc/network/interfaces', 'r')
                        interfaces = fp.readlines()
                        fp.close()
                        fp = file('/etc/network/interfaces', 'r')
                        interfaces = fp.readlines()
                        fp.close()

-                       
-                       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"] = "yes"
-                                       else:
-                                               ifaces[currif]["dhcp"] = "no"
-                               if (currif != ""):
-                                       if (split[0] == "address"):
-                                               ifaces[currif]["address"] = map(int, split[1].split('.'))
-                                       if (split[0] == "netmask"):
-                                               ifaces[currif]["netmask"] = map(int, split[1].split('.'))
-                                       if (split[0] == "gateway"):
-                                               ifaces[currif]["gateway"] = map(int, split[1].split('.'))                                                                       
-                       
-                       # parse the resolv.conf-file
+               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] == "post-down"):
+                                       if self.ifaces[currif].has_key("postdown"):
+                                               self.ifaces[currif]["postdown"] = 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()
                        fp = file('/etc/resolv.conf', 'r')
                        resolv = fp.readlines()
                        fp.close()

+                       self.nameservers = []

                except:
                except:

-                       print "[Network.py] loading network files failed"
-                       
-               try:
-                       for i in resolv:
-                               split = i.strip().split(' ')
-                               if (split[0] == "nameserver"):
-                                       config.network.dns.value = map(int, split[1].split('.'))
-               except:
-                       print "[Network.py] resolv.conf parsing failed"
-               
-               try:
-                       # set this config
-                       if (ifaces.has_key("eth0")):
-                               if (ifaces["eth0"]["dhcp"] == "yes"):
-                                       config.network.dhcp.value = 1
-                               else:
-                                       config.network.dhcp.value = 0
-                               if (ifaces["eth0"].has_key("address")): config.network.ip.value = ifaces["eth0"]["address"]
-                               if (ifaces["eth0"].has_key("netmask")): config.network.netmask.value = ifaces["eth0"]["netmask"]
-                               if (ifaces["eth0"].has_key("gateway")): config.network.gateway.value = ifaces["eth0"]["gateway"]
-               except:
-                       print "[Network.py] parsing network failed"
+                       print "[Network.py] resolv.conf - opening failed"

 
 

-       def activateNetworkConfig(self):
-               import os
-               os.system("/etc/init.d/networking restart")
-               config.network.ip.value = self.getCurrentIP()
-               
-       def setDHCP(self, useDHCP):
-               if (useDHCP):
-                       print "Using DHCP"
-                       config.network.ip.enabled = False
-                       config.network.netmask.enabled = False
-                       config.network.gateway.enabled = False
-                       config.network.dns.enabled = False
-               else:
-                       print "NOT using DHCP"
-                       config.network.ip.enabled = True
-                       config.network.netmask.enabled = True
-                       config.network.gateway.enabled = True
-                       config.network.dns.enabled = True
-                                       
-       def setIPNameserver(self, ip):
-               return
-               resolvconf = file('/etc/resolv.conf', 'w')
-               resolvconf.write("nameserver %d.%d.%d.%d" % tuple(ip))
-               resolvconf.close()
-               
-       def setMACAddress(self, mac):
-               #os.system("echo ifconfig eth0 ether %02x:%02x:%02x:%02x:%02x:%02x" % tuple(mac))
-               pass
+               for line in resolv:
+                       if self.regExpMatch(nameserverPattern, line) is not None:
+                               ip = self.regExpMatch(ipPattern, line)
+                               if ip is not None:
+                                       self.nameservers.append(self.convertIP(ip))
+
+               print "nameservers:", self.nameservers
+
+       def deactivateNetworkConfig(self, callback = None):
+               if self.onRemoteRootFS():
+                       if callback is not None:
+                               callback(True)
+                       return
+               self.deactivateConsole = Console()
+               self.commands = []
+               self.commands.append("/etc/init.d/avahi-daemon stop")
+               for iface in self.ifaces.keys():
+                       cmd = "ip addr flush " + iface
+                       self.commands.append(cmd)               
+               self.commands.append("/etc/init.d/networking stop")
+               self.commands.append("killall -9 udhcpc")
+               self.commands.append("rm /var/run/udhcpc*")
+               self.deactivateConsole.eBatch(self.commands, self.deactivateNetworkFinished, callback, debug=True)

                
                

-       def setIPAddress(self, ip):
-               pass
-               #os.system("echo ifconfig eth0 %d.%d.%d.%d" % tuple(ip))
-               #self.writeNetworkConfig()
+       def deactivateNetworkFinished(self,extra_args):
+               callback = extra_args
+               if len(self.deactivateConsole.appContainers) == 0:
+                       if callback is not None:
+                               callback(True)

 
 

-       def setGateway(self, ip):
-               pass
-               #os.system("echo route add default gw %d.%d.%d.%d" % tuple(ip))
-               #self.writeNetworkConfig()
+       def activateNetworkConfig(self, callback = None):
+               if self.onRemoteRootFS():
+                       if callback is not None:
+                               callback(True)
+                       return
+               self.activateConsole = Console()
+               self.commands = []
+               self.commands.append("/etc/init.d/networking start")
+               self.commands.append("/etc/init.d/avahi-daemon start")
+               self.activateConsole.eBatch(self.commands, self.activateNetworkFinished, callback, debug=True)

                
                

-       def setNetmask(self, ip):
-               pass
-               #os.system("echo ifconfig eth0 netmask %d.%d.%d.%d" % tuple(ip))                
-               #self.writeNetworkConfig()              
-
-       def getCurrentIP(self):
-               ipstr = [0,0,0,0]
-               for x in os.popen("ifconfig eth0 | grep 'inet addr:'", "r").readline().split(' '):
-                       if x.split(':')[0] == "addr":
-                               ipstr = x.split(':')[1].split('.')
-               ip = []
-               for x in ipstr:
-                       ip.append(int(x))
-               print "[Network.py] got ip " + str(ip)
-               return ip
+       def activateNetworkFinished(self,extra_args):
+               callback = extra_args
+               if len(self.activateConsole.appContainers) == 0:
+                       if callback is not None:
+                               callback(True)

 
 

-iNetwork = Network()
+       def getConfiguredAdapters(self):
+               return self.configuredNetworkAdapters

 
 

-def InitNetwork():
-       ip = iNetwork.getCurrentIP()
+       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
+
+       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 removeAdapterAttribute(self, iface, attribute):
+               if self.ifaces.has_key(iface):
+                       if self.ifaces[iface].has_key(attribute):
+                               del self.ifaces[iface][attribute]
+
+       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):
+               if self.onRemoteRootFS():
+                       if callback is not None:
+                               callback(True)
+                       return
+               self.resetNetworkConsole = Console()
+               self.commands = []
+               self.commands.append("/etc/init.d/avahi-daemon stop")
+               for iface in self.ifaces.keys():
+                       cmd = "ip addr flush " + iface
+                       self.commands.append(cmd)               
+               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)

                
                

-       config.network = ConfigSubsection()
-       config.network.dhcp = configElement_nonSave("config.network.dhcp", configSelection, 1, (("no", _("no")), ("yes", _("yes"))))
-       config.network.ip = configElement_nonSave("config.network.ip", configSequence, ip, configsequencearg.get("IP"))
-       config.network.netmask = configElement_nonSave("config.network.netmask", configSequence, [255,255,255,0], configsequencearg.get("IP"))
-       config.network.gateway = configElement_nonSave("config.network.gateway", configSequence, [192,168,1,3], configsequencearg.get("IP"))
-       config.network.dns = configElement_nonSave("config.network.dns", configSequence, [192,168,1,3], configsequencearg.get("IP"))
-       config.network.mac = configElement_nonSave("config.network.mac", configSequence, [00,11,22,33,44,55], configsequencearg.get("MAC"))
-
-       iNetwork.loadNetworkConfig()
+       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):
+               if self.onRemoteRootFS():
+                       if callback is not None:
+                               callback(True)
+                       return
+               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():
+                       cmd = "ip addr flush " + iface
+                       self.commands.append(cmd)               
+               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)

        
        

-       #FIXME using this till other concept for this is implemented
-       #config.network.activate = configElement("config.network.activate", configSelection, 0, ("yes, sir", "you are my hero"))
-       #config.network.activate = configElement("config.network.activate", configSelection, 0, ("yes", "you are my hero"))
+       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)

 
 

-       def writeNetworkConfig(configElement):
-               iNetwork.writeNetworkConfig()
-               
-       def setIPAddress(configElement):
-               iNetwork.setIPAddress(configElement.value)
+       def getLinkStateFinished(self, result, retval,extra_args):
+               (callback) = extra_args

 
 

-       def setGateway(configElement):
-               iNetwork.setGateway(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 setNetmask(configElement):
-               iNetwork.setNetmask(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:
+                       if len(self.deactivateInterfaceConsole.appContainers):
+                               for name in self.deactivateInterfaceConsole.appContainers.keys():
+                                       self.deactivateInterfaceConsole.kill(name)
+                                       
+       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 setDHCP(configElement):
-               iNetwork.setDHCP(configElement.value)
+       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 setIPNameserver(configElement):
-               iNetwork.setIPNameserver(configElement.value)
+       def deactivateInterface(self,iface,callback = None):
+               if self.onRemoteRootFS():
+                       if callback is not None:
+                               callback(True)
+                       return
+               self.deactivateInterfaceConsole = Console()
+               self.commands = []
+               cmd1 = "ip addr flush " + iface
+               cmd2 = "ifconfig " + iface + " down"
+               self.commands.append(cmd1)
+               self.commands.append(cmd2)
+               self.deactivateInterfaceConsole.eBatch(self.commands, self.deactivateInterfaceFinished, callback, debug=True)

 
 

-       def setMACAddress(configElement):
-               iNetwork.setMACAddress(configElement.value)
+       def deactivateInterfaceFinished(self,extra_args):
+               callback = extra_args
+               if self.deactivateInterfaceConsole:
+                       if len(self.deactivateInterfaceConsole.appContainers) == 0:
+                               if callback is not None:
+                                       callback(True)

 
 

+       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'
+               if os_path.exists(rt73_dir):
+                       rtfiles = listdir(rt73_dir)
+                       if len(rtfiles) == 2 or len(rtfiles) == 5:
+                               self.wlanmodule = 'ralink'
+               if os_path.exists(zd1211b_dir):
+                       zdfiles = listdir(zd1211b_dir)
+                       if len(zdfiles) == 1 or len(zdfiles) == 5:
+                               self.wlanmodule = 'zydas'
+               return self.wlanmodule
+       
+       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()

 
 

-       # this will call the "setup-val" initial
-       config.network.dhcp.addNotifier(setDHCP)
-       config.network.ip.addNotifier(setIPAddress)
-       config.network.netmask.addNotifier(setNetmask)  
-       config.network.gateway.addNotifier(setGateway)
-       config.network.dns.addNotifier(setIPNameserver)
-       config.network.mac.addNotifier(setMACAddress)
+def InitNetwork():
+       pass