Merge remote-tracking branch 'origin/bug_747_cancel_waiting_tasks'
authorghost <andreas.monzner@multimedia-labs.de>
Tue, 6 Sep 2011 13:19:29 +0000 (15:19 +0200)
committerghost <andreas.monzner@multimedia-labs.de>
Tue, 6 Sep 2011 13:19:29 +0000 (15:19 +0200)
64 files changed:
lib/base/thread.cpp
lib/driver/rcsdl.cpp
lib/dvb/db.cpp
lib/dvb/dvb.cpp
lib/dvb/frontend.cpp
lib/dvb/frontend.h
lib/dvb/sec.cpp
lib/gdi/picexif.cpp
lib/python/Components/DreamInfoHandler.py
lib/python/Components/Network.py
lib/python/Components/NimManager.py
lib/python/Components/PluginComponent.py
lib/python/Components/config.py
lib/python/Plugins/SystemPlugins/NetworkWizard/NetworkWizard.py
lib/python/Plugins/SystemPlugins/NetworkWizard/networkwizard.xml
lib/python/Plugins/SystemPlugins/NetworkWizard/plugin.py
lib/python/Plugins/SystemPlugins/PositionerSetup/plugin.py
lib/python/Plugins/SystemPlugins/Satfinder/plugin.py
lib/python/Plugins/SystemPlugins/SoftwareManager/BackupRestore.py
lib/python/Plugins/SystemPlugins/SoftwareManager/ImageWizard.py
lib/python/Plugins/SystemPlugins/SoftwareManager/SoftwareTools.py
lib/python/Plugins/SystemPlugins/SoftwareManager/plugin.py
lib/python/Plugins/SystemPlugins/Videomode/VideoHardware.py
lib/python/Plugins/SystemPlugins/WirelessLan/Wlan.py
lib/python/Plugins/SystemPlugins/WirelessLan/plugin.py
lib/python/Screens/DefaultWizard.py
lib/python/Screens/InputBox.py
lib/python/Screens/NetworkSetup.py
lib/python/Screens/ScanSetup.py
lib/python/Screens/Screen.py
lib/python/Screens/ServiceInfo.py
lib/python/Tools/Directories.py
lib/python/Tools/Transponder.py
lib/python/connections.h
mytest.py
po/ar.po
po/ca.po
po/cs.po
po/da.po
po/de.po
po/el.po
po/en.po
po/es.po
po/et.po
po/fi.po
po/fr.po
po/fy.po
po/hr.po
po/hu.po
po/is.po
po/it.po
po/lt.po
po/lv.po
po/nl.po
po/no.po
po/pl.po
po/pt.po
po/ru.po
po/sk.po
po/sl.po
po/sr.po
po/sv.po
po/tr.po
po/uk.po

index fa923de..1fda6a4 100644 (file)
@@ -58,7 +58,12 @@ int eThread::runAsync(int prio, int policy)
                pthread_attr_setschedpolicy(&attr, policy);
                pthread_attr_setschedparam(&attr, &p);
        }
-       
+
+       if (the_thread) {
+               eDebug("old thread joined %d", pthread_join(the_thread, 0));
+               the_thread = 0;
+       }
+
        if (pthread_create(&the_thread, &attr, wrapper, this))
        {
                pthread_attr_destroy(&attr);
@@ -69,7 +74,7 @@ int eThread::runAsync(int prio, int policy)
        
        pthread_attr_destroy(&attr);
        return 0;
-}                     
+}
 
 int eThread::run(int prio, int policy)
 {
index 145b23c..0705cb0 100644 (file)
@@ -1,3 +1,4 @@
+#include <lib/base/etrace.h>
 #include <lib/driver/rcsdl.h>
 //#include <lib/actions/action.h>
 #include <lib/base/init.h>
@@ -18,6 +19,8 @@ eSDLInputDevice::~eSDLInputDevice()
 
 void eSDLInputDevice::handleCode(long arg)
 {
+       D_ENTER();
+
        const SDL_KeyboardEvent *event = (const SDL_KeyboardEvent *)arg;
        const SDL_keysym *key = &event->keysym;
        int km = input->getKeyboardMode();
@@ -32,48 +35,43 @@ void eSDLInputDevice::handleCode(long arg)
 
        if (km == eRCInput::kmNone) {
                code = translateKey(key->sym);
+               D_PRINT("translated code: %d", code);
        } else {
-               // ASCII keys should only generate key press events
-               if (flags == eRCKey::flagBreak)
-                       return;
-
-               eDebug("unicode=%04x scancode=%02x", m_unicode, key->scancode);
-               if (m_unicode & 0xff80) {
-                       eDebug("SDL: skipping unicode character");
-                       return;
-               }
-               code = m_unicode & ~0xff80;
-               // unicode not set...!? use key symbol
-               if (code == 0) {
-                       // keysym is ascii
-                       if (key->sym >= 128) {
-                               eDebug("SDL: cannot emulate ASCII");
-                               return;
-                       }
-                       eDebug("SDL: emulate ASCII");
+               code = m_unicode;
+               D_PRINT("native virtual code: %d / sym: %d", code, key->sym);
+               if ((code == 0) && (key->sym < 128)) {
                        code = key->sym;
+                       D_PRINT("ASCII code: %u", code);
                }
-               if (km == eRCInput::kmAscii) {
-                       // skip ESC c or ESC '[' c
-                       if (m_escape) {
-                               if (code != '[')
-                                       m_escape = false;
-                               return;
-                       }
 
-                       if (code == SDLK_ESCAPE)
-                               m_escape = true;
+               if ((km == eRCInput::kmAscii) &&
+                   ((code < SDLK_SPACE) ||
+                    (code == 0x7e) ||
+                    (code == SDLK_DELETE) ||
+                    (code > 255))) {
+                       code = translateKey(key->sym);
+               } else {
+                       // ASCII keys should only generate key press events
+                       if (flags == eRCKey::flagBreak)
+                               D_RETURN();
 
-                       if ((code < SDLK_SPACE) ||
-                           (code == 0x7e) ||   // really?
-                           (code == SDLK_DELETE))
-                               return;
+                       if (km == eRCInput::kmAscii) {
+                               // skip ESC c or ESC '[' c
+                               if (m_escape) {
+                                       if (code != '[')
+                                               m_escape = false;
+                                       D_RETURN();
+                               }
+                               if (code == SDLK_ESCAPE)
+                                       m_escape = true;
+                       }
+                       flags |= eRCKey::flagAscii;
                }
-               flags |= eRCKey::flagAscii;
        }
 
-       eDebug("SDL code=%d flags=%d", code, flags);
+       D_PRINT("code=%d (%#x) flags=%d (%#x)", code, code, flags, flags);
        input->keyPressed(eRCKey(this, code, flags));
+       D_RETURN();
 }
 
 const char *eSDLInputDevice::getDescription() const
index 522035e..0547407 100644 (file)
@@ -325,19 +325,11 @@ void eDVBDB::loadServicelist(const char *file)
 {
        eDebug("---- opening lame channel db");
        FILE *f=fopen(file, "rt");
-       if (!f && strcmp(file, eEnv::resolve("${sysconfdir}/enigma2/lamedb").c_str()) == 0)
-       {
-               struct stat s;
-               if ( !stat("lamedb", &s) )
-               {
-                       if ( !stat(eEnv::resolve("${sysconfdir}/enigma2").c_str(), &s) )
-                       {
-                               rename("lamedb", eEnv::resolve("${sysconfdir}/enigma2/lamedb").c_str());
-                               reloadServicelist();
-                       }
-               }
+       if (!f) {
+               eDebug("can't open %s: %m", file);
                return;
        }
+
        char line[256];
        int version=3;
        if ((!fgets(line, 256, f)) || sscanf(line, "eDVB services /%d/", &version) != 1)
@@ -623,24 +615,16 @@ void eDVBDB::loadBouquet(const char *path)
        p+=path;
        eDebug("loading bouquet... %s", p.c_str());
        FILE *fp=fopen(p.c_str(), "rt");
-       int entries=0;
        if (!fp)
        {
-               struct stat s;
-               if ( !stat(path, &s) )
-               {
-                       rename(path, p.c_str() );
-                       loadBouquet(path);
-                       return;
-               }
-               eDebug("failed to open.");
-               if ( strstr(path, "bouquets.tv") )
+               eDebug("can't open %s: %m", p.c_str());
+               if (!strcmp(path, "bouquets.tv"))
                {
                        eDebug("recreate bouquets.tv");
                        bouquet.m_bouquet_name="Bouquets (TV)";
                        bouquet.flushChanges();
                }
-               else if ( strstr(path, "bouquets.radio") )
+               else if (!strcmp(path, "bouquets.radio"))
                {
                        eDebug("recreate bouquets.radio");
                        bouquet.m_bouquet_name="Bouquets (Radio)";
@@ -648,6 +632,7 @@ void eDVBDB::loadBouquet(const char *path)
                }
                return;
        }
+       int entries=0;
        char line[256];
        bool read_descr=false;
        eServiceReference *e = NULL;
index 6f9a67f..0b1bdc2 100644 (file)
@@ -145,19 +145,20 @@ eDVBAdapterLinux::eDVBAdapterLinux(int nr): m_nr(nr)
 #endif
                if (stat(filename, &s))
                        break;
-               ePtr<eDVBFrontend> fe;
+               eDVBFrontend *fe;
 
                {
                        int ok = 0;
-                       fe = new eDVBFrontend(m_nr, num_fe, ok);
+                       fe = new eDVBFrontend(m_nr, num_fe, ok, true);
                        if (ok)
-                               m_frontend.push_back(fe);
+                               m_simulate_frontend.push_back(ePtr<eDVBFrontend>(fe));
                }
+
                {
                        int ok = 0;
-                       fe = new eDVBFrontend(m_nr, num_fe, ok, true);
+                       fe = new eDVBFrontend(m_nr, num_fe, ok, false, fe);
                        if (ok)
-                               m_simulate_frontend.push_back(fe);
+                               m_frontend.push_back(ePtr<eDVBFrontend>(fe));
                }
                ++num_fe;
        }
index b5de46c..5718896 100644 (file)
@@ -453,8 +453,8 @@ DEFINE_REF(eDVBFrontend);
 
 int eDVBFrontend::PriorityOrder=0;
 
-eDVBFrontend::eDVBFrontend(int adap, int fe, int &ok, bool simulate)
-       :m_simulate(simulate), m_enabled(false), m_type(-1), m_dvbid(fe), m_slotid(fe)
+eDVBFrontend::eDVBFrontend(int adap, int fe, int &ok, bool simulate, eDVBFrontend *simulate_fe)
+       :m_simulate(simulate), m_enabled(false), m_type(-1), m_simulate_fe(simulate_fe), m_dvbid(fe), m_slotid(fe)
        ,m_fd(-1), m_rotor_mode(false), m_need_rotor_workaround(false), m_can_handle_dvbs2(false)
        ,m_state(stateClosed), m_timeout(0), m_tuneTimer(0)
 #if HAVE_DVB_API_VERSION < 3
@@ -503,10 +503,10 @@ int eDVBFrontend::openFrontend()
 #else
        dvb_frontend_info fe_info;
 #endif
-       eDebugNoSimulate("opening frontend %d", m_dvbid);
-       if (m_fd < 0)
+       if (!m_simulate)
        {
-               if (!m_simulate || m_type == -1)
+               eDebug("opening frontend %d", m_dvbid);
+               if (m_fd < 0)
                {
                        m_fd = ::open(m_filename, O_RDWR|O_NONBLOCK);
                        if (m_fd < 0)
@@ -515,70 +515,69 @@ int eDVBFrontend::openFrontend()
                                return -1;
                        }
                }
-       }
-       else
-               eWarning("frontend %d already opened", m_dvbid);
-       if (m_type == -1)
-       {
-               if (::ioctl(m_fd, FE_GET_INFO, &fe_info) < 0)
+               else
+                       eWarning("frontend %d already opened", m_dvbid);
+               if (m_type == -1)
                {
-                       eWarning("ioctl FE_GET_INFO failed");
-                       ::close(m_fd);
-                       m_fd = -1;
-                       return -1;
-               }
+                       if (::ioctl(m_fd, FE_GET_INFO, &fe_info) < 0)
+                       {
+                               eWarning("ioctl FE_GET_INFO failed");
+                               ::close(m_fd);
+                               m_fd = -1;
+                               return -1;
+                       }
 
-               switch (fe_info.type)
-               {
-               case FE_QPSK:
-                       m_type = iDVBFrontend::feSatellite;
-                       break;
-               case FE_QAM:
-                       m_type = iDVBFrontend::feCable;
-                       break;
-               case FE_OFDM:
-                       m_type = iDVBFrontend::feTerrestrial;
-                       break;
-               default:
-                       eWarning("unknown frontend type.");
-                       ::close(m_fd);
-                       m_fd = -1;
-                       return -1;
+                       switch (fe_info.type)
+                       {
+                       case FE_QPSK:
+                               m_type = iDVBFrontend::feSatellite;
+                               break;
+                       case FE_QAM:
+                               m_type = iDVBFrontend::feCable;
+                               break;
+                       case FE_OFDM:
+                               m_type = iDVBFrontend::feTerrestrial;
+                               break;
+                       default:
+                               eWarning("unknown frontend type.");
+                               ::close(m_fd);
+                               m_fd = -1;
+                               return -1;
+                       }
+                       if (m_simulate_fe)
+                               m_simulate_fe->m_type = m_type;
+                       eDebugNoSimulate("detected %s frontend", "satellite\0cable\0    terrestrial"+fe_info.type*10);
                }
-               eDebugNoSimulate("detected %s frontend", "satellite\0cable\0    terrestrial"+fe_info.type*10);
-       }
 
 #if HAVE_DVB_API_VERSION < 3
-       if (m_type == iDVBFrontend::feSatellite)
-       {
-                       if (m_secfd < 0)
-                       {
-                               if (!m_simulate)
+               if (m_type == iDVBFrontend::feSatellite)
+               {
+                               if (m_secfd < 0)
                                {
-                                       m_secfd = ::open(m_sec_filename, O_RDWR);
-                                       if (m_secfd < 0)
+                                       if (!m_simulate)
                                        {
-                                               eWarning("failed! (%s) %m", m_sec_filename);
-                                               ::close(m_fd);
-                                               m_fd=-1;
-                                               return -1;
+                                               m_secfd = ::open(m_sec_filename, O_RDWR);
+                                               if (m_secfd < 0)
+                                               {
+                                                       eWarning("failed! (%s) %m", m_sec_filename);
+                                                       ::close(m_fd);
+                                                       m_fd=-1;
+                                                       return -1;
+                                               }
                                        }
                                }
-                       }
-                       else
-                               eWarning("sec %d already opened", m_dvbid);
-       }
+                               else
+                                       eWarning("sec %d already opened", m_dvbid);
+               }
 #endif
 
-       setTone(iDVBFrontend::toneOff);
-       setVoltage(iDVBFrontend::voltageOff);
-
-       if (!m_simulate)
-       {
                m_sn = eSocketNotifier::create(eApp, m_fd, eSocketNotifier::Read, false);
                CONNECT(m_sn->activated, eDVBFrontend::feEvent);
        }
 
+       setTone(iDVBFrontend::toneOff);
+       setVoltage(iDVBFrontend::voltageOff);
+
        return 0;
 }
 
index bef4a18..5887f40 100644 (file)
@@ -72,6 +72,7 @@ private:
        bool m_simulate;
        bool m_enabled;
        int m_type;
+       eDVBFrontend *m_simulate_fe; // only used to set frontend type in dvb.cpp
        int m_dvbid;
        int m_slotid;
        int m_fd;
@@ -115,7 +116,7 @@ private:
        bool setSecSequencePos(int steps);
        static int PriorityOrder;
 public:
-       eDVBFrontend(int adap, int fe, int &ok, bool simulate=false);
+       eDVBFrontend(int adap, int fe, int &ok, bool simulate=false, eDVBFrontend *simulate_fe=NULL);
        virtual ~eDVBFrontend();
 
        int readInputpower();
index a2bc886..e4f00ad 100644 (file)
@@ -324,6 +324,10 @@ RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPA
                        bool diseqc13V = voltage_mode == eDVBSatelliteSwitchParameters::HV_13;
                        bool is_unicable = lnb_param.SatCR_idx != -1;
 
+                       bool useGotoXX = false;
+                       int RotorCmd=-1;
+                       int send_mask = 0;
+
                        lnb_param.guard_offset = 0; //HACK
 
                        frontend.setData(eDVBFrontend::SATCR, lnb_param.SatCR_idx);
@@ -411,6 +415,7 @@ RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPA
                                                eDebug("[prepare] UnicableTuningWord %#04x",lnb_param.UnicableTuningWord);
                                                eDebug("[prepare] guard_offset %d",lnb_param.guard_offset);
                                frontend.setData(eDVBFrontend::FREQ_OFFSET, (lnb_param.UnicableTuningWord & 0x3FF) *4000 + 1400000 + lof - (2 * (lnb_param.SatCRvco - (tmp1-tmp2))) );
+                               voltage = VOLTAGE(13);
                        }
 
                        if (diseqc_mode >= eDVBSatelliteDiseqcParameters::V1_0)
@@ -433,7 +438,7 @@ RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPA
                                        (di_param.m_toneburst_param != eDVBSatelliteDiseqcParameters::NO);
                                bool changed_burst = send_burst && (forceChanged || toneburst != lastToneburst);
 
-                               int send_mask = 0; /*
+                               /* send_mask
                                        1 must send csw
                                        2 must send ucsw
                                        4 send toneburst first
@@ -487,8 +492,7 @@ RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPA
 #endif
                                if (doSetVoltageToneFrontend)
                                {
-                                       int RotorCmd=-1;
-                                       bool useGotoXX = false;
+
                                        if ( diseqc_mode == eDVBSatelliteDiseqcParameters::V1_2
                                                && !sat.no_rotor_command_on_tune )
                                        {
@@ -561,7 +565,7 @@ RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPA
                                                        vlt = iDVBFrontend::voltage13;
                                                else if ( RotorCmd != -1 && RotorCmd != lastRotorCmd )
                                                {
-                                                       if (rotor_param.m_inputpower_parameters.m_use)
+                                                       if (rotor_param.m_inputpower_parameters.m_use && !is_unicable)
                                                                vlt = VOLTAGE(18);  // in input power mode set 18V for measure input power
                                                        else
                                                                vlt = VOLTAGE(13);  // in normal mode start turning with 13V
@@ -687,187 +691,6 @@ RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPA
                                                }
                                        }
 
-                                       eDebugNoSimulate("RotorCmd %02x, lastRotorCmd %02lx", RotorCmd, lastRotorCmd);
-                                       if ( RotorCmd != -1 && RotorCmd != lastRotorCmd )
-                                       {
-                                               eSecCommand::pair compare;
-                                               if (!send_mask && !is_unicable)
-                                               {
-                                                       compare.steps = +3;
-                                                       compare.tone = iDVBFrontend::toneOff;
-                                                       sec_sequence.push_back( eSecCommand(eSecCommand::IF_TONE_GOTO, compare) );
-                                                       sec_sequence.push_back( eSecCommand(eSecCommand::SET_TONE, iDVBFrontend::toneOff) );
-                                                       sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_AFTER_CONT_TONE_DISABLE_BEFORE_DISEQC]) );
-
-                                                       compare.voltage = iDVBFrontend::voltageOff;
-                                                       compare.steps = +4;
-                                                       // the next is a check if voltage is switched off.. then we first set a voltage :)
-                                                       // else we set voltage after all diseqc stuff..
-                                                       sec_sequence.push_back( eSecCommand(eSecCommand::IF_NOT_VOLTAGE_GOTO, compare) );
-
-                                                       if (rotor_param.m_inputpower_parameters.m_use)
-                                                               sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, VOLTAGE(18)) ); // set 18V for measure input power
-                                                       else
-                                                               sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, VOLTAGE(13)) ); // in normal mode start turning with 13V
-
-                                                       sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_AFTER_ENABLE_VOLTAGE_BEFORE_MOTOR_CMD]) ); // wait 750ms when voltage was disabled
-                                                       sec_sequence.push_back( eSecCommand(eSecCommand::GOTO, +9) );  // no need to send stop rotor cmd and recheck voltage
-                                               }
-                                               else
-                                                       sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_BETWEEN_SWITCH_AND_MOTOR_CMD]) ); // wait 700ms when diseqc changed
-
-                                               eDVBDiseqcCommand diseqc;
-                                               memset(diseqc.data, 0, MAX_DISEQC_LENGTH);
-                                               diseqc.len = 3;
-                                               diseqc.data[0] = 0xE0;
-                                               diseqc.data[1] = 0x31;  // positioner
-                                               diseqc.data[2] = 0x60;  // stop
-                                               sec_sequence.push_back( eSecCommand(eSecCommand::IF_ROTORPOS_VALID_GOTO, +5) );
-                                               sec_sequence.push_back( eSecCommand(eSecCommand::SEND_DISEQC, diseqc) );
-                                               sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 50) );
-                                               sec_sequence.push_back( eSecCommand(eSecCommand::SEND_DISEQC, diseqc) );
-                                               // wait 150msec after send rotor stop cmd
-                                               sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_AFTER_MOTOR_STOP_CMD]) );
-
-                                               diseqc.data[0] = 0xE0;
-                                               diseqc.data[1] = 0x31;          // positioner
-                                               if ( useGotoXX )
-                                               {
-                                                       diseqc.len = 5;
-                                                       diseqc.data[2] = 0x6E;  // drive to angular position
-                                                       diseqc.data[3] = ((RotorCmd & 0xFF00) / 0x100);
-                                                       diseqc.data[4] = RotorCmd & 0xFF;
-                                               }
-                                               else
-                                               {
-                                                       diseqc.len = 4;
-                                                       diseqc.data[2] = 0x6B;  // goto stored sat position
-                                                       diseqc.data[3] = RotorCmd;
-                                                       diseqc.data[4] = 0x00;
-                                               }
-//                                             if(!is_unicable)
-                                               {
-                                                       int mrt = m_params[MOTOR_RUNNING_TIMEOUT]; // in seconds!
-                                                       if ( rotor_param.m_inputpower_parameters.m_use && !is_unicable)
-                                                       { // use measure rotor input power to detect rotor state
-                                                               bool turn_fast = need_turn_fast(rotor_param.m_inputpower_parameters.m_turning_speed);
-                                                               eSecCommand::rotor cmd;
-                                                               eSecCommand::pair compare;
-                                                               if (turn_fast)
-                                                                       compare.voltage = VOLTAGE(18);
-                                                               else
-                                                                       compare.voltage = VOLTAGE(13);
-                                                               compare.steps = +3;
-                                                               sec_sequence.push_back( eSecCommand(eSecCommand::IF_VOLTAGE_GOTO, compare) );
-                                                               sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, compare.voltage) );
-       // measure idle power values
-                                                               compare.steps = -2;
-                                                               if (turn_fast) {
-                                                                       sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_AFTER_VOLTAGE_CHANGE_BEFORE_MEASURE_IDLE_INPUTPOWER]) );  // wait 150msec after voltage change
-                                                                       sec_sequence.push_back( eSecCommand(eSecCommand::MEASURE_IDLE_INPUTPOWER, 1) );
-                                                                       compare.val = 1;
-                                                                       sec_sequence.push_back( eSecCommand(eSecCommand::IF_MEASURE_IDLE_WAS_NOT_OK_GOTO, compare) );
-                                                                       sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, VOLTAGE(13)) );
-                                                               }
-                                                               sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_AFTER_VOLTAGE_CHANGE_BEFORE_MEASURE_IDLE_INPUTPOWER]) );  // wait 150msec before measure
-                                                               sec_sequence.push_back( eSecCommand(eSecCommand::MEASURE_IDLE_INPUTPOWER, 0) );
-                                                               compare.val = 0;
-                                                               sec_sequence.push_back( eSecCommand(eSecCommand::IF_MEASURE_IDLE_WAS_NOT_OK_GOTO, compare) );
-       ////////////////////////////
-                                                               sec_sequence.push_back( eSecCommand(eSecCommand::SET_ROTOR_DISEQC_RETRYS, m_params[MOTOR_COMMAND_RETRIES]) );  // 2 retries
-                                                               sec_sequence.push_back( eSecCommand(eSecCommand::INVALIDATE_CURRENT_ROTORPARMS) );
-                                                               sec_sequence.push_back( eSecCommand(eSecCommand::SEND_DISEQC, diseqc) );
-                                                               sec_sequence.push_back( eSecCommand(eSecCommand::SET_TIMEOUT, 40) );  // 2 seconds rotor start timout
-       // rotor start loop
-                                                               sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 50) );  // 50msec delay
-                                                               sec_sequence.push_back( eSecCommand(eSecCommand::MEASURE_RUNNING_INPUTPOWER) );
-                                                               cmd.direction=1;  // check for running rotor
-                                                               cmd.deltaA=rotor_param.m_inputpower_parameters.m_delta;
-                                                               cmd.steps=+5;
-                                                               cmd.okcount=0;
-                                                               sec_sequence.push_back( eSecCommand(eSecCommand::IF_INPUTPOWER_DELTA_GOTO, cmd ) );  // check if rotor has started
-                                                               sec_sequence.push_back( eSecCommand(eSecCommand::IF_TIMEOUT_GOTO, +2 ) );  // timeout .. we assume now the rotor is already at the correct position
-                                                               sec_sequence.push_back( eSecCommand(eSecCommand::GOTO, -4) );  // goto loop start
-                                                               sec_sequence.push_back( eSecCommand(eSecCommand::IF_NO_MORE_ROTOR_DISEQC_RETRYS_GOTO, turn_fast ? 10 : 9 ) );  // timeout .. we assume now the rotor is already at the correct position 
-                                                               sec_sequence.push_back( eSecCommand(eSecCommand::GOTO, -8) );  // goto loop start
-       ////////////////////
-                                                               sec_sequence.push_back( eSecCommand(eSecCommand::SET_ROTOR_MOVING) );
-                                                               if (turn_fast)
-                                                                       sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, VOLTAGE(18)) );
-                                                               sec_sequence.push_back( eSecCommand(eSecCommand::SET_TIMEOUT, mrt*20) );  // mrt is in seconds... our SLEEP time is 50ms.. so * 20
-       // rotor running loop
-                                                               sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 50) );  // wait 50msec
-                                                               sec_sequence.push_back( eSecCommand(eSecCommand::MEASURE_RUNNING_INPUTPOWER) );
-                                                               cmd.direction=0;  // check for stopped rotor
-                                                               cmd.steps=+3;
-                                                               sec_sequence.push_back( eSecCommand(eSecCommand::IF_INPUTPOWER_DELTA_GOTO, cmd ) );
-                                                               sec_sequence.push_back( eSecCommand(eSecCommand::IF_TIMEOUT_GOTO, +2 ) );  // timeout ? this should never happen
-                                                               sec_sequence.push_back( eSecCommand(eSecCommand::GOTO, -4) );  // running loop start
-       /////////////////////
-                                                               sec_sequence.push_back( eSecCommand(eSecCommand::UPDATE_CURRENT_ROTORPARAMS) );
-                                                               sec_sequence.push_back( eSecCommand(eSecCommand::SET_ROTOR_STOPPED) );
-                                                       }
-                                                       else
-                                                       {  // use normal turning mode
-                                                               if (curRotorPos != -1)
-                                                               {               
-                                                                       mrt = abs(curRotorPos - sat.orbital_position);
-                                                                       if (mrt > 1800)
-                                                                               mrt = 3600 - mrt;
-                                                                       if (mrt % 10)
-                                                                               mrt += 10; // round a little bit
-                                                                       mrt *= 2000;  // (we assume a very slow rotor with just 0.5 degree per second here)
-                                                                       mrt /= 10000;
-                                                                       mrt += 3; // a little bit overhead
-                                                               }
-                                                               doSetVoltageToneFrontend=false;
-                                                               doSetFrontend=false;
-                                                               eSecCommand::rotor cmd;
-                                                               eSecCommand::pair compare;
-                                                               compare.voltage = VOLTAGE(13);
-                                                               compare.steps = +3;
-                                                               sec_sequence.push_back( eSecCommand(eSecCommand::IF_VOLTAGE_GOTO, compare) );
-                                                               sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, compare.voltage) );
-                                                               sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_AFTER_VOLTAGE_CHANGE_BEFORE_MOTOR_CMD]) );  // wait 150msec after voltage change
-       
-                                                               sec_sequence.push_back( eSecCommand(eSecCommand::INVALIDATE_CURRENT_ROTORPARMS) );
-                                                               sec_sequence.push_back( eSecCommand(eSecCommand::SET_ROTOR_MOVING) );
-                                                               sec_sequence.push_back( eSecCommand(eSecCommand::SEND_DISEQC, diseqc) );
-                                                               sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 1000) ); // sleep one second before change voltage or tone
-
-                                                               compare.voltage = voltage;
-                                                               compare.steps = +3;
-                                                               sec_sequence.push_back( eSecCommand(eSecCommand::IF_VOLTAGE_GOTO, compare) ); // correct final voltage?
-                                                               sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 2000) );  // wait 2 second before set high voltage
-                                                               sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, voltage) );
-
-                                                               compare.tone = tone;
-                                                               sec_sequence.push_back( eSecCommand(eSecCommand::IF_TONE_GOTO, compare) );
-                                                               sec_sequence.push_back( eSecCommand(eSecCommand::SET_TONE, tone) );
-                                                               sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_AFTER_FINAL_CONT_TONE_CHANGE]) );
-                                                               sec_sequence.push_back( eSecCommand(eSecCommand::SET_FRONTEND, 0) );
-       
-                                                               cmd.direction=1;  // check for running rotor
-                                                               cmd.deltaA=0;
-                                                               cmd.steps = +3;
-                                                               cmd.okcount=0;
-                                                               sec_sequence.push_back( eSecCommand(eSecCommand::SET_TIMEOUT, mrt*4) );  // mrt is in seconds... our SLEEP time is 250ms.. so * 4
-                                                               sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 250) );  // 250msec delay
-                                                               sec_sequence.push_back( eSecCommand(eSecCommand::IF_TUNER_LOCKED_GOTO, cmd ) );
-                                                               sec_sequence.push_back( eSecCommand(eSecCommand::IF_TIMEOUT_GOTO, +5 ) );
-                                                               sec_sequence.push_back( eSecCommand(eSecCommand::GOTO, -3) );  // goto loop start
-                                                               sec_sequence.push_back( eSecCommand(eSecCommand::UPDATE_CURRENT_ROTORPARAMS) );
-                                                               sec_sequence.push_back( eSecCommand(eSecCommand::SET_ROTOR_STOPPED) );
-                                                               sec_sequence.push_back( eSecCommand(eSecCommand::GOTO, +4) );
-                                                               sec_sequence.push_back( eSecCommand(eSecCommand::START_TUNE_TIMEOUT, tunetimeout) );
-                                                               sec_sequence.push_back( eSecCommand(eSecCommand::SET_FRONTEND, 1) );
-                                                               sec_sequence.push_back( eSecCommand(eSecCommand::GOTO, -5) );
-                                                       }
-                                                       eDebug("set rotor timeout to %d seconds", mrt);
-                                                       sec_fe->setData(eDVBFrontend::NEW_ROTOR_CMD, RotorCmd);
-                                                       sec_fe->setData(eDVBFrontend::NEW_ROTOR_POS, sat.orbital_position);
-                                               }
-                                       }
                                }
                        }
                        else
@@ -880,22 +703,6 @@ RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPA
                        sec_fe->setData(eDVBFrontend::NEW_UCSW, ucsw);
                        sec_fe->setData(eDVBFrontend::NEW_TONEBURST, di_param.m_toneburst_param);
 
-                       if (doSetVoltageToneFrontend && !is_unicable)
-                       {
-                               eSecCommand::pair compare;
-                               compare.voltage = voltage;
-                               compare.steps = +3;
-                               sec_sequence.push_back( eSecCommand(eSecCommand::IF_VOLTAGE_GOTO, compare) ); // voltage already correct ?
-                               sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, voltage) );
-                               sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_AFTER_FINAL_VOLTAGE_CHANGE]) );
-                               compare.tone = tone;
-                               sec_sequence.push_back( eSecCommand(eSecCommand::IF_TONE_GOTO, compare) );
-                               sec_sequence.push_back( eSecCommand(eSecCommand::SET_TONE, tone) );
-                               sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_AFTER_FINAL_CONT_TONE_CHANGE]) );
-                       }
-
-                       sec_sequence.push_back( eSecCommand(eSecCommand::UPDATE_CURRENT_SWITCHPARMS) );
-
                        if(is_unicable)
                        {
                                // check if voltage is disabled
@@ -903,10 +710,10 @@ RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPA
                                compare.steps = +3;
                                compare.voltage = iDVBFrontend::voltageOff;
                                sec_sequence.push_back( eSecCommand(eSecCommand::IF_NOT_VOLTAGE_GOTO, compare) );
-                               sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, iDVBFrontend::voltage13) );
+                               sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, VOLTAGE(13)) );
                                sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_AFTER_ENABLE_VOLTAGE_BEFORE_SWITCH_CMDS] ) );
 
-                               sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, iDVBFrontend::voltage18_5) );
+                               sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, VOLTAGE(18)) );
                                sec_sequence.push_back( eSecCommand(eSecCommand::SET_TONE, iDVBFrontend::toneOff) );
                                sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_AFTER_VOLTAGE_CHANGE_BEFORE_SWITCH_CMDS]) );  // wait 20 ms after voltage change
        
@@ -921,9 +728,209 @@ RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPA
 
                                sec_sequence.push_back( eSecCommand(eSecCommand::SEND_DISEQC, diseqc) );
                                sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_AFTER_LAST_DISEQC_CMD]) );
-                               sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, iDVBFrontend::voltage13) );
+                               sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, VOLTAGE(13)) );
+                               if ( RotorCmd != -1 && RotorCmd != lastRotorCmd && !rotor_param.m_inputpower_parameters.m_use)
+                                       sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_AFTER_VOLTAGE_CHANGE_BEFORE_MOTOR_CMD]) );  // wait 150msec after voltage change
                        }
 
+                       eDebugNoSimulate("RotorCmd %02x, lastRotorCmd %02lx", RotorCmd, lastRotorCmd);
+                       if ( RotorCmd != -1 && RotorCmd != lastRotorCmd )
+                       {
+                               eSecCommand::pair compare;
+                               if (!send_mask && !is_unicable)
+                               {
+                                       compare.steps = +3;
+                                       compare.tone = iDVBFrontend::toneOff;
+                                       sec_sequence.push_back( eSecCommand(eSecCommand::IF_TONE_GOTO, compare) );
+                                       sec_sequence.push_back( eSecCommand(eSecCommand::SET_TONE, iDVBFrontend::toneOff) );
+                                       sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_AFTER_CONT_TONE_DISABLE_BEFORE_DISEQC]) );
+
+                                       compare.voltage = iDVBFrontend::voltageOff;
+                                       compare.steps = +4;
+                                       // the next is a check if voltage is switched off.. then we first set a voltage :)
+                                       // else we set voltage after all diseqc stuff..
+                                       sec_sequence.push_back( eSecCommand(eSecCommand::IF_NOT_VOLTAGE_GOTO, compare) );
+
+                                       if (rotor_param.m_inputpower_parameters.m_use)
+                                               sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, VOLTAGE(18)) ); // set 18V for measure input power
+                                       else
+                                               sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, VOLTAGE(13)) ); // in normal mode start turning with 13V
+
+                                       sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_AFTER_ENABLE_VOLTAGE_BEFORE_MOTOR_CMD]) ); // wait 750ms when voltage was disabled
+                                       sec_sequence.push_back( eSecCommand(eSecCommand::GOTO, +9) );  // no need to send stop rotor cmd and recheck voltage
+                               }
+                               else
+                                       sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_BETWEEN_SWITCH_AND_MOTOR_CMD]) ); // wait 700ms when diseqc changed
+
+                               eDVBDiseqcCommand diseqc;
+                               memset(diseqc.data, 0, MAX_DISEQC_LENGTH);
+                               diseqc.len = 3;
+                               diseqc.data[0] = 0xE0;
+                               diseqc.data[1] = 0x31;  // positioner
+                               diseqc.data[2] = 0x60;  // stop
+                               sec_sequence.push_back( eSecCommand(eSecCommand::IF_ROTORPOS_VALID_GOTO, +5) );
+                               sec_sequence.push_back( eSecCommand(eSecCommand::SEND_DISEQC, diseqc) );
+                               sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 50) );
+                               sec_sequence.push_back( eSecCommand(eSecCommand::SEND_DISEQC, diseqc) );
+                               // wait 150msec after send rotor stop cmd
+                               sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_AFTER_MOTOR_STOP_CMD]) );
+
+                               diseqc.data[0] = 0xE0;
+                               diseqc.data[1] = 0x31;          // positioner
+                               if ( useGotoXX )
+                               {
+                                       diseqc.len = 5;
+                                       diseqc.data[2] = 0x6E;  // drive to angular position
+                                       diseqc.data[3] = ((RotorCmd & 0xFF00) / 0x100);
+                                       diseqc.data[4] = RotorCmd & 0xFF;
+                               }
+                               else
+                               {
+                                       diseqc.len = 4;
+                                       diseqc.data[2] = 0x6B;  // goto stored sat position
+                                       diseqc.data[3] = RotorCmd;
+                                       diseqc.data[4] = 0x00;
+                               }
+
+                               {
+                                       int mrt = m_params[MOTOR_RUNNING_TIMEOUT]; // in seconds!
+                                       if ( rotor_param.m_inputpower_parameters.m_use)
+                                       { // use measure rotor input power to detect rotor state
+                                               bool turn_fast = need_turn_fast(rotor_param.m_inputpower_parameters.m_turning_speed) && !is_unicable;
+                                               eSecCommand::rotor cmd;
+                                               eSecCommand::pair compare;
+                                               if (turn_fast)
+                                                       compare.voltage = VOLTAGE(18);
+                                               else
+                                                       compare.voltage = VOLTAGE(13);
+                                               compare.steps = +3;
+                                               sec_sequence.push_back( eSecCommand(eSecCommand::IF_VOLTAGE_GOTO, compare) );
+                                               sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, compare.voltage) );
+       // measure idle power values
+                                               compare.steps = -2;
+                                               if (turn_fast) {
+                                                       sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_AFTER_VOLTAGE_CHANGE_BEFORE_MEASURE_IDLE_INPUTPOWER]) );  // wait 150msec after voltage change
+                                                       sec_sequence.push_back( eSecCommand(eSecCommand::MEASURE_IDLE_INPUTPOWER, 1) );
+                                                       compare.val = 1;
+                                                       sec_sequence.push_back( eSecCommand(eSecCommand::IF_MEASURE_IDLE_WAS_NOT_OK_GOTO, compare) );
+                                                       sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, VOLTAGE(13)) );
+                                               }
+                                               sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_AFTER_VOLTAGE_CHANGE_BEFORE_MEASURE_IDLE_INPUTPOWER]) );  // wait 150msec before measure
+                                               sec_sequence.push_back( eSecCommand(eSecCommand::MEASURE_IDLE_INPUTPOWER, 0) );
+                                               compare.val = 0;
+                                               sec_sequence.push_back( eSecCommand(eSecCommand::IF_MEASURE_IDLE_WAS_NOT_OK_GOTO, compare) );
+       ////////////////////////////
+                                               sec_sequence.push_back( eSecCommand(eSecCommand::SET_ROTOR_DISEQC_RETRYS, m_params[MOTOR_COMMAND_RETRIES]) );  // 2 retries
+                                               sec_sequence.push_back( eSecCommand(eSecCommand::INVALIDATE_CURRENT_ROTORPARMS) );
+                                               sec_sequence.push_back( eSecCommand(eSecCommand::SEND_DISEQC, diseqc) );
+                                               sec_sequence.push_back( eSecCommand(eSecCommand::SET_TIMEOUT, 40) );  // 2 seconds rotor start timout
+       // rotor start loop
+                                               sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 50) );  // 50msec delay
+                                               sec_sequence.push_back( eSecCommand(eSecCommand::MEASURE_RUNNING_INPUTPOWER) );
+                                               cmd.direction=1;  // check for running rotor
+                                               cmd.deltaA=rotor_param.m_inputpower_parameters.m_delta;
+                                               cmd.steps=+5;
+                                               cmd.okcount=0;
+                                               sec_sequence.push_back( eSecCommand(eSecCommand::IF_INPUTPOWER_DELTA_GOTO, cmd ) );  // check if rotor has started
+                                               sec_sequence.push_back( eSecCommand(eSecCommand::IF_TIMEOUT_GOTO, +2 ) );  // timeout .. we assume now the rotor is already at the correct position
+                                               sec_sequence.push_back( eSecCommand(eSecCommand::GOTO, -4) );  // goto loop start
+                                               sec_sequence.push_back( eSecCommand(eSecCommand::IF_NO_MORE_ROTOR_DISEQC_RETRYS_GOTO, turn_fast ? 10 : 9 ) );  // timeout .. we assume now the rotor is already at the correct position 
+                                               sec_sequence.push_back( eSecCommand(eSecCommand::GOTO, -8) );  // goto loop start
+       ////////////////////
+                                               sec_sequence.push_back( eSecCommand(eSecCommand::SET_ROTOR_MOVING) );
+                                               if (turn_fast)
+                                                       sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, VOLTAGE(18)) );
+                                               sec_sequence.push_back( eSecCommand(eSecCommand::SET_TIMEOUT, mrt*20) );  // mrt is in seconds... our SLEEP time is 50ms.. so * 20
+       // rotor running loop
+                                               sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 50) );  // wait 50msec
+                                               sec_sequence.push_back( eSecCommand(eSecCommand::MEASURE_RUNNING_INPUTPOWER) );
+                                               cmd.direction=0;  // check for stopped rotor
+                                               cmd.steps=+3;
+                                               sec_sequence.push_back( eSecCommand(eSecCommand::IF_INPUTPOWER_DELTA_GOTO, cmd ) );
+                                               sec_sequence.push_back( eSecCommand(eSecCommand::IF_TIMEOUT_GOTO, +2 ) );  // timeout ? this should never happen
+                                               sec_sequence.push_back( eSecCommand(eSecCommand::GOTO, -4) );  // running loop start
+       /////////////////////
+                                               sec_sequence.push_back( eSecCommand(eSecCommand::UPDATE_CURRENT_ROTORPARAMS) );
+                                               sec_sequence.push_back( eSecCommand(eSecCommand::SET_ROTOR_STOPPED) );
+                                       }
+                                       else
+                                       { // use normal turning mode
+                                               if (curRotorPos != -1)
+                                               {
+                                                       mrt = abs(curRotorPos - sat.orbital_position);
+                                                       if (mrt > 1800)
+                                                               mrt = 3600 - mrt;
+                                                       if (mrt % 10)
+                                                               mrt += 10; // round a little bit
+                                                       mrt *= 2000;  // (we assume a very slow rotor with just 0.5 degree per second here)
+                                                       mrt /= 10000;
+                                                       mrt += 3; // a little bit overhead
+                                               }
+                                               doSetVoltageToneFrontend=false;
+                                               doSetFrontend=false;
+                                               eSecCommand::rotor cmd;
+                                               eSecCommand::pair compare;
+                                               compare.voltage = VOLTAGE(13);
+                                               compare.steps = +3;
+                                               sec_sequence.push_back( eSecCommand(eSecCommand::IF_VOLTAGE_GOTO, compare) );
+                                               sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, compare.voltage) );
+                                               sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_AFTER_VOLTAGE_CHANGE_BEFORE_MOTOR_CMD]) );  // wait 150msec after voltage change
+
+                                               sec_sequence.push_back( eSecCommand(eSecCommand::INVALIDATE_CURRENT_ROTORPARMS) );
+                                               sec_sequence.push_back( eSecCommand(eSecCommand::SET_ROTOR_MOVING) );
+                                               sec_sequence.push_back( eSecCommand(eSecCommand::SEND_DISEQC, diseqc) );
+                                               sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 1000) ); // sleep one second before change voltage or tone
+
+                                               compare.voltage = voltage;
+                                               compare.steps = +3;
+                                               sec_sequence.push_back( eSecCommand(eSecCommand::IF_VOLTAGE_GOTO, compare) ); // correct final voltage?
+                                               sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 2000) );  // wait 2 second before set high voltage
+                                               sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, voltage) );
+
+                                               compare.tone = tone;
+                                               sec_sequence.push_back( eSecCommand(eSecCommand::IF_TONE_GOTO, compare) );
+                                               sec_sequence.push_back( eSecCommand(eSecCommand::SET_TONE, tone) );
+                                               sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_AFTER_FINAL_CONT_TONE_CHANGE]) );
+                                               sec_sequence.push_back( eSecCommand(eSecCommand::SET_FRONTEND, 0) );
+
+                                               cmd.direction=1;  // check for running rotor
+                                               cmd.deltaA=0;
+                                               cmd.steps = +3;
+                                               cmd.okcount=0;
+                                               sec_sequence.push_back( eSecCommand(eSecCommand::SET_TIMEOUT, mrt*4) );  // mrt is in seconds... our SLEEP time is 250ms.. so * 4
+                                               sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 250) );  // 250msec delay
+                                               sec_sequence.push_back( eSecCommand(eSecCommand::IF_TUNER_LOCKED_GOTO, cmd ) );
+                                               sec_sequence.push_back( eSecCommand(eSecCommand::IF_TIMEOUT_GOTO, +5 ) );
+                                               sec_sequence.push_back( eSecCommand(eSecCommand::GOTO, -3) );  // goto loop start
+                                               sec_sequence.push_back( eSecCommand(eSecCommand::UPDATE_CURRENT_ROTORPARAMS) );
+                                               sec_sequence.push_back( eSecCommand(eSecCommand::SET_ROTOR_STOPPED) );
+                                               sec_sequence.push_back( eSecCommand(eSecCommand::GOTO, +4) );
+                                               sec_sequence.push_back( eSecCommand(eSecCommand::START_TUNE_TIMEOUT, tunetimeout) );
+                                               sec_sequence.push_back( eSecCommand(eSecCommand::SET_FRONTEND, 1) );
+                                               sec_sequence.push_back( eSecCommand(eSecCommand::GOTO, -5) );
+                                       }
+                                       eDebug("set rotor timeout to %d seconds", mrt);
+                                       sec_fe->setData(eDVBFrontend::NEW_ROTOR_CMD, RotorCmd);
+                                       sec_fe->setData(eDVBFrontend::NEW_ROTOR_POS, sat.orbital_position);
+                               }
+                       }
+
+                       if (doSetVoltageToneFrontend && !is_unicable)
+                       {
+                               eSecCommand::pair compare;
+                               compare.voltage = voltage;
+                               compare.steps = +3;
+                               sec_sequence.push_back( eSecCommand(eSecCommand::IF_VOLTAGE_GOTO, compare) ); // voltage already correct ?
+                               sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, voltage) );
+                               sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_AFTER_FINAL_VOLTAGE_CHANGE]) );
+                               compare.tone = tone;
+                               sec_sequence.push_back( eSecCommand(eSecCommand::IF_TONE_GOTO, compare) );
+                               sec_sequence.push_back( eSecCommand(eSecCommand::SET_TONE, tone) );
+                               sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_AFTER_FINAL_CONT_TONE_CHANGE]) );
+                       }
+
+                       sec_sequence.push_back( eSecCommand(eSecCommand::UPDATE_CURRENT_SWITCHPARMS) );
+
                        if (doSetFrontend)
                        {
                                sec_sequence.push_back( eSecCommand(eSecCommand::START_TUNE_TIMEOUT, tunetimeout) );
index 2daeeff..1eacc29 100644 (file)
@@ -90,9 +90,9 @@ void Cexif::ClearExif()
 
 bool Cexif::DecodeExif(const char *filename, int Thumb)
 {
+       bool ret = false;
        FILE * hFile = fopen(filename, "r");
-       if(!hFile) return false;
-
+       if(!hFile) return ret;
 
        m_exifinfo = new EXIFINFO;
        memset(m_exifinfo,0,sizeof(EXIFINFO));
@@ -107,7 +107,8 @@ bool Cexif::DecodeExif(const char *filename, int Thumb)
        int a = fgetc(hFile);
        strcpy(m_szLastError,"EXIF-Data not found");
 
-       if (a != 0xff || fgetc(hFile) != M_SOI) return false;
+       if (a != 0xff || fgetc(hFile) != M_SOI)
+               goto decode_exif_out_false;
 
        for(;;)
        {
@@ -117,7 +118,8 @@ bool Cexif::DecodeExif(const char *filename, int Thumb)
 
                if (SectionsRead >= MAX_SECTIONS)
                {
-                       strcpy(m_szLastError,"Too many sections in jpg file"); return false;
+                       strcpy(m_szLastError,"Too many sections in jpg file");
+                       goto decode_exif_out_false;
                }
 
                for (a=0;a<7;a++)
@@ -127,13 +129,15 @@ bool Cexif::DecodeExif(const char *filename, int Thumb)
 
                        if (a >= 6)
                        {
-                               strcpy(m_szLastError,"too many padding unsigned chars\n"); return false;
+                               strcpy(m_szLastError,"too many padding unsigned chars\n");
+                               goto decode_exif_out_false;
                        }
                }
 
                if (marker == 0xff)
                {
-                       strcpy(m_szLastError,"too many padding unsigned chars!"); return false;
+                       strcpy(m_szLastError,"too many padding unsigned chars!");
+                       goto decode_exif_out_false;
                }
 
                Sections[SectionsRead].Type = marker;
@@ -145,14 +149,16 @@ bool Cexif::DecodeExif(const char *filename, int Thumb)
 
                if (itemlen < 2)
                {
-                       strcpy(m_szLastError,"invalid marker"); return false;
+                       strcpy(m_szLastError,"invalid marker");
+                       goto decode_exif_out_false;
                }
                Sections[SectionsRead].Size = itemlen;
 
                Data = (unsigned char *)malloc(itemlen);
                if (Data == NULL)
                {
-                       strcpy(m_szLastError,"Could not allocate memory"); return false;
+                       strcpy(m_szLastError,"Could not allocate memory");
+                       goto decode_exif_out_false;
                }
                Sections[SectionsRead].Data = Data;
 
@@ -163,17 +169,18 @@ bool Cexif::DecodeExif(const char *filename, int Thumb)
                got = fread(Data+2, 1, itemlen-2,hFile);
                if (got != itemlen-2)
                {
-                       strcpy(m_szLastError,"Premature end of file?"); return false;
+                       strcpy(m_szLastError,"Premature end of file?");
+                       goto decode_exif_out_false;
                }
                SectionsRead += 1;
 
                switch(marker)
                {
                case M_SOS:
-                       return true;
+                       goto decode_exif_out_true;
                case M_EOI:
                        printf("No image in jpeg!\n");
-                       return false;
+                       goto decode_exif_out_false;
                case M_COM:
                        if (HaveCom)
                        {
@@ -221,8 +228,12 @@ bool Cexif::DecodeExif(const char *filename, int Thumb)
                }
        }
 
+decode_exif_out_true:
+       ret = true;
+
+decode_exif_out_false:
        fclose(hFile);
-       return true;
+       return ret;
 }
 
 bool Cexif::process_EXIF(unsigned char * CharBuf, unsigned int length)
index 8e9c29d..8097365 100755 (executable)
@@ -84,6 +84,8 @@ class InfoHandler(xml.sax.ContentHandler):
                                self.attributes["packagename"] = str(attrs["packagename"])
                        if attrs.has_key("packagetype"):
                                self.attributes["packagetype"] = str(attrs["packagetype"])
+                       if attrs.has_key("needsRestart"):
+                               self.attributes["needsRestart"] = str(attrs["needsRestart"])
                        if attrs.has_key("shortdescription"):
                                self.attributes["shortdescription"] = str(attrs["shortdescription"])
 
@@ -120,6 +122,8 @@ class InfoHandler(xml.sax.ContentHandler):
                        self.attributes["name"] = str(data)
                if self.elements[-1] == "packagename":
                        self.attributes["packagename"] = str(data)
+               if self.elements[-1] == "needsRestart":
+                       self.attributes["needsRestart"] = str(data)
                if self.elements[-1] == "shortdescription":
                        self.attributes["shortdescription"] = str(data)
                if self.elements[-1] == "description":
index 04511d2..32b8bdb 100755 (executable)
@@ -20,9 +20,8 @@ class Network:
                self.Console = Console()
                self.LinkConsole = Console()
                self.restartConsole = Console()
-               self.deactivateConsole = Console()
                self.deactivateInterfaceConsole = Console()
-               self.activateConsole = Console()
+               self.activateInterfaceConsole = Console()
                self.resetNetworkConsole = Console()
                self.DnsConsole = Console()
                self.PingConsole = Console()
@@ -30,37 +29,29 @@ class Network:
                self.friendlyNames = {}
                self.lan_interfaces = []
                self.wlan_interfaces = []
+               self.remoteRootFS = 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
+               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):
-               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])
+               for device in self.getInstalledAdapters():
+                       self.getAddrInet(device, callback)
 
        # helper function
        def regExpMatch(self, pattern, string):
@@ -69,21 +60,16 @@ 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,callback):
-               #get ip out of ip addr, as avahi sometimes overrides it in ifconfig.
+               return [ int(n) for n in ip.split('.') ]
+
+       def getAddrInet(self, iface, callback):
                if not self.Console:
                        self.Console = Console()
-               cmd = "ip -o addr"
+               cmd = "ip -o addr show dev " + iface
                self.Console.ePopen(cmd, self.IPaddrFinished, [iface,callback])
 
        def IPaddrFinished(self, result, retval, extra_args):
@@ -92,14 +78,14 @@ class Network:
                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}'
+               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('[0-9]{2}\:[0-9]{2}\:[0-9]{2}\:[a-z0-9]{2}\:[a-z0-9]{2}\:[a-z0-9]{2}')
+               macPattern = re_compile(macRegexp)
                macLinePattern = re_compile('link/ether ' + macRegexp)
                
                for line in result.splitlines():
@@ -144,7 +130,7 @@ class Network:
                        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)
                                        
                self.ifaces[iface] = data
@@ -176,8 +162,9 @@ class Network:
                                fp.write(iface["preup"])
                        if iface["predown"] is not False and not iface.has_key("configStrings"):
                                fp.write(iface["predown"])
-                       fp.write("\n")
+                       fp.write("\n")                          
                fp.close()
+               self.configuredNetworkAdapters = self.configuredInterfaces
                self.writeNameserverConfig()
 
        def writeNameserverConfig(self):
@@ -263,49 +250,13 @@ 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, 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 deactivateNetworkFinished(self,extra_args):
-               callback = extra_args
-               if len(self.deactivateConsole.appContainers) == 0:
-                       if callback is not None:
-                               callback(True)
-
-       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 activateNetworkFinished(self,extra_args):
-               callback = extra_args
-               if len(self.activateConsole.appContainers) == 0:
-                       if callback is not None:
-                               callback(True)
+       def getInstalledAdapters(self):
+               return [x for x in listdir('/sys/class/net') if not self.isBlacklisted(x)]
 
        def getConfiguredAdapters(self):
                return self.configuredNetworkAdapters
@@ -316,47 +267,44 @@ class Network:
        def getFriendlyAdapterName(self, x):
                if x in self.friendlyNames.keys():
                        return self.friendlyNames.get(x, x)
-               else:
-                       self.friendlyNames[x] = self.getFriendlyAdapterNaming(x)
-                       return self.friendlyNames.get(x, x) # when we have no friendly name, use adapter name
+               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):
-               if iface.startswith('eth'):
-                       if iface not in self.lan_interfaces and len(self.lan_interfaces) == 0:
-                               self.lan_interfaces.append(iface)
-                               return _("LAN connection")
-                       elif iface not in self.lan_interfaces and len(self.lan_interfaces) >= 1:
-                               self.lan_interfaces.append(iface)
-                               return _("LAN connection") + " " + str(len(self.lan_interfaces))
+               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.wlan_interfaces and len(self.wlan_interfaces) == 0:
-                               self.wlan_interfaces.append(iface)
-                               return _("WLAN connection")
-                       elif iface not in self.wlan_interfaces and len(self.wlan_interfaces) >= 1:
-                               self.wlan_interfaces.append(iface)
-                               return _("WLAN connection") + " " + str(len(self.wlan_interfaces))
-
+                       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 iface == 'eth0':
-                       return _("Internal LAN adapter.")
+               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:
-                       classdir = "/sys/class/net/" + iface + "/device/"
-                       driverdir = "/sys/class/net/" + iface + "/device/driver/"
-                       if os_path.exists(classdir):
-                               files = listdir(classdir)
-                               if 'driver' in files:
-                                       if os_path.realpath(driverdir).endswith('ath_pci'):
-                                               return _("Atheros")+ " " + str(os_path.basename(os_path.realpath(driverdir))) + " " + _("WLAN adapter.") 
-                                       elif os_path.realpath(driverdir).endswith('zd1211b'):
-                                               return _("Zydas")+ " " + str(os_path.basename(os_path.realpath(driverdir))) + " " + _("WLAN adapter.") 
-                                       elif os_path.realpath(driverdir).endswith('rt73'):
-                                               return _("Ralink")+ " " + str(os_path.basename(os_path.realpath(driverdir))) + " " + _("WLAN adapter.") 
-                                       elif os_path.realpath(driverdir).endswith('rt73usb'):
-                                               return _("Ralink")+ " " + str(os_path.basename(os_path.realpath(driverdir))) + " " + _("WLAN adapter.") 
-                                       else:
-                                               return str(os_path.basename(os_path.realpath(driverdir))) + " " + _("WLAN adapter.") 
-                               else:
-                                       return _("Unknown network adapter.")
+                       name = _('Unknown')
+
+               return name + ' ' + _('wireless network interface')
 
        def getAdapterName(self, iface):
                return iface
@@ -404,16 +352,12 @@ class Network:
                                        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)               
+                       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*")
@@ -487,18 +431,15 @@ class Network:
                                        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)               
+                       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*")
@@ -555,9 +496,13 @@ class Network:
                                        
        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)
+                       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:
@@ -590,59 +535,138 @@ class Network:
                                if len(self.DnsConsole.appContainers) == 0:
                                        statecallback(self.DnsState)
 
-       def deactivateInterface(self,iface,callback = None):
-               if self.onRemoteRootFS():
+       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
-               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)
+               if not self.activateInterfaceConsole:
+                       self.activateInterfaceConsole = Console()
+               commands = []
+               commands.append("ifup " + iface)
+               self.activateInterfaceConsole.eBatch(commands, self.activateInterfaceFinished, callback, debug=True)
 
-       def deactivateInterfaceFinished(self,extra_args):
+       def activateInterfaceFinished(self,extra_args):
                callback = extra_args
-               if self.deactivateInterfaceConsole:
-                       if len(self.deactivateInterfaceConsole.appContainers) == 0:
+               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):
-               self.wlanmodule = None
-               classdir = "/sys/class/net/" + iface + "/device/"
-               driverdir = "/sys/class/net/" + iface + "/device/driver/"
-               if os_path.exists(classdir):
-                       classfiles = listdir(classdir)
-                       driver_found = False
-                       nl80211_found = False
-                       for x in classfiles:
-                               if x == 'driver':
-                                       driver_found = True
-                               if x.startswith('ieee80211:'):
-                                       nl80211_found = True
-
-                       if driver_found and nl80211_found:
-                               #print about.getKernelVersionString()
-                               self.wlanmodule = "nl80211"
-                       else:
-                               if driver_found and not nl80211_found:
-                                       driverfiles = listdir(driverdir)
-                                       if os_path.realpath(driverdir).endswith('ath_pci'):
-                                               if len(driverfiles) >= 1:
-                                                       self.wlanmodule = 'madwifi'
-                                       if os_path.realpath(driverdir).endswith('rt73'):
-                                               if len(driverfiles) == 2 or len(driverfiles) == 5:
-                                                       self.wlanmodule = 'ralink'                                      
-                                       if os_path.realpath(driverdir).endswith('zd1211b'):
-                                               if len(driverfiles) == 1 or len(driverfiles) == 5:
-                                                       self.wlanmodule = 'zydas'
-                       if self.wlanmodule is None:
-                               self.wlanmodule = "wext"
-                       print 'Using "%s" as wpa-supplicant driver' % (self.wlanmodule)
-                       return self.wlanmodule
+               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
index 7f7dd5c..bd1a363 100644 (file)
@@ -1361,25 +1361,32 @@ def InitNimManager(nimmgr):
                slot_id = configElement.slot_id
                if nimmgr.nim_slots[slot_id].description == 'Alps BSBE2':
                        open("/proc/stb/frontend/%d/tone_amplitude" %(fe_id), "w").write(configElement.value)
-                       
+
        def tunerTypeChanged(nimmgr, configElement):
                fe_id = configElement.fe_id
-               print "tunerTypeChanged feid %d to mode %s" % (fe_id, configElement.value)
-               try:
-                       oldvalue = open("/sys/module/dvb_core/parameters/dvb_shutdown_timeout", "r").readline()
-                       open("/sys/module/dvb_core/parameters/dvb_shutdown_timeout", "w").write("0")
-               except:
-                       print "[info] no /sys/module/dvb_core/parameters/dvb_shutdown_timeout available"
-               frontend = eDVBResourceManager.getInstance().allocateRawChannel(fe_id).getFrontend()
-               frontend.closeFrontend()
-               open("/proc/stb/frontend/%d/mode" % (fe_id), "w").write(configElement.value)
-               frontend.reopenFrontend()
-               try:
-                       open("/sys/module/dvb_core/parameters/dvb_shutdown_timeout", "w").write(oldvalue)
-               except:
-                       print "[info] no /sys/module/dvb_core/parameters/dvb_shutdown_timeout available"
-               nimmgr.enumerateNIMs()
-       
+
+               cur_type = int(open("/proc/stb/frontend/%d/mode" % (fe_id), "r").read())
+               if cur_type != int(configElement.value):
+                       print "tunerTypeChanged feid %d from %d to mode %d" % (fe_id, cur_type, int(configElement.value))
+
+                       try:
+                               oldvalue = open("/sys/module/dvb_core/parameters/dvb_shutdown_timeout", "r").readline()
+                               open("/sys/module/dvb_core/parameters/dvb_shutdown_timeout", "w").write("0")
+                       except:
+                               print "[info] no /sys/module/dvb_core/parameters/dvb_shutdown_timeout available"
+
+                       frontend = eDVBResourceManager.getInstance().allocateRawChannel(fe_id).getFrontend()
+                       frontend.closeFrontend()
+                       open("/proc/stb/frontend/%d/mode" % (fe_id), "w").write(configElement.value)
+                       frontend.reopenFrontend()
+                       try:
+                               open("/sys/module/dvb_core/parameters/dvb_shutdown_timeout", "w").write(oldvalue)
+                       except:
+                               print "[info] no /sys/module/dvb_core/parameters/dvb_shutdown_timeout available"
+                       nimmgr.enumerateNIMs()
+               else:
+                       print "tuner type is already already %d" %cur_type
+
        empty_slots = 0
        for slot in nimmgr.nim_slots:
                x = slot.slot
index c6ad584..b06246b 100755 (executable)
@@ -49,7 +49,6 @@ class PluginComponent:
                        directory_category = directory + c
                        if not os_path.isdir(directory_category):
                                continue
-                       open(directory_category + "/__init__.py", "a").close()
                        for pluginname in os_listdir(directory_category):
                                path = directory_category + "/" + pluginname
                                if os_path.isdir(path):
index 6e56085..5507cae 100755 (executable)
@@ -1661,9 +1661,12 @@ class Config(ConfigSubsection):
 
        def saveToFile(self, filename):
                text = self.pickle()
-               f = open(filename, "w")
-               f.write(text)
-               f.close()
+               try:
+                       f = open(filename, "w")
+                       f.write(text)
+                       f.close()
+               except IOError:
+                       print "Config: Couldn't write %s" % filename
 
        def loadFromFile(self, filename, base_file=False):
                f = open(filename, "r")
index d7e8307..cb954bb 100755 (executable)
@@ -4,31 +4,10 @@ from Screens.Rc import Rc
 from Screens.MessageBox import MessageBox
 from Components.Pixmap import Pixmap, MovingPixmap, MultiPixmap
 from Components.Sources.Boolean import Boolean
-from Components.config import config, ConfigBoolean, configfile, ConfigYesNo, NoSave, ConfigSubsection, ConfigText, getConfigListEntry, ConfigSelection, ConfigPassword
 from Components.Network import iNetwork
 from Tools.Directories import resolveFilename, SCOPE_PLUGINS, SCOPE_SKIN_IMAGE
 from enigma import eTimer
-
-config.misc.firstrun = ConfigBoolean(default = True)
-list = []
-list.append("WEP")
-list.append("WPA")
-list.append("WPA2")
-list.append("WPA/WPA2")
-
-weplist = []
-weplist.append("ASCII")
-weplist.append("HEX")
-
-config.plugins.wlan = ConfigSubsection()
-config.plugins.wlan.essid = NoSave(ConfigText(default = "home", fixed_size = False))
-config.plugins.wlan.hiddenessid = NoSave(ConfigText(default = "home", fixed_size = False))
-
-config.plugins.wlan.encryption = ConfigSubsection()
-config.plugins.wlan.encryption.enabled = NoSave(ConfigYesNo(default = False))
-config.plugins.wlan.encryption.type = NoSave(ConfigSelection(list, default = "WPA/WPA2" ))
-config.plugins.wlan.encryption.wepkeytype = NoSave(ConfigSelection(weplist, default = "ASCII"))
-config.plugins.wlan.encryption.psk = NoSave(ConfigPassword(default = "mysecurewlan", fixed_size = False))
+from os import system
 
 class NetworkWizard(WizardLanguage, Rc):
        skin = """
@@ -65,8 +44,9 @@ class NetworkWizard(WizardLanguage, Rc):
                self.Adapterlist = None
                self.InterfaceState = None
                self.isInterfaceUp = None
-               self.WlanPluginInstalled = None
+               self.WlanPluginInstalled = False
                self.ap = None
+               self.w = None
                if interface is not None:
                        self.selectedInterface = interface
                else:
@@ -77,11 +57,9 @@ class NetworkWizard(WizardLanguage, Rc):
                self.AdapterRef = None
                self.APList = None
                self.newAPlist = None
-               self.WlanList = None
                self.oldlist = None
-               self.originalAth0State = None
-               self.originalEth0State = None
-               self.originalWlan0State = None
+               
+               self.originalInterfaceState = {}
                self.originalInterfaceStateChanged = False
                self.Text = None
                self.rescanTimer = eTimer()
@@ -95,65 +73,64 @@ class NetworkWizard(WizardLanguage, Rc):
                        self.close()
                
        def markDone(self):
-               self.rescanTimer.stop()
+               self.stopScan()
                del self.rescanTimer
                self.checkOldInterfaceState()
                pass
 
-       def getInstalledInterfaceCount(self):
+       def back(self):
+               self.stopScan()
+               self.ap = None
+               WizardLanguage.back(self)
+               
+       def stopScan(self):
                self.rescanTimer.stop()
+               if self.w is not None:
+                       from Plugins.SystemPlugins.WirelessLan.Wlan import iWlan
+                       iWlan.stopGetNetworkList()
+                       self.w = None
+
+       def getInstalledInterfaceCount(self):
+               self.originalInterfaceState = {}
                self.Adapterlist = iNetwork.getAdapterList()
                self.InstalledInterfaceCount = len(self.Adapterlist)
                if self.Adapterlist is not None:
                        if self.InstalledInterfaceCount == 1 and self.selectedInterface is None:
                                        self.selectedInterface = self.Adapterlist[0]
-               self.originalAth0State = iNetwork.getAdapterAttribute('ath0', 'up')
-               self.originalEth0State = iNetwork.getAdapterAttribute('eth0', 'up')
-               self.originalWlan0State = iNetwork.getAdapterAttribute('wlan0', 'up')
+               for interface in iNetwork.getAdapterList():
+                       self.originalInterfaceState[interface] = {}
+                       self.originalInterfaceState[interface]["up"] = iNetwork.getAdapterAttribute(interface, 'up')
 
        def selectInterface(self):
                self.InterfaceState = None
-               if self.selectedInterface is None and self.InstalledInterfaceCount <= 1:
-                       if self.selectedInterface == 'eth0':
-                               self.NextStep = 'nwconfig'
-                       else:
-                               self.NextStep = 'scanwlan'
-                       self.checkInterface(self.selectedInterface)
-               elif self.selectedInterface is not None and self.InstalledInterfaceCount <= 1:
-                       if self.selectedInterface == 'eth0':
-                               self.NextStep = 'nwconfig'
+               if self.selectedInterface is None:
+                       if self.InstalledInterfaceCount <= 1:
+                               if not iNetwork.isWirelessInterface(self.selectedInterface):
+                                       self.NextStep = 'nwconfig'
+                               else:
+                                       self.NextStep = 'asknetworktype'
+                               self.checkInterface(self.selectedInterface)
                        else:
-                               self.NextStep = 'scanwlan'
-                       self.checkInterface(self.selectedInterface)
-               elif self.selectedInterface is None and self.InstalledInterfaceCount > 1:
-                       self.NextStep = 'selectinterface'
-                       self.currStep = self.getStepWithID(self.NextStep)
-                       self.afterAsyncCode()
-               elif self.selectedInterface is not None and self.InstalledInterfaceCount > 1:
-                       if self.selectedInterface == 'eth0':
+                               self.NextStep = 'selectinterface'
+                               self.currStep = self.getStepWithID(self.NextStep)
+                               self.afterAsyncCode()
+               else:
+                       if not iNetwork.isWirelessInterface(self.selectedInterface):
                                self.NextStep = 'nwconfig'
                        else:
-                               self.NextStep = 'scanwlan'
+                               self.NextStep = 'asknetworktype'
                        self.checkInterface(self.selectedInterface)
-               else:
-                       self.NextStep = 'selectinterface'
-                       self.currStep = self.getStepWithID(self.NextStep)
-                       self.afterAsyncCode()                   
 
        def checkOldInterfaceState(self):
                # disable up interface if it was originally down and config is unchanged.
-               if self.originalAth0State is False and self.originalInterfaceStateChanged is False:
-                       if iNetwork.checkforInterface('ath0') is True:
-                               iNetwork.deactivateInterface('ath0')            
-               if self.originalEth0State is False and self.originalInterfaceStateChanged is False:
-                       if iNetwork.checkforInterface('eth0') is True:
-                               iNetwork.deactivateInterface('eth0')
-               if self.originalWlan0State is False and self.originalInterfaceStateChanged is False:
-                       if iNetwork.checkforInterface('wlan0') is True:
-                               iNetwork.deactivateInterface('wlan0')
+               if self.originalInterfaceStateChanged is False:
+                       for interface in self.originalInterfaceState.keys():
+                               if interface == self.selectedInterface:
+                                       if self.originalInterfaceState[interface]["up"] is False:
+                                               if iNetwork.checkforInterface(interface) is True:
+                                                       system("ifconfig " + interface + " down")
 
        def listInterfaces(self):
-               self.rescanTimer.stop()
                self.checkOldInterfaceState()
                list = [(iNetwork.getFriendlyAdapterName(x),x) for x in iNetwork.getAdapterList()]
                list.append((_("Exit network wizard"), "end"))
@@ -169,13 +146,13 @@ class NetworkWizard(WizardLanguage, Rc):
                elif index == 'eth0':
                        self.NextStep = 'nwconfig'
                else:
-                       self.NextStep = 'scanwlan'
+                       self.NextStep = 'asknetworktype'
 
        def InterfaceSelectionMoved(self):
                self.InterfaceSelect(self.selection)
                
        def checkInterface(self,iface):
-               self.rescanTimer.stop()
+               self.stopScan()
                if self.Adapterlist is None:
                        self.Adapterlist = iNetwork.getAdapterList()
                if self.NextStep is not 'end':
@@ -183,7 +160,7 @@ class NetworkWizard(WizardLanguage, Rc):
                                #Reset Network to defaults if network broken
                                iNetwork.resetNetworkConfig('lan', self.resetNetworkConfigCB)
                                self.resetRef = self.session.openWithCallback(self.resetNetworkConfigFinished, MessageBox, _("Please wait while we prepare your network interfaces..."), type = MessageBox.TYPE_INFO, enable_input = False)
-                       if iface in ('eth0', 'wlan0', 'ath0'):
+                       if iface in iNetwork.getInstalledAdapters():
                                if iface in iNetwork.configuredNetworkAdapters and len(iNetwork.configuredNetworkAdapters) == 1:
                                        if iNetwork.getAdapterAttribute(iface, 'up') is True:
                                                self.isInterfaceUp = True
@@ -232,7 +209,7 @@ class NetworkWizard(WizardLanguage, Rc):
 
        def AdapterSetupEndCB(self,data):
                if data is True:
-                       if self.selectedInterface in ('wlan0', 'ath0'):
+                       if iNetwork.isWirelessInterface(self.selectedInterface):
                                if self.WlanPluginInstalled == True:
                                        from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus
                                        iStatus.getDataForInterface(self.selectedInterface,self.checkWlanStateCB)
@@ -255,7 +232,7 @@ class NetworkWizard(WizardLanguage, Rc):
                        if data is True:
                                if status is not None:
                                        text1 = _("Your Dreambox is now ready to use.\n\nYour internet connection is working now.\n\n")
-                                       text2 = _('Accesspoint:') + "\t" + str(status[self.selectedInterface]["acesspoint"]) + "\n"
+                                       text2 = _('Accesspoint:') + "\t" + str(status[self.selectedInterface]["accesspoint"]) + "\n"
                                        text3 = _('SSID:') + "\t" + str(status[self.selectedInterface]["essid"]) + "\n"
                                        text4 = _('Link Quality:') + "\t" + str(status[self.selectedInterface]["quality"])+ "\n"
                                        text5 = _('Signal Strength:') + "\t" + str(status[self.selectedInterface]["signal"]) + "\n"
@@ -265,7 +242,7 @@ class NetworkWizard(WizardLanguage, Rc):
                                        infotext = text1 + text2 + text3 + text4 + text5 + text7 +"\n" + text8
                                        self.currStep = self.getStepWithID("checkWlanstatusend")
                                        self.Text = infotext
-                                       if str(status[self.selectedInterface]["acesspoint"]) == "Not-Associated":
+                                       if str(status[self.selectedInterface]["accesspoint"]) == "Not-Associated":
                                                self.InterfaceState = False
                                        self.afterAsyncCode()
 
@@ -275,7 +252,7 @@ class NetworkWizard(WizardLanguage, Rc):
 
        def checkNetworkCB(self,data):
                if data is True:
-                       if self.selectedInterface in ('wlan0', 'ath0'):
+                       if iNetwork.isWirelessInterface(self.selectedInterface):
                                if self.WlanPluginInstalled == True:
                                        from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus
                                        iStatus.getDataForInterface(self.selectedInterface,self.checkWlanStateCB)
@@ -310,96 +287,74 @@ class NetworkWizard(WizardLanguage, Rc):
                                newList.append(oldentry)
                                
                for newentry in newList:
-                       if newentry[1] == "hidden...":
-                               continue
                        self.newAPlist.append(newentry)
-               
-               if len(self.newAPlist):
-                       if "hidden..." not in self.newAPlist:
-                               self.newAPlist.append(( _("enter hidden network SSID"), "hidden..." ))
 
+               if len(self.newAPlist):
                        if (self.wizard[self.currStep].has_key("dynamiclist")):
                                currentListEntry = self["list"].getCurrent()
-                               idx = 0
-                               for entry in self.newAPlist:
-                                       if entry == currentListEntry:
-                                               newListIndex = idx
-                                       idx +=1
+                               if currentListEntry is not None:
+                                       idx = 0
+                                       for entry in self.newAPlist:
+                                               if entry == currentListEntry:
+                                                       newListIndex = idx
+                                               idx +=1
                                self.wizard[self.currStep]["evaluatedlist"] = self.newAPlist
                                self['list'].setList(self.newAPlist)
-                               self["list"].setIndex(newListIndex)
+                               if newListIndex is not None:
+                                       self["list"].setIndex(newListIndex)
                                self["list"].updateList(self.newAPlist)
 
        def listAccessPoints(self):
                self.APList = []
-               try:
-                       from Plugins.SystemPlugins.WirelessLan.Wlan import Wlan
-               except ImportError:
-                       self.APList.append( ( _("No networks found"),_("unavailable") ) )
-                       return self.APList
+               if self.WlanPluginInstalled is False:
+                       self.APList.append( ( _("No networks found"), None ) )
                else:
-                       try:
-                               self.w = Wlan(self.selectedInterface)
-                               aps = self.w.getNetworkList()
-                       except ValueError:
-                               self.APList = []
-                               self.APList.append( ( _("No networks found"),_("unavailable") ) )
-                               return self.APList
-                       else:
-                               if aps is not None:
-                                       print "[NetworkWizard.py] got Accespoints!"
-                                       tmplist = []
-                                       complist = []
-                                       for ap in aps:
-                                               a = aps[ap]
-                                               if a['active']:
-                                                       tmplist.append( (a['bssid'], a['essid']) )
-                                                       complist.append( (a['bssid'], a['essid']) )
-                                       
-                                       for entry in tmplist:
-                                               if entry[1] == "":
-                                                       for compentry in complist:
-                                                               if compentry[0] == entry[0]:
-                                                                       complist.remove(compentry)
-                                       for entry in complist:
-                                               self.APList.append( (entry[1], entry[1]) )
-       
-                               if "hidden..." not in self.APList:
-                                       self.APList.append(( _("enter hidden network SSID"), "hidden..." ))
+                       from Plugins.SystemPlugins.WirelessLan.Wlan import iWlan
+                       iWlan.setInterface(self.selectedInterface)
+                       self.w = iWlan.getInterface()
+                       aps = iWlan.getNetworkList()
+                       if aps is not None:
+                               print "[NetworkWizard.py] got Accespoints!"
+                               tmplist = []
+                               complist = []
+                               for ap in aps:
+                                       a = aps[ap]
+                                       if a['active']:
+                                               tmplist.append( (a['bssid'], a['essid']) )
+                                               complist.append( (a['bssid'], a['essid']) )
+                               
+                               for entry in tmplist:
+                                       if entry[1] == "":
+                                               for compentry in complist:
+                                                       if compentry[0] == entry[0]:
+                                                               complist.remove(compentry)
+                               for entry in complist:
+                                       self.APList.append( (entry[1], entry[1]) )
+                       if not len(aps):
+                               self.APList.append( ( _("No networks found"), None ) )
                        
-                               self.rescanTimer.start(3000)
-                               return self.APList
+               self.rescanTimer.start(4000)
+               return self.APList
 
-       def AccessPointsSelectionMade(self, index):
-               self.ap = index
-               self.WlanList = []
-               currList = []
-               if (self.wizard[self.currStep].has_key("dynamiclist")):
-                       currList = self['list'].list
-                       for entry in currList:
-                               self.WlanList.append( (entry[1], entry[0]) )
-               self.AccessPointsSelect(index)
-
-       def AccessPointsSelect(self, index):
-               self.NextStep = 'wlanconfig'
 
        def AccessPointsSelectionMoved(self):
-               self.AccessPointsSelect(self.selection)
+               self.ap = self.selection
+               self.NextStep = 'wlanconfig'
 
        def checkWlanSelection(self):
-               self.rescanTimer.stop()
+               self.stopScan()
                self.currStep = self.getStepWithID(self.NextStep)
 
        def isWlanPluginInstalled(self):
                try:
-                       from Plugins.SystemPlugins.WirelessLan.Wlan import Wlan
+                       from Plugins.SystemPlugins.WirelessLan.Wlan import iWlan
                except ImportError:
                        self.WlanPluginInstalled = False
                else:
                        self.WlanPluginInstalled = True
 
        def listChoices(self):
-               self.rescanTimer.stop()
+               self.stopScan()
                list = []
                if self.WlanPluginInstalled == True:
                        list.append((_("Configure your wireless LAN again"), "scanwlan"))
@@ -417,8 +372,7 @@ class NetworkWizard(WizardLanguage, Rc):
                        self.selectedInterface = "eth0"
                        self.NextStep = 'nwconfig'
                else:
-                       self.NextStep = 'scanwlan'
+                       self.NextStep = 'asknetworktype'
 
        def ChoicesSelectionMoved(self):
                pass
-
index c430043..0b3a298 100755 (executable)
@@ -87,13 +87,33 @@ self.selectKey("DOWN")
                         <listentry caption="Exit network wizard" step="end" />
                 </list>
         </step>
+
+        <step id="asknetworktype">
+               <condition>
+self.condition = (self.isInterfaceUp == True and self.WlanPluginInstalled == True)
+               </condition>
+                <text value="Wireless network connection setup." />
+                <displaytext value="Wireless network connection setup" />
+                <code>
+self.clearSelectedKeys()
+self.selectKey("OK")
+self.selectKey("UP")
+self.selectKey("DOWN")
+                </code>
+                <list>
+                        <listentry caption="List available networks" step="scanwlan" />
+                        <listentry caption="Manual configuration" step="wlanconfig" />
+                        <listentry caption="Exit network wizard" step="end" />
+                </list>
+        </step>
+
         <step id="scanwlan">
                <condition>
 self.condition = (self.isInterfaceUp == True and self.WlanPluginInstalled == True)
                 </condition>
                 <text value="Please select the wireless network that you want to connect to.\n\nPlease press OK to continue." />
                 <displaytext value="Select wireless network" />
-                <list type="dynamic" source="listAccessPoints" evaluation="AccessPointsSelectionMade" onselect="AccessPointsSelectionMoved" />
+                <list type="dynamic" source="listAccessPoints" onselect="AccessPointsSelectionMoved" />
                 <code>
 self.clearSelectedKeys()
 self.selectKey("OK")
@@ -138,7 +158,7 @@ self.selectKey("DOWN")
         <step id="wlanconfig">
                 <text value="Please configure your internet connection by filling out the required values.\nWhen you are ready press OK to continue." />
                 <displaytext value="Configure interface" />
-                <config screen="AdapterSetup" module="NetworkSetup" args="(self.selectedInterface,self.ap,self.WlanList)" type="ConfigList" />
+                <config screen="AdapterSetup" module="NetworkSetup" args="(self.selectedInterface,self.ap)" type="ConfigList" />
                 <code>
 self.clearSelectedKeys()
 self.selectKey("OK")
@@ -196,4 +216,3 @@ self.selectKey("OK")
         </step>
 </wizard>
 
-
index 56cebdb..30a2423 100644 (file)
@@ -1,6 +1,8 @@
 from Screens.Screen import Screen
 from Plugins.Plugin import PluginDescriptor
-from Components.config import getConfigListEntry, config
+from Components.config import getConfigListEntry, config, ConfigBoolean
+
+config.misc.firstrun = ConfigBoolean(default = True)
 
 def NetworkWizardMain(session, **kwargs):
        session.open(NetworkWizard)
index be246db..e097117 100644 (file)
@@ -441,15 +441,15 @@ class TunerScreen(ScanSetup):
                                self.scan_sat.system.value = eDVBFrontendParametersSatellite.System_DVB_S
                        self.list.append(getConfigListEntry(_('Frequency'), self.scan_sat.frequency))
                        self.list.append(getConfigListEntry(_('Inversion'), self.scan_sat.inversion))
-                       self.list.append(getConfigListEntry(_('Symbol Rate'), self.scan_sat.symbolrate))
-                       self.list.append(getConfigListEntry(_("Polarity"), self.scan_sat.polarization))
+                       self.list.append(getConfigListEntry(_('Symbol rate'), self.scan_sat.symbolrate))
+                       self.list.append(getConfigListEntry(_('Polarization'), self.scan_sat.polarization))
                        if self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S:
                                self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec))
                        elif self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S2:
                                self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2))
                                self.modulationEntry = getConfigListEntry(_('Modulation'), self.scan_sat.modulation)
                                self.list.append(self.modulationEntry)
-                               self.list.append(getConfigListEntry(_('Rolloff'), self.scan_sat.rolloff))
+                               self.list.append(getConfigListEntry(_('Roll-off'), self.scan_sat.rolloff))
                                self.list.append(getConfigListEntry(_('Pilot'), self.scan_sat.pilot))
                elif tuning.type.value == "predefined_transponder":
                        self.list.append(getConfigListEntry(_("Transponder"), tuning.transponder))
index e737466..e611ca5 100644 (file)
@@ -79,15 +79,15 @@ class Satfinder(ScanSetup):
                                self.scan_sat.system.value = eDVBFrontendParametersSatellite.System_DVB_S
                        self.list.append(getConfigListEntry(_('Frequency'), self.scan_sat.frequency))
                        self.list.append(getConfigListEntry(_('Inversion'), self.scan_sat.inversion))
-                       self.list.append(getConfigListEntry(_('Symbol Rate'), self.scan_sat.symbolrate))
-                       self.list.append(getConfigListEntry(_("Polarity"), self.scan_sat.polarization))
+                       self.list.append(getConfigListEntry(_('Symbol rate'), self.scan_sat.symbolrate))
+                       self.list.append(getConfigListEntry(_('Polarization'), self.scan_sat.polarization))
                        if self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S:
                                self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec))
                        elif self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S2:
                                self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2))
                                self.modulationEntry = getConfigListEntry(_('Modulation'), self.scan_sat.modulation)
                                self.list.append(self.modulationEntry)
-                               self.list.append(getConfigListEntry(_('Rolloff'), self.scan_sat.rolloff))
+                               self.list.append(getConfigListEntry(_('Roll-off'), self.scan_sat.rolloff))
                                self.list.append(getConfigListEntry(_('Pilot'), self.scan_sat.pilot))
                elif self.tuning_transponder and self.tuning_type.value == "predefined_transponder":
                        self.list.append(getConfigListEntry(_("Transponder"), self.tuning_transponder))
index 01649bb..bfe28b4 100755 (executable)
@@ -17,10 +17,9 @@ from os import popen, path, makedirs, listdir, access, stat, rename, remove, W_O
 from time import gmtime, strftime, localtime
 from datetime import date
 
-
 config.plugins.configurationbackup = ConfigSubsection()
 config.plugins.configurationbackup.backuplocation = ConfigText(default = '/media/hdd/', visible_width = 50, fixed_size = False)
-config.plugins.configurationbackup.backupdirs = ConfigLocations(default=[eEnv.resolve('${sysconfdir}/enigma2/'), '/etc/network/interfaces', '/etc/wpa_supplicant.conf', '/etc/resolv.conf', '/etc/default_gw', '/etc/hostname'])
+config.plugins.configurationbackup.backupdirs = ConfigLocations(default=[eEnv.resolve('${sysconfdir}/enigma2/'), '/etc/network/interfaces', '/etc/wpa_supplicant.conf', '/etc/wpa_supplicant.ath0.conf', '/etc/wpa_supplicant.wlan0.conf', '/etc/resolv.conf', '/etc/default_gw', '/etc/hostname'])
 
 def getBackupPath():
        backuppath = config.plugins.configurationbackup.backuplocation.value
index 32d7140..3ea787c 100755 (executable)
@@ -13,10 +13,11 @@ from enigma import eEnv
 
 from Components.config import config, getConfigListEntry, ConfigSubsection, ConfigText, ConfigLocations, ConfigBoolean
 from Components.Harddisk import harddiskmanager
+
 config.misc.firstrun = ConfigBoolean(default = True)
 config.plugins.configurationbackup = ConfigSubsection()
 config.plugins.configurationbackup.backuplocation = ConfigText(default = '/media/hdd/', visible_width = 50, fixed_size = False)
-config.plugins.configurationbackup.backupdirs = ConfigLocations(default=[eEnv.resolve('${sysconfdir}/enigma2/'), '/etc/network/interfaces', '/etc/wpa_supplicant.conf'])
+config.plugins.configurationbackup.backupdirs = ConfigLocations(default=[eEnv.resolve('${sysconfdir}/enigma2/'), '/etc/network/interfaces', '/etc/wpa_supplicant.conf', '/etc/wpa_supplicant.ath0.conf', '/etc/wpa_supplicant.wlan0.conf', '/etc/resolv.conf', '/etc/default_gw', '/etc/hostname'])
 
 
 backupfile = "enigma2settingsbackup.tar.gz"
index 87f0a4d..ec2f82c 100755 (executable)
@@ -9,9 +9,10 @@ from Components.Ipkg import IpkgComponent
 from Components.Network import iNetwork
 from Tools.Directories import pathExists, fileExists, resolveFilename, SCOPE_METADIR
 from Tools.HardwareInfo import HardwareInfo
-import sha
-
+import hashlib
 from time import time
+from os import urandom
+
 rootkey = ['\x9f', '|', '\xe4', 'G', '\xc9', '\xb4', '\xf4', '#', '&', '\xce', '\xb3', '\xfe', '\xda', '\xc9', 'U', '`', '\xd8', '\x8c', 's', 'o', '\x90', '\x9b', '\\', 'b', '\xc0', '\x89', '\xd1', '\x8c', '\x9e', 'J', 'T', '\xc5', 'X', '\xa1', '\xb8', '\x13', '5', 'E', '\x02', '\xc9', '\xb2', '\xe6', 't', '\x89', '\xde', '\xcd', '\x9d', '\x11', '\xdd', '\xc7', '\xf4', '\xe4', '\xe4', '\xbc', '\xdb', '\x9c', '\xea', '}', '\xad', '\xda', 't', 'r', '\x9b', '\xdc', '\xbc', '\x18', '3', '\xe7', '\xaf', '|', '\xae', '\x0c', '\xe3', '\xb5', '\x84', '\x8d', '\r', '\x8d', '\x9d', '2', '\xd0', '\xce', '\xd5', 'q', '\t', '\x84', 'c', '\xa8', ')', '\x99', '\xdc', '<', '"', 'x', '\xe8', '\x87', '\x8f', '\x02', ';', 'S', 'm', '\xd5', '\xf0', '\xa3', '_', '\xb7', 'T', '\t', '\xde', '\xa7', '\xf1', '\xc9', '\xae', '\x8a', '\xd7', '\xd2', '\xcf', '\xb2', '.', '\x13', '\xfb', '\xac', 'j', '\xdf', '\xb1', '\x1d', ':', '?']
 
 def bin2long(s):
@@ -30,7 +31,7 @@ def decrypt_block(src, mod):
        if len(src) != 128 and len(src) != 202:
                return None
        dest = rsa_pub1024(src[:128], mod)
-       hash = sha.new(dest[1:107])
+       hash = hashlib.sha1(dest[1:107])
        if len(src) == 202:
                hash.update(src[131:192])       
        result = hash.digest()
@@ -46,10 +47,12 @@ def validate_cert(cert, key):
 
 def read_random():
        try:
-               fd = open("/dev/urandom", "r")
-               buf = fd.read(8)
-               fd.close()
-               return buf
+               xor = lambda a,b: ''.join(chr(ord(c)^ord(d)) for c,d in zip(a,b*100))
+               random = urandom(8)
+               x = str(time())[-8:]
+               result = xor(random, x)
+                               
+               return result
        except:
                return None
 
@@ -241,7 +244,7 @@ class SoftwareTools(DreamInfoHandler):
                        if self.NetworkConnectionAvailable == True:
                                if not self.UpdateConsole:
                                        self.UpdateConsole = Console()
-                               cmd = "opkg install enigma2-meta enigma2-plugins-meta enigma2-skins-meta"
+                               cmd = "opkg install enigma2-meta enigma2-plugins-meta enigma2-skins-meta enigma2-drivers-meta"
                                self.UpdateConsole.ePopen(cmd, self.InstallMetaPackageCB, callback)
                        else:
                                self.InstallMetaPackageCB(True)
index b3a0a17..12fd609 100644 (file)
@@ -43,10 +43,10 @@ from SoftwareTools import iSoftwareTools
 
 config.plugins.configurationbackup = ConfigSubsection()
 config.plugins.configurationbackup.backuplocation = ConfigText(default = '/media/hdd/', visible_width = 50, fixed_size = False)
-config.plugins.configurationbackup.backupdirs = ConfigLocations(default=[eEnv.resolve('${sysconfdir}/enigma2/'), '/etc/network/interfaces', '/etc/wpa_supplicant.conf', '/etc/resolv.conf', '/etc/default_gw', '/etc/hostname'])
+config.plugins.configurationbackup.backupdirs = ConfigLocations(default=[eEnv.resolve('${sysconfdir}/enigma2/'), '/etc/network/interfaces', '/etc/wpa_supplicant.conf', '/etc/wpa_supplicant.ath0.conf', '/etc/wpa_supplicant.wlan0.conf', '/etc/resolv.conf', '/etc/default_gw', '/etc/hostname'])
 
-config.plugins.SoftwareManager = ConfigSubsection()
-config.plugins.SoftwareManager.overwriteConfigFiles = ConfigSelection(
+config.plugins.softwaremanager = ConfigSubsection()
+config.plugins.softwaremanager.overwriteConfigFiles = ConfigSelection(
                                [
                                 ("Y", _("Yes, always")),
                                 ("N", _("No, never")),                          
@@ -365,7 +365,7 @@ class SoftwareManagerSetup(Screen, ConfigListScreen):
 
        def createSetup(self):
                self.list = [ ]
-               self.overwriteConfigfilesEntry = getConfigListEntry(_("Overwrite configuration files ?"), config.plugins.SoftwareManager.overwriteConfigFiles)
+               self.overwriteConfigfilesEntry = getConfigListEntry(_("Overwrite configuration files ?"), config.plugins.softwaremanager.overwriteConfigFiles)
                self.list.append(self.overwriteConfigfilesEntry)        
                self["config"].list = self.list
                self["config"].l.setSeperation(400)
@@ -489,7 +489,6 @@ class SoftwareManagerInfo(Screen):
                        self.list = []
                        backupfiles = config.plugins.configurationbackup.backupdirs.value
                        for entry in backupfiles:
-                               print entry
                                self.list.append((entry,))
                        self['list'].setList(self.list)
                        
@@ -569,6 +568,7 @@ class PluginManager(Screen, DreamInfoHandler):
                self.currentSelectedIndex = None
                self.currentSelectedPackage = None
                self.saved_currentSelectedPackage = None
+               self.restartRequired = False
                
                self.onShown.append(self.setWindowTitle)
                self.onLayoutFinish.append(self.getUpdateInfos)
@@ -892,6 +892,8 @@ class PluginManager(Screen, DreamInfoHandler):
                                        self.package = iSoftwareTools.packageDetails[0]
                                        if self.package[0].has_key("attributes"):
                                                self.attributes = self.package[0]["attributes"]
+                                               if self.attributes.has_key("needsRestart"):
+                                                       self.restartRequired = True
                                        if self.attributes.has_key("package"):
                                                self.packagefiles = self.attributes["package"]
                                        if plugin[1] == 'installed':
@@ -924,11 +926,11 @@ class PluginManager(Screen, DreamInfoHandler):
 
        def runExecuteFinished(self):
                self.reloadPluginlist()
-               restartRequired = plugins.restartRequired
-               if restartRequired:
+               if plugins.restartRequired or self.restartRequired:
                        self.session.openWithCallback(self.ExecuteReboot, MessageBox, _("Install or remove finished.") +" "+_("Do you want to reboot your Dreambox?"), MessageBox.TYPE_YESNO)
                else:
                        self.selectedFiles = []
+                       self.restartRequired = False
                        self.detailsClosed(True)
 
        def ExecuteReboot(self, result):
@@ -936,6 +938,7 @@ class PluginManager(Screen, DreamInfoHandler):
                        quitMainloop(3)
                else:
                        self.selectedFiles = []
+                       self.restartRequired = False
                        self.detailsClosed(True)
 
        def reloadPluginlist(self):
@@ -1174,7 +1177,7 @@ class PluginDetails(Screen, DreamInfoHandler):
                self.package = self.packageDetails[0]
                if self.package[0].has_key("attributes"):
                        self.attributes = self.package[0]["attributes"]
-
+               self.restartRequired = False
                self.cmdList = []
                self.oktext = _("\nAfter pressing OK, please wait!")
                self.picload = ePicLoad()
@@ -1272,6 +1275,8 @@ class PluginDetails(Screen, DreamInfoHandler):
        def go(self):
                if self.attributes.has_key("package"):
                        self.packagefiles = self.attributes["package"]
+               if self.attributes.has_key("needsRestart"):
+                       self.restartRequired = True
                self.cmdList = []
                if self.pluginstate in ('installed', 'remove'):
                        if self.packagefiles:
@@ -1293,8 +1298,7 @@ class PluginDetails(Screen, DreamInfoHandler):
 
        def runUpgradeFinished(self):
                self.reloadPluginlist()
-               restartRequired = plugins.restartRequired
-               if restartRequired:
+               if plugins.restartRequired or self.restartRequired:
                        self.session.openWithCallback(self.UpgradeReboot, MessageBox, _("Installation finished.") +" "+_("Do you want to reboot your Dreambox?"), MessageBox.TYPE_YESNO)
                else:
                        self.close(True)
@@ -1414,8 +1418,8 @@ class UpdatePlugin(Screen):
                        self.status.setText(_("Configuring"))
                        
                elif event == IpkgComponent.EVENT_MODIFIED:
-                       if config.plugins.SoftwareManager.overwriteConfigFiles.value in ("N", "Y"):
-                               self.ipkg.write(True and config.plugins.SoftwareManager.overwriteConfigFiles.value)
+                       if config.plugins.softwaremanager.overwriteConfigFiles.value in ("N", "Y"):
+                               self.ipkg.write(True and config.plugins.softwaremanager.overwriteConfigFiles.value)
                        else:
                                self.session.openWithCallback(
                                        self.modificationCallback,
index dc4e8c5..6ecbfd4 100644 (file)
@@ -196,10 +196,12 @@ class VideoHardware:
                print "saveMode", port, mode, rate
                config.av.videoport.value = port
                config.av.videoport.save()
-               config.av.videomode[port].value = mode
-               config.av.videomode[port].save()
-               config.av.videorate[mode].value = rate
-               config.av.videorate[mode].save()
+               if port in config.av.videomode:
+                       config.av.videomode[port].value = mode
+                       config.av.videomode[port].save()
+               if mode in config.av.videorate:
+                       config.av.videorate[mode].value = rate
+                       config.av.videorate[mode].save()
 
        def isPortAvailable(self, port):
                # fixme
index 480f201..a185157 100755 (executable)
@@ -1,36 +1,42 @@
 from Components.config import config, ConfigYesNo, NoSave, ConfigSubsection, ConfigText, ConfigSelection, ConfigPassword
 from Components.Console import Console
+from Components.Network import iNetwork
 
-from os import system
+from os import system, path as os_path
 from string import maketrans, strip
 import sys
 import types
-from re import compile as re_compile, search as re_search
+from re import compile as re_compile, search as re_search, escape as re_escape
 from pythonwifi.iwlibs import getNICnames, Wireless, Iwfreq, getWNICnames
 from pythonwifi import flags as wififlags
 
 list = []
+list.append("Unencrypted")
 list.append("WEP")
 list.append("WPA")
-list.append("WPA2")
 list.append("WPA/WPA2")
+list.append("WPA2")
 
 weplist = []
 weplist.append("ASCII")
 weplist.append("HEX")
 
 config.plugins.wlan = ConfigSubsection()
-config.plugins.wlan.essid = NoSave(ConfigText(default = "home", fixed_size = False))
-config.plugins.wlan.hiddenessid = NoSave(ConfigText(default = "home", fixed_size = False))
+config.plugins.wlan.essid = NoSave(ConfigText(default = "", fixed_size = False))
+config.plugins.wlan.hiddenessid = NoSave(ConfigYesNo(default = False))
+config.plugins.wlan.encryption = NoSave(ConfigSelection(list, default = "WPA2"))
+config.plugins.wlan.wepkeytype = NoSave(ConfigSelection(weplist, default = "ASCII"))
+config.plugins.wlan.psk = NoSave(ConfigPassword(default = "", fixed_size = False))
+
 
-config.plugins.wlan.encryption = ConfigSubsection()
-config.plugins.wlan.encryption.enabled = NoSave(ConfigYesNo(default = True))
-config.plugins.wlan.encryption.type = NoSave(ConfigSelection(list, default = "WPA/WPA2"))
-config.plugins.wlan.encryption.wepkeytype = NoSave(ConfigSelection(weplist, default = "ASCII"))
-config.plugins.wlan.encryption.psk = NoSave(ConfigPassword(default = "mysecurewlan", fixed_size = False))
+def getWlanConfigName(iface):
+       return '/etc/wpa_supplicant.' + iface + '.conf'
 
 class Wlan:
-       def __init__(self, iface):
+       def __init__(self, iface = None):
+               self.iface = iface
+               self.oldInterfaceState = None
+               
                a = ''; b = ''
                for i in range(0, 255):
                        a = a + chr(i)
@@ -39,135 +45,37 @@ class Wlan:
                        else:
                                b = b + chr(i)
                
-               self.iface = iface
-               self.wlaniface = {}
-               self.WlanConsole = Console()
                self.asciitrans = maketrans(a, b)
 
-       def stopWlanConsole(self):
-               if self.WlanConsole is not None:
-                       print "killing self.WlanConsole"
-                       self.WlanConsole = None
-                       del self.WlanConsole
-                       
-       def getDataForInterface(self, callback = None):
-               #get ip out of ip addr, as avahi sometimes overrides it in ifconfig.
-               print "self.iface im getDataForInterface",self.iface
-               if len(self.WlanConsole.appContainers) == 0:
-                       self.WlanConsole = Console()
-                       cmd = "iwconfig " + self.iface
-                       self.WlanConsole.ePopen(cmd, self.iwconfigFinished, callback)
-
-       def iwconfigFinished(self, result, retval, extra_args):
-               print "self.iface im iwconfigFinished",self.iface
-               callback = extra_args
-               data = { 'essid': False, 'frequency': False, 'acesspoint': False, 'bitrate': False, 'encryption': False, 'quality': False, 'signal': False }
-               
-               for line in result.splitlines():
-                       line = line.strip()
-                       if "ESSID" in line:
-                               if "off/any" in line:
-                                       ssid = _("No Connection")
-                               else:
-                                       if "Nickname" in line:
-                                               tmpssid=(line[line.index('ESSID')+7:line.index('"  Nickname')])
-                                               if tmpssid == '':
-                                                       ssid = _("Hidden networkname")
-                                               elif tmpssid ==' ':
-                                                       ssid = _("Hidden networkname")
-                                               else:
-                                                       ssid = tmpssid
-                                       else:
-                                               tmpssid=(line[line.index('ESSID')+7:len(line)-1])
-                                               if tmpssid == '':
-                                                       ssid = _("Hidden networkname")
-                                               elif tmpssid ==' ':
-                                                       ssid = _("Hidden networkname")
-                                               else:
-                                                       ssid = tmpssid                                          
-
-                               if ssid is not None:
-                                       data['essid'] = ssid
-                       if 'Frequency' in line:
-                               frequency = line[line.index('Frequency')+10 :line.index(' GHz')]
-                               if frequency is not None:
-                                       data['frequency'] = frequency
-                       if "Access Point" in line:
-                               ap=line[line.index('Access Point')+14:len(line)-1]
-                               if ap is not None:
-                                       data['acesspoint'] = ap
-                       if "Bit Rate" in line:
-                               br = line[line.index('Bit Rate')+9 :line.index(' Mb/s')]
-                               if br is not None:
-                                       data['bitrate'] = br
-                       if 'Encryption key' in line:
-                               if ":off" in line:
-                                   enc = _("Disabled")
-                               else:
-                                   enc = line[line.index('Encryption key')+15 :line.index('   Security')]
-                               if enc is not None:
-                                       data['encryption'] = _("Enabled")
-                       if 'Quality' in line:
-                               if "/100" in line:
-                                       qual = line[line.index('Quality')+8:line.index('/100')]
-                               else:
-                                       qual = line[line.index('Quality')+8:line.index('Sig')]
-                               if qual is not None:
-                                       data['quality'] = qual
-                       if 'Signal level' in line:
-                               signal = line[line.index('Signal level')+13 :line.index(' dBm')]
-                               if signal is not None:
-                                       data['signal'] = signal
-
-               self.wlaniface[self.iface] = data
-               
-               if len(self.WlanConsole.appContainers) == 0:
-                       print "self.wlaniface after loading:", self.wlaniface
-                       self.WlanConsole = None
-                       if callback is not None:
-                               callback(True,self.wlaniface)
-
-       def getAdapterAttribute(self, attribute):
-               if self.wlaniface.has_key(self.iface):
-                       print "self.wlaniface.has_key",self.iface
-                       if self.wlaniface[self.iface].has_key(attribute):
-                               return self.wlaniface[self.iface][attribute]
-               return None
-               
        def asciify(self, str):
                return str.translate(self.asciitrans)
-
        
        def getWirelessInterfaces(self):
-               device = re_compile('[a-z]{2,}[0-9]*:')
-               ifnames = []
+               return getWNICnames()
 
-               fp = open('/proc/net/wireless', 'r')
-               for line in fp:
-                       try:
-                               # append matching pattern, without the trailing colon
-                               ifnames.append(device.search(line).group()[:-1])
-                       except AttributeError:
-                               pass
-               return ifnames
+       def setInterface(self, iface = None):
+               self.iface = iface
+
+       def getInterface(self):
+               return self.iface
 
-       
        def getNetworkList(self):
-               system("ifconfig "+self.iface+" up")
+               if self.oldInterfaceState is None:
+                       self.oldInterfaceState = iNetwork.getAdapterAttribute(self.iface, "up")
+               if self.oldInterfaceState is False:
+                       if iNetwork.getAdapterAttribute(self.iface, "up") is False:
+                               iNetwork.setAdapterAttribute(self.iface, "up", True)
+                               system("ifconfig "+self.iface+" up")
+
                ifobj = Wireless(self.iface) # a Wireless NIC Object
-               
-               #Association mappings
-               #stats, quality, discard, missed_beacon = ifobj.getStatistics()
-               #snr = quality.signallevel - quality.noiselevel
 
                try:
                        scanresults = ifobj.scan()
                except:
                        scanresults = None
-                       print "[Wlan.py] No Wireless Networks could be found"
-               
+                       print "[Wlan.py] No wireless networks could be found"
+               aps = {}
                if scanresults is not None:
-                       aps = {}
                        (num_channels, frequencies) = ifobj.getChannelInfo()
                        index = 1
                        for result in scanresults:
@@ -188,7 +96,6 @@ class Wlan:
                                        element = element.encode()
                                        extra.append( strip(self.asciify(element)) )
                                for element in extra:
-                                       print element
                                        if 'SignalStrength' in element:
                                                signal = element[element.index('SignalStrength')+15:element.index(',L')]                                        
                                        if 'LinkQuality' in element:
@@ -207,183 +114,151 @@ class Wlan:
                                        'signal' : str(signal),
                                        'custom' : extra,
                                }
-                               #print "GOT APS ENTRY:",aps[bssid]
-                               index = index + 1
-                       return aps
 
+                               index = index + 1
+               return aps
                
-       def getStatus(self):
-               ifobj = Wireless(self.iface)
-               fq = Iwfreq()
-               try:
-                       self.channel = str(fq.getChannel(str(ifobj.getFrequency()[0:-3])))
-               except:
-                       self.channel = 0
-               status = {
-                                 'BSSID': str(ifobj.getAPaddr()), #ifobj.getStatistics()
-                                 'ESSID': str(ifobj.getEssid()),
-                                 'quality': "%s/%s" % (ifobj.getStatistics()[1].quality,ifobj.getQualityMax().quality),
-                                 'signal': str(ifobj.getStatistics()[1].siglevel-0x100) + " dBm",
-                                 'bitrate': str(ifobj.getBitrate()),
-                                 'channel': str(self.channel),
-                                 #'channel': str(fq.getChannel(str(ifobj.getFrequency()[0:-3]))),
-               }
-               
-               for (key, item) in status.items():
-                       if item is "None" or item is "":
-                                       status[key] = _("N/A")
-                               
-               return status
+       def stopGetNetworkList(self):
+               if self.oldInterfaceState is not None:
+                       if self.oldInterfaceState is False:
+                               iNetwork.setAdapterAttribute(self.iface, "up", False)
+                               system("ifconfig "+self.iface+" down")
+                               self.oldInterfaceState = None
+                               self.iface = None
 
+iWlan = Wlan()
 
 class wpaSupplicant:
        def __init__(self):
                pass
-       
                
-       def writeConfig(self):  
-                       
-                       essid = config.plugins.wlan.essid.value
-                       hiddenessid = config.plugins.wlan.hiddenessid.value
-                       encrypted = config.plugins.wlan.encryption.enabled.value
-                       encryption = config.plugins.wlan.encryption.type.value
-                       wepkeytype = config.plugins.wlan.encryption.wepkeytype.value
-                       psk = config.plugins.wlan.encryption.psk.value
-                       fp = file('/etc/wpa_supplicant.conf', 'w')
-                       fp.write('#WPA Supplicant Configuration by enigma2\n')
-                       fp.write('ctrl_interface=/var/run/wpa_supplicant\n')
-                       fp.write('eapol_version=1\n')
-                       fp.write('fast_reauth=1\n')     
-                       if essid == 'hidden...':
-                               fp.write('ap_scan=2\n')
-                       else:
-                               fp.write('ap_scan=1\n')
-                       fp.write('network={\n')
-                       if essid == 'hidden...':
-                               fp.write('\tssid="'+hiddenessid+'"\n')
+       def writeConfig(self, iface):
+               essid = config.plugins.wlan.essid.value
+               hiddenessid = config.plugins.wlan.hiddenessid.value
+               encryption = config.plugins.wlan.encryption.value
+               wepkeytype = config.plugins.wlan.wepkeytype.value
+               psk = config.plugins.wlan.psk.value
+               fp = file(getWlanConfigName(iface), 'w')
+               fp.write('#WPA Supplicant Configuration by enigma2\n')
+               fp.write('ctrl_interface=/var/run/wpa_supplicant\n')
+               fp.write('eapol_version=1\n')
+               fp.write('fast_reauth=1\n')     
+
+               if hiddenessid:
+                       fp.write('ap_scan=2\n')
+               else:
+                       fp.write('ap_scan=1\n')
+               fp.write('network={\n')
+               fp.write('\tssid="'+essid+'"\n')
+               fp.write('\tscan_ssid=0\n')                     
+               if encryption in ('WPA', 'WPA2', 'WPA/WPA2'):
+                       fp.write('\tkey_mgmt=WPA-PSK\n')
+                       if encryption == 'WPA':
+                               fp.write('\tproto=WPA\n')
+                               fp.write('\tpairwise=TKIP\n')
+                               fp.write('\tgroup=TKIP\n')
+                       elif encryption == 'WPA2':
+                               fp.write('\tproto=RSN\n')
+                               fp.write('\tpairwise=CCMP\n')
+                               fp.write('\tgroup=CCMP\n')
                        else:
-                               fp.write('\tssid="'+essid+'"\n')
-                       fp.write('\tscan_ssid=0\n')                     
-                       if encrypted:
-                               if encryption in ('WPA', 'WPA2', 'WPA/WPA2'):
-                                       fp.write('\tkey_mgmt=WPA-PSK\n')
-               
-                                       if encryption == 'WPA':
-                                               fp.write('\tproto=WPA\n')
-                                               fp.write('\tpairwise=TKIP\n')
-                                               fp.write('\tgroup=TKIP\n')
-                                       elif encryption == 'WPA2':
-                                               fp.write('\tproto=RSN\n')
-                                               fp.write('\tpairwise=CCMP\n')
-                                               fp.write('\tgroup=CCMP\n')
-                                       else:
-                                               fp.write('\tproto=WPA RSN\n')
-                                               fp.write('\tpairwise=CCMP TKIP\n')
-                                               fp.write('\tgroup=CCMP TKIP\n')
-                                       fp.write('\tpsk="'+psk+'"\n')
-                               elif encryption == 'WEP':
-                                       fp.write('\tkey_mgmt=NONE\n')
-                                       if wepkeytype == 'ASCII':
-                                               fp.write('\twep_key0="'+psk+'"\n')
-                                       else:
-                                               fp.write('\twep_key0='+psk+'\n')
+                               fp.write('\tproto=WPA RSN\n')
+                               fp.write('\tpairwise=CCMP TKIP\n')
+                               fp.write('\tgroup=CCMP TKIP\n')
+                       fp.write('\tpsk="'+psk+'"\n')
+               elif encryption == 'WEP':
+                       fp.write('\tkey_mgmt=NONE\n')
+                       if wepkeytype == 'ASCII':
+                               fp.write('\twep_key0="'+psk+'"\n')
                        else:
-                               fp.write('\tkey_mgmt=NONE\n')                   
-                       fp.write('}')
-                       fp.write('\n')
-                       fp.close()
-                       system("cat /etc/wpa_supplicant.conf")
+                               fp.write('\twep_key0='+psk+'\n')
+               else:
+                       fp.write('\tkey_mgmt=NONE\n')
+               fp.write('}')
+               fp.write('\n')
+               fp.close()
+               #system('cat ' + getWlanConfigName(iface))
                
-       def loadConfig(self):
+       def loadConfig(self,iface):
+               configfile = getWlanConfigName(iface)
+               if not os_path.exists(configfile):
+                       configfile = '/etc/wpa_supplicant.conf'
                try:
                        #parse the wpasupplicant configfile
-                       fp = file('/etc/wpa_supplicant.conf', 'r')
+                       print "[Wlan.py] parsing configfile: ",configfile
+                       fp = file(configfile, 'r')
                        supplicant = fp.readlines()
                        fp.close()
-                       ap_scan = False
                        essid = None
+                       encryption = "Unencrypted"
 
                        for s in supplicant:
                                split = s.strip().split('=',1)
                                if split[0] == 'ap_scan':
-                                       print "[Wlan.py] Got Hidden SSID Scan  Value "+split[1]
                                        if split[1] == '2':
-                                               ap_scan = True
+                                               config.plugins.wlan.hiddenessid.value = True
                                        else:
-                                               ap_scan = False
-                                               
+                                               config.plugins.wlan.hiddenessid.value = False
+
                                elif split[0] == 'ssid':
-                                       print "[Wlan.py] Got SSID "+split[1][1:-1]
                                        essid = split[1][1:-1]
-                                       
+                                       config.plugins.wlan.essid.value = essid
+
                                elif split[0] == 'proto':
-                                       config.plugins.wlan.encryption.enabled.value = True
                                        if split[1] == 'WPA' :
                                                mode = 'WPA'
                                        if split[1] == 'RSN':
                                                mode = 'WPA2'
                                        if split[1] in ('WPA RSN', 'WPA WPA2'):
                                                mode = 'WPA/WPA2'
-
-                                       config.plugins.wlan.encryption.type.value = mode
-                                       print "[Wlan.py] Got Encryption: "+mode
+                                       encryption = mode
                                        
                                elif split[0] == 'wep_key0':
-                                       config.plugins.wlan.encryption.enabled.value = True
-                                       config.plugins.wlan.encryption.type.value = 'WEP'
+                                       encryption = 'WEP'
                                        if split[1].startswith('"') and split[1].endswith('"'):
-                                               config.plugins.wlan.encryption.wepkeytype.value = 'ASCII'
-                                               config.plugins.wlan.encryption.psk.value = split[1][1:-1]
+                                               config.plugins.wlan.wepkeytype.value = 'ASCII'
+                                               config.plugins.wlan.psk.value = split[1][1:-1]
                                        else:
-                                               config.plugins.wlan.encryption.wepkeytype.value = 'HEX'
-                                               config.plugins.wlan.encryption.psk.value = split[1]                                             
+                                               config.plugins.wlan.wepkeytype.value = 'HEX'
+                                               config.plugins.wlan.psk.value = split[1]                                                
                                        
                                elif split[0] == 'psk':
-                                       config.plugins.wlan.encryption.psk.value = split[1][1:-1]
+                                       config.plugins.wlan.psk.value = split[1][1:-1]
                                else:
                                        pass
+
+                       config.plugins.wlan.encryption.value = encryption
                                
-                       if ap_scan is True:
-                               config.plugins.wlan.hiddenessid.value = essid
-                               config.plugins.wlan.essid.value = 'hidden...'
-                       else:
-                               config.plugins.wlan.hiddenessid.value = essid
-                               config.plugins.wlan.essid.value = essid
                        wsconfig = {
                                        'hiddenessid': config.plugins.wlan.hiddenessid.value,
                                        'ssid': config.plugins.wlan.essid.value,
-                                       'encryption': config.plugins.wlan.encryption.enabled.value,
-                                       'encryption_type': config.plugins.wlan.encryption.type.value,
-                                       'encryption_wepkeytype': config.plugins.wlan.encryption.wepkeytype.value,
-                                       'key': config.plugins.wlan.encryption.psk.value,
+                                       'encryption': config.plugins.wlan.encryption.value,
+                                       'wepkeytype': config.plugins.wlan.wepkeytype.value,
+                                       'key': config.plugins.wlan.psk.value,
                                }
                
                        for (key, item) in wsconfig.items():
                                if item is "None" or item is "":
                                        if key == 'hiddenessid':
-                                               wsconfig['hiddenessid'] = "home"
+                                               wsconfig['hiddenessid'] = False
                                        if key == 'ssid':
-                                               wsconfig['ssid'] = "home"
-                                       if key == 'encryption':
-                                               wsconfig['encryption'] = True                           
-                                       if key == 'encryption':
-                                               wsconfig['encryption_type'] = "WPA/WPA2"
+                                               wsconfig['ssid'] = ""
                                        if key == 'encryption':
-                                               wsconfig['encryption_wepkeytype'] = "ASCII"
-                                       if key == 'encryption':
-                                               wsconfig['key'] = "mysecurewlan"
-
+                                               wsconfig['encryption'] = "WPA2"                 
+                                       if key == 'wepkeytype':
+                                               wsconfig['wepkeytype'] = "ASCII"
+                                       if key == 'key':
+                                               wsconfig['key'] = ""
                except:
-                       print "[Wlan.py] Error parsing /etc/wpa_supplicant.conf"
+                       print "[Wlan.py] Error parsing ",configfile
                        wsconfig = {
-                                       'hiddenessid': "home",
-                                       'ssid': "home",
-                                       'encryption': True,
-                                       'encryption_type': "WPA/WPA2",
-                                       'encryption_wepkeytype': "ASCII",
-                                       'key': "mysecurewlan",
+                                       'hiddenessid': False,
+                                       'ssid': "",
+                                       'encryption': "WPA2",
+                                       'wepkeytype': "ASCII",
+                                       'key': "",
                                }
-               print "[Wlan.py] WS-CONFIG-->",wsconfig
+               #print "[Wlan.py] WS-CONFIG-->",wsconfig
                return wsconfig
 
 
@@ -391,82 +266,70 @@ class Status:
        def __init__(self):
                self.wlaniface = {}
                self.backupwlaniface = {}
+               self.statusCallback = None
                self.WlanConsole = Console()
 
        def stopWlanConsole(self):
                if self.WlanConsole is not None:
-                       print "killing self.WlanConsole"
+                       print "[iStatus] killing self.WlanConsole"
                        self.WlanConsole.killAll()
                        self.WlanConsole = None
                        
        def getDataForInterface(self, iface, callback = None):
                self.WlanConsole = Console()
                cmd = "iwconfig " + iface
-               self.WlanConsole.ePopen(cmd, self.iwconfigFinished, [iface, callback])
+               if callback is not None:
+                       self.statusCallback = callback
+               self.WlanConsole.ePopen(cmd, self.iwconfigFinished, iface)
 
        def iwconfigFinished(self, result, retval, extra_args):
-               (iface, callback) = extra_args
-               data = { 'essid': False, 'frequency': False, 'acesspoint': False, 'bitrate': False, 'encryption': False, 'quality': False, 'signal': False }
+               iface = extra_args
+               data = { 'essid': False, 'frequency': False, 'accesspoint': False, 'bitrate': False, 'encryption': False, 'quality': False, 'signal': False }
                for line in result.splitlines():
                        line = line.strip()
                        if "ESSID" in line:
                                if "off/any" in line:
-                                       ssid = _("No Connection")
+                                       ssid = "off"
                                else:
                                        if "Nickname" in line:
-                                               tmpssid=(line[line.index('ESSID')+7:line.index('"  Nickname')])
-                                               if tmpssid == '':
-                                                       ssid = _("Hidden networkname")
-                                               elif tmpssid ==' ':
-                                                       ssid = _("Hidden networkname")
-                                               else:
-                                                       ssid = tmpssid
+                                               ssid=(line[line.index('ESSID')+7:line.index('"  Nickname')])
                                        else:
-                                               tmpssid=(line[line.index('ESSID')+7:len(line)-1])
-                                               if tmpssid == '':
-                                                       ssid = _("Hidden networkname")
-                                               elif tmpssid ==' ':
-                                                       ssid = _("Hidden networkname")
-                                               else:
-                                                       ssid = tmpssid                                          
+                                               ssid=(line[line.index('ESSID')+7:len(line)-1])
                                if ssid is not None:
                                        data['essid'] = ssid
-                       if 'Frequency' in line:
+                       if "Frequency" in line:
                                frequency = line[line.index('Frequency')+10 :line.index(' GHz')]
                                if frequency is not None:
                                        data['frequency'] = frequency
                        if "Access Point" in line:
-                               ap=line[line.index('Access Point')+14:len(line)]
+                               if "Sensitivity" in line:
+                                       ap=line[line.index('Access Point')+14:line.index('   Sensitivity')]
+                               else:
+                                       ap=line[line.index('Access Point')+14:len(line)]
                                if ap is not None:
-                                       data['acesspoint'] = ap
-                                       if ap == "Not-Associated":
-                                               data['essid'] = _("No Connection")
+                                       data['accesspoint'] = ap
                        if "Bit Rate" in line:
                                if "kb" in line:
                                        br = line[line.index('Bit Rate')+9 :line.index(' kb/s')]
-                                       if br == '0':
-                                               br = _("Unsupported")
-                                       else:
-                                               br += " Mb/s"
                                else:
-                                       br = line[line.index('Bit Rate')+9 :line.index(' Mb/s')] + " Mb/s"
+                                       br = line[line.index('Bit Rate')+9 :line.index(' Mb/s')]
                                if br is not None:
                                        data['bitrate'] = br
-                       if 'Encryption key' in line:
+                       if "Encryption key" in line:
                                if ":off" in line:
-                                       if data['acesspoint'] is not "Not-Associated":
-                                               enc = _("Unsupported")
-                                       else:
-                                               enc = _("Disabled")
-                               else:
+                                       enc = "off"
+                               elif "Security" in line:
                                        enc = line[line.index('Encryption key')+15 :line.index('   Security')]
                                        if enc is not None:
-                                               enc = _("Enabled")
+                                               enc = "on"
+                               else:
+                                       enc = line[line.index('Encryption key')+15 :len(line)]
+                                       if enc is not None:
+                                               enc = "on"
                                if enc is not None:
                                        data['encryption'] = enc
                        if 'Quality' in line:
                                if "/100" in line:
-                                       #qual = line[line.index('Quality')+8:line.index('/100')]
                                        qual = line[line.index('Quality')+8:line.index('  Signal')]
                                else:
                                        qual = line[line.index('Quality')+8:line.index('Sig')]
@@ -474,8 +337,7 @@ class Status:
                                        data['quality'] = qual
                        if 'Signal level' in line:
                                if "dBm" in line:
-                                       signal = line[line.index('Signal level')+13 :line.index(' dBm')]
-                                       signal += " dBm"
+                                       signal = line[line.index('Signal level')+13 :line.index(' dBm')] + " dBm"
                                elif "/100" in line:
                                        if "Noise" in line:
                                                signal = line[line.index('Signal level')+13:line.index('  Noise')]
@@ -494,9 +356,10 @@ class Status:
                
                if self.WlanConsole is not None:
                        if len(self.WlanConsole.appContainers) == 0:
-                               print "self.wlaniface after loading:", self.wlaniface
-                               if callback is not None:
-                                       callback(True,self.wlaniface)
+                               print "[Wlan.py] self.wlaniface after loading:", self.wlaniface
+                               if self.statusCallback is not None:
+                                               self.statusCallback(True,self.wlaniface)
+                                               self.statusCallback = None
 
        def getAdapterAttribute(self, iface, attribute):
                self.iface = iface
index efec340..10213eb 100644 (file)
@@ -8,37 +8,40 @@ from Components.Sources.List import List
 from Components.MenuList import MenuList
 from Components.config import config, getConfigListEntry, ConfigYesNo, NoSave, ConfigSubsection, ConfigText, ConfigSelection, ConfigPassword
 from Components.ConfigList import ConfigListScreen
-from Components.Network import Network, iNetwork
+from Components.Network import iNetwork
 from Components.Console import Console
 from Plugins.Plugin import PluginDescriptor
 from os import system, path as os_path, listdir
 from Tools.Directories import resolveFilename, SCOPE_PLUGINS, SCOPE_SKIN_IMAGE
 from Tools.LoadPixmap import LoadPixmap
 from Tools.HardwareInfo import HardwareInfo
-from Wlan import Wlan, wpaSupplicant, iStatus
-import sha
+from Wlan import iWlan, wpaSupplicant, iStatus, getWlanConfigName
+import hashlib
+from time import time
+from os import urandom, system
+from re import escape as re_escape
 
 plugin_path = eEnv.resolve("${libdir}/enigma2/python/Plugins/SystemPlugins/WirelessLan")
 
+
 list = []
+list.append("Unencrypted")
 list.append("WEP")
 list.append("WPA")
-list.append("WPA2")
 list.append("WPA/WPA2")
+list.append("WPA2")
 
 weplist = []
 weplist.append("ASCII")
 weplist.append("HEX")
 
 config.plugins.wlan = ConfigSubsection()
-config.plugins.wlan.essid = NoSave(ConfigText(default = "home", fixed_size = False))
-config.plugins.wlan.hiddenessid = NoSave(ConfigText(default = "home", fixed_size = False))
+config.plugins.wlan.essid = NoSave(ConfigText(default = "", fixed_size = False))
+config.plugins.wlan.hiddenessid = NoSave(ConfigYesNo(default = False))
+config.plugins.wlan.encryption = NoSave(ConfigSelection(list, default = "WPA2"))
+config.plugins.wlan.wepkeytype = NoSave(ConfigSelection(weplist, default = "ASCII"))
+config.plugins.wlan.psk = NoSave(ConfigPassword(default = "", fixed_size = False))
 
-config.plugins.wlan.encryption = ConfigSubsection()
-config.plugins.wlan.encryption.enabled = NoSave(ConfigYesNo(default = False))
-config.plugins.wlan.encryption.type = NoSave(ConfigSelection(list, default = "WPA/WPA2" ))
-config.plugins.wlan.encryption.wepkeytype = NoSave(ConfigSelection(weplist, default = "ASCII"))
-config.plugins.wlan.encryption.psk = NoSave(ConfigPassword(default = "mysecurewlan", fixed_size = False))
 
 
 class WlanStatus(Screen):
@@ -46,20 +49,19 @@ class WlanStatus(Screen):
                <screen name="WlanStatus" position="center,center" size="560,400" title="Wireless Network State" >
                        <ePixmap pixmap="skin_default/buttons/red.png" position="0,0" size="140,40" alphatest="on" />
                        <widget source="key_red" render="Label" position="0,0" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#9f1313" transparent="1" />
-       
-                       <widget source="LabelBSSID" render="Label" position="10,60" size="250,25" valign="left" font="Regular;20" transparent="1" foregroundColor="#FFFFFF" />
-                       <widget source="LabelESSID" render="Label" position="10,100" size="250,25" valign="center" font="Regular;20" transparent="1" foregroundColor="#FFFFFF" />
-                       <widget source="LabelQuality" render="Label" position="10,140" size="250,25" valign="center" font="Regular;20" transparent="1" foregroundColor="#FFFFFF" />
-                       <widget source="LabelSignal" render="Label" position="10,180" size="250,25" valign="center" font="Regular;20" transparent="1" foregroundColor="#FFFFFF" />
-                       <widget source="LabelBitrate" render="Label" position="10,220" size="250,25" valign="center" font="Regular;20" transparent="1" foregroundColor="#FFFFFF" />
-                       <widget source="LabelEnc" render="Label" position="10,260" size="250,25" valign="center" font="Regular;20" transparent="1" foregroundColor="#FFFFFF" />
-                       
-                       <widget source="BSSID" render="Label" position="320,60" size="180,25" valign="center" font="Regular;20" transparent="1" foregroundColor="#FFFFFF" />
-                       <widget source="ESSID" render="Label" position="320,100" size="180,25" valign="center" font="Regular;20" transparent="1" foregroundColor="#FFFFFF" />
-                       <widget source="quality" render="Label" position="320,140" size="180,25" valign="center" font="Regular;20" transparent="1" foregroundColor="#FFFFFF" />
-                       <widget source="signal" render="Label" position="320,180" size="180,25" valign="center" font="Regular;20" transparent="1" foregroundColor="#FFFFFF" />
-                       <widget source="bitrate" render="Label" position="320,220" size="180,25" valign="center" font="Regular;20" transparent="1" foregroundColor="#FFFFFF" />
-                       <widget source="enc" render="Label" position="320,260" size="180,25" valign="center" font="Regular;20" transparent="1" foregroundColor="#FFFFFF" />
+
+                       <widget source="LabelBSSID" render="Label" position="10,60" size="200,25" valign="left" font="Regular;20" transparent="1" foregroundColor="#FFFFFF" />
+                       <widget source="LabelESSID" render="Label" position="10,100" size="200,25" valign="center" font="Regular;20" transparent="1" foregroundColor="#FFFFFF" />
+                       <widget source="LabelQuality" render="Label" position="10,140" size="200,25" valign="center" font="Regular;20" transparent="1" foregroundColor="#FFFFFF" />
+                       <widget source="LabelSignal" render="Label" position="10,180" size="200,25" valign="center" font="Regular;20" transparent="1" foregroundColor="#FFFFFF" />
+                       <widget source="LabelBitrate" render="Label" position="10,220" size="200,25" valign="center" font="Regular;20" transparent="1" foregroundColor="#FFFFFF" />
+                       <widget source="LabelEnc" render="Label" position="10,260" size="200,25" valign="center" font="Regular;20" transparent="1" foregroundColor="#FFFFFF" />
+                       <widget source="BSSID" render="Label" position="220,60" size="330,25" valign="center" font="Regular;20" transparent="1" foregroundColor="#FFFFFF" />
+                       <widget source="ESSID" render="Label" position="220,100" size="330,25" valign="center" font="Regular;20" transparent="1" foregroundColor="#FFFFFF" />
+                       <widget source="quality" render="Label" position="220,140" size="330,25" valign="center" font="Regular;20" transparent="1" foregroundColor="#FFFFFF" />
+                       <widget source="signal" render="Label" position="220,180" size="330,25" valign="center" font="Regular;20" transparent="1" foregroundColor="#FFFFFF" />
+                       <widget source="bitrate" render="Label" position="220,220" size="330,25" valign="center" font="Regular;20" transparent="1" foregroundColor="#FFFFFF" />
+                       <widget source="enc" render="Label" position="220,260" size="330,25" valign="center" font="Regular;20" transparent="1" foregroundColor="#FFFFFF" />
        
                        <ePixmap pixmap="skin_default/div-h.png" position="0,350" zPosition="1" size="560,2" />         
                        <widget source="IFtext" render="Label" position="10,355" size="120,21" zPosition="10" font="Regular;20" halign="left" backgroundColor="#25062748" transparent="1" />
@@ -105,7 +107,7 @@ class WlanStatus(Screen):
                }, -1)
                self.timer = eTimer()
                self.timer.timeout.get().append(self.resetList) 
-               self.onShown.append(lambda: self.timer.start(5000))
+               self.onShown.append(lambda: self.timer.start(8000))
                self.onLayoutFinish.append(self.layoutFinished)
                self.onClose.append(self.cleanup)
 
@@ -113,7 +115,7 @@ class WlanStatus(Screen):
                iStatus.stopWlanConsole()
                
        def layoutFinished(self):
-               self.setTitle(_("Wireless Network State"))
+               self.setTitle(_("Wireless network state"))
                
        def resetList(self):
                iStatus.getDataForInterface(self.iface,self.getInfoCB)
@@ -122,32 +124,65 @@ class WlanStatus(Screen):
                if data is not None:
                        if data is True:
                                if status is not None:
-                                       self["BSSID"].setText(status[self.iface]["acesspoint"])
-                                       self["ESSID"].setText(status[self.iface]["essid"])
-                                       self["quality"].setText(status[self.iface]["quality"])
-                                       self["signal"].setText(status[self.iface]["signal"])
-                                       self["bitrate"].setText(status[self.iface]["bitrate"])
-                                       self["enc"].setText(status[self.iface]["encryption"])
+                                       if status[self.iface]["essid"] == "off":
+                                               essid = _("No Connection")
+                                       else:
+                                               essid = status[self.iface]["essid"]
+                                       if status[self.iface]["accesspoint"] == "Not-Associated":
+                                               accesspoint = _("Not-Associated")
+                                               essid = _("No Connection")
+                                       else:
+                                               accesspoint = status[self.iface]["accesspoint"]
+                                       if self.has_key("BSSID"):
+                                               self["BSSID"].setText(accesspoint)
+                                       if self.has_key("ESSID"):
+                                               self["ESSID"].setText(essid)
+
+                                       quality = status[self.iface]["quality"]
+                                       if self.has_key("quality"):
+                                               self["quality"].setText(quality)
+                                               
+                                       if status[self.iface]["bitrate"] == '0':
+                                               bitrate = _("Unsupported")
+                                       else:
+                                               bitrate = str(status[self.iface]["bitrate"]) + " Mb/s"
+                                       if self.has_key("bitrate"):
+                                               self["bitrate"].setText(bitrate)                                        
+                                       
+                                       signal = status[self.iface]["signal"]
+                                       if self.has_key("signal"):
+                                               self["signal"].setText(signal)
+
+                                       if status[self.iface]["encryption"] == "off":
+                                               if accesspoint == "Not-Associated":
+                                                       encryption = _("Disabled")
+                                               else:
+                                                       encryption = _("Unsupported")
+                                       else:
+                                               encryption = _("Enabled")
+                                       if self.has_key("enc"):
+                                               self["enc"].setText(encryption)
                                        self.updateStatusLink(status)
 
        def exit(self):
                self.timer.stop()
-               self.close(True)        
+               self.close(True)
 
        def updateStatusbar(self):
-               self["BSSID"].setText(_("Please wait..."))
-               self["ESSID"].setText(_("Please wait..."))
-               self["quality"].setText(_("Please wait..."))
-               self["signal"].setText(_("Please wait..."))
-               self["bitrate"].setText(_("Please wait..."))
-               self["enc"].setText(_("Please wait..."))
+               wait_txt = _("Please wait...")
+               self["BSSID"].setText(wait_txt)
+               self["ESSID"].setText(wait_txt)
+               self["quality"].setText(wait_txt)
+               self["signal"].setText(wait_txt)
+               self["bitrate"].setText(wait_txt)
+               self["enc"].setText(wait_txt)
                self["IFtext"].setText(_("Network:"))
                self["IF"].setText(iNetwork.getFriendlyAdapterName(self.iface))
                self["Statustext"].setText(_("Link:"))
 
        def updateStatusLink(self,status):
                if status is not None:
-                       if status[self.iface]["acesspoint"] == "No Connection" or status[self.iface]["acesspoint"] == "Not-Associated" or status[self.iface]["acesspoint"] == False:
+                       if status[self.iface]["essid"] == "off" or status[self.iface]["accesspoint"] == "Not-Associated" or status[self.iface]["accesspoint"] == False:
                                self["statuspic"].setPixmapNum(1)
                        else:
                                self["statuspic"].setPixmapNum(0)
@@ -217,6 +252,8 @@ class WlanScan(Screen):
                        "red": self.cancel,
                        "green": self.select,
                })
+               iWlan.setInterface(self.iface)
+               self.w = iWlan.getInterface()
                self.onLayoutFinish.append(self.layoutFinished)
                self.getAccessPoints(refresh = False)
                
@@ -226,42 +263,24 @@ class WlanScan(Screen):
        def select(self):
                cur = self["list"].getCurrent()
                if cur is not None:
+                       iWlan.stopGetNetworkList()
                        self.rescanTimer.stop()
                        del self.rescanTimer
-                       if cur[1] is not None:
-                               if cur[1] == 'hidden...':
-                                       essid = cur[1]
-                               else:
-                                       essid = cur[0]
-                               self.close(essid,self.getWlanList())
+                       if cur[0] is not None:
+                               self.close(cur[0])
                        else:
-                               self.close(None,None)
+                               self.close(None)
                else:
-                       self.rescanTimer.stop()
-                       del self.rescanTimer
-                       self.close(None,None)
-       
-       def WlanSetupClosed(self, *ret):
-               if ret[0] == 2:
+                       iWlan.stopGetNetworkList()
                        self.rescanTimer.stop()
                        del self.rescanTimer
                        self.close(None)
        
        def cancel(self):
-               if self.oldInterfaceState is False:
-                       iNetwork.setAdapterAttribute(self.iface, "up", False)
-                       iNetwork.deactivateInterface(self.iface,self.deactivateInterfaceCB)
-               else:
-                       self.rescanTimer.stop()
-                       del self.rescanTimer
-                       self.close(None)
-
-       def deactivateInterfaceCB(self,data):
-               if data is not None:
-                       if data is True:
-                               self.rescanTimer.stop()
-                               del self.rescanTimer
-                               self.close(None)
+               iWlan.stopGetNetworkList()
+               self.rescanTimer.stop()
+               del self.rescanTimer
+               self.close(None)
 
        def rescanTimerFired(self):
                self.rescanTimer.stop()
@@ -270,10 +289,7 @@ class WlanScan(Screen):
        def buildEntryComponent(self, essid, bssid, encrypted, iface, maxrate, signal):
                divpng = LoadPixmap(cached=True, path=resolveFilename(SCOPE_SKIN_IMAGE, "skin_default/div-h.png"))
                encryption = encrypted and _("Yes") or _("No")
-               if bssid == 'hidden...':
-                       return((essid, bssid, None, None, None, None, divpng))
-               else:                                   
-                       return((essid, bssid, _("Signal: ") + str(signal), _("Max. Bitrate: ") + str(maxrate), _("Encrypted: ") + encryption, _("Interface: ") + str(iface), divpng))
+               return((essid, bssid, _("Signal: ") + str(signal), _("Max. Bitrate: ") + str(maxrate), _("Encrypted: ") + encryption, _("Interface: ") + str(iface), divpng))
 
        def updateAPList(self):
                newList = []
@@ -290,20 +306,19 @@ class WlanScan(Screen):
                                tmpList.append(data)
 
                if len(tmpList):
-                       if "hidden..." not in tmpList:
-                               tmpList.append( ( _("enter hidden network SSID"), "hidden...", True, self.iface, _("unavailable"), "" ) )
-       
                        for entry in tmpList:
                                self.newAPList.append(self.buildEntryComponent( entry[0], entry[1], entry[2], entry[3], entry[4], entry[5] ))
        
                        currentListEntry = self["list"].getCurrent()
-                       idx = 0
-                       for entry in self.newAPList:
-                               if entry[0] == currentListEntry[0]:
-                                       newListIndex = idx
-                               idx +=1
+                       if currentListEntry is not None:
+                               idx = 0
+                               for entry in self.newAPList:
+                                       if entry[0] == currentListEntry[0]:
+                                               newListIndex = idx
+                                       idx +=1
                        self['list'].setList(self.newAPList)
-                       self["list"].setIndex(newListIndex)
+                       if newListIndex is not None:
+                               self["list"].setIndex(newListIndex)
                        self["list"].updateList(self.newAPList)
                        self.listLength = len(self.newAPList)
                        self.buildWlanList()
@@ -312,8 +327,7 @@ class WlanScan(Screen):
        def getAccessPoints(self, refresh = False):
                self.APList = []
                self.cleanList = []
-               self.w = Wlan(self.iface)
-               aps = self.w.getNetworkList()
+               aps = iWlan.getNetworkList()
                if aps is not None:
                        print "[WirelessLan.py] got Accespoints!"
                        tmpList = []
@@ -336,9 +350,6 @@ class WlanScan(Screen):
                                else:
                                        self.oldlist[entry[0]]['data'] = entry
                
-               if "hidden..." not in self.cleanList:
-                       self.cleanList.append( ( _("enter hidden network SSID"), "hidden...", True, self.iface, _("unavailable"), "" ) )
-
                for entry in self.cleanList:
                        self.APList.append(self.buildEntryComponent( entry[0], entry[1], entry[2], entry[3], entry[4], entry[5] ))
                
@@ -351,20 +362,17 @@ class WlanScan(Screen):
 
        def setInfo(self):
                length = self.getLength()
-               if length <= 1:
-                       self["info"].setText(_("No wireless networks found! Please refresh."))
-               elif length == 2:
+               if length == 0:
+                       self["info"].setText(_("No wireless networks found! Searching..."))
+               elif length == 1:
                        self["info"].setText(_("1 wireless network found!"))
                else:
-                       self["info"].setText(str(length-1)+_(" wireless networks found!"))
+                       self["info"].setText(str(length)+_(" wireless networks found!"))
 
        def buildWlanList(self):
                self.WlanList = []
                for entry in self['list'].list:
-                       if entry[1] == "hidden...":
-                               self.WlanList.append(( "hidden...",_("enter hidden network SSID") ))#continue
-                       else:
-                               self.WlanList.append( (entry[0], entry[0]) )
+                       self.WlanList.append( (entry[0], entry[0]) )
 
        def getLength(self):
                return self.listLength          
@@ -391,7 +399,7 @@ def decrypt_block(src, mod):
        if len(src) != 128 and len(src) != 202:
                return None
        dest = rsa_pub1024(src[:128], mod)
-       hash = sha.new(dest[1:107])
+       hash = hashlib.sha1(dest[1:107])
        if len(src) == 202:
                hash.update(src[131:192])       
        result = hash.digest()
@@ -399,65 +407,69 @@ def decrypt_block(src, mod):
                return dest
        return None
 
-def validate_cert(cert, key):
+def validate_certificate(cert, key):
        buf = decrypt_block(cert[8:], key) 
        if buf is None:
                return None
        return buf[36:107] + cert[139:196]
 
-def read_random():
+def get_random():
        try:
-               fd = open("/dev/urandom", "r")
-               buf = fd.read(8)
-               fd.close()
-               return buf
+               xor = lambda a,b: ''.join(chr(ord(c)^ord(d)) for c,d in zip(a,b*100))
+               random = urandom(8)
+               x = str(time())[-8:]
+               result = xor(random, x)
+                               
+               return result
        except:
                return None
 
 def WlanStatusScreenMain(session, iface):
        session.open(WlanStatus, iface)
 
-
 def callFunction(iface):
-       w = Wlan(iface)
-       i = w.getWirelessInterfaces()
+       iWlan.setInterface(iface)
+       i = iWlan.getWirelessInterfaces()
        if i:
-               if iface in i:
+               if iface in i or iNetwork.isWirelessInterface(iface):
                        return WlanStatusScreenMain
+               return None
        return None
 
-
 def configStrings(iface):
-       hardware_info = HardwareInfo()
-       if  hardware_info.device_name != "dm7025":
+       try:
+               device = open("/proc/stb/info/model", "r").readline().strip()
+       except:
+               device = ""     
+       if device != "dm7025":
                rootkey = ['\x9f', '|', '\xe4', 'G', '\xc9', '\xb4', '\xf4', '#', '&', '\xce', '\xb3', '\xfe', '\xda', '\xc9', 'U', '`', '\xd8', '\x8c', 's', 'o', '\x90', '\x9b', '\\', 'b', '\xc0', '\x89', '\xd1', '\x8c', '\x9e', 'J', 'T', '\xc5', 'X', '\xa1', '\xb8', '\x13', '5', 'E', '\x02', '\xc9', '\xb2', '\xe6', 't', '\x89', '\xde', '\xcd', '\x9d', '\x11', '\xdd', '\xc7', '\xf4', '\xe4', '\xe4', '\xbc', '\xdb', '\x9c', '\xea', '}', '\xad', '\xda', 't', 'r', '\x9b', '\xdc', '\xbc', '\x18', '3', '\xe7', '\xaf', '|', '\xae', '\x0c', '\xe3', '\xb5', '\x84', '\x8d', '\r', '\x8d', '\x9d', '2', '\xd0', '\xce', '\xd5', 'q', '\t', '\x84', 'c', '\xa8', ')', '\x99', '\xdc', '<', '"', 'x', '\xe8', '\x87', '\x8f', '\x02', ';', 'S', 'm', '\xd5', '\xf0', '\xa3', '_', '\xb7', 'T', '\t', '\xde', '\xa7', '\xf1', '\xc9', '\xae', '\x8a', '\xd7', '\xd2', '\xcf', '\xb2', '.', '\x13', '\xfb', '\xac', 'j', '\xdf', '\xb1', '\x1d', ':', '?']
                etpm = eTPM()
                l2cert = etpm.getCert(eTPM.TPMD_DT_LEVEL2_CERT)
                if l2cert is None:
                        return
-               l2key = validate_cert(l2cert, rootkey)
+               l2key = validate_certificate(l2cert, rootkey)
                if l2key is None:
                        return
                l3cert = etpm.getCert(eTPM.TPMD_DT_LEVEL3_CERT)
                if l3cert is None:
-                       print "better run the genuine dreambox plugin"
                        return
-               l3key = validate_cert(l3cert, l2key)
+               l3key = validate_certificate(l3cert, l2key)
                if l3key is None:
                        return
-               rnd = read_random()
+               rnd = get_random()
                if rnd is None:
                        return
                val = etpm.challenge(rnd)
                result = decrypt_block(val, l3key)
-       if hardware_info.device_name == "dm7025" or result[80:88] == rnd:
+       if device == "dm7025" or result[80:88] == rnd:
                driver = iNetwork.detectWlanModule(iface)
        else:
                driver = 'dreambox'
+       print 'Using "%s" as wpa-supplicant driver' % (driver)
        ret = ""
-       if driver == 'madwifi' and config.plugins.wlan.essid.value == "hidden...":
-               ret += "\tpre-up iwconfig " + iface + " essid \"" + config.plugins.wlan.hiddenessid.value + "\" || true\n"
-       ret += "\tpre-up wpa_supplicant -i" + iface + " -c/etc/wpa_supplicant.conf -B -dd -D" + driver + " || true\n"
+       if driver == 'madwifi' and config.plugins.wlan.hiddenessid.value:
+               ret += "\tpre-up iwconfig " + iface + " essid \"" + re_escape(config.plugins.wlan.essid.value) + "\" || true\n"
+       ret += "\tpre-up wpa_supplicant -i" + iface + " -c" + getWlanConfigName(iface) + " -B -dd -D" + driver + " || true\n"
        ret += "\tpre-down wpa_cli -i" + iface + " terminate || true\n"
        return ret
 
index 73b07ac..54e241d 100644 (file)
@@ -25,9 +25,10 @@ class DefaultWizard(WizardLanguage, DreamInfoHandler):
                self["arrowup2"] = MovingPixmap()
        
        def setDirectory(self):
-               os_system("mount %s %s" % (resolveFilename(SCOPE_DEFAULTPARTITION), resolveFilename(SCOPE_DEFAULTPARTITIONMOUNTDIR)))
                self.directory = resolveFilename(SCOPE_DEFAULTPARTITIONMOUNTDIR)
                self.xmlfile = "defaultwizard.xml"
+               if self.directory:
+                       os_system("mount %s %s" % (resolveFilename(SCOPE_DEFAULTPARTITION), self.directory))
         
        def markDone(self):
                config.misc.defaultchosen.value = 0
index 61ce356..7dd7b12 100644 (file)
@@ -41,9 +41,11 @@ class InputBox(Screen):
                        "9": self.keyNumberGlobal,
                        "0": self.keyNumberGlobal
                }, -1)
+
                if self["input"].type == Input.TEXT:
-                       rcinput = eRCInput.getInstance()
-                       rcinput.setKeyboardMode(rcinput.kmAscii)
+                       self.onExecBegin.append(self.setKeyboardModeAscii)
+               else:
+                       self.onExecBegin.append(self.setKeyboardModeNone)
 
        def gotAsciiCode(self):
                self["input"].handleAscii(getPrevAsciiCode())
@@ -61,13 +63,9 @@ class InputBox(Screen):
                self["input"].delete()
 
        def go(self):
-               rcinput = eRCInput.getInstance()
-               rcinput.setKeyboardMode(rcinput.kmNone)
                self.close(self["input"].getText())
 
        def cancel(self):
-               rcinput = eRCInput.getInstance()
-               rcinput.setKeyboardMode(rcinput.kmNone)
                self.close(None)
 
        def keyHome(self):
@@ -142,19 +140,13 @@ class PinInput(InputBox):
                                pass
        
        def closePinWrong(self, *args):
-               rcinput = eRCInput.getInstance()
-               rcinput.setKeyboardMode(rcinput.kmNone)
                print "args:", args
                self.close(False)
                
        def closePinCorrect(self, *args):
-               rcinput = eRCInput.getInstance()
-               rcinput.setKeyboardMode(rcinput.kmNone)
                self.close(True)
                
        def closePinCancel(self, *args):
-               rcinput = eRCInput.getInstance()
-               rcinput.setKeyboardMode(rcinput.kmNone)
                self.close(None)
                        
        def cancel(self):
index de2fa99..4b15ee0 100755 (executable)
@@ -11,7 +11,7 @@ from Components.Sources.List import List
 from Components.Label import Label,MultiColorLabel
 from Components.Pixmap import Pixmap,MultiPixmap
 from Components.MenuList import MenuList
-from Components.config import config, ConfigYesNo, ConfigIP, NoSave, ConfigText, ConfigPassword, ConfigSelection, getConfigListEntry, ConfigNothing
+from Components.config import config, ConfigYesNo, ConfigIP, NoSave, ConfigText, ConfigPassword, ConfigSelection, getConfigListEntry, ConfigNothing, ConfigBoolean
 from Components.ConfigList import ConfigListScreen
 from Components.PluginComponent import plugins
 from Components.MultiContent import MultiContentEntryText, MultiContentEntryPixmapAlphaTest
@@ -42,11 +42,6 @@ class NetworkAdapterSelection(Screen,HelpableScreen):
                self["key_blue"] = StaticText("")
                self["introduction"] = StaticText(self.edittext)
                
-               self.adapters = [(iNetwork.getFriendlyAdapterName(x),x) for x in iNetwork.getAdapterList()]
-               
-               if not self.adapters:
-                       self.onFirstExecBegin.append(self.NetworkFallback)
-                       
                self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions",
                        {
                        "cancel": (self.close, _("exit network interface list")),
@@ -65,6 +60,14 @@ class NetworkAdapterSelection(Screen,HelpableScreen):
                        "yellow": (self.setDefaultInterface, [_("Set interface as default Interface"),_("* Only available if more than one interface is active.")] ),
                        })
 
+               self.adapters = [(iNetwork.getFriendlyAdapterName(x),x) for x in iNetwork.getAdapterList()]
+
+               if not self.adapters:
+                       self.adapters = [(iNetwork.getFriendlyAdapterName(x),x) for x in iNetwork.getConfiguredAdapters()]
+
+               if len(self.adapters) == 0:
+                       self.adapters = [(iNetwork.getFriendlyAdapterName(x),x) for x in iNetwork.getInstalledAdapters()]
+
                self.list = []
                self["list"] = List(self.list)
                self.updateList()
@@ -80,14 +83,14 @@ class NetworkAdapterSelection(Screen,HelpableScreen):
                description = None
                interfacepng = None
 
-               if iface in iNetwork.lan_interfaces:
+               if not iNetwork.isWirelessInterface(iface):
                        if active is True:
                                interfacepng = LoadPixmap(resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/icons/network_wired-active.png"))
                        elif active is False:
                                interfacepng = LoadPixmap(resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/icons/network_wired-inactive.png"))
                        else:
                                interfacepng = LoadPixmap(resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/icons/network_wired.png"))
-               elif iface in iNetwork.wlan_interfaces:
+               elif iNetwork.isWirelessInterface(iface):
                        if active is True:
                                interfacepng = LoadPixmap(resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/icons/network_wireless-active.png"))
                        elif active is False:
@@ -132,19 +135,16 @@ class NetworkAdapterSelection(Screen,HelpableScreen):
                        fp.close()
                        default_gw = result
                                        
-               if len(self.adapters) == 0: # no interface available => display only eth0
-                       self.list.append(self.buildInterfaceList("eth0",iNetwork.getFriendlyAdapterName('eth0'),True,True ))
-               else:
-                       for x in self.adapters:
-                               if x[1] == default_gw:
-                                       default_int = True
-                               else:
-                                       default_int = False
-                               if iNetwork.getAdapterAttribute(x[1], 'up') is True:
-                                       active_int = True
-                               else:
-                                       active_int = False
-                               self.list.append(self.buildInterfaceList(x[1],_(x[0]),default_int,active_int ))
+               for x in self.adapters:
+                       if x[1] == default_gw:
+                               default_int = True
+                       else:
+                               default_int = False
+                       if iNetwork.getAdapterAttribute(x[1], 'up') is True:
+                               active_int = True
+                       else:
+                               active_int = False
+                       self.list.append(self.buildInterfaceList(x[1],_(x[0]),default_int,active_int ))
                
                if os_path.exists(resolveFilename(SCOPE_PLUGINS, "SystemPlugins/NetworkWizard/networkwizard.xml")):
                        self["key_blue"].setText(_("NetworkWizard"))
@@ -179,22 +179,6 @@ class NetworkAdapterSelection(Screen,HelpableScreen):
                else:
                        self.updateList()
 
-       def NetworkFallback(self):
-               if iNetwork.configuredNetworkAdapters.has_key('wlan0') is True:
-                       self.session.openWithCallback(self.ErrorMessageClosed, MessageBox, self.wlan_errortext, type = MessageBox.TYPE_INFO,timeout = 10)
-               if iNetwork.configuredNetworkAdapters.has_key('ath0') is True:
-                       self.session.openWithCallback(self.ErrorMessageClosed, MessageBox, self.wlan_errortext, type = MessageBox.TYPE_INFO,timeout = 10)
-               else:
-                       self.session.openWithCallback(self.ErrorMessageClosed, MessageBox, self.lan_errortext, type = MessageBox.TYPE_INFO,timeout = 10)
-
-       def ErrorMessageClosed(self, *ret):
-               if iNetwork.configuredNetworkAdapters.has_key('wlan0') is True:
-                       self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetupConfiguration, 'wlan0')
-               elif iNetwork.configuredNetworkAdapters.has_key('ath0') is True:
-                       self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetupConfiguration, 'ath0')
-               else:
-                       self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetupConfiguration, 'eth0')
-
        def cleanup(self):
                iNetwork.stopLinkStateConsole()
                iNetwork.stopRestartConsole()
@@ -312,18 +296,17 @@ class NameserverSetup(Screen, ConfigListScreen, HelpableScreen):
 
 
 class AdapterSetup(Screen, ConfigListScreen, HelpableScreen):
-       def __init__(self, session, networkinfo, essid=None, aplist=None):
+       def __init__(self, session, networkinfo, essid=None):
                Screen.__init__(self, session)
                HelpableScreen.__init__(self)
                self.session = session
                if isinstance(networkinfo, (list, tuple)):
                        self.iface = networkinfo[0]
                        self.essid = networkinfo[1]
-                       self.aplist = networkinfo[2]
                else:
                        self.iface = networkinfo
                        self.essid = essid
-                       self.aplist = aplist
+                       
                self.extended = None
                self.applyConfigRef = None
                self.finished_cb = None
@@ -414,62 +397,36 @@ class AdapterSetup(Screen, ConfigListScreen, HelpableScreen):
                self.gatewayEntry = None
                self.hiddenSSID = None
                self.wlanSSID = None
-               self.encryptionEnabled = None
-               self.encryptionKey = None
+               self.encryption = None
                self.encryptionType = None
-               self.nwlist = None
+               self.encryptionKey = None
                self.encryptionlist = None
                self.weplist = None
                self.wsconfig = None
                self.default = None
 
-               if self.iface in iNetwork.wlan_interfaces:
-                       from Plugins.SystemPlugins.WirelessLan.Wlan import wpaSupplicant,Wlan
-                       self.w = Wlan(self.iface)
+               if iNetwork.isWirelessInterface(self.iface):
+                       from Plugins.SystemPlugins.WirelessLan.Wlan import wpaSupplicant
                        self.ws = wpaSupplicant()
                        self.encryptionlist = []
+                       self.encryptionlist.append(("Unencrypted", _("Unencrypted")))
                        self.encryptionlist.append(("WEP", _("WEP")))
                        self.encryptionlist.append(("WPA", _("WPA")))
-                       self.encryptionlist.append(("WPA2", _("WPA2")))
                        self.encryptionlist.append(("WPA/WPA2", _("WPA or WPA2")))
+                       self.encryptionlist.append(("WPA2", _("WPA2")))
                        self.weplist = []
                        self.weplist.append("ASCII")
                        self.weplist.append("HEX")
-                       if self.aplist is not None:
-                               self.nwlist = self.aplist
-                               self.nwlist.sort(key = lambda x: x[0])
-                       else:
-                               self.nwlist = []
-                               self.aps = None
-                               try:
-                                       self.aps = self.w.getNetworkList()
-                                       if self.aps is not None:
-                                               for ap in self.aps:
-                                                       a = self.aps[ap]
-                                                       if a['active']:
-                                                               if a['essid'] != '':
-                                                                       self.nwlist.append((a['essid'],a['essid']))
-                                       self.nwlist.sort(key = lambda x: x[0])
-                               except:
-                                       self.nwlist.append(("No Networks found",_("No Networks found")))
-
-                       self.wsconfig = self.ws.loadConfig()
-                       if self.essid is not None: # ssid from wlan scan
-                               self.default = self.essid
-                       else:
-                               self.default = self.wsconfig['ssid']
 
-                       if "hidden..." not in self.nwlist:
-                               self.nwlist.append(("hidden...",_("enter hidden network SSID")))
-                       if self.default not in self.nwlist:
-                               self.nwlist.append((self.default,self.default))
-                       config.plugins.wlan.essid = NoSave(ConfigSelection(self.nwlist, default = self.default ))
-                       config.plugins.wlan.hiddenessid = NoSave(ConfigText(default = self.wsconfig['hiddenessid'], visible_width = 50, fixed_size = False))
+                       self.wsconfig = self.ws.loadConfig(self.iface)
+                       if self.essid is None:
+                               self.essid = self.wsconfig['ssid']
 
-                       config.plugins.wlan.encryption.enabled = NoSave(ConfigYesNo(default = self.wsconfig['encryption'] ))
-                       config.plugins.wlan.encryption.type = NoSave(ConfigSelection(self.encryptionlist, default = self.wsconfig['encryption_type'] ))
-                       config.plugins.wlan.encryption.wepkeytype = NoSave(ConfigSelection(self.weplist, default = self.wsconfig['encryption_wepkeytype'] ))
-                       config.plugins.wlan.encryption.psk = NoSave(ConfigPassword(default = self.wsconfig['key'], visible_width = 50, fixed_size = False))
+                       config.plugins.wlan.hiddenessid = NoSave(ConfigYesNo(default = self.wsconfig['hiddenessid']))
+                       config.plugins.wlan.essid = NoSave(ConfigText(default = self.essid, visible_width = 50, fixed_size = False))
+                       config.plugins.wlan.encryption = NoSave(ConfigSelection(self.encryptionlist, default = self.wsconfig['encryption'] ))
+                       config.plugins.wlan.wepkeytype = NoSave(ConfigSelection(self.weplist, default = self.wsconfig['wepkeytype'] ))
+                       config.plugins.wlan.psk = NoSave(ConfigPassword(default = self.wsconfig['key'], visible_width = 50, fixed_size = False))
 
                self.activateInterfaceEntry = NoSave(ConfigYesNo(default=iNetwork.getAdapterAttribute(self.iface, "up") or False))
                self.dhcpConfigEntry = NoSave(ConfigYesNo(default=iNetwork.getAdapterAttribute(self.iface, "dhcp") or False))
@@ -502,6 +459,7 @@ class AdapterSetup(Screen, ConfigListScreen, HelpableScreen):
                                        self.list.append(getConfigListEntry(_('Gateway'), self.gatewayConfigEntry))
 
                        self.extended = None
+                       self.configStrings = None
                        for p in plugins.getPlugins(PluginDescriptor.WHERE_NETWORKSETUP):
                                callFnc = p.__call__["ifaceSupported"](self.iface)
                                if callFnc is not None:
@@ -509,30 +467,21 @@ class AdapterSetup(Screen, ConfigListScreen, HelpableScreen):
                                                self.extended = callFnc
                                                if p.__call__.has_key("configStrings"):
                                                        self.configStrings = p.__call__["configStrings"]
-                                               else:
-                                                       self.configStrings = None
-                                               if config.plugins.wlan.essid.value == 'hidden...':
-                                                       self.wlanSSID = getConfigListEntry(_("Network SSID"), config.plugins.wlan.essid)
-                                                       self.list.append(self.wlanSSID)
-                                                       self.hiddenSSID = getConfigListEntry(_("Hidden network SSID"), config.plugins.wlan.hiddenessid)
-                                                       self.list.append(self.hiddenSSID)
-                                               else:
-                                                       self.wlanSSID = getConfigListEntry(_("Network SSID"), config.plugins.wlan.essid)
-                                                       self.list.append(self.wlanSSID)
-                                               self.encryptionEnabled = getConfigListEntry(_("Encryption"), config.plugins.wlan.encryption.enabled)
-                                               self.list.append(self.encryptionEnabled)
-                                               
-                                               if config.plugins.wlan.encryption.enabled.value:
-                                                       self.encryptionType = getConfigListEntry(_("Encryption Type"), config.plugins.wlan.encryption.type)
-                                                       self.list.append(self.encryptionType)
-                                                       if config.plugins.wlan.encryption.type.value == 'WEP':
-                                                               self.list.append(getConfigListEntry(_("Encryption Keytype"), config.plugins.wlan.encryption.wepkeytype))
-                                                               self.encryptionKey = getConfigListEntry(_("Encryption Key"), config.plugins.wlan.encryption.psk)
-                                                               self.list.append(self.encryptionKey)
-                                                       else:
-                                                               self.encryptionKey = getConfigListEntry(_("Encryption Key"), config.plugins.wlan.encryption.psk)
-                                                               self.list.append(self.encryptionKey)
 
+                                               self.hiddenSSID = getConfigListEntry(_("Hidden network"), config.plugins.wlan.hiddenessid)
+                                               self.list.append(self.hiddenSSID)
+                                               self.wlanSSID = getConfigListEntry(_("Networkname (SSID)"), config.plugins.wlan.essid)
+                                               self.list.append(self.wlanSSID)
+                                               self.encryption = getConfigListEntry(_("Encryption"), config.plugins.wlan.encryption)
+                                               self.list.append(self.encryption)                                               
+
+                                               self.encryptionType = getConfigListEntry(_("Encryption Keytype"), config.plugins.wlan.wepkeytype)
+                                               self.encryptionKey = getConfigListEntry(_("Encryption Key"), config.plugins.wlan.psk)
+                                               
+                                               if config.plugins.wlan.encryption.value != "Unencrypted":
+                                                       if config.plugins.wlan.encryption.value == 'WEP':
+                                                               self.list.append(self.encryptionType)
+                                                       self.list.append(self.encryptionKey)
                self["config"].list = self.list
                self["config"].l.setList(self.list)
 
@@ -546,12 +495,8 @@ class AdapterSetup(Screen, ConfigListScreen, HelpableScreen):
                        self.createSetup()
                if self["config"].getCurrent() == self.gatewayEntry:
                        self.createSetup()
-               if self.iface in iNetwork.wlan_interfaces:
-                       if self["config"].getCurrent() == self.wlanSSID:
-                               self.createSetup()
-                       if self["config"].getCurrent() == self.encryptionEnabled:
-                               self.createSetup()
-                       if self["config"].getCurrent() == self.encryptionType:
+               if iNetwork.isWirelessInterface(self.iface):
+                       if self["config"].getCurrent() == self.encryption:
                                self.createSetup()
 
        def keyLeft(self):
@@ -576,7 +521,7 @@ class AdapterSetup(Screen, ConfigListScreen, HelpableScreen):
                if (ret == True):               
                        num_configured_if = len(iNetwork.getConfiguredAdapters())
                        if num_configured_if >= 1:
-                               if num_configured_if == 1 and self.iface in iNetwork.getConfiguredAdapters():
+                               if self.iface in iNetwork.getConfiguredAdapters():      
                                        self.applyConfig(True)
                                else:
                                        self.session.openWithCallback(self.secondIfaceFoundCB, MessageBox, _("A second configured interface has been found.\n\nDo you want to disable the second network interface?"), default = True)
@@ -594,11 +539,15 @@ class AdapterSetup(Screen, ConfigListScreen, HelpableScreen):
                                if interface == self.iface:
                                        continue
                                iNetwork.setAdapterAttribute(interface, "up", False)
-                               iNetwork.deactivateInterface(interface)
-                               self.applyConfig(True)
+                       iNetwork.deactivateInterface(configuredInterfaces,self.deactivateSecondInterfaceCB)
+
+       def deactivateSecondInterfaceCB(self, data):
+               if data is True:
+                       self.applyConfig(True)
 
        def applyConfig(self, ret = False):
                if (ret == True):
+                       self.applyConfigRef = None
                        iNetwork.setAdapterAttribute(self.iface, "up", self.activateInterfaceEntry.value)
                        iNetwork.setAdapterAttribute(self.iface, "dhcp", self.dhcpConfigEntry.value)
                        iNetwork.setAdapterAttribute(self.iface, "ip", self.ipConfigEntry.value)
@@ -607,17 +556,33 @@ class AdapterSetup(Screen, ConfigListScreen, HelpableScreen):
                                iNetwork.setAdapterAttribute(self.iface, "gateway", self.gatewayConfigEntry.value)
                        else:
                                iNetwork.removeAdapterAttribute(self.iface, "gateway")
-                       if self.extended is not None and self.configStrings is not None:
+
+                       if (self.extended is not None and self.configStrings is not None):
                                iNetwork.setAdapterAttribute(self.iface, "configStrings", self.configStrings(self.iface))
-                               self.ws.writeConfig()
+                               self.ws.writeConfig(self.iface)
+                               
                        if self.activateInterfaceEntry.value is False:
-                               iNetwork.deactivateInterface(self.iface)
-                       iNetwork.writeNetworkConfig()
-                       iNetwork.restartNetwork(self.applyConfigDataAvail)
-                       self.applyConfigRef = self.session.openWithCallback(self.applyConfigfinishedCB, MessageBox, _("Please wait for activation of your network configuration..."), type = MessageBox.TYPE_INFO, enable_input = False)
+                               iNetwork.deactivateInterface(self.iface,self.deactivateInterfaceCB)
+                               iNetwork.writeNetworkConfig()
+                               self.applyConfigRef = self.session.openWithCallback(self.applyConfigfinishedCB, MessageBox, _("Please wait for activation of your network configuration..."), type = MessageBox.TYPE_INFO, enable_input = False)
+                       else:
+                               if self.oldInterfaceState is False:
+                                       iNetwork.activateInterface(self.iface,self.deactivateInterfaceCB)
+                               else:
+                                       iNetwork.deactivateInterface(self.iface,self.activateInterfaceCB)
+                               iNetwork.writeNetworkConfig()
+                               self.applyConfigRef = self.session.openWithCallback(self.applyConfigfinishedCB, MessageBox, _("Please wait for activation of your network configuration..."), type = MessageBox.TYPE_INFO, enable_input = False)
                else:
                        self.keyCancel()
 
+       def deactivateInterfaceCB(self, data):
+               if data is True:
+                       self.applyConfigDataAvail(True)
+
+       def activateInterfaceCB(self, data):
+               if data is True:
+                       iNetwork.activateInterface(self.iface,self.applyConfigDataAvail)
+
        def applyConfigDataAvail(self, data):
                if data is True:
                        iNetwork.getInterfaces(self.getInterfacesDataAvail)
@@ -675,10 +640,10 @@ class AdapterSetup(Screen, ConfigListScreen, HelpableScreen):
                
        def hideInputHelp(self):
                current = self["config"].getCurrent()
-               if current == self.hiddenSSID and config.plugins.wlan.essid.value == 'hidden...':
+               if current == self.wlanSSID:
                        if current[1].help_window.instance is not None:
                                current[1].help_window.instance.hide()
-               elif current == self.encryptionKey and config.plugins.wlan.encryption.enabled.value:
+               elif current == self.encryptionKey and config.plugins.wlan.encryption.value is not "Unencrypted":
                        if current[1].help_window.instance is not None:
                                current[1].help_window.instance.hide()
 
@@ -703,7 +668,8 @@ class AdapterSetupConfiguration(Screen, HelpableScreen):
                
                self.oktext = _("Press OK on your remote control to continue.")
                self.reboottext = _("Your Dreambox will restart after pressing OK on your remote control.")
-               self.errortext = _("No working wireless network interface found.\n Please verify that you have attached a compatible WLAN device or enable your local network interface.")      
+               self.errortext = _("No working wireless network interface found.\n Please verify that you have attached a compatible WLAN device or enable your local network interface.")
+               self.missingwlanplugintxt = _("The wireless LAN plugin is not installed!\nPlease install it.")
                
                self["WizardActions"] = HelpableActionMap(self, "WizardActions",
                        {
@@ -739,30 +705,39 @@ class AdapterSetupConfiguration(Screen, HelpableScreen):
                self.onLayoutFinish.append(self.layoutFinished)
                self.onClose.append(self.cleanup)
 
+
+       def queryWirelessDevice(self,iface):
+               try:
+                       from pythonwifi.iwlibs import Wireless
+                       import errno
+               except ImportError:
+                       return False
+               else:
+                       try:
+                               ifobj = Wireless(iface) # a Wireless NIC Object
+                               wlanresponse = ifobj.getAPaddr()
+                       except IOError, (error_no, error_str):
+                               if error_no in (errno.EOPNOTSUPP, errno.ENODEV, errno.EPERM):
+                                       return False
+                               else:
+                                       print "error: ",error_no,error_str
+                                       return True
+                       else:
+                               return True
+
        def ok(self):
                self.cleanup()
                if self["menulist"].getCurrent()[1] == 'edit':
-                       if self.iface in iNetwork.wlan_interfaces:
+                       if iNetwork.isWirelessInterface(self.iface):
                                try:
                                        from Plugins.SystemPlugins.WirelessLan.plugin import WlanScan
-                                       from pythonwifi.iwlibs import Wireless
                                except ImportError:
-                                       self.session.open(MessageBox, _("The wireless LAN plugin is not installed!\nPlease install it."), type = MessageBox.TYPE_INFO,timeout = 10 )
+                                       self.session.open(MessageBox, self.missingwlanplugintxt, type = MessageBox.TYPE_INFO,timeout = 10 )
                                else:
-                                       ifobj = Wireless(self.iface) # a Wireless NIC Object
-                                       try:
-                                               self.wlanresponse = ifobj.getAPaddr()
-                                       except IOError:
-                                               self.wlanresponse = ifobj.getStatistics()
-                                       if self.wlanresponse:
-                                               if self.wlanresponse[0] not in (19,95): # 19 = 'No such device', 95 = 'Operation not supported'
-                                                       self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetup,self.iface)
-                                               else:
-                                                       # Display Wlan not available Message
-                                                       self.showErrorMessage()
+                                       if self.queryWirelessDevice(self.iface):
+                                               self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetup,self.iface)
                                        else:
-                                               # Display Wlan not available Message
-                                               self.showErrorMessage()
+                                               self.showErrorMessage() # Display Wlan not available Message
                        else:
                                self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetup,self.iface)
                if self["menulist"].getCurrent()[1] == 'test':
@@ -772,45 +747,23 @@ class AdapterSetupConfiguration(Screen, HelpableScreen):
                if self["menulist"].getCurrent()[1] == 'scanwlan':
                        try:
                                from Plugins.SystemPlugins.WirelessLan.plugin import WlanScan
-                               from pythonwifi.iwlibs import Wireless
                        except ImportError:
-                               self.session.open(MessageBox, _("The wireless LAN plugin is not installed!\nPlease install it."), type = MessageBox.TYPE_INFO,timeout = 10 )
+                               self.session.open(MessageBox, self.missingwlanplugintxt, type = MessageBox.TYPE_INFO,timeout = 10 )
                        else:
-                               ifobj = Wireless(self.iface) # a Wireless NIC Object
-                               try:
-                                       self.wlanresponse = ifobj.getAPaddr()
-                               except IOError:
-                                       self.wlanresponse = ifobj.getStatistics()
-                               if self.wlanresponse:
-                                       if self.wlanresponse[0] not in (19,95): # 19 = 'No such device', 95 = 'Operation not supported'
-                                               self.session.openWithCallback(self.WlanScanClosed, WlanScan, self.iface)
-                                       else:
-                                               # Display Wlan not available Message
-                                               self.showErrorMessage()
+                               if self.queryWirelessDevice(self.iface):
+                                       self.session.openWithCallback(self.WlanScanClosed, WlanScan, self.iface)
                                else:
-                                       # Display Wlan not available Message
-                                       self.showErrorMessage()
+                                       self.showErrorMessage() # Display Wlan not available Message
                if self["menulist"].getCurrent()[1] == 'wlanstatus':
                        try:
                                from Plugins.SystemPlugins.WirelessLan.plugin import WlanStatus
-                               from pythonwifi.iwlibs import Wireless
                        except ImportError:
-                               self.session.open(MessageBox, _("The wireless LAN plugin is not installed!\nPlease install it."), type = MessageBox.TYPE_INFO,timeout = 10 )
-                       else:   
-                               ifobj = Wireless(self.iface) # a Wireless NIC Object
-                               try:
-                                       self.wlanresponse = ifobj.getAPaddr()
-                               except IOError:
-                                       self.wlanresponse = ifobj.getStatistics()
-                               if self.wlanresponse:
-                                       if self.wlanresponse[0] not in (19,95): # 19 = 'No such device', 95 = 'Operation not supported'
-                                               self.session.openWithCallback(self.WlanStatusClosed, WlanStatus,self.iface)
-                                       else:
-                                               # Display Wlan not available Message
-                                               self.showErrorMessage()
+                               self.session.open(MessageBox, self.missingwlanplugintxt, type = MessageBox.TYPE_INFO,timeout = 10 )
+                       else:
+                               if self.queryWirelessDevice(self.iface):
+                                       self.session.openWithCallback(self.WlanStatusClosed, WlanStatus,self.iface)
                                else:
-                                       # Display Wlan not available Message
-                                       self.showErrorMessage()
+                                       self.showErrorMessage() # Display Wlan not available Message
                if self["menulist"].getCurrent()[1] == 'lanrestart':
                        self.session.openWithCallback(self.restartLan, MessageBox, (_("Are you sure you want to restart your network interfaces?\n\n") + self.oktext ) )
                if self["menulist"].getCurrent()[1] == 'openwizard':
@@ -866,7 +819,7 @@ class AdapterSetupConfiguration(Screen, HelpableScreen):
                self["IF"].setText(iNetwork.getFriendlyAdapterName(self.iface))
                self["Statustext"].setText(_("Link:"))
                
-               if self.iface in iNetwork.wlan_interfaces:
+               if iNetwork.isWirelessInterface(self.iface):
                        try:
                                from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus
                        except:
@@ -916,27 +869,16 @@ class AdapterSetupConfiguration(Screen, HelpableScreen):
 
        def AdapterSetupClosed(self, *ret):
                if ret is not None and len(ret):
-                       if ret[0] == 'ok' and (self.iface in iNetwork.wlan_interfaces) and iNetwork.getAdapterAttribute(self.iface, "up") is True:
+                       if ret[0] == 'ok' and (iNetwork.isWirelessInterface(self.iface) and iNetwork.getAdapterAttribute(self.iface, "up") is True):
                                try:
                                        from Plugins.SystemPlugins.WirelessLan.plugin import WlanStatus
-                                       from pythonwifi.iwlibs import Wireless
                                except ImportError:
-                                       self.session.open(MessageBox, _("The wireless LAN plugin is not installed!\nPlease install it."), type = MessageBox.TYPE_INFO,timeout = 10 )
+                                       self.session.open(MessageBox, self.missingwlanplugintxt, type = MessageBox.TYPE_INFO,timeout = 10 )
                                else:   
-                                       ifobj = Wireless(self.iface) # a Wireless NIC Object
-                                       try:
-                                               self.wlanresponse = ifobj.getAPaddr()
-                                       except IOError:
-                                               self.wlanresponse = ifobj.getStatistics()
-                                       if self.wlanresponse:
-                                               if self.wlanresponse[0] not in (19,95): # 19 = 'No such device', 95 = 'Operation not supported'
-                                                       self.session.openWithCallback(self.WlanStatusClosed, WlanStatus,self.iface)
-                                               else:
-                                                       # Display Wlan not available Message
-                                                       self.showErrorMessage()
+                                       if self.queryWirelessDevice(self.iface):
+                                               self.session.openWithCallback(self.WlanStatusClosed, WlanStatus,self.iface)
                                        else:
-                                               # Display Wlan not available Message
-                                               self.showErrorMessage()
+                                               self.showErrorMessage() # Display Wlan not available Message
                        else:
                                self.updateStatusbar()
                else:
@@ -950,7 +892,7 @@ class AdapterSetupConfiguration(Screen, HelpableScreen):
 
        def WlanScanClosed(self,*ret):
                if ret[0] is not None:
-                       self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetup, self.iface,ret[0],ret[1])
+                       self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetup, self.iface,ret[0])
                else:
                        from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus
                        iStatus.stopWlanConsole()
@@ -995,6 +937,7 @@ class AdapterSetupConfiguration(Screen, HelpableScreen):
        def cleanup(self):
                iNetwork.stopLinkStateConsole()
                iNetwork.stopDeactivateInterfaceConsole()
+               iNetwork.stopActivateInterfaceConsole()
                iNetwork.stopPingConsole()
                try:
                        from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus
@@ -1008,7 +951,7 @@ class AdapterSetupConfiguration(Screen, HelpableScreen):
                if data is not None:
                        if data is True:
                                if status is not None:
-                                       if status[self.iface]["acesspoint"] == "No Connection" or status[self.iface]["acesspoint"] == "Not-Associated" or status[self.iface]["acesspoint"] == False:
+                                       if status[self.iface]["essid"] == "off" or status[self.iface]["accesspoint"] == "Not-Associated" or status[self.iface]["accesspoint"] == False:
                                                self.LinkState = False
                                                self["statuspic"].setPixmapNum(1)
                                                self["statuspic"].show()
@@ -1376,7 +1319,7 @@ class NetworkAdapterTest(Screen):
 
        def LinkStatedataAvail(self,data):
                self.output = data.strip()
-               result = self.output.split('\n')
+               result = self.output.splitlines()
                pattern = re_compile("Link detected: yes")
                for item in result:
                        if re_search(pattern, item):
@@ -1430,7 +1373,7 @@ class NetworkAdapterTest(Screen):
                if data is not None:
                        if data is True:
                                if status is not None:
-                                       if status[self.iface]["acesspoint"] == "No Connection" or status[self.iface]["acesspoint"] == "Not-Associated" or status[self.iface]["acesspoint"] == False:
+                                       if status[self.iface]["essid"] == "off" or status[self.iface]["accesspoint"] == "Not-Associated" or status[self.iface]["accesspoint"] == False:
                                                self["Network"].setForegroundColorNum(1)
                                                self["Network"].setText(_("disconnected"))
                                                self["NetworkInfo_Check"].setPixmapNum(1)
index f9263d8..f8bfeb7 100644 (file)
@@ -361,15 +361,15 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport):
                                self.list.append(getConfigListEntry(_('Satellite'), self.scan_satselection[index_to_scan]))
                                self.list.append(getConfigListEntry(_('Frequency'), self.scan_sat.frequency))
                                self.list.append(getConfigListEntry(_('Inversion'), self.scan_sat.inversion))
-                               self.list.append(getConfigListEntry(_('Symbol Rate'), self.scan_sat.symbolrate))
-                               self.list.append(getConfigListEntry(_("Polarity"), self.scan_sat.polarization))
+                               self.list.append(getConfigListEntry(_('Symbol rate'), self.scan_sat.symbolrate))
+                               self.list.append(getConfigListEntry(_('Polarization'), self.scan_sat.polarization))
                                if self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S:
                                        self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec))
                                elif self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S2:
                                        self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2))
                                        self.modulationEntry = getConfigListEntry(_('Modulation'), self.scan_sat.modulation)
                                        self.list.append(self.modulationEntry)
-                                       self.list.append(getConfigListEntry(_('Rolloff'), self.scan_sat.rolloff))
+                                       self.list.append(getConfigListEntry(_('Roll-off'), self.scan_sat.rolloff))
                                        self.list.append(getConfigListEntry(_('Pilot'), self.scan_sat.pilot))
                        elif self.scan_type.value == "single_satellite":
                                self.updateSatList()
@@ -391,7 +391,7 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport):
                        if self.scan_typecable.value == "single_transponder":
                                self.list.append(getConfigListEntry(_("Frequency"), self.scan_cab.frequency))
                                self.list.append(getConfigListEntry(_("Inversion"), self.scan_cab.inversion))
-                               self.list.append(getConfigListEntry(_("Symbol Rate"), self.scan_cab.symbolrate))
+                               self.list.append(getConfigListEntry(_("Symbol rate"), self.scan_cab.symbolrate))
                                self.list.append(getConfigListEntry(_("Modulation"), self.scan_cab.modulation))
                                self.list.append(getConfigListEntry(_("FEC"), self.scan_cab.fec))
                elif nim.isCompatible("DVB-T"):
@@ -399,12 +399,12 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport):
                                self.list.append(getConfigListEntry(_("Frequency"), self.scan_ter.frequency))
                                self.list.append(getConfigListEntry(_("Inversion"), self.scan_ter.inversion))
                                self.list.append(getConfigListEntry(_("Bandwidth"), self.scan_ter.bandwidth))
-                               self.list.append(getConfigListEntry(_("Code rate high"), self.scan_ter.fechigh))
-                               self.list.append(getConfigListEntry(_("Code rate low"), self.scan_ter.feclow))
+                               self.list.append(getConfigListEntry(_("Code rate HP"), self.scan_ter.fechigh))
+                               self.list.append(getConfigListEntry(_("Code rate LP"), self.scan_ter.feclow))
                                self.list.append(getConfigListEntry(_("Modulation"), self.scan_ter.modulation))
                                self.list.append(getConfigListEntry(_("Transmission mode"), self.scan_ter.transmission))
-                               self.list.append(getConfigListEntry(_("Guard interval mode"), self.scan_ter.guard))
-                               self.list.append(getConfigListEntry(_("Hierarchy mode"), self.scan_ter.hierarchy))
+                               self.list.append(getConfigListEntry(_("Guard interval"), self.scan_ter.guard))
+                               self.list.append(getConfigListEntry(_("Hierarchy info"), self.scan_ter.hierarchy))
                self.list.append(getConfigListEntry(_("Network scan"), self.scan_networkScan))
                self.list.append(getConfigListEntry(_("Clear before scan"), self.scan_clearallservices))
                self.list.append(getConfigListEntry(_("Only Free scan"), self.scan_onlyfree))
@@ -557,8 +557,8 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport):
                                (eDVBFrontendParametersSatellite.System_DVB_S2, _("DVB-S2"))])
                        self.scan_sat.frequency = ConfigInteger(default = defaultSat["frequency"], limits = (1, 99999))
                        self.scan_sat.inversion = ConfigSelection(default = defaultSat["inversion"], choices = [
-                               (eDVBFrontendParametersSatellite.Inversion_Off, _("off")),
-                               (eDVBFrontendParametersSatellite.Inversion_On, _("on")),
+                               (eDVBFrontendParametersSatellite.Inversion_Off, _("Off")),
+                               (eDVBFrontendParametersSatellite.Inversion_On, _("On")),
                                (eDVBFrontendParametersSatellite.Inversion_Unknown, _("Auto"))])
                        self.scan_sat.symbolrate = ConfigInteger(default = defaultSat["symbolrate"], limits = (1, 99999))
                        self.scan_sat.polarization = ConfigSelection(default = defaultSat["polarization"], choices = [
@@ -592,15 +592,15 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport):
                                (eDVBFrontendParametersSatellite.RollOff_alpha_0_25, "0.25"),
                                (eDVBFrontendParametersSatellite.RollOff_alpha_0_20, "0.20")])
                        self.scan_sat.pilot = ConfigSelection(default = defaultSat.get("pilot", eDVBFrontendParametersSatellite.Pilot_Unknown), choices = [
-                               (eDVBFrontendParametersSatellite.Pilot_Off, _("off")),
-                               (eDVBFrontendParametersSatellite.Pilot_On, _("on")),
+                               (eDVBFrontendParametersSatellite.Pilot_Off, _("Off")),
+                               (eDVBFrontendParametersSatellite.Pilot_On, _("On")),
                                (eDVBFrontendParametersSatellite.Pilot_Unknown, _("Auto"))])
 
                        # cable
                        self.scan_cab.frequency = ConfigInteger(default = defaultCab["frequency"], limits = (50, 999))
                        self.scan_cab.inversion = ConfigSelection(default = defaultCab["inversion"], choices = [
-                               (eDVBFrontendParametersCable.Inversion_Off, _("off")),
-                               (eDVBFrontendParametersCable.Inversion_On, _("on")),
+                               (eDVBFrontendParametersCable.Inversion_Off, _("Off")),
+                               (eDVBFrontendParametersCable.Inversion_On, _("On")),
                                (eDVBFrontendParametersCable.Inversion_Unknown, _("Auto"))])
                        self.scan_cab.modulation = ConfigSelection(default = defaultCab["modulation"], choices = [
                                (eDVBFrontendParametersCable.Modulation_QAM16, "16-QAM"),
@@ -622,8 +622,8 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport):
                        # terrestial
                        self.scan_ter.frequency = ConfigInteger(default = 466000, limits = (50000, 999000))
                        self.scan_ter.inversion = ConfigSelection(default = defaultTer["inversion"], choices = [
-                               (eDVBFrontendParametersTerrestrial.Inversion_Off, _("off")),
-                               (eDVBFrontendParametersTerrestrial.Inversion_On, _("on")),
+                               (eDVBFrontendParametersTerrestrial.Inversion_Off, _("Off")),
+                               (eDVBFrontendParametersTerrestrial.Inversion_On, _("On")),
                                (eDVBFrontendParametersTerrestrial.Inversion_Unknown, _("Auto"))])
                        # WORKAROUND: we can't use BW-auto
                        self.scan_ter.bandwidth = ConfigSelection(default = defaultTer["bandwidth"], choices = [
index f0bf773..4a0accd 100644 (file)
@@ -6,6 +6,8 @@ profile("LOAD:Source")
 from Components.Sources.Source import Source
 profile("LOAD:GUIComponent")
 from Components.GUIComponent import GUIComponent
+profile("LOAD:eRCInput")
+from enigma import eRCInput
 
 class Screen(dict, GUISkin):
 
@@ -46,6 +48,24 @@ class Screen(dict, GUISkin):
                # stand alone screens (for example web screens)
                # don't care about having or not having focus.
                self.stand_alone = False
+               self.keyboardMode = None
+
+       def saveKeyboardMode(self):
+               rcinput = eRCInput.getInstance()
+               self.keyboardMode = rcinput.getKeyboardMode()
+
+       def setKeyboardModeAscii(self):
+               rcinput = eRCInput.getInstance()
+               rcinput.setKeyboardMode(rcinput.kmAscii)
+
+       def setKeyboardModeNone(self):
+               rcinput = eRCInput.getInstance()
+               rcinput.setKeyboardMode(rcinput.kmNone)
+
+       def restoreKeyboardMode(self):
+               rcinput = eRCInput.getInstance()
+               if self.keyboardMode is not None:
+                       rcinput.setKeyboardMode(self.keyboardMode)
 
        def execBegin(self):
                self.active_components = [ ]
index fa2f447..61885df 100644 (file)
@@ -81,9 +81,9 @@ class ServiceInfo(Screen):
                        self.feinfo = None
                else:
                        self.type = TYPE_SERVICE_INFO
-                       self["red"] = Label(_("Serviceinfo"))
+                       self["red"] = Label(_("Service"))
                        self["green"] = Label(_("PIDs"))
-                       self["yellow"] = Label(_("Transponder"))
+                       self["yellow"] = Label(_("Multiplex"))
                        self["blue"] = Label(_("Tuner status"))
                        service = session.nav.getCurrentService()
                        if service is not None:
@@ -105,63 +105,63 @@ class ServiceInfo(Screen):
                                name = ServiceReference(self.session.nav.getCurrentlyPlayingServiceReference()).getServiceName()
                                refstr = self.session.nav.getCurrentlyPlayingServiceReference().toString()
                        else:
-                               name = "N/A"
-                               refstr = "N/A"
+                               name = _("N/A")
+                               refstr = _("N/A")
                        aspect = self.getServiceInfoValue(iServiceInformation.sAspect)
                        if aspect in ( 1, 2, 5, 6, 9, 0xA, 0xD, 0xE ):
-                               aspect = "4:3"
+                               aspect = _("4:3")
                        else:
-                               aspect = "16:9"
+                               aspect = _("16:9")
                        width = self.info and self.info.getInfo(iServiceInformation.sVideoWidth) or -1
                        height = self.info and self.info.getInfo(iServiceInformation.sVideoHeight) or -1
                        if width != -1 and height != -1:
-                               Labels = ( ("Name", name, TYPE_TEXT),
-                                                  ("Provider", self.getServiceInfoValue(iServiceInformation.sProvider), TYPE_TEXT),
-                                                  ("Videoformat", aspect, TYPE_TEXT),
-                                                  ("Videosize", "%dx%d" %(width, height), TYPE_TEXT),
-                                                  ("Namespace", self.getServiceInfoValue(iServiceInformation.sNamespace), TYPE_VALUE_HEX, 8),
-                                                  ("Service Reference", refstr, TYPE_TEXT))
+                               Labels = ( (_("Name"), name, TYPE_TEXT),
+                                                  (_("Provider"), self.getServiceInfoValue(iServiceInformation.sProvider), TYPE_TEXT),
+                                                  (_("Aspect ratio"), aspect, TYPE_TEXT),
+                                                  (_("Resolution"), "%dx%d" %(width, height), TYPE_TEXT),
+                                                  (_("Namespace"), self.getServiceInfoValue(iServiceInformation.sNamespace), TYPE_VALUE_HEX, 8),
+                                                  (_("Service reference"), refstr, TYPE_TEXT))
                        else:
-                               Labels = ( ("Name", name, TYPE_TEXT),
-                                                  ("Provider", self.getServiceInfoValue(iServiceInformation.sProvider), TYPE_TEXT),
-                                                  ("Videoformat", aspect, TYPE_TEXT),
-                                                  ("Namespace", self.getServiceInfoValue(iServiceInformation.sNamespace), TYPE_VALUE_HEX, 8),
-                                                  ("Service Reference", refstr, TYPE_TEXT))
+                               Labels = ( (_("Name"), name, TYPE_TEXT),
+                                                  (_("Provider"), self.getServiceInfoValue(iServiceInformation.sProvider), TYPE_TEXT),
+                                                  (_("Aspect ratio"), aspect, TYPE_TEXT),
+                                                  (_("Namespace"), self.getServiceInfoValue(iServiceInformation.sNamespace), TYPE_VALUE_HEX, 8),
+                                                  (_("Service reference"), refstr, TYPE_TEXT))
                        self.fillList(Labels)
                else:
                        if self.transponder_info:
                                tp_info = ConvertToHumanReadable(self.transponder_info)
-                               conv = { "tuner_type"           : _("Transponder Type"),
-                                                "system"                       : _("System"),
-                                                "modulation"           : _("Modulation"),
-                                                "orbital_position" : _("Orbital Position"),
-                                                "frequency"            : _("Frequency"),
-                                                "symbol_rate"          : _("Symbolrate"),
-                                                "bandwidth"            : _("Bandwidth"),
-                                                "polarization"         : _("Polarization"),
-                                                "inversion"            : _("Inversion"),
-                                                "pilot"                        : _("Pilot"),
-                                                "rolloff"                      : _("Rolloff"),
-                                                "fec_inner"            : _("FEC"),
-                                                "code_rate_lp"         : _("Coderate LP"),
-                                                "code_rate_hp"         : _("Coderate HP"),
-                                                "constellation"        : _("Constellation"),
-                                                "transmission_mode": _("Transmission Mode"),
-                                                "guard_interval"       : _("Guard Interval"),
-                                                "hierarchy_information": _("Hierarchy Information") }
+                               conv = { "tuner_type"                   : _("Type"),
+                                        "system"                       : _("System"),
+                                        "modulation"                   : _("Modulation"),
+                                        "orbital_position"             : _("Orbital position"),
+                                        "frequency"                    : _("Frequency"),
+                                        "symbol_rate"                  : _("Symbol rate"),
+                                        "bandwidth"                    : _("Bandwidth"),
+                                        "polarization"                 : _("Polarization"),
+