24 files changed, 139 insertions, 137 deletions
diff --git a/noncore/settings/networksettings2/bluetooth/bluetoothRFCOMMrun.cpp b/noncore/settings/networksettings2/bluetooth/bluetoothRFCOMMrun.cpp
index ef6878a..3df7f5c 100644
--- a/noncore/settings/networksettings2/bluetooth/bluetoothRFCOMMrun.cpp
+++ b/noncore/settings/networksettings2/bluetooth/bluetoothRFCOMMrun.cpp
@@ -1,164 +1,164 @@
 #include <qapplication.h>
 #include <resources.h>
 #include <OTDevice.h>
 #include <OTGateway.h>
 #include "bluetoothRFCOMMrun.h"
 using Opietooth2::OTGateway;
 using Opietooth2::OTDevice;
 using Opietooth2::OTDeviceAddress;
 BluetoothRFCOMMRun::~BluetoothRFCOMMRun( void ) {
      if( OT ) {
        OTGateway::releaseOTGateway();
      }
 }
 State_t BluetoothRFCOMMRun::detectState( void ) {
      if( ! OT ) {
        OT = OTGateway::getOTGateway();
      }
      if( deviceNrOfConnection() >= 0 ) {
        return Available;
      }
-      owarn << "Bluetooth " 
+      odebug << "Bluetooth " 
            << OT->isEnabled()
            << oendl;
      return ( OT->isEnabled() ) ? Off : Unavailable;
 }
 QString BluetoothRFCOMMRun::setMyState( NodeCollection *, 
                                      Action_t A, 
                                      bool ) {
      if( OT ) {
        OTGateway::getOTGateway();
      }
      if( A == Activate ) {
        // from OFF to Available
        RFCOMMChannel * Ch = getChannel( );
        System & Sys = NSResources->system();
 
        if( Ch ) {
          // connect to this peer
          DeviceNr = OT->getFreeRFCommDevice();
          QStringList S;
          S << "rfcomm" 
            << "bind"
            << QString().setNum( DeviceNr )
            << Ch->BDAddress
            << QString().setNum( Ch->Channel );
 
          if( Sys.runAsRoot( S ) ) {
            return QString( "Error starting %1").arg(S.join(" "));
          }
          // here rfcomm should be running -> we will detect state later
          return QString();
        } else {
          Log(( "No channel selected -> cancel\n" ));
          return QString( "No channel selected. Operation cancelled" );
        }
      }
      if( A == Deactivate ) {
        if( DeviceNr >= 0 ) {
          if( OT->releaseRFCommDevice( DeviceNr ) ) {
           return QString( "Cannot release RFCOMM connection" );
          }
          DeviceNr = -1;
        }
      }
      return QString();
 }
 #include <qlistbox.h>
 #include <qframe.h>
 #include <qlabel.h>
 #include <qlayout.h>
 #include <qdialog.h>
 RFCOMMChannel * BluetoothRFCOMMRun::getChannel( void ) {
    if( Data->Devices.count() == 1 ) {
      // only one device -> return channel
      return Data->Devices[0];
    }
    RFCOMMChannel * Ch = 0;
    QDialog * Dlg = new QDialog( qApp->mainWidget(), 0, TRUE );
    QVBoxLayout * V = new QVBoxLayout( Dlg );
    QLabel * L = new QLabel( 
      qApp->translate( "BluetoothRFCOMMRun", 
                       "Select device to connect to"),
                       Dlg );
    QListBox * LB = new QListBox( Dlg );
    for( unsigned int i = 0; i < Data->Devices.count(); i ++ ) {
      LB->insertItem( QString( "%1 (%2 Chnl %3)" ).
                        arg( Data->Devices[i]->Name ).
                        arg( Data->Devices[i]->BDAddress ).
                        arg( Data->Devices[i]->Channel ) );
    }
    V->addWidget( L );
    V->addWidget( LB );
    Dlg->resize( 100, 100 );
    Dlg->move( 20, 
               (qApp->desktop()->height()-100)/2 );
    if( Dlg->exec() == QDialog::Accepted ) {
      unsigned int i = 0;
      for( i = 0; i < Data->Devices.count(); i ++ ) {
        if( LB->isSelected(i) ) {
-          owarn << "Selected " << Data->Devices[i]->Name << oendl;
+          odebug << "Selected " << Data->Devices[i]->Name << oendl;
          Ch = Data->Devices[i];
          break;
        }
      }
    }
    delete Dlg;
    return Ch;
 }
 QString BluetoothRFCOMMRun::deviceFile( void ) {
    if( deviceNrOfConnection() >= 0 ) {
      OTDevice * OTD = OT->getOTDevice();
      // there is a connection
      return OTD->getRFCommDevicePattern().arg(DeviceNr);
    }
    return QString();
 }
 int BluetoothRFCOMMRun::deviceNrOfConnection( void ) {
    if( ! OT ) {
      OT = OTGateway::getOTGateway();
    }
    DeviceNr = -1;
    for( unsigned int i = 0; i < Data->Devices.count(); i ++ ) {
-      owarn << "Check for rfcomm on " 
+      odebug << "Check for rfcomm on " 
            << Data->Devices[i]->BDAddress
            << " "
            << Data->Devices[i]->Channel
            << oendl;
      if( ( DeviceNr = OT->connectedToRFCommChannel( 
              OTDeviceAddress( Data->Devices[i]->BDAddress ),
              Data->Devices[i]->Channel ) ) >= 0 ) {
-        owarn << "Up " 
+        odebug << "Up " 
              << oendl;
        break;
      }
    }
    return DeviceNr;
 }
diff --git a/noncore/settings/networksettings2/bluetooth/config.in b/noncore/settings/networksettings2/bluetooth/config.in
index 398cff1..1a76f96 100644
--- a/noncore/settings/networksettings2/bluetooth/config.in
+++ b/noncore/settings/networksettings2/bluetooth/config.in
@@ -1,4 +1,4 @@
  config NS2BT
    boolean "opie-networksettings2plugin-bluetooth (set up BLUETOOTH)"
    default "n" if NS2
-    depends ( LIBQPE || LIBQPE-X11 ) && LIBOPIE2CORE && NS2CORE && NS2OPIETOOTH
+    depends ( LIBQPE || LIBQPE-X11 ) && LIBOPIE2CORE && NS2CORE && NS2OPIETOOTH && LIBBLUEZ_DEP
diff --git a/noncore/settings/networksettings2/config.in b/noncore/settings/networksettings2/config.in
index d2b5f26..0236bab 100644
--- a/noncore/settings/networksettings2/config.in
+++ b/noncore/settings/networksettings2/config.in
@@ -1,21 +1,21 @@
  source noncore/settings/networksettings2/networksettings2/config.in
  source noncore/settings/networksettings2/opietooth2/config.in
  source noncore/settings/networksettings2/opietooth2_applet/config.in
 config NS2
-  boolean
+  boolean "opie-networksettings2 application"
  default "y"
  depends ( LIBQPE || LIBQPE-X11 ) && LIBOPIE2CORE && NS2CORE && NS2OPIETOOTH
  source noncore/settings/networksettings2/profile/config.in
  source noncore/settings/networksettings2/network/config.in
  source noncore/settings/networksettings2/lancard/config.in
  source noncore/settings/networksettings2/ppp/config.in
  source noncore/settings/networksettings2/wlan/config.in
  source noncore/settings/networksettings2/usb/config.in
  source noncore/settings/networksettings2/irda/config.in
  source noncore/settings/networksettings2/vpn/config.in
  source noncore/settings/networksettings2/bluetooth/config.in
  source noncore/settings/networksettings2/cable/config.in
  source noncore/settings/networksettings2/modem/config.in
  source noncore/settings/networksettings2/gprs/config.in
diff --git a/noncore/settings/networksettings2/editconnection.cpp b/noncore/settings/networksettings2/editconnection.cpp
index 0c3ead6..717d9e9 100644
--- a/noncore/settings/networksettings2/editconnection.cpp
+++ b/noncore/settings/networksettings2/editconnection.cpp
@@ -1,630 +1,629 @@
 #include <opie2/odebug.h>
 #include <qlistview.h>
 #include <qwidgetstack.h>
 #include <qframe.h>
 #include <qcombobox.h>
 #include <qtabwidget.h>
 #include <qmessagebox.h>
 #include <qpushbutton.h>
 #include <qlineedit.h>
 #include <qheader.h>
 #include <qpainter.h>
 #include <qcheckbox.h>
 #include <qlabel.h>
 #include "editconnection.h"
 #include "resources.h"
 #include "netnode.h"
 //
 //
 // THESE TO GIVE BETTER FEEDBACK ABOUT DISABLED ITEMS
 //
 //
 class MyQCheckListItem : public QCheckListItem
 {
 public:
    MyQCheckListItem( QListView *parent, const QString & S, Type T ) :
      QCheckListItem( parent, S, T ) { }
    MyQCheckListItem( QCheckListItem *parent, const QString & S, Type T ) :
      QCheckListItem( parent, S, T ) { }
    MyQCheckListItem( QListViewItem *parent, const QString & S, Type T ) :
      QCheckListItem( parent, S, T ) { }
    MyQCheckListItem( QListView *parent, const QString & S ) :
      QCheckListItem( parent, S, QCheckListItem::Controller ) { }
    MyQCheckListItem( QCheckListItem *parent, const QString & S ) :
      QCheckListItem( parent, S, QCheckListItem::Controller ) { }
    MyQCheckListItem( QListViewItem *parent, const QString & S ) :
      QCheckListItem( parent, S, QCheckListItem::Controller ) { }
    virtual void paintCell( QPainter *p, const QColorGroup &cg,
                            int column, int width, int alignment );
 };
 void MyQCheckListItem::paintCell( QPainter *p, const QColorGroup &cg,
                                 int column, int width, int alignment )
 {
    QColorGroup _cg( cg );
    QColor c = _cg.text();
    if ( ! isSelectable() )
        _cg.setColor( QColorGroup::Text, Qt::lightGray );
    QCheckListItem::paintCell( p, _cg, column, width, alignment );
    _cg.setColor( QColorGroup::Text, c );
 }
 class MyQListViewItem : public QListViewItem
 {
 public:
    MyQListViewItem( QListView *parent, const QString & S ) :
      QListViewItem( parent, S ) { }
    MyQListViewItem( QListViewItem *parent, const QString & S ) :
      QListViewItem( parent, S ) { }
    virtual void paintCell( QPainter *p, const QColorGroup &cg,
                            int column, int width, int alignment );
 };
 void MyQListViewItem::paintCell( QPainter *p, const QColorGroup &cg,
                                 int column, int width, int alignment )
 {
    QColorGroup _cg( cg );
    QColor c = _cg.text();
    if ( ! isSelectable() )
        _cg.setColor( QColorGroup::Text, Qt::lightGray );
    QListViewItem::paintCell( p, _cg, column, width, alignment );
    _cg.setColor( QColorGroup::Text, c );
 }
 //
 //
 // REAL GUI
 //
 //
 bool EditConnection::AutoCollapse = 1;
 EditConnection::EditConnection( QWidget* parent ) :
      EditConnectionGUI( parent, 0, TRUE ), TmpCollection() {
      Tab_TB->setTabEnabled( Setup_FRM, FALSE );
      Setup_FRM->setEnabled( FALSE );
      TmpIsValid = 0;
      SelectedNodes = 0;
      AutoCollapse_CB->setChecked( AutoCollapse );
      Mapping = new QPtrDict<ANetNode>;
      Mapping->setAutoDelete( FALSE );
      Nodes_LV->header()->hide();
      // popluate tree with all NetNodes 
      buildFullTree();
 }
 NodeCollection * EditConnection::getTmpCollection( void ) {
      if( TmpIsValid ) 
        // content is stil OK
        return &(TmpCollection);
      // reset collection -> delete all NEW NetNodes
      for( QListIterator<ANetNodeInstance> it(TmpCollection);
           it.current();
           ++it ) {
        if( it.current()->isNew() ) {
          delete it.current();
        }
      }
      TmpCollection.clear();
      // update content
      QListViewItem * it = Nodes_LV->firstChild();
      ANetNode * NN;
      // start iter (if there is a collection)
      /*
          a node collection is sorted from the toplevel
          node to the deepest node
      */
      ANetNodeInstance * NNI = 
        (SelectedNodes) ? SelectedNodes->first() : 0 ;
      TmpCollection.setModified( 0 );
      // the listview always starts with the toplevel 
      // hierarchy.  This is always a controller item
      while ( it ) {
        NN = (*Mapping)[it];
        if( NN == 0 ) {
          // this item is a controller -> 
          // has radio items as children -> 
          // find selected one 
          it = it->firstChild();
          while( it ) {
            if( ((QCheckListItem *)it)->isOn() ) {
              // this radio is selected -> go deeper
              break;
            }
            it = it->nextSibling();
          }
          if( ! it ) {
-            owarn  << "Radio not selected" << oendl;
            TmpIsValid = 0;
            return 0;
          }
          // it now contains selected radio
          NN = (*Mapping)[it];
        }
        // NN here contains the netnode of the
        // current item -> this node needs to
        // be stored in the collection
        if( NNI == 0 ||
            it->text(0) != NNI->nodeClass()->name() ) {
          // new item not in previous collection
          ANetNodeInstance * NNI = NN->createInstance();
          NNI->initialize();
          // this node type not in collection
          TmpCollection.append( NNI );
          // master collection changed because new item in it
          TmpCollection.setModified( 1 );
          // no more valid items in old list
          NNI = 0;
        } else {
          // already in list -> copy pointer
          TmpCollection.append( NNI );
          NNI = SelectedNodes->next();
        }
        // go deeper to next level
        // this level is can be a new controller
        // or an item
        it = it->firstChild();
      }
      TmpIsValid = 1;
      return &(TmpCollection);
 }
 // pass a connection NodeCollection to be edited
 void EditConnection::setConnection( NodeCollection * NC ) {
      ANetNodeInstance * NNI;
      ANetNode * NN;
      SelectedNodes = NC;
      Name_LE->setText( NC->name() );
      NNI = NC->first();
      // show configure tabl
      Tab_TB->setCurrentPage( 1 );
      // valid colledction
      Tab_TB->setTabEnabled( Setup_FRM, FALSE );
      Setup_FRM->setEnabled( FALSE );
      // select items in collection
      QListViewItem * it = Nodes_LV->firstChild();
      bool Found;
      TmpIsValid = 0;
      while ( it ) {
        NN = (*Mapping)[it];
        if( NN == 0 ) {
          // this item is a controller -> 
          // has radio items as children -> 
          // find selected one 
          it = it->firstChild();
          Found = 0;
          while( it ) {
            if( NNI && it->text(0) == NNI->nodeClass()->name() ) {
              // this radio is part of the collection
              ((QCheckListItem *)it)->setOn( 1 );
              updateGUI( it, NNI->nodeClass() );
              // check its children
              Found = 1;
              it = it->firstChild();
              NNI = SelectedNodes->next();
              // do not bother to check other items
              break;
            }
            it = it->nextSibling();
          }
          if( ! Found ) {
            // this means that this level is NOT present in collection
            // probably INCOMPATIBEL collection OR Missing plugin
            QMessageBox::warning(
                0, 
                tr( "Error presentig Connection" ),
                tr( "<p>Old connection or missing plugin \"<i>%1</i>\"</p>" ).
                    arg(NNI->nodeClass()->name()) );
            return;
          }
          // it now contains selected radio
          NN = (*Mapping)[it];
        } else {
          // automatic selection 
          if( NNI == 0 ||  it->text(0) != NNI->nodeClass()->name() ) {
            // should exist and be the same
            if( NNI ) {
              QMessageBox::warning(
                  0, 
                  tr( "Error presentig Connection" ),
                  tr( "<p>Old connection or missing plugin \"<i>%1</i>\"</p>" ).
                      arg(NNI->nodeClass()->name()) );
            } else {
              QMessageBox::warning(
                  0, 
                  tr( "Error presentig Connection" ),
                  tr( "<p>Missing connection\"<i>%1</i>\"</p>" ).
                      arg(it->text(0)) );
            }
            return;
          }
          it = it->firstChild();
        }
      }
 }
 // get result of editing (either new OR updated collection
 NodeCollection * EditConnection::connection( void ) {
      if( SelectedNodes == 0 ) {
        // new collection 
        SelectedNodes = new NodeCollection;
      }
      // clean out old entries
      SelectedNodes->clear();
      // transfer 
      for( QListIterator<ANetNodeInstance> it(TmpCollection);
           it.current();
           ++it ) {
        SelectedNodes->append( it.current() );
      }
      if( TmpCollection.isModified() )
        SelectedNodes->setModified( 1 );
      if( SelectedNodes->name() != Name_LE->text() ) {
        SelectedNodes->setName( Name_LE->text() );
        SelectedNodes->setModified( 1 );
      }
      return SelectedNodes;
 }
 // Build device tree -> start 
 void EditConnection::buildFullTree( void ) {
    ANetNode * NN;
    // toplevel item
    MyQCheckListItem * TheTop = new MyQCheckListItem( 
        Nodes_LV, 
        NSResources->netNode2Name("fullsetup"),
        QCheckListItem::Controller );
    TheTop->setOpen( TRUE );
    Description_LBL->setText( 
          NSResources->netNode2Description( "fullsetup" ) );
    Nodes_LV->setSelected( TheTop, TRUE );
    // find all Nodes that are toplevel nodes -> ie provide
    // TCP/IP Connection
    for( QDictIterator<ANetNode> Iter(NSResources->netNodes());
         Iter.current();
         ++Iter ) {
      NN = Iter.current();
      if( ! NN->isToplevel() ) {
        continue;
      }
      MyQCheckListItem * it = new MyQCheckListItem( TheTop, 
          NN->name(), 
          QCheckListItem::RadioButton );
      it->setPixmap( 0, 
                     NSResources->getPixmap( NN->pixmapName() )
                   );
      // remember that this node maps to this listitem
      Mapping->insert( it, NN );
      buildSubTree( it, NN );
    }
 }
 // Build device tree -> help function 
 void EditConnection::buildSubTree( QListViewItem * it, ANetNode *NN ) {
    ANetNode::NetNodeList & NNL = NN->alternatives();
    if( NNL.size() > 1 ) {
      // this node has alternatives -> needs radio buttons
      it = new MyQCheckListItem( 
        it, 
        NSResources->netNode2Name(NN->needs()[0]),
        QCheckListItem::Controller );
      it->setSelectable( FALSE );
    }
    for ( unsigned int i=0; i < NNL.size(); i++ ) {
      QListViewItem * CI;
      if( NNL.size() > 1 ) {
        // generate radio buttons
        CI = new MyQCheckListItem( 
                (QCheckListItem *)it, 
                NNL[i]->name(), QCheckListItem::RadioButton );
        // remember that this node maps to this listitem
        CI->setPixmap( 0, NSResources->getPixmap( NNL[i]->pixmapName() ) );
        Mapping->insert( CI, NNL[i] );
        CI->setSelectable( FALSE );
      } else {
        // Single item
        CI = new MyQListViewItem( it, NNL[i]->name() );
        // remember that this node maps to this listitem
        Mapping->insert( CI, NNL[i] );
        CI->setSelectable( FALSE );
        CI->setPixmap( 0, NSResources->getPixmap( NNL[i]->pixmapName() ) );
      }
      buildSubTree( CI, NNL[i] );
    }
 }
 // Clicked ok OK button
 void EditConnection::accept( void ) {
    if( ! haveCompleteConfig( 0 ) || Name_LE->text().isEmpty() ) {
      QMessageBox::warning(
          0, 
          tr( "Closing Connection Setup" ),
          tr( "Definition not complete or no name" ) );
      return;
    }
    // check if all devices have acceptable input
    getTmpCollection();
    { ANetNodeInstance * NNI;
      QString S;
      for( QListIterator<ANetNodeInstance> it(TmpCollection);
           it.current();
           ++it ) {
        NNI = it.current();
        // widget must show its own problems
        S = NNI->acceptable();
        if( ! S.isEmpty() ) {
          QMessageBox::warning(
              0, 
              tr( "Cannot save" ),
              S );
          return;
        }
        NNI->commit();
        if( NNI->isModified() ) {
          TmpCollection.setModified( 1 );
          // commit the data
        }
      }
    }
    QDialog::accept();
 }
 // triggered by CB
 void EditConnection::SLOT_AutoCollapse( bool b ) {
    AutoCollapse = b;
 }
 // clicked on node in tree -> update GUI
 void EditConnection::SLOT_SelectNode( QListViewItem * it ) {
    ANetNode * NN;
    if( it == 0 || it->depth() == 0 ) {
      Description_LBL->setText( 
          NSResources->netNode2Description( "fullsetup" ) );
      // topevel or no selection
      return;
    }
    // store conversion from lvitem to node
    NN = (*Mapping)[ it ];
    if( ! NN ) {
      // intermediate node
      NN = (*Mapping)[ it->parent() ];
      if( NN ) {
        // figure out type of this node -> produce mesage
        Description_LBL->setText( NSResources->netNode2Description(
                                  NN->needs()[0]) );
      } else {
        Description_LBL->setText( "" );
      }
      return;
    }
    Description_LBL->setText( NN->nodeDescription() );
    if( ! it->isSelectable() ) {
      return;
    }
    if( ! ((QCheckListItem *)it)->isOn() ) {
      // clicked on line but NOT on Check or Radio item
      return;
    }
    // item has really changed -> update 
    TmpIsValid = 0;
    updateGUI( it, NN );
 }
 // cliecked on TAB to go to setup
 void EditConnection::SLOT_AlterTab( const QString & S ) {
    if( S == tr( "Setup" ) && Setup_FRM->isEnabled() ) {
      // switched to setup -> update CB and populate ws with
      // forms for devices
      if( ! TmpIsValid ) {
        getTmpCollection();
        // clear CB and Ws
        { QWidget * W;
          int i = 0;
          Devices_CB->clear();
          while( ( W = Setup_WS->widget( i ) ) ) {
            Setup_WS->removeWidget( W );
            i ++;
          }
        }
        // update CB
        // and populate WidgetStack
        { ANetNodeInstance * NNI;
          QListIterator<ANetNodeInstance> it(TmpCollection);
          int i = 0;
          QWidget * W;
          for ( ; it.current(); ++it ) {
            NNI = it.current();
            Devices_CB->insertItem(
                NSResources->getPixmap( NNI->nodeClass()->pixmapName() ),
                NNI->nodeClass()->name()
            );
            // add edit widget
            W = NNI->edit( Setup_WS );
            if( ! W) {
              W = new QLabel( Setup_WS, 
                              tr("No configuration required"));
            }
            Setup_WS->addWidget( W , i );
            i ++;
          }
        }
        Setup_WS->raiseWidget( 0 );
      } // still valid
    }
 }
 // update visual feedback of selection state
 void EditConnection::updateGUI( QListViewItem * it, ANetNode * NN ) {
    bool HCC = haveCompleteConfig( it );
    Tab_TB->setTabEnabled( Setup_FRM, HCC );
    Setup_FRM->setEnabled( HCC );
    // disable children of all siblings at same level
    QListViewItem * Sbl = it->parent()->firstChild();
    while( Sbl ) {
      if ( Sbl != it ) {
        disableTree( Sbl->firstChild(), FALSE );
        Sbl->setSelectable( TRUE );
        if( AutoCollapse )
          Sbl->setOpen( FALSE );
      }
      Sbl = Sbl->nextSibling();
    }
    // enable selected path (as deep as it goes
    it->setOpen( TRUE );
    enablePath( it->firstChild(), 
                (it->depth()==1) ? 
                    1 : // toplevel always alternatives
                    (NN->alternatives().size() > 1) );
 }
 void EditConnection::disableTree( QListViewItem * it, bool Mode ) {
    while( it ) {
      // disable sbl's chidren
      it->setSelectable( Mode );
      if( AutoCollapse )
        it->setOpen( Mode );
      disableTree( it->firstChild(), Mode );
      it = it->nextSibling();
    }
 }
 // pah : ParentHasAlternatives
 void EditConnection::enablePath( QListViewItem * it, bool pha ) {
    while( it ) {
      ANetNode * NN;
      NN = (*Mapping)[it];
      if( NN ) {
        if( pha ) {
          bool doOn = ((QCheckListItem *)it)->isOn();
          // we are a checklistitem for sure
          it->setSelectable( TRUE );
          if( AutoCollapse && ! doOn )
            it->setOpen( doOn );
          if( doOn ) {
            // selected alternative
            enablePath( it->firstChild(), 
                        NN->alternatives().size() > 1);
          } else {
            // non-selected alternative
            disableTree( it->firstChild(), FALSE);
          }
        } else {
          // we are single subitem
          it->setSelectable( TRUE );
          it->setOpen( TRUE );
          enablePath( it->firstChild(),
                      NN->alternatives().size() > 1);
        }
      } else {
        // controller node
        it->setSelectable( TRUE );
        it->setOpen( TRUE );
        enablePath( it->firstChild(), pha );
      }
      it = it->nextSibling();
    }
 }
 // do we have a complete configuration (all needs are provided for ?)
 bool EditConnection::haveCompleteConfig( QListViewItem * it ) {
    // check if all below this level is selected
    it = ( it ) ?it : Nodes_LV->firstChild();
    ANetNode *NN;
    bool Found;
    while ( it ) {
      NN = (*Mapping)[it];
      if( NN == 0 ) {
        // this item is a controller -> 
        // has radio items as children -> 
        // find selected one 
        it = it->firstChild();
        Found = 0;
        while( it ) {
          if( ((QCheckListItem *)it)->isOn() ) {
            Found = 1;
            // go deeper
            it = it->firstChild();
            break;
          }
          it = it->nextSibling();
        }
        if( ! Found ) {
          return 0; // no not complete -> a radio should have been chkd
        }
        // it now contains selected radio
        NN = (*Mapping)[it];
      } else {
        // automatic selection 
        it = it->firstChild();
      }
    }
    return 1;
 }
diff --git a/noncore/settings/networksettings2/gprs/GPRSrun.cpp b/noncore/settings/networksettings2/gprs/GPRSrun.cpp
index e842b99..cccc71a 100644
--- a/noncore/settings/networksettings2/gprs/GPRSrun.cpp
+++ b/noncore/settings/networksettings2/gprs/GPRSrun.cpp
@@ -1,105 +1,105 @@
 #include <sys/types.h>
 #include <signal.h>
 #include <errno.h>
 #include <qdir.h>
 #include <system.h>
 #include <resources.h>
 #include <netnode.h>
 #include "GPRSrun.h"
 State_t GPRSRun::detectState( void ) { 
      // is pppd still running ?
      // is rfcomm still active
      NodeCollection * NC = nodeCollection();
      InterfaceInfo * I = NC->assignedInterface();
      QDir D("/var/run");
      if( I ) {
        // has some pppx attached
        return ( I->IsUp ) ? IsUp : Available;
      }
      // check ppp itself and figure out interface
-      owarn << "Check for ppp " << NC->name() << oendl;
+      odebug << "Check for ppp " << NC->name() << oendl;
      if( D.exists( QString("ppp-")+removeSpaces(NC->name())+".pid") ) {
        // get pid and check if pppd is still running
        QFile F( D.path()+"/ppp-"+removeSpaces(NC->name())+".pid");
-        owarn << "PPP PID " << F.name() << oendl;
+        odebug << "PPP PID " << F.name() << oendl;
        if( F.open( IO_ReadOnly ) ) {
          QTextStream TS(&F);
          QString X = TS.readLine();
          PPPPid = X.toULong();
          int rv;
          rv = ::kill( PPPPid, 0 );
          if( rv == 0 ||
              ( rv < 0 && errno == EPERM )
            ) {
            // pppd is still up
            X = TS.readLine();
            I = NSResources->system().findInterface(X);
-            owarn << "ppp running : IFace " << X << " = " << (long)I << oendl;
+            odebug << "ppp running : IFace " << X << " = " << (long)I << oendl;
            if( I ) {
              NC->assignInterface( I );
              return (I->IsUp) ? IsUp : Available;
            }
            return Available;
          } else {
            // pppd is down
            PPPPid = 0;
          } 
        } // else pppd is down
      }
      NC->assignInterface( 0 );
      return Unknown;
 }
 QString GPRSRun::setMyState( NodeCollection * NC, Action_t A , bool ) { 
    if( A == Up ) {
      // start ppp on deviceFile
      QStringList SL;
      SL << "pon"
         << removeSpaces( NC->name() )
         << NC->device()->deviceFile();
      if( ! NSResources->system().execAsUser( SL ) ) {
        return QString("Cannot start pppd for %1").arg(NC->name());
      }
    } else if ( A == Down ) {
      if( PPPPid == 0 ) {
        detectState();
      }
      if( PPPPid ) {
        QStringList SL;
        SL << "poff"
           << removeSpaces( NC->name() );
        if( ! NSResources->system().execAsUser( SL ) ) {
          return QString("Cannot terminate pppd for %1").arg(NC->name());
        }
        NC->assignInterface( 0 );
-        owarn << "ppp stopped " << oendl;
+        odebug << "ppp stopped " << oendl;
        PPPPid = 0;
      }
    }
    return QString();
 }
 bool GPRSRun::handlesInterface( const QString & S ) {
    return Pat.match( S ) >= 0;
 }
 bool GPRSRun::handlesInterface( InterfaceInfo * I ) {
    return handlesInterface( I->Name );
 }
diff --git a/noncore/settings/networksettings2/network/networkrun.cpp b/noncore/settings/networksettings2/network/networkrun.cpp
index c17aa7f..2c93d9d 100644
--- a/noncore/settings/networksettings2/network/networkrun.cpp
+++ b/noncore/settings/networksettings2/network/networkrun.cpp
@@ -1,51 +1,50 @@
 #include <system.h>
 #include <netnode.h>
 #include <resources.h>
 #include "networkrun.h"
 State_t NetworkRun::detectState( void ) { 
    InterfaceInfo * II = nodeCollection()->assignedInterface();
    Log(( "Interface %p : %d\n", II, (II) ? II->IsUp : 0 ));
    if( II && II->IsUp ) {
      // device has assigned interface
      return IsUp;
    }
    // had no interface or interface is no longer up -> release
    nodeCollection()->assignInterface( 0 );
    return Unknown;
 }
 QString NetworkRun::setMyState( NodeCollection * NC, Action_t A, bool ) { 
    // we handle UP and DOWN
    InterfaceInfo * II = NC->assignedInterface();
+    if( ! II ) {
+      Log(( "no interface assigned." ));
+      return QString();
+    }
+    QStringList SL;
    if( A == Up ) {
      // we can bring UP if lower level is available
-      QStringList SL;
+      SL << "ifup";
-      SL << "ifup"
+    } else if( A == Down ) {
-         << QString().sprintf( "%s=%s-c%d-allowed",
+      SL << "ifdown";
+    } else {
+      return QString();
+    }
+    SL << QString().sprintf( "%s=%s-c%d-allowed",
                        II->Name.latin1(), II->Name.latin1(),
                        nodeCollection()->number() );
-      if( ! NSResources->system().runAsRoot( SL ) ) {
-        return QString("Cannot call %1").arg(SL.join(" "));
+    if( ! NSResources->system().runAsRoot( SL ) ) {
-      }
+      return QString("Cannot call %1").arg(SL.join(" "));
-      return QString();
+    }
-    } 
-    if( A == Down ) {
-      QStringList SL;
-      if( II ) {
-        SL << "ifdown"
-           << II->Name.latin1();
-        if( !  NSResources->system().runAsRoot( SL ) ) {
-          return QString( "Cannot call %1" ).arg( SL.join( " " ));
-        }
-      } else {
-        Log(( "no interface assigned." ));
-      }
-    } 
    return QString();
 }
diff --git a/noncore/settings/networksettings2/networksettings.cpp b/noncore/settings/networksettings2/networksettings.cpp
index 9680a96..78b6cce 100644
--- a/noncore/settings/networksettings2/networksettings.cpp
+++ b/noncore/settings/networksettings2/networksettings.cpp
@@ -1,514 +1,510 @@
 #include <stdio.h>
 #include <unistd.h>
 #include <errno.h>
 #include <opie2/odebug.h>
 #include <opie2/oledbox.h>
 #include <qpe/qpeapplication.h>
 #include <qlistbox.h>
 #include <qlayout.h>
 #include <qgroupbox.h>
 #include <qtimer.h>
 #include <qlistbox.h>
 #include <qmessagebox.h>
 #include <qlabel.h>
 #include <qiconview.h>
 #include <qtimer.h>
 #include <qpe/qpeapplication.h>
 #include <qtoolbutton.h>
 #include <qevent.h>
 #include "networksettings.h"
 #include "netnode.h"
 #include "editconnection.h"
 NetworkSettings::NetworkSettings( QWidget *parent, 
               const char *name, 
               WFlags fl ) : NetworkSettingsGUI(parent,name,fl), 
                             NSD() {
    UpdateTimer = new QTimer( this );
    // set pixmaps 
    Add_TB->setPixmap( NSResources->getPixmap( "add" ) );
    Delete_TB->setPixmap( NSResources->getPixmap( "remove" ) );
    CheckState_TB->setPixmap( NSResources->getPixmap( "check" ) );
    GenConfig_TB->setPixmap( NSResources->getPixmap( "configure" ) );
    Disable_TB->setPixmap( NSResources->getPixmap( "disabled" ) );
    Up_TB->setPixmap( NSResources->getPixmap( "more" ) );
    Down_TB->setPixmap( NSResources->getPixmap( "less" ) );
    QVBoxLayout* V = new QVBoxLayout( LED_Frm );
    QHBoxLayout * H = new QHBoxLayout( 0 );
    V->addStretch(1);
    V->addLayout( H );
    Leds[0] = new Opie::Ui::OLedBox( red, LED_Frm );
    H->addWidget( Leds[0], 0, Qt::AlignVCenter );
    Leds[1] = new Opie::Ui::OLedBox( red, LED_Frm );
    H->addWidget( Leds[1], 0, Qt::AlignVCenter );
    Leds[2] = new Opie::Ui::OLedBox( red, LED_Frm );
    H->addWidget( Leds[2], 0, Qt::AlignVCenter );
    V->addStretch(1);
    SLOT_ToProfile();
    // populate main Listbox
    Profiles_LB->clear();
    QPEApplication::setStylusOperation( 
        Profiles_LB->viewport(), QPEApplication::RightOnHold );
    connect( Profiles_LB, 
             SIGNAL(rightButtonPressed(QListBoxItem*,const QPoint&)),
             this, SLOT(SLOT_EditNode(QListBoxItem*)) );
    { Name2Connection_t & M = NSResources->connections();
      NodeCollection * NC;
      // for all connections
      for( QDictIterator<NodeCollection> it(M);
           it.current();
           ++it ) {
        NC = it.current();
        Profiles_LB->insertItem( NC->devicePixmap(),
                                 NC->name() );
      }
    }
    if( Profiles_LB->count() ) {
      Profiles_LB->setSelected( 0, TRUE );
    }
    // if no profiles -> auto popup editing
    if( NSResources->connections().count() == 0 ) {
      QTimer::singleShot( 100, this, SLOT(SLOT_AddNode() ) );
    }
    connect( &(NSResources->system()), 
             SIGNAL( stdoutLine(const QString &) ),
             this, SLOT( SLOT_CmdMessage(const QString &) ) );
    connect( &(NSResources->system()), 
             SIGNAL( stderrLine(const QString &) ),
             this, SLOT( SLOT_CmdMessage(const QString &) ) );
    connect( &(NSResources->system()), 
             SIGNAL( processEvent(const QString &) ),
             this, SLOT( SLOT_CmdMessage(const QString &) ) );
    UpdateTimer->start( 5000 );
    connect( UpdateTimer, SIGNAL( timeout() ),
             this, SLOT( SLOT_RefreshStates() ) );
    /* Add QCopChannel */
    connect( qApp, SIGNAL(appMessage(const QCString&,const QByteArray&)),
             this, SLOT(SLOT_QCopMessage(const QCString&,const QByteArray&)) );
 }
 NetworkSettings::~NetworkSettings() {
    QString S;
-    owarn << "Dispose NS" << oendl;
    if( NSD.isModified() ) {
-      owarn << "Modified" << oendl;
      S = NSD.saveSettings();
      if( ! S.isEmpty() ) {
        S.insert( 0, "<p>" );
        S.append( "</p>" );
        // problem saving
        QMessageBox::warning(
              0, 
              tr( "Saving setup" ), S );
      }
      SLOT_GenerateConfig();
      NSD.setModified( 0 );
    }
 }
 void NetworkSettings::SLOT_CmdMessage( const QString & S ) {
    Messages_LB->insertItem( S );
    Messages_LB->setCurrentItem( Messages_LB->count()-1 );
    Messages_LB->ensureCurrentVisible();
 }
 void NetworkSettings::SLOT_RefreshStates( void ) {
    QListBoxItem * LBI = Profiles_LB->item( Profiles_LB->currentItem() ); // remember
    if( LBI ) {
      NodeCollection * NC;
      NSResources->system().probeInterfaces();
      // update current selection only
      NC = NSResources->findConnection( LBI->text() );
      if( NC ) {
        State_t OldS = NC->state();
        State_t NewS = NC->state(1);
        if( OldS != NewS ) {
          updateProfileState( LBI );
        }
      }
    }
    /* -> LATER !!
    bool is;
    NodeCollection * NC;
    for( unsigned int i = 0; i < Profiles_LB->count() ; i ++ ) {
      NC = NSResources->findConnection( Profiles_LB->text(i) );
      if( NC ) {
        State_t OldS = NC->state();
        State_t NewS = NC->state(1);
        if( OldS != NewS ) {
          is = Profiles_LB->isSelected(i);
          Profiles_LB->changeItem( NC->statePixmap(NewS), 
                                   NC->name(), 
                                   i );
          if( is ) {
            Profiles_LB->setSelected( i, TRUE );
          }
        }
      }
    }
    if( ci >= 0 )
      Profiles_LB->setCurrentItem( ci );
    */
 }
 void NetworkSettings::SLOT_AddNode( void ) {
    SLOT_EditNode( 0 );
 }
 void NetworkSettings::SLOT_DeleteNode( void ) {
    QListBoxItem * LBI = Profiles_LB->item( Profiles_LB->currentItem() ); 
    if ( ! LBI ) 
      return;
    if( QMessageBox::warning(
          0, 
          tr( "Removing profile" ),
          tr( "Remove selected profile ?" ), 
          1, 0 ) == 1 ) {
      NSResources->removeConnection( LBI->text() );
      delete LBI;
      NSD.setModified( 1 );
    }
 }
 void NetworkSettings::SLOT_EditNode( QListBoxItem * LBI ) {
    QString OldName = "";
    EditConnection EC( this );
    if( LBI ) {
      NodeCollection * NC = NSResources->findConnection( LBI->text() );
      if( ! NC ) {
        return;
      }
      OldName = NC->name();
      EC.setConnection( NC );
    }
    EC.showMaximized();
    // disable refresh timer 
    UpdateTimer->stop();
    // we need to retry
    while( 1 ) {
      if( EC.exec() == QDialog::Accepted ) {
        // toplevel item -> store
        NodeCollection * NC = EC.connection();
        if( NC->isModified() ) {
          if( LBI ) {
            if( NC->name() != OldName ) {
              // find if new name is free
              NodeCollection * LCN = NSResources->findConnection(
                    NC->name() );
              if( LCN ) {
                QMessageBox::warning(
                  0, 
                  tr( "In System Config" ),
                  tr( "Name %1 already exists" ).arg(NC->name())
                );
                continue; // restart exec
              } // else new name
              // new name -> remove item
              NSResources->removeConnection( OldName );
              NSResources->addConnection( NC, 0 );
            } // else not changed
            // must add it here since change will trigger event
            Profiles_LB->changeItem( NC->devicePixmap(),
                                     NC->name(),
                                     Profiles_LB->index( LBI )
                                   );
          } else {
            // new item
            int ci = Profiles_LB->count();
            NSResources->addConnection( NC, 0 );
            NC->setNumber( NSResources->assignConnectionNumber() );
            Profiles_LB->insertItem( NC->devicePixmap(), NC->name() );
            Profiles_LB->setSelected( ci, TRUE );
          }
          updateProfileState( LBI );
        }
      } else {
        // cancelled : reset connection 
        if( LBI ) {
          NodeCollection * NC = NSResources->findConnection( LBI->text() );
          NC->reassign();
        }
      }
      break;
    }
    // reenable 
    UpdateTimer->start( 5000 );
 }
 void NetworkSettings::SLOT_ShowNode( QListBoxItem * LBI ) {
    if( LBI == 0 ) 
      return;
    NodeCollection * NC = NSResources->findConnection( LBI->text() );
    if( NC->description().isEmpty() ) {
      Description_LBL->setText( tr( "<<No description>>" ) );
    } else {
      Description_LBL->setText( NC->description() );
    }
    Profile_GB->setTitle( LBI->text() + " : " + NC->stateName() );
    bool FrmActive = 1;
    bool IsEnabled = 1;
    int leds = 0;
-    owarn << "State " << NC->state() << oendl;
    switch( NC->state() ) {
      case Disabled : // no further work
        IsEnabled = 0;
        FrmActive = 0;
-        owarn << "LEds " << leds << oendl;
        break;
      case Unknown :
      case Unchecked :
      case Unavailable :
        FrmActive = 0;
        break;
      case Off :
        leds = 1;
        break;
      case Available :
        leds = 2;
        break;
      case IsUp :
        leds = 3;
        break;
    }
    Disable_TB->setOn( ! IsEnabled );
    LED_Frm->setEnabled( FrmActive );
    for( int i = 0 ; i < leds; i ++ ) {
      Leds[i]->setColor( red );
      Leds[i]->setOn( true );
    }
    for( int i = leds ; i < 3; i ++ ) {
      Leds[i]->setColor( red );
      Leds[i]->setOn( false );
    }
    Up_TB->setEnabled( leds < 3 && leds != 0 );
    Down_TB->setEnabled( leds > 0 );
 }
 void NetworkSettings::SLOT_CheckState( void ) {
    QListBoxItem * LBI = Profiles_LB->item( Profiles_LB->currentItem() ); 
    if ( ! LBI ) 
      return;
    updateProfileState( LBI );
 }
 void NetworkSettings::updateProfileState( QListBoxItem * LBI ) {
    if( LBI == Profiles_LB->item( Profiles_LB->currentItem() ) ) {
      SLOT_ShowNode( LBI );
    }
 }
 void NetworkSettings::SLOT_GenerateConfig( void ) {
    QString S = NSD.generateSettings();
    if( ! S.isEmpty() ) {
      S.insert( 0, "<p>" );
      S.append( "</p>" );
      QMessageBox::warning(
          0, 
          tr( "Generate config" ),
          S);
    }
 }
 void NetworkSettings::SLOT_Disable( bool T ) {
    QListBoxItem * LBI = Profiles_LB->item( Profiles_LB->currentItem() );
    QString Msg;
    if ( ! LBI ) 
      return;
    NodeCollection * NC = NSResources->findConnection( LBI->text() );
-    owarn << "Prepare to disable" << oendl;
+    Log(( "Prepare to %sable\n", (T) ? "en" : "dis" ));
    Msg = NC->setState( (T) ? Disable : Enable );
    if( ! Msg.isEmpty() ) {
      Msg.insert( 0, "<p>" );
      Msg.append( "</p>" );
      QMessageBox::warning(
          0, 
          tr( "Activating profile" ),
          Msg );
      return;
    }
    // reload new state
    NC->state( true );
    updateProfileState( LBI );
 }
 void NetworkSettings::SLOT_Up( void ) {
    // bring more up
    QListBoxItem * LBI = Profiles_LB->item( Profiles_LB->currentItem() );
    QString Msg;
    int led = -1;
    if ( ! LBI ) 
      return;
    NodeCollection * NC = 
        NSResources->findConnection( LBI->text() );
    switch( NC->state() ) {
      case Disabled : // cannot modify this state
      case Unknown : // cannot modify this state
      case Unchecked : // cannot modify this state
      case Unavailable : // cannot modify this state
      case IsUp : // highest UP state
        return;
      case Off : // -> activate
        led = 1;
        Down_TB->setEnabled( true );
        Log(( "Activate interface %s\n", NC->name().latin1() ));
        Msg = NC->setState( Activate );
        break;
      case Available : // -> up
        led = 2;
        Log(( "Bring up interface %s\n", NC->name().latin1() ));
        Msg = NC->setState( Up );
        if( Msg.isEmpty() ) {
          Up_TB->setEnabled( false );
        }
        break;
    }
    if( ! Msg.isEmpty() ) {
      Msg.insert( 0, "<p>" );
      Msg.append( "</p>" );
      QMessageBox::warning(
          0, 
          tr( "Increase availability" ),
          Msg );
      return;
    }
    updateProfileState( LBI );
    // set color of led we should change 
    if( led > 0 ) {
      Leds[led]->setColor( blue );
      Leds[led]->setOn( true );
    }
 }
 void NetworkSettings::SLOT_Down( void ) {
    // bring more down
    QListBoxItem * LBI = Profiles_LB->item( Profiles_LB->currentItem() );
    int led = -1;
    QString Msg;
    if ( ! LBI ) 
      return;
    NodeCollection * NC = 
        NSResources->findConnection( LBI->text() );
    switch( NC->state() ) {
      case Disabled : // cannot modify this state
      case Unknown : // cannot modify this state
      case Unchecked : // cannot modify this state
      case Unavailable : // cannot modify this state
      case Off : // highest DOWN state
        break;
      case Available : // -> down
        led = 0;
        Log(( "Deactivate interface %s\n", NC->name().latin1() ));
        Msg = NC->setState( Deactivate );
        Down_TB->setEnabled( false );
        break;
      case IsUp : // highest UP state
        led = 1;
        Up_TB->setEnabled( true );
        Log(( "Bring down interface %s\n", NC->name().latin1() ));
        Msg = NC->setState( Down, 1 );
        if( Msg.isEmpty() ) {
          // remove 'up' file to make sure
          unlink ( QString().sprintf( "/tmp/Profile-%d.up", NC->number() ).latin1() );;
        }
        break;
    }
    if( ! Msg.isEmpty() ) {
      Msg.insert( 0, "<p>" );
      Msg.append( "</p>" );
      QMessageBox::warning(
          0, 
          tr( "Decrease availability" ),
          Msg );
      return;
    }
    updateProfileState( LBI );
    // set color of led we should change 
    if( led >= 0 ) {
      Leds[led]->setColor( blue );
    }
 }
 void NetworkSettings::SLOT_ToMessages( void ) {
    Profiles_LB->hide();
    Profile_GB->hide();
    Messages_GB->show();
 }
 void NetworkSettings::SLOT_ToProfile( void ) {
    Profiles_LB->show();
    Profile_GB->show();
    Messages_GB->hide();
 }
 void NetworkSettings::SLOT_QCopMessage(const QCString &msg, const QByteArray &data) {
  QDataStream stream( data, IO_ReadOnly );
  if( msg == "raise" ) {
      raise();
      return;
  } /* if ( msg == "someMessage(int,int,int)" ) {
    int a,b,c;
    stream >> a >> b >> c;
    ...
  } */
 }
diff --git a/noncore/settings/networksettings2/networksettings2/config.in b/noncore/settings/networksettings2/networksettings2/config.in
index b384e18..56e971e 100644
--- a/noncore/settings/networksettings2/networksettings2/config.in
+++ b/noncore/settings/networksettings2/networksettings2/config.in
@@ -1,5 +1,5 @@
 config NS2CORE
-  boolean "opie-networksettings2 (TCP/IP network settings)"
+  boolean "opie-networksettings2 library"
  default "y"
  depends ( LIBQPE || LIBQPE-X11 ) && LIBOPIE2CORE && LIBOPIE2UI
diff --git a/noncore/settings/networksettings2/networksettings2/system.cpp b/noncore/settings/networksettings2/networksettings2/system.cpp
index e642c08..f027d35 100644
--- a/noncore/settings/networksettings2/networksettings2/system.cpp
+++ b/noncore/settings/networksettings2/networksettings2/system.cpp
@@ -1,587 +1,587 @@
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <net/if.h>
 #include <net/if_arp.h>
 #include <netinet/in.h>
 #include <arpa/inet.h>
 #include <sys/ioctl.h>
 #include <sys/socket.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <fcntl.h>
 #include <errno.h>
 #include <unistd.h>
 #include <opie2/oprocess.h>
 #include <qdir.h>
 #include <qregexp.h>
 #include <qstringlist.h>
 #include <qfile.h>
 #include <qtextstream.h>
 #include <qapplication.h>
 #include "resources.h"
 #include "system.h"
 #define PROCNETDEV "/proc/net/dev"
 #ifndef ARPHRD_IEEE80211
 #define ARPHRD_IEEE80211 801
 #endif
 static char Dig2Hex[] = { 
  '0', '1', '2', '3', 
  '4', '5', '6', '7', 
  '8', '9', 'A', 'B', 
  'C', 'D', 'E', 'F'
 };
 // get HIGH nibble of byte
 #define HN(x)           Dig2Hex[(((x)&0xf0)>>4)]
 // get LOW nibble of byte
 #define LN(x)           Dig2Hex[((x)&0x0f)]
 System::System( void ) : QObject(), ProbedInterfaces() {
    ProcDevNet = 0;
 }
 System::~System( void ) {
    if( ProcDevNet )
      delete ProcDevNet;
 }
 QDict<InterfaceInfo> & System::interfaces( void ) {
    if( ProbedInterfaces.count() == 0 ) {
      probeInterfaces();
    }
    return ProbedInterfaces;
 }
 int System::runAsRoot( QStringList & S, MyProcess * Prc ) {
    char * usr = getenv("USER");
    if( S.count() == 0 ) {
      // loophole to start shell
      return 8888;
    }
    if( usr == 0 || strcmp( usr, "root" ) ) {
      // unknown or non-root user -> use SUDO
      S.prepend( "sudo" );
    }
    if( getenv( "NS2TESTMODE" ) ) {
-      owarn << "TESTMODE !!! execute " 
+      odebug << "TESTMODE !!! execute " 
            << S.join( " ") 
            << oendl;
    } else {
      MyProcess * P;
      if( Prc ) {
        P = Prc;
      } else {
        P = new MyProcess();
        emit processEvent( tr("Command : ") + S.join( " " ) );
        connect( P, 
                 SIGNAL( stdoutLine( const QString & ) ),
                 this, 
                 SIGNAL( stdoutLine( const QString & ) ) );
        connect( P, 
                 SIGNAL( stderrLine( const QString & ) ),
                 this, 
                 SIGNAL( stderrLine( const QString & ) ) );
        connect( P, 
                 SIGNAL(processExited(MyProcess*) ),
                 this, SLOT
                 (SLOT_ProcessExited(MyProcess*) ) );
      }
      P->process() << S;
      Log(("Executing %s\n", S.join( " " ).latin1() ));
      if( ! P->process().start( OProcess::DontCare, 
                      OProcess::AllOutput ) ) {
-        owarn << "Error starting " << S << oendl;
+        odebug << "Error starting " << S << oendl;
        if( ! Prc )
          delete P;
        // error starting app
        return 0;
      }
-      owarn << "Started " << S << oendl;
+      odebug << "Started " << S << oendl;
    }
    // all is fine
    return 1;
 }
 int System::execAsUser( QStringList & SL ) {
      MyProcess * P = new MyProcess();
      CurrentQPEUser CU = NSResources->currentUser();
      char * usr = getenv("USER");
      if( strcmp( usr, "root" ) == 0 ) {
        // find user running qpe
        if( CU.UserName.isEmpty() ) {
          // if we come here, the exec was not successfull
          Log(("User not known \n" ));
          return 0;
        }
      }
      // now we are ready to exec the requested command
      setuid( CU.Uid );
      setgid( CU.Gid );
      for( unsigned int i = 0 ; i < CU.EnvList.count() ; i ++ ) {
        QString X;
        QStringList SL;
        X = CU.EnvList[i];
        SL = QStringList::split( "=", X );
        P->process().setEnvironment( SL[0], SL[1] );
      }
      P->process() << SL;
      emit processEvent( tr("Command : ") + SL.join( " " ) );
      Log(("Executing as user %s : %s\n", 
            CU.UserName.latin1(),
            SL.join( " " ).latin1() ));
      int rv = ( P->process().start( OProcess::DontCare, 
                      OProcess::NoCommunication ) );
      delete P;
      if( rv ) {
        // if we come here, the exec was not successfull
        Log(("Could not exec : %d\n", errno ));
      }
      return ! rv;
 }
 void System::SLOT_ProcessExited( MyProcess * P ) {
      QString R;
      for( QValueListConstIterator<QCString> it = P->process().args().begin();
           it != P->process().args().end(); 
           ++it ) {
        R += (*it); 
        R += " ";
      }
      R += "Returned with " + QString().setNum( P->process().exitStatus() );
      emit processEvent( R );
      delete P;
 }
 void System::refreshStatistics( InterfaceInfo & I ) {
    if( ! ProcDevNet ) {
      return;
    }
    // cannot seek on dev
    ProcDevNet->close();
    ProcDevNet->open( IO_ReadOnly );
    QString line;
    QTextStream procTs(ProcDevNet);
    QStringList SL;
    int loc = -1;
    int version;
    procTs.readLine();
    line = procTs.readLine();
    // get version
    if( line.find("compressed") )
      version = 3;
    else if( line.find( "bytes" ) )
      version = 2;
    else 
      version = 1;
    while((line = procTs.readLine().simplifyWhiteSpace()) != QString::null) {
      if( (loc = line.find(":") ) == -1) {
        continue;
      }
      if( I.Name != line.left(loc) ) 
        continue;
      // tokenize
      SL = QStringList::split( ' ', line, FALSE );
      // update data
      switch( version ) {
        case 1 :
          I.RcvBytes = SL[1];
          I.RcvErrors = SL[3];
          I.RcvDropped = SL[4];
          I.SndBytes = SL[6];
          I.SndErrors = SL[8];
          I.SndDropped = SL[9];
          I.Collisions = SL[11];
          break;
        case 2 :
          I.RcvBytes = SL[1];
          I.RcvErrors = SL[3];
          I.RcvDropped = SL[4];
          I.SndBytes = SL[7];
          I.SndErrors = SL[9];
          I.SndDropped = SL[10];
          I.Collisions = SL[12];
          break;
        case 3 :
          I.RcvBytes = SL[1];
          I.RcvErrors = SL[3];
          I.RcvDropped = SL[4];
          I.SndBytes = SL[9];
          I.SndErrors = SL[11];
          I.SndDropped = SL[12];
          I.Collisions = SL[14];
          break;
      }
      break;
    }
 }
 //
 // THIS UPDATES THE LIST -> INTERFACES ARE NOT DELETED BUT
 // FLAGGED AS ! 'IsUp' IF NO LONGER PRESENT
 //
 void System::probeInterfaces( void ) {
    // probe interfaces
    int sockfd;
    // get list of all interfaces
    struct ifreq ifrs;
    InterfaceInfo * IFI;
    // flag all as 'down'
    for( QDictIterator<InterfaceInfo> it( ProbedInterfaces ); 
         it.current();
         ++it ) {
      it.current()->IsUp = 0;
    }
    sockfd = socket(PF_INET, SOCK_DGRAM, 0);
    if(sockfd == -1) {
-      owarn << "Cannot open INET socket "
+      odebug << "Cannot open INET socket "
            << errno 
            << " "
            << strerror( errno )
            << oendl;
      return;
    }
    // read interfaces from /proc/dev/net
    // SIOCGIFCONF does not return ALL interfaces ???!?
    ProcDevNet = new QFile(PROCNETDEV);
    if( ! ProcDevNet->open(IO_ReadOnly) ) {
-      owarn << "Cannot open " 
+      odebug << "Cannot open " 
            << PROCNETDEV
            << " "
            << errno 
            << " "
            << strerror( errno )
            << oendl;
      delete ProcDevNet;
      ProcDevNet =0;
      ::close( sockfd );
      return;
    }
    QString line;
    QString NicName;
    QTextStream procTs(ProcDevNet);
    int loc = -1;
    procTs.readLine(); // eat a line
    procTs.readLine(); // eat a line
    while((line = procTs.readLine().simplifyWhiteSpace()) != QString::null) {
      if((loc = line.find(":")) == -1) {
        continue;
      }
      NicName = line.left(loc);
      // set name for ioctl
      strcpy( ifrs.ifr_name, NicName.latin1() );
      if ( ! ( IFI = ProbedInterfaces.find( NicName ) ) ) {
        // new nic
        Log(("New NIC found : %s\n", NicName.latin1()));
        IFI = new InterfaceInfo;
        IFI->Name = line.left(loc);
        IFI->Collection = 0;
        ProbedInterfaces.insert( IFI->Name, IFI );
        // get dynamic info
        if( ioctl(sockfd, SIOCGIFFLAGS, &ifrs) >= 0 ) {
          IFI->IsPointToPoint = ((ifrs.ifr_flags & IFF_POINTOPOINT) == IFF_POINTOPOINT);
        } else {
          IFI->IsPointToPoint = 0;
        }
        // settings that never change
        IFI->DstAddress = "";
        if( IFI->IsPointToPoint ) {
          if( ioctl(sockfd, SIOCGIFDSTADDR, &ifrs) >= 0 ) {
            IFI->DstAddress = 
             inet_ntoa(((struct sockaddr_in*)&ifrs.ifr_dstaddr)->sin_addr);
          }
        }
        IFI->CardType = 999999;
        IFI->MACAddress = "";
        if( ioctl(sockfd, SIOCGIFHWADDR, &ifrs) >= 0 ) {
          Log(("Family for NIC %s : %d\n", IFI->Name.latin1(), 
              ifrs.ifr_hwaddr.sa_family ));
          IFI->CardType = ifrs.ifr_hwaddr.sa_family;
          switch( ifrs.ifr_hwaddr.sa_family ) {
            case ARPHRD_ETHER : // regular MAC address
              // valid address -> convert to regular ::: format
              // length = 6 bytes = 12 DIGITS -> 6 :
              IFI->MACAddress.sprintf(
                "%c%c:%c%c:%c%c:%c%c:%c%c:%c%c",
                HN( ifrs.ifr_hwaddr.sa_data[0] ),
                LN( ifrs.ifr_hwaddr.sa_data[0] ),
                HN( ifrs.ifr_hwaddr.sa_data[1] ),
                LN( ifrs.ifr_hwaddr.sa_data[1] ),
                HN( ifrs.ifr_hwaddr.sa_data[2] ),
                LN( ifrs.ifr_hwaddr.sa_data[2] ),
                HN( ifrs.ifr_hwaddr.sa_data[3] ),
                LN( ifrs.ifr_hwaddr.sa_data[3] ),
                HN( ifrs.ifr_hwaddr.sa_data[4] ),
                LN( ifrs.ifr_hwaddr.sa_data[4] ),
                HN( ifrs.ifr_hwaddr.sa_data[5] ),
                LN( ifrs.ifr_hwaddr.sa_data[5] )
              );
              break;
 #ifdef ARPHRD_IEEE1394
            case ARPHRD_IEEE1394 : // Firewire Eth address
              IFI->MACAddress.sprintf(
                "%c%c-%c%c-%c%c-%c%c-%c%c-%c%c-%c%c-%c%c-%c%c-%c%c-%c%c-%c%c-%c%c-%c%c-00-00",
                HN( ifrs.ifr_hwaddr.sa_data[0] ),
                LN( ifrs.ifr_hwaddr.sa_data[0] ),
                HN( ifrs.ifr_hwaddr.sa_data[1] ),
                LN( ifrs.ifr_hwaddr.sa_data[1] ),
                HN( ifrs.ifr_hwaddr.sa_data[2] ),
                LN( ifrs.ifr_hwaddr.sa_data[2] ),
                HN( ifrs.ifr_hwaddr.sa_data[3] ),
                LN( ifrs.ifr_hwaddr.sa_data[3] ),
                HN( ifrs.ifr_hwaddr.sa_data[4] ),
                LN( ifrs.ifr_hwaddr.sa_data[4] ),
                HN( ifrs.ifr_hwaddr.sa_data[5] ),
                LN( ifrs.ifr_hwaddr.sa_data[5] ),
                HN( ifrs.ifr_hwaddr.sa_data[6] ),
                LN( ifrs.ifr_hwaddr.sa_data[6] ),
                HN( ifrs.ifr_hwaddr.sa_data[7] ),
                LN( ifrs.ifr_hwaddr.sa_data[7] ),
                HN( ifrs.ifr_hwaddr.sa_data[8] ),
                LN( ifrs.ifr_hwaddr.sa_data[8] ),
                HN( ifrs.ifr_hwaddr.sa_data[9] ),
                LN( ifrs.ifr_hwaddr.sa_data[9] ),
                HN( ifrs.ifr_hwaddr.sa_data[10] ),
                LN( ifrs.ifr_hwaddr.sa_data[10] ),
                HN( ifrs.ifr_hwaddr.sa_data[11] ),
                LN( ifrs.ifr_hwaddr.sa_data[11] ),
                HN( ifrs.ifr_hwaddr.sa_data[12] ),
                LN( ifrs.ifr_hwaddr.sa_data[12] ),
                HN( ifrs.ifr_hwaddr.sa_data[13] ),
                LN( ifrs.ifr_hwaddr.sa_data[13] )
              );
              break;
 #endif
            case ARPHRD_PPP : // PPP
              break;
            case ARPHRD_IEEE80211 : // WLAN
              break;
            case ARPHRD_IRDA : // IRDA
              break;
          }
        }
      } else // else already probed before -> just update
        Log(("Redetected NIC %s\n", NicName.latin1()));
      // get dynamic info
      if( ioctl(sockfd, SIOCGIFFLAGS, &ifrs) >= 0 ) {
        IFI->IsUp = ((ifrs.ifr_flags & IFF_UP) == IFF_UP);
        IFI->HasMulticast = ((ifrs.ifr_flags & IFF_MULTICAST) == IFF_MULTICAST);
      } else {
        IFI->IsUp = 0;
        IFI->HasMulticast = 0;
      }
      if( ioctl(sockfd, SIOCGIFADDR, &ifrs) >= 0 ) {
        IFI->Address = 
           inet_ntoa(((struct sockaddr_in*)&ifrs.ifr_addr)->sin_addr);
      } else {
        IFI->Address = "";
        IFI->IsUp = 0;
      }
      if( ioctl(sockfd, SIOCGIFBRDADDR, &ifrs) >= 0 ) {
        IFI->BCastAddress = 
           inet_ntoa(((struct sockaddr_in*)&ifrs.ifr_broadaddr)->sin_addr);
      } else {
        IFI->BCastAddress = "";
      }
      if( ioctl(sockfd, SIOCGIFNETMASK, &ifrs) >= 0 ) {
        IFI->Netmask = 
           inet_ntoa(((struct sockaddr_in*)&ifrs.ifr_netmask)->sin_addr);
      } else {
        IFI->Netmask = "";
      }
      Log(("NIC %s UP ? %d\n", NicName.latin1(), IFI->IsUp ));
    }
    ::close( sockfd );
 }
 InterfaceInfo * System::findInterface( const QString & N ) {
      InterfaceInfo * Run;
      // has PAN connection UP interface ?
      for( QDictIterator<InterfaceInfo> It(ProbedInterfaces);
           It.current();
           ++It ) {
        Run = It.current();
        if( N == Run->Name ) {
          // this PAN connection is up
          return Run;
        }
      }
      return 0;
 }
 #include <stdarg.h>
 static FILE * logf = 0;
 void VLog( char * Format, ... ) {
      va_list l;
      va_start(l, Format );
      if( logf == (FILE *)0 ) {
        QString S = getenv("NS2LOG");
        if( S == "stderr" ) {
          logf = stderr;
        } else if( S.isEmpty() ) {
          logf = fopen( "/tmp/ns2log", "a" );
        } else {
          logf = fopen( S, "a" );
        }
        if( ! logf ) {
          fprintf( stderr, "Cannot open logfile %s : %d\n", 
              S.latin1(), errno );
          logf = (FILE *)1;
        } else {
          fprintf( logf, "____ OPEN LOGFILE ____\n");
        }
      }
      if( (unsigned long)logf > 1 ) {
        vfprintf( logf, Format, l );
      }
      va_end( l );
      fflush( logf );
 }
 void LogClose( void ) {
      if( (long)logf > 1 ) {
        fprintf( logf, "____ CLOSE LOGFILE ____\n");
        if( logf != stderr ) {
          fclose( logf );
        }
        logf = 0;
      }
 }
 QString removeSpaces( const QString & X ) {
      QString Y;
      Y = X.simplifyWhiteSpace(); 
      Y.replace( QRegExp(" "), "_" );
-      owarn << X <<  " **" << Y << "**" << oendl;
+      odebug << X <<  " **" << Y << "**" << oendl;
      return Y;
 }
 //
 //
 //
 //
 //
 MyProcess::MyProcess() : QObject(), StdoutBuffer(), StderrBuffer() {
      P = new OProcess();
      connect( P, 
               SIGNAL( receivedStdout(Opie::Core::OProcess*, char*, int ) ),
               this, 
               SLOT( SLOT_Stdout(Opie::Core::OProcess*,char*,int) ) );
      connect( P, 
               SIGNAL( receivedStderr(Opie::Core::OProcess*, char*, int ) ),
               this, 
               SLOT( SLOT_Stderr(Opie::Core::OProcess*,char*,int) ) );
      connect( P, 
               SIGNAL( processExited(Opie::Core::OProcess*) ),
               this,
               SLOT( SLOT_ProcessExited(Opie::Core::OProcess*) ) );
 }
 MyProcess::~MyProcess() {
      delete P;
 }
 void MyProcess::SLOT_Stdout( Opie::Core::OProcess * , char * Buf, int len ) {
      char * LB = (char *)alloca( len + 1 );
      memcpy( LB, Buf, len );
      LB[len] = '\0';
      // now input is zero terminated
      StdoutBuffer += LB;
-      owarn << "Received " << len << " bytes on stdout" << oendl;
+      odebug << "Received " << len << " bytes on stdout" << oendl;
      // see if we have some lines (allow empty lines)
      QStringList SL = QStringList::split( "\n", StdoutBuffer, TRUE );
      for( unsigned int i = 0; i < SL.count()-1; i ++ ) {
        Log(( "Stdout : \"%s\"\n", SL[i].latin1() ) );
        emit stdoutLine( SL[i] );
      }
      // last line is rest
      StdoutBuffer = SL[ SL.count()-1 ];
 }
 void MyProcess::SLOT_Stderr( Opie::Core::OProcess * , char * Buf, int len ) {
      char * LB = (char *)alloca( len + 1 );
      memcpy( LB, Buf, len );
      LB[len] = '\0';
      // now input is zero terminated
      StderrBuffer += LB;
-      owarn << "Received " << len << " bytes on stderr" << oendl;
+      odebug << "Received " << len << " bytes on stderr" << oendl;
      // see if we have some lines (allow empty lines)
      QStringList SL = QStringList::split( "\n", StderrBuffer, TRUE );
      for( unsigned int i = 0; i < SL.count()-1; i ++ ) {
        Log(( "Stderr : \"%s\"\n", SL[i].latin1() ) );
        emit stderrLine( SL[i] );
      }
      // last line is rest
      StderrBuffer = SL[ SL.count()-1 ];
 }
 void MyProcess::SLOT_ProcessExited( Opie::Core::OProcess * ) {
      emit processExited( this );
 }
diff --git a/noncore/settings/networksettings2/networksettings2/systemfile.cpp b/noncore/settings/networksettings2/networksettings2/systemfile.cpp
index 8deef94..1b1988e 100644
--- a/noncore/settings/networksettings2/networksettings2/systemfile.cpp
+++ b/noncore/settings/networksettings2/networksettings2/systemfile.cpp
@@ -1,235 +1,235 @@
 #include <stdio.h>
 #include <qpe/qpeapplication.h>
 #include <qfileinfo.h>
 #include <qmessagebox.h>
 #include <qfile.h>
 #include <qtextstream.h>
 #include "resources.h"
 #include "systemfile.h"
 #define TEMPLATEDIR "NS2templates/"
 QString TemplDir;
 SystemFile::SystemFile( const QString & N, 
                        const QString & P,
                        bool KDI ){
      Name = N;
      Path = P;
      InAppend = 0;
      F = 0;
      // get template info
      { QString S;
        QFileInfo FI;
        // find location of templates
        TemplDir = QPEApplication::qpeDir() + "etc/" + TEMPLATEDIR;
        FI.setFile( TemplDir );
        if( ! FI.isDir() ) {
          // try current dir
          TemplDir = "./" TEMPLATEDIR;
          FI.setFile( TemplDir );
          if( ! FI.isDir() ) {
            hasPreSection = 
              hasPostSection = 
              hasPreNodeSection = 
              hasPostNodeSection = 
              hasPreDeviceSection = 
              hasPostDeviceSection = 0;
            return;
          }
        }
        // have found location
        S = TemplDir + Name + "/presection";
        FI.setFile( S );
        hasPreSection = ( FI.exists() && FI.isReadable() );
        S = TemplDir + Name + "/postsection";
        FI.setFile( S );
        hasPostSection = ( FI.exists() && FI.isReadable() );
        S = TemplDir + Name + "/prenodesection";
        FI.setFile( S );
        hasPreNodeSection = ( FI.exists() && FI.isReadable() );
        S = TemplDir + Name + "/postnodesection";
        FI.setFile( S );
        hasPostNodeSection = ( FI.exists() && FI.isReadable() );
        S = TemplDir + Name + "/predevicesection";
        FI.setFile( S );
        hasPreDeviceSection = ( FI.exists() && FI.isReadable() );
        S = TemplDir + Name + "/postdevicesection";
        FI.setFile( S );
        hasPostDeviceSection = ( FI.exists() && FI.isReadable() );
      }
      KnowsDeviceInstances = KDI;
 }
 SystemFile::SystemFile( const QString & N, bool KDI ){
      Name = N;
      Path = "";
      InAppend = 0;
      F =0;
      KnowsDeviceInstances = KDI;
      hasPreSection = 
        hasPostSection = 
        hasPreNodeSection = 
        hasPostNodeSection = 
        hasPreDeviceSection = 
        hasPostDeviceSection = 0;
 }
 SystemFile::~SystemFile( void ) {
      close();
 }
 bool SystemFile::open( void ) {
      QString Prefix = getenv( "NS2OUTPUTTO" );
      if( Prefix != "stderr" /* && Name != "interfaces" */ ) {
        // generate files where the need to be
        if( F ) {
          F->close();
          delete F;
        }
        F = new QFile( Prefix + Path + ((InAppend)?"":"bup") );
        Log(( "Open systemfile %s\n", F->name().latin1() ));
        if( ! F->open( ((InAppend)?IO_Append : 0 ) | IO_WriteOnly ) ) {
          return 0;
        }
      } else {
        if( ! F ) {
-          owarn << "!!!!!!!!!!!!!!!!!! " << oendl;
+          odebug << "!!!!!!!!!!!!!!!!!! " << oendl;
-          owarn << "!!!! TESTMODE !!!!" << oendl;
+          odebug << "!!!! TESTMODE !!!!" << oendl;
-          owarn << "!!!!!!!!!!!!!!!!!! " << oendl;
+          odebug << "!!!!!!!!!!!!!!!!!! " << oendl;
-          owarn << "!!!!" << oendl;
+          odebug << "!!!!" << oendl;
-          owarn << "!!!! GENERATE " << Path << oendl;
+          odebug << "!!!! GENERATE " << Path << oendl;
          if( InAppend ) {
-            owarn << "!!!! In APPEND mode" << oendl;
+            odebug << "!!!! In APPEND mode" << oendl;
          }
-          owarn << "!!!!" << oendl;
+          odebug << "!!!!" << oendl;
-          owarn << "!!!!!!!!!!!!!!!!!!" << oendl;
+          odebug << "!!!!!!!!!!!!!!!!!!" << oendl;
          F = new QFile();
          F->open( IO_WriteOnly, stderr );
        }
      }
      setDevice( F );
      return 1;
 }
 bool SystemFile::close( void ) {
      if( ! F || ! F->isOpen() ) {
        return 1 ;
      }
      QString Prefix = getenv( "NS2OUTPUTTO" );
      if( Prefix == "stderr" ) {
        return 1;
      }
      QString OldP = Prefix + Path + "bup";
      F->close();
      delete F;
      F = 0;
      if( ! InAppend ) {
-        owarn << "Rename " << OldP << " to " << Path << oendl;
+        odebug << "Rename " << OldP << " to " << Path << oendl;
        return ( rename( OldP.latin1(), Path.latin1() ) >= 0 );
      } 
      return 1;
 }
 bool SystemFile::preSection( void ) {
      if( hasPreSection ) {
        QFile Fl( TemplDir + Name + "/presection" );
        if( ! Fl.open( IO_ReadOnly ) )
          return 0; // error
        // copy file to this file
        F->writeBlock( Fl.readAll() );
      }
      return 1;
 }
 bool SystemFile::postSection( void ) {
      if( hasPostSection ) {
        QFile Fl( TemplDir + Name + "/postsection" );
        if( ! Fl.open( IO_ReadOnly ) )
          return 0; // error
        // copy file to this file
        F->writeBlock( Fl.readAll() );
      }
      return 1;
 }
 bool SystemFile::preNodeSection( ANetNodeInstance * NNI, long ) {
      if( hasPreNodeSection ) {
        QFile Fl( TemplDir + Name + "/prenodesection" );
        if( ! Fl.open( IO_ReadOnly ) )
          return 0; // error
        QTextStream TX( &Fl );
        QString Out;
        QString S = TX.readLine();
        while( ! TX.eof() ) {
          Out = S.
              arg(NNI->nodeClass()->name());
          (*this) << Out << endl;
          S = TX.readLine();
        }
      }
      return 1;
 }
 bool SystemFile::postNodeSection( ANetNodeInstance * NNI, long ) {
      if( hasPostNodeSection ) {
        QFile Fl( TemplDir + Name + "/postnodesection" );
        if( ! Fl.open( IO_ReadOnly ) )
          return 0; // error
        QTextStream TX( &Fl );
        QString Out;
        QString S = TX.readLine();
        while( ! TX.eof() ) {
          Out = S.
              arg(NNI->name());
          (*this) << Out << endl;
          S = TX.readLine();
        }
      }
      return 1;
 }
 bool SystemFile::preDeviceSection( ANetNode * NN ) {
      if( hasPreDeviceSection ) {
        QFile Fl( TemplDir + Name + "/predevicesection" );
        if( ! Fl.open( IO_ReadOnly ) )
          return 0; // error
        QTextStream TX( &Fl );
        QString Out;
        QString S = TX.readLine();
        while( ! TX.eof() ) {
          Out = S.arg(NN->name());
          (*this) << Out << endl;
          S = TX.readLine();
        }
      }
      return 1;
 }
 bool SystemFile::postDeviceSection( ANetNode * NN ) {
      if( hasPostDeviceSection ) {
        QFile Fl( TemplDir + Name + "/postdevicesection" );
        if( ! Fl.open( IO_ReadOnly ) )
          return 0; // error
        QTextStream TX( &Fl );
        QString Out;
        QString S = TX.readLine();
        while( ! TX.eof() ) {
          Out = S.arg(NN->name());
          (*this) << Out << endl;
          S = TX.readLine();
        }
      }
      return 1;
 }
diff --git a/noncore/settings/networksettings2/opie-networksettings2.postinst b/noncore/settings/networksettings2/opie-networksettings2.postinst
index ce43274..d1d98ac 100755
--- a/noncore/settings/networksettings2/opie-networksettings2.postinst
+++ b/noncore/settings/networksettings2/opie-networksettings2.postinst
@@ -1,9 +1,9 @@
 #!/bin/sh
 QTPB=/opt/QtPalmtop/bin
 [ ! -L ${QTPB}/networksettings2-request ] && ln -sf ${QTPB}/networksettings2 ${QTPB}/networksettings2-request
-qcop QPE/TaskBar "reloadApps()"
+${QTPB}/qcop QPE/TaskBar "reloadApps()"
 exit 0
diff --git a/noncore/settings/networksettings2/opietooth2/OTDevice.cpp b/noncore/settings/networksettings2/opietooth2/OTDevice.cpp
index 62f17a0..c6f7d5e 100644
--- a/noncore/settings/networksettings2/opietooth2/OTDevice.cpp
+++ b/noncore/settings/networksettings2/opietooth2/OTDevice.cpp
@@ -1,256 +1,256 @@
 #include <qdir.h>
 #include <qfileinfo.h>
 #include <bluezlib.h>
 /* OPIE */
 #include <opie2/odevice.h>
 #include <opie2/oprocess.h>
 #include <opie2/odebug.h>
 #include <OTDevice.h>
 using namespace Opie::Core;
 using namespace Opietooth2;
 using Opie::Core::OProcess;
 OTDevice::OTDevice( OTGateway * _OT ) : QObject(0, "device") {
      
      // initialize 
      OT = _OT;
      // detect bluetooth type
      QString a, b; // fake
      unsigned long c; // fake
      detectDeviceType( a, b, c );
      if( needsAttach() ) {
        // requires HCIATTACH
        // pid of hciattach
        m_hciattachPid = getPidOfHCIAttach();
        m_hciattach = 0;
        if( m_hciattachPid == 0 ) {
          // no pid -> not attached
          m_deviceNr = -1;
        } else {
          // system enabled
          // currently no way to figure out which attach produce which
          // hci
          m_deviceNr = 0;
        }
      } else {
        m_deviceNr = 0;
      }
 }
 OTDevice::~OTDevice(){
      if( needsAttach() && m_hciattach ) {
        // does not auto stop bluetooth
        m_hciattach->detach();
        delete m_hciattach;
      }
 }
 bool OTDevice::attach(){
      if( needsAttach() && m_hciattachPid == 0 ) {
        QString Dev, Mode;
        unsigned long Spd;
        detectDeviceType( Dev, Mode, Spd );
        // not yet started
        m_hciattach = new OProcess();
        *m_hciattach << "hciattach";
        *m_hciattach << "-p"; // so that it prints its pid
        *m_hciattach << Dev 
                     << Mode 
                     << QString().setNum(Spd);
        connect( m_hciattach, 
                 SIGNAL(receivedStdout(Opie::Core::OProcess*, char*, int ) ),
                 this, SLOT
                 (slotStdOut(Opie::Core::OProcess*,char*,int) ) );
        connect( m_hciattach, 
                 SIGNAL(receivedStderr(Opie::Core::OProcess*, char*, int ) ),
                 this, SLOT
                 (slotStdErr(Opie::Core::OProcess*,char*,int) ) );
        // we need to start this in 'dontcare' mode because
        // if qpe exists we want the hci to keep running
        if( ! m_hciattach->start( OProcess::DontCare, 
                                  OProcess::AllOutput
                                ) ){
          emit error( tr( "Could not start hciattach" ) );
          delete m_hciattach;
          m_hciattach = 0;
          return FALSE;
        }
      }
      return TRUE;
 }
 bool OTDevice::detach(){
      if( needsAttach() && m_hciattachPid ) {
        if( m_hciattach ) {
          delete m_hciattach;
          m_hciattach = 0;
        }
        if( kill( m_hciattachPid, 9) < 0 ) {
-          owarn << "could not stop " << errno << oendl;
+          odebug << "could not stop " << errno << oendl;
          emit error( tr( "Could not stop process" ) );
          return FALSE;
        }
        m_hciattachPid = 0;
        emit isEnabled( m_deviceNr, 0 );
        m_deviceNr = -1;
      }
      return TRUE;
 }
 bool OTDevice::isAttached()const{
      return ! needsAttach() || m_hciattachPid != 0;
 }
 bool OTDevice::checkAttach(){
      if( ! needsAttach() ) {
        m_deviceNr = 0;
        emit isEnabled( 0, 1 );
        return TRUE;
      }
      if( m_hciattachPid ) {
        QString S;
        S.setNum( m_hciattachPid );
        QDir D( "/proc" );
        if( !D.exists( S ) ) {
          // down
          m_hciattachPid = 0;
          emit isEnabled( m_deviceNr, 0 );
          m_deviceNr = -1;
        }
      } else {
        // check
        m_hciattachPid = getPidOfHCIAttach();
        if ( m_hciattachPid ) {
          m_deviceNr = 0;
          emit isEnabled( m_deviceNr, 1 );
        }
      }
      return m_hciattachPid != 0;
 }
 void OTDevice::slotStdOut(OProcess* proc, char* , int ) {
      if( proc == m_hciattach ) {
        m_hciattach->detach();
        // system enabled
        // currently no way to figure out which attach produce which
        // hci
        if( m_deviceNr == -1 ) {
          m_deviceNr = 0;
          emit isEnabled( m_deviceNr, 1 );
        }
      } 
 }
 void OTDevice::slotStdErr(OProcess* proc, char* chars, int len) {
      if(proc == m_hciattach && len >= 1 ){
        // collect output
        QCString string( chars, len+1 ); // \0 == +1
        QString m_output;
        m_output.append( string.data() );
-        owarn << m_output << oendl;
+        odebug << m_output << oendl;
      }
 }
 pid_t OTDevice::getPidOfHCIAttach( void ) {
      if( needsAttach() ) {
        // not yet attached -> perhaps now ?
        // load /proc dir and check if command name contains hciattach
        QRegExp R("[0-9]+");
        QDir ProcDir( "/proc" );
        QFileInfo FI;
        QStringList EL = ProcDir.entryList( QDir::Dirs );
        // print it out
        for ( QStringList::Iterator it = EL.begin(); 
              it != EL.end(); 
              ++it ) {
          if( R.match( (*it) ) >= 0 ) {
            // is pid
            // get command being executed
            FI.setFile( ProcDir.path()+"/"+ (*it) + "/exe" );
            // get the link
            if( FI.readLink().right( 9 ) == "hciattach" ) {
              // this is hci attach process
              return (*it).toULong();
              break;
            }
          }
        }
      }
      return 0;
 }
 void OTDevice::detectDeviceType( QString & Device,
                                 QString & Mode,
                                 unsigned long & Speed ) {
     // detect device type and determine parms
-     owarn << "Detecting device" << oendl;
+     odebug << "Detecting device" << oendl;
     switch ( ODevice::inst()->model() ) {
      case Model_iPAQ_H39xx:
          Device = "/dev/tts/1";
          Mode = "bcsp";
          Speed = 921600;
          NeedsAttach = 1;
          break;
      case Model_iPAQ_H5xxx:
          Device = "/dev/tts/1";
          Mode = "any";
          Speed = 921600;
          NeedsAttach = 1;
          break;
      case Model_GenuineIntel :
          Device = "";
          Mode = "";
          Speed = 0;
          NeedsAttach = 0;
          break;
      default:
          Device = "/dev/ttySB0";
          Mode = "bcsp";
          Speed = 230400;
          NeedsAttach = 1;
          break;
      }
 }
 QString OTDevice::getRFCommDevicePattern( void ) {
      QDir D( "/dev/bluetooth/rfcomm" );
      if( D.exists() ) {
        // devfs
        return QString( "/dev/bluetooth/rfcomm/%1" );
      }
      // regular 'dev' directory
      return QString( "/dev/rfcomm%1" );
 }
diff --git a/noncore/settings/networksettings2/opietooth2/OTDriver.cpp b/noncore/settings/networksettings2/opietooth2/OTDriver.cpp
index 8bd7919..a7ee662 100644
--- a/noncore/settings/networksettings2/opietooth2/OTDriver.cpp
+++ b/noncore/settings/networksettings2/opietooth2/OTDriver.cpp
@@ -1,744 +1,744 @@
 /***************************************************************************
 *   Copyright (C) 2003 by Mattia Merzi                                    *
 *   ottobit@ferrara.linux.it                                              *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 ***************************************************************************/
 #include <opie2/odebug.h>
 #include <qtimer.h>
 #include <sys/poll.h>
 #include <bluezlib.h>
 #include <OTGateway.h>
 #include <OTDriver.h>
 #include <OTHCISocket.h>
 using namespace Opietooth2;
 static struct {
    const char  *str;
    unsigned short rev;
 } csr_map[] = {
    { "HCI 11.2 (bc01b)",   114 },
    { "HCI 11.3 (bc01b)",   115 },
    { "HCI 12.1 (bc01b)",   119 },
    { "HCI 12.3 (bc01b)",   134 },
    { "HCI 12.7 (bc01b)",   188 },
    { "HCI 12.8 (bc01b)",   218 },
    { "HCI 12.9 (bc01b)",   283 },
    { "HCI 13.10 (bc01b)",  309 },
    { "HCI 13.11 (bc01b)",  351 },
    { "HCI 16.4 (bc01b)",   523 },
    { "HCI 14.3 (bc02x)",   272 },
    { "HCI 14.6 (bc02x)",   336 },
    { "HCI 14.7 (bc02x)",   373 },
    { "HCI 14.8 (bc02x)",   487 },
    { "HCI 15.3 (bc02x)",   443 },
    { "HCI 16.4 (bc02x)",   525 },
    { NULL, 0}
 };
 static char *services[] = { "Positioning",
                            "Networking",
                            "Rendering",
                            "Capturing",
                            "Object Transfer",
                            "Audio",
                            "Telephony",
                            "Information" };
 static char *major_devices[] = { "Miscellaneous",
                                 "Computer",
                                 "Phone",
                                 "LAN Access",
                                 "Audio/Video",
                                 "Peripheral",
                                 "Imaging",
                                 "Uncategorized" };
 typedef struct {
    short Minor;
    const char * Description;
 } ClassMap_t;
 static ClassMap_t MapMiscClass[] = {
    { -1, "" }
 };
 static ClassMap_t MapUnclassifiedClass[] = {
    { -1, "" }
 };
 static ClassMap_t MapComputerClass[] = {
    { 0, "Uncategorized" } ,
    { 1, "Desktop workstation" } ,
    { 2, "Server" } ,
    { 3, "Laptop" } ,
    { 4, "Handheld" } ,
    { 5, "Palm" } ,
    { 6, "Wearable" },
    { -1, 0 }
 };
 static ClassMap_t MapPhoneClass[] = {
    { 0, "Uncategorized" },
    { 1, "Cellular" },
    { 2, "Cordless" },
    { 3, "Smart phone" },
    { 4, "Wired modem or voice gateway" },
    { 5, "Common ISDN Access" },
    { 6, "Sim Card Reader" },
    { -1, 0 }
 };
 static ClassMap_t MapAVClass[] = {
    { 0, "Uncategorized" },
    { 1, "Device conforms to the Headset profile" },
    { 2, "Hands-free" },
    { 3, 0 },
    { 4, "Microphone" },
    { 5, "Loudspeaker" },
    { 6, "Headphones" },
    { 7, "Portable Audio" },
    { 8, "Car Audio" },
    { 9, "Set-top box" },
    { 10, "HiFi Audio Device" },
    { 11, "VCR" },
    { 12, "Video Camera" },
    { 13, "Camcorder" },
    { 14, "Video Monitor" },
    { 15, "Video Display and Loudspeaker" },
    { 16, "Video Conferencing" },
    { 17, 0 },
    { 18, "Gaming/Toy" },
    { -1, 0 }
 };
 static ClassMap_t MapPeripheralClass[] = {
    { 16, "Keyboard" },
    { 32, "Pointing device" },
    { 48, "Combo keyboard/pointing device" },
    { -1, 0 }
 };
 typedef struct {
    int Major;
    ClassMap_t * Map;
 } MainClassMap_t;
 static MainClassMap_t MainClasses[] = {
    { 0, MapMiscClass },
    { 1, MapComputerClass },
    { 2, MapPhoneClass },
    { 3, 0 }, // special case
    { 4, MapAVClass },
    { 5, MapPeripheralClass },
    { 6, 0 }, // special case
    { 63, MapUnclassifiedClass },
    { -1, 0 }
 };
 OTDriver::OTDriver( OTGateway * _OT, struct hci_dev_info* di) : QObject( _OT ), Address() {
    OT = _OT;
    IsUp = 0;
    Socket = 0;
    init(di);
-    owarn << "Driver " << devname() << oendl;
+    odebug << "Driver " << devname() << oendl;
    AutoClose = new QTimer( this );
    connect( AutoClose,
             SIGNAL( timeout() ),
             this,
             SLOT( SLOT_CloseFd() )
           );
 }
 OTDriver::~OTDriver() {
    closeSocket();
    SLOT_CloseFd();
 }
 void OTDriver::SLOT_CloseFd( void ){
    if ( isOpen() ) {
      AutoClose->stop();
      ::close( fd() );
      setfd( -1 );
    }
 }
 void OTDriver::init(struct hci_dev_info* di) {
    Dev = di->name;
    setDevId(di->dev_id);
    setType(di->type);
    setFlags(di->flags);
    Address.setBDAddr( di->bdaddr );
    setFeatures(di->features);
    setfd( -1 ); // not open
    Manufacturer = "";
 }
 // internal reinitialize
 void OTDriver::reinit() {
    bool Old;
    Old = IsUp;
    if( currentState() < 0 )
      return;
    if( Old != IsUp ) {
      // state changes
      emit stateChange( this, IsUp );
    }
 }
 // requested by application
 int OTDriver::currentState() {
    struct hci_dev_info di;
    //  uint16_t tmp_dev_id = device_info.dev_id;
    //  bzero(&device_info,sizeof(struct hci_dev_info));
    //  device_info.dev_id = tmp_dev_id;
    memset( &di, 0, sizeof( di ) );
    di.dev_id = Dev_id;
    if( ioctl( OT->getSocket(), HCIGETDEVINFO, (void*)&di) < 0 ) {
      SLOT_CloseFd();
      return -1;
    } else {
      // load new info
      init(&di);
    }
    return IsUp;
 }
 bool OTDriver::open() {
    // (re)start single shot close
    AutoClose->start( 30000, TRUE );
    if( isOpen() )
      // is open
      return 1;
    setfd(hci_open_dev(devId()));
    if (fd() < 0) {
      emit error( tr( "Can't open device %1. %2 : %3" ).
                      arg( devname() ).
                      arg( errno ).
                      arg( strerror(errno) )
                );
      return 0;
    }
    return 1;
 }
 QString OTDriver::name() {
    char name[1000];
    if( ! open() ) {
      return tr("Cannot open");
    }
    if (hci_read_local_name( fd(), sizeof(name), name, 1000) < 0) {
      if (errno != ETIMEDOUT) {
        emit error( tr("Can't read local name on %1. %2 : %3.  Default to %4" ).
            arg( devname() ).
            arg( errno  ).
            arg( strerror(errno) ).
            arg( devname() )
          );
      } // ETIMEDOUT error is quite normal, device is down ... I think ! :)
      strcpy(name,devname().latin1());
    }
    return QString(name);
 }
 void OTDriver::setFlags(unsigned long flags) {
    //  kdDebug() << "Setting OTDriver Values ..." << endl;
    IsUp = BTVALUE(hci_test_bit(HCI_UP, &flags));
    if (isUp()) {
        setIScan(BTVALUE(hci_test_bit(HCI_ISCAN, &flags)));
        setPScan(BTVALUE(hci_test_bit(HCI_PSCAN, &flags)));
        setAuthentication(BTVALUE(hci_test_bit(HCI_AUTH, &flags)));
        setEncryption(BTVALUE(hci_test_bit(HCI_ENCRYPT, &flags)));
    } else {
        setIScan(BT_UNKNOWN);
        setPScan(BT_UNKNOWN);
        setAuthentication(BT_UNKNOWN);
        setEncryption(BT_UNKNOWN);
    }
 }
 QString OTDriver::revision() {
    struct hci_version ver;
    if( ! open() ) {
      return tr("Cannot open");
    }
    if (hci_read_local_version(fd(), &ver, 1000) < 0) {
      emit error( tr( "Can't read revision info on %1. %2 : %3" ).
          arg( devname() ).
          arg( errno ).
          arg( strerror(errno) ) );
      return QString();
    }
    setManufacturer(ver.manufacturer);
    switch (ver.manufacturer) {
      case 0:
        return getRevEricsson();
        break;
      case 10:
        return getRevCsr(ver.hci_rev);
        break;
      default:
        return tr( "Unsupported manufacturer" );
        break;
    }
 }
 QString OTDriver::getRevEricsson() {
    char revision[102];
    struct hci_request rq;
    if( ! open() ) {
      return QString( "Cannot open" );
    }
    memset(&rq, 0, sizeof(rq));
    rq.ogf = 0x3f;
    rq.ocf = 0x000f;
    rq.cparam = NULL;
    rq.clen = 0;
    rq.rparam = &revision;
    rq.rlen = sizeof(revision);
    if (hci_send_req(fd(), &rq, 1000) < 0) {
      emit error( tr( "Can't read revision info on %1. %2 : %3" ).
          arg( devname() ).
          arg( errno ).
          arg( strerror(errno) ) );
      return QString();
    }
    return QString( revision+1 );
 }
 QString OTDriver::getRevCsr( unsigned short rev) {
    int i;
    for (i = 0; csr_map[i].str; i++)
      if (csr_map[i].rev == rev) {
        return QString( csr_map[i].str );
      }
    return tr( "Unknown firmware" );
 }
 int OTDriver::reset() {
    if( ! open() ) {
      return 0;
    }
    if( ioctl(fd(), HCIDEVRESET, devId()) < 0 ) {
      if( errno != EALREADY ) {
        emit error( tr( "Reset failed for %1. %2 : %3" ).
            arg( devname() ).
            arg( errno ).
            arg( strerror(errno) ) );
        if (errno == EACCES) {
          return EACCES;
        }
      }
    }
    return 0;
 }
 void OTDriver::setUp( bool M )  {
    if( M && ! isUp() ) {
      bringUp();
    } else if( ! M && isUp() ) {
      bringDown();
    }
 }
 void OTDriver::bringUp() {
-    owarn << "bringUp : " << Dev << oendl;
+    odebug << "bringUp : " << Dev << oendl;
    if( ! open() ) {
      return;
    }
    if (! isUp()) {
      if( ioctl(fd(), HCIDEVUP, devId()) < 0 ) {
        if( errno != EALREADY ) {
          emit error( tr( "Cannot bring interface %1 up. %2 : %3" ).
              arg( devname() ).
              arg( errno ).
              arg( strerror(errno) ) );
        }
        return;
      }
      // have to wait a bit for the 'up' to become active
      QTimer::singleShot( 3000, this, SLOT( reinit() ) );
    }
 }
 void OTDriver::bringDown() {
-    owarn << "bringDown : " << Dev << oendl;
+    odebug << "bringDown : " << Dev << oendl;
    if( ! open() ) {
      return;
    }
    if ( isUp() ) {
      if( ioctl(fd(), HCIDEVDOWN, devId()) < 0 ) {
        if( errno != EALREADY ) {
          emit error( tr( "Cannot bring interface %1 down. %2 : %3" ).
              arg( devname() ).
              arg( errno ).
              arg( strerror(errno) ) );
        }
        return;
      }
      reinit();
    }
 }
 void OTDriver::setScanMode(bool iscan, bool pscan) {
    struct hci_dev_req dr;
    if( ! open() ) {
      return;
    }
    dr.dev_id  = devId();
    dr.dev_opt = SCAN_DISABLED;
    if( iscan&&(!pscan) )
      dr.dev_opt = SCAN_INQUIRY;
    else if( pscan&&(!iscan) )
      dr.dev_opt = SCAN_PAGE;
    else if( pscan&&iscan )
      dr.dev_opt = SCAN_PAGE | SCAN_INQUIRY;
    if( ioctl(fd(), HCISETSCAN, (unsigned long)&dr) < 0 ) {
      if( errno != EALREADY ) {
        emit error( tr( "Can't set scan mode on %1. %2 : %3" ).
            arg( devname() ).
            arg( errno ).
            arg( strerror(errno) ) );
      }
      return;
    }
    reinit();
 }
 void OTDriver::changeDevName(const char* name) {
    if( ! open() ) {
      return;
    }
    if (hci_write_local_name(fd(), name, 1000) < 0) {
      emit error( tr( "Can't change local name on %1. %2 : %3" ).
          arg( devname() ).
          arg( errno ).
          arg( strerror(errno) ) );
    }
 }
 void OTDriver::changeAuthentication(bool _auth) {
    struct hci_dev_req dr;
    if( ! open() ) {
      return;
    }
    dr.dev_id  = devId();
    dr.dev_opt = _auth?AUTH_ENABLED:AUTH_DISABLED;
   
    if (ioctl(fd(),HCISETAUTH,(unsigned long)&dr) < 0) {
      if( errno != EALREADY ) {
        emit error( tr( "Can't change authentication on %1. %2 : %3" ).
            arg( devname() ).
            arg( errno ).
            arg( strerror(errno) ) );
      }
      return;
    }
    reinit();
 }
 void OTDriver::changeEncryption(bool _encrypt) {
    struct hci_dev_req dr;
    if( ! open() ) {
      return;
    }
    dr.dev_id  = devId();
    dr.dev_opt = _encrypt?ENCRYPT_P2P:ENCRYPT_DISABLED;
        
    if (ioctl(fd(),HCISETENCRYPT,(unsigned long)&dr) < 0) {
      if( errno != EALREADY ) {
        emit error( tr( "Can't change encryption on %1. %2 : %3" ).
            arg( devname() ).
            arg( errno ).
            arg( strerror(errno) ) );
      }
      return;
    }
    reinit();
 }
 void OTDriver::changeClass ( unsigned char service,  
                             unsigned char major,
                             unsigned char minor ) {
    unsigned long cod = 0;
    cod = (service << 16) |
          (major   <<  8) |
          (minor        ) ;
    if( ! open() ) {
      return;
    }
    if ( hci_write_class_of_dev(fd(),cod,1000) < 0 ) {
      emit error( tr( "Can't change class informations for %1. %2 : %3" ).
          arg( devname() ).
          arg( errno ).
          arg( strerror(errno) ) );
      return;
    }
 }
 void OTDriver::getClass( QString & service,  
                         QString & device ) {
    unsigned char cls[3];
    if( ! open() ) {
      return;
    }
    if ( hci_read_class_of_dev(fd(),cls,1000) < 0 ) {
      emit error( tr( "Can't read class information for %1. %2 : %3" ).
          arg( devname() ).
          arg( errno ).
          arg( strerror(errno) ) );
      return;
    }
    if( cls[2] ) {
      int first = 1;
      for ( unsigned int s = 0; s < sizeof(*services); s++) {
        if (cls[2] & (1 << s)) {
          if( !first )
            service += ", ";
          service += services[s];
          first = 0;
        }
      }
    } else {
      service = "unspecified";
    }
    MainClassMap_t * MCM = MainClasses;
    int major = cls[1] & 0x1f;
    int minor = cls[0] >> 2;
    if( (unsigned)(cls[1] & 0x1f) > sizeof(*major_devices)) {
      device = tr("Invalid Device Class");
      return;
    }
    device = major_devices[cls[1] & 0x1f];
    while( MCM->Major != -1 ) {
      if( major == MCM->Major ) {
        // this class
        ClassMap_t * CM = MCM->Map;
        if( MCM->Map ) {
          while( CM->Minor != -1 ) {
            if( minor == CM->Minor ) {
              break;
            }
            CM ++;
          }
          device = CM->Description;
        } else {
          // special case
          if( major == 3 ) {
            /* lan access */
            if( minor == 0 ) {
              device = "Uncategorized";
            } else {
              switch( minor / 8 ) {
                case 0:
                  device = "Fully available";
                  break;
                case 1:
                  device = "1-17% utilized";
                  break;
                case 2:
                  device = "17-33% utilized";
                  break;
                case 3:
                  device = "33-50% utilized";
                  break;
                case 4:
                  device = "50-67% utilized";
                  break;
                case 5:
                  device = "67-83% utilized";
                  break;
                case 6:
                  device = "83-99% utilized";
                  break;
                case 7:
                  device = "No service available";
                  break;
              }
            }
          } else if( major == 6 ) { /* imaging */
            if (minor & 4)
              device = "Display";
            if (minor & 8)
              device = "Camera";
            if (minor & 16)
              device = "Scanner";
            if (minor & 32)
              device = "Printer";
          }
        }
        break;
      }
      MCM ++;
    }
    if( MCM->Major == -1 ) {
      device = "Unknown (reserved) minor device class";
    }
 }
 QString OTDriver::strType() {
    return QString( hci_dtypetostr(Type) );
 }
 void OTDriver::setFeatures( unsigned char * _f) {
    Features = lmp_featurestostr(_f, NULL, 255);
 }
 void OTDriver::setManufacturer(int compid) {
    Manufacturer = bt_compidtostr(compid);
 }
 OTHCISocket * OTDriver::openSocket( void ) {
    if( ! Socket ) {
-      owarn << "Open HCI socket to " << devname() << oendl;
+      odebug << "Open HCI socket to " << devname() << oendl;
      Socket = new OTHCISocket( this );
    }
    return Socket;
 }
 void OTDriver::closeSocket( void ) {
    if( Socket ) {
-      owarn << "Close HCI socket to " << devname() << oendl;
+      odebug << "Close HCI socket to " << devname() << oendl;
      delete Socket;
      Socket = 0;
    }
 }
 QString OTDriver::getPeerName( const OTDeviceAddress & PAddr ) {
      QString S;
      char name[100 ];
      if( ! open() ) {
        return QString("N/A");
      }
      if( hci_read_remote_name( fd(), 
                                &(PAddr.getBDAddr()), 
                                sizeof(name), 
                                name, 
                                100000 ) < 0 ) {
        return QString( "N/A" );
      }
      return QString( name );
 }
 long OTDriver::getLinkQuality( const OTDeviceAddress & Addr ) {
      struct hci_conn_info_req *cr;
      struct hci_request rq;
      read_rssi_rp rp;
      uint16_t handle;
      if( ! open() ) {
        return 0;
      }
      cr = (struct hci_conn_info_req *)malloc(
                sizeof(*cr) + sizeof(struct hci_conn_info));
      if (!cr)
        return 0;
      bacpy( &(cr->bdaddr), &(Addr.getBDAddr()) );
      cr->type = ACL_LINK;
      if (ioctl( fd(), HCIGETCONNINFO, (unsigned long) cr) < 0) {
-        owarn << "Get connection info failed" << oendl;
+        odebug << "Get connection info failed" << oendl;
        free(cr);
        return 0;
      }
      handle = htobs(cr->conn_info->handle);
      free(cr);
      memset(&rq, 0, sizeof(rq));
      rq.ogf    = OGF_STATUS_PARAM;
      rq.ocf    = OCF_READ_RSSI;
      rq.cparam = &handle;
      rq.clen   = 2;
      rq.rparam = &rp;
      rq.rlen   = GET_LINK_QUALITY_RP_SIZE;
      if (hci_send_req( fd(), &rq, 100) < 0) {
-         owarn << "Get connection info failed" << oendl;
+         odebug << "Get connection info failed" << oendl;
         return 0;
      }
      if( rp.status ) {
-        owarn << QString().sprintf("HCI get_link_quality cmd failed (0x%2.2X)", rp.status) << oendl;
+        odebug << QString().sprintf("HCI get_link_quality cmd failed (0x%2.2X)", rp.status) << oendl;
        return 0;
      }
      return rp.rssi+50;
 }
diff --git a/noncore/settings/networksettings2/opietooth2/OTDriverList.cpp b/noncore/settings/networksettings2/opietooth2/OTDriverList.cpp
index f703834..e5af742 100644
--- a/noncore/settings/networksettings2/opietooth2/OTDriverList.cpp
+++ b/noncore/settings/networksettings2/opietooth2/OTDriverList.cpp
@@ -1,86 +1,86 @@
 /***************************************************************************
 *   Copyright (C) 2003 by Mattia Merzi                                    *
 *   ottobit@ferrara.linux.it                                              *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 ***************************************************************************/
 #include <malloc.h>
 #include <bluezlib.h>
 #include <opie2/odebug.h>
 #include <OTDriverList.h>
 #include <OTGateway.h>
 #include <OTDriver.h>
 using namespace Opietooth2;
 OTDriverList::OTDriverList( OTGateway * _OT ) : QVector<OTDriver>() {
    OT = _OT;
    setAutoDelete( true );
 }
 OTDriverList::~OTDriverList() {
 }
 void OTDriverList::update() {
    struct hci_dev_list_req *dl;
    struct hci_dev_req *dr;
    struct hci_dev_info di;
    int cur;
    dl = 0;
    cur = 0;
    do {
      cur += 5;
      dl = (struct hci_dev_list_req*)
          ::realloc( dl, sizeof( struct hci_dev_list_req ) +
                       ( cur * sizeof(struct hci_dev_req) )
                 );
      if( dl == 0 ) {
        // memory problem
        exit(1);
      }
      dl->dev_num = cur;
      if( ioctl( OT->getSocket(), HCIGETDEVLIST, (void*)dl) ) {
-        owarn << "WARNING : cannot read device list. "
+        odebug << "WARNING : cannot read device list. "
              << errno 
              << strerror( errno ) << oendl;
        return;
      }
      // if num == cur perhaps we did not get all devices yet
    } while( dl->dev_num == cur );
    if( dl->dev_num != count() ) {
      // new or missing devices
      clear();
      dr = dl->dev_req;
      resize( dl->dev_num );
      for( cur=0; cur < dl->dev_num; cur ++) {
          memset( &di, 0, sizeof( di ) );
          di.dev_id = (dr+cur)->dev_id;
          // get device info 
          if( ioctl( OT->getSocket(), HCIGETDEVINFO, (void*)&di) != 0 )
              continue;  // uh ?
          insert( cur, new OTDriver( OT, &di ) );
      }
-      owarn << "Found " << count() << " devices" << oendl;
+      odebug << "Found " << count() << " devices" << oendl;
      ::free( dl );
    }
 }
diff --git a/noncore/settings/networksettings2/opietooth2/OTGateway.cpp b/noncore/settings/networksettings2/opietooth2/OTGateway.cpp
index 6531cf6..e8137dd 100644
--- a/noncore/settings/networksettings2/opietooth2/OTGateway.cpp
+++ b/noncore/settings/networksettings2/opietooth2/OTGateway.cpp
@@ -1,773 +1,773 @@
 #include <qmessagebox.h>
 #include <qfile.h>
 #include <qdir.h>
 #include <qtextstream.h>
 #include <qpixmap.h>
 #include <qvector.h>
 #include <qpe/resource.h>
 #include <opie2/odebug.h>
 #include <bluezlib.h>
 #include <OTDevice.h>
 #include <OTDriver.h>
 #include <OTInquiry.h>
 #include <OTDriverList.h>
 #include <OTDeviceAddress.h>
 #include <OTGateway.h>
 using namespace Opietooth2;
 // single instance
 OTGateway * OTGateway::SingleGateway = 0;
 int OTGateway::UseCount = 0;
 OTGateway * OTGateway::getOTGateway( void ) {
      if(SingleGateway == 0 ) {
        SingleGateway = new OTGateway();
      }
      UseCount ++;
      return SingleGateway;
 }
 void OTGateway::releaseOTGateway( void ) {
      UseCount --;
      if( UseCount == 0 ) {
        delete SingleGateway;
        SingleGateway = 0;
      }
 }
 // open bluetooth system
 OTGateway::OTGateway( void ) : QObject( 0, "OTGateway" ),
                               AllDrivers( this ),
                               AllPeers() {
      ErrorConnectCount = 0;
      TheOTDevice = 0;
      Scanning = 0;
      AllPeersModified = 0;
      AllPeers.setAutoDelete( TRUE );
      if ( ( HciCtl = socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI)) < 0) {
        SLOT_ShowError( tr( "error opening hci socket" ) );
        return;
      }
      // load all known devices
      updateDrivers();
      // load all peers we have ever seen
      loadKnownPeers();
      // iterate over drivers and find active connections
      // adding/updating peers
      loadActiveConnections();
      // check every 4 seconds the state of BT
      timerEvent(0);
      RefreshTimer = -1;
      setRefreshTimer( 4000 );
      // load known link keys
      readLinkKeys();
 }
 // close bluetooth system
 OTGateway::~OTGateway( void ) {
      if( AllPeersModified ) {
        saveKnownPeers();
      }
      if( Scanning )
        delete Scanning;
      if( TheOTDevice )
        delete TheOTDevice;
      if( HciCtl >= 0 ) {
        ::close( HciCtl );
      }
 }
 void OTGateway::setRefreshTimer( int T ) {
      if( RefreshTimer != -1 ) {
        killTimer( RefreshTimer );
      }
      if( T == 0 ) 
        T = 4000;
      RefreshTimer = startTimer( T );
 }
 OTDevice * OTGateway::getOTDevice( ) {
      if( TheOTDevice == 0 ) {
        // load bluetooth device and check state
        TheOTDevice = new OTDevice( this );
        connect( TheOTDevice, 
                 SIGNAL( isEnabled( int, bool ) ),
                 this, 
                 SLOT( SLOT_Enabled( int, bool ) ) );
        connect( TheOTDevice, 
                 SIGNAL( error( const QString & ) ),
                 this, 
                 SLOT( SLOT_ShowError( const QString & ) ) );
      }
      return TheOTDevice;
 }
 // start bluetooth (if stopped)
 // return TRUE if started
 void OTGateway::SLOT_SetEnabled( bool Mode ) {
      if( Mode ) {
        SLOT_Enable();
        return;
      }
      SLOT_Disable();
 }
 void OTGateway::SLOT_Enable() {
      getOTDevice()->attach();
 }
 void OTGateway::SLOT_Disable() {
      getOTDevice()->detach();
 }
 bool OTGateway::needsEnabling() {
      return getOTDevice()->needsAttach();
 }
 bool OTGateway::isEnabled() {
      if( getOTDevice()->deviceNr() >= 0 &&
          driver( getOTDevice()->deviceNr() )->isUp() )
        return TRUE;
      // else check system
      return getOTDevice()->isAttached();
 }
 void OTGateway::SLOT_ShowError( const QString & S ) {
-      owarn << S << oendl;
+      odebug << S << oendl;
      if( ErrorConnectCount > 0 ) {
        // pass error
        emit error( QString( "<p>" ) + S + "</p>" );
        return;
      }
      QMessageBox::warning( 0,
          tr("OTGateway error"),
          S );
 }
 void OTGateway::connectNotify( const char * S ) {
      if( S && strcmp( S, "error(const QString&)" ) == 0 ) {
        ErrorConnectCount ++;
      }
 }
 void OTGateway::disconnectNotify( const char * S ) {
      if( S && strcmp( S, "error(const QString&)" ) == 0 ) {
        ErrorConnectCount --;
      }
 }
 void OTGateway::timerEvent( QTimerEvent * ) {
      OTDriver * D;
      unsigned int oldc = AllDrivers.count();
      bool old;
      AllDrivers.update();
      if( oldc != AllDrivers.count() ) {
        updateDrivers();
      } else {
        for( unsigned int i = 0;
             i < AllDrivers.count();
             i ++ ) {
          D = AllDrivers[i];
          old = D->isUp();
          if( D->currentState() >= 0 ) {
            if( old != D->isUp() ) {
              emit stateChange( D, D->isUp() );
            }
          } else {
            // if one driver is unable to provide info
            // we refresh all devices
            updateDrivers();
            return;
          }
        }
      }
 }
 void OTGateway::SLOT_Enabled( int id, bool Up ) {
-      owarn << "device " << id << " state " << Up << oendl;
+      odebug << "device " << id << " state " << Up << oendl;
      if( Up ) {
        // device is up -> detect it
        updateDrivers();
        if( (unsigned)id >= AllDrivers.count() ) {
          // to make sure that the driver really IS detected
          AllDrivers[id]->bringUp();
        }
      } // if DOWN device already down
      emit deviceEnabled( Up );
 }
 void OTGateway::updateDrivers( void ) {
      OTDriver * D;
      AllDrivers.update();
-      owarn << "updated drivers. now " << AllDrivers.count() << oendl;
+      odebug << "updated drivers. now " << AllDrivers.count() << oendl;
      // connect signals for each driver
      for( unsigned int i = 0;
           i < AllDrivers.count();
           i ++ ) {
        D = AllDrivers[i];
        connect( D, 
                 SIGNAL( error( const QString & ) ),
                 this, 
                 SLOT( SLOT_ShowError( const QString & ) )
               );
        connect( D, 
                 SIGNAL( stateChange( OTDriver *, bool ) ),
                 this, 
                 SIGNAL( stateChange( OTDriver *, bool ) )
               );
        connect( D, 
                 SIGNAL( driverDisappeared( OTDriver * ) ),
                 this, 
                 SLOT( SLOT_DriverDisappeared( OTDriver * ) )
               );
      }
      // verify main device too
      if( TheOTDevice )
        TheOTDevice->checkAttach();
      // set to default scanning hardware
      setScanWith( 0 );
      emit driverListChanged();
 }
 void OTGateway::SLOT_DriverDisappeared( OTDriver * D ) {
-      owarn << "Driver " << D->devname() << " when offline" << oendl;
+      odebug << "Driver " << D->devname() << " when offline" << oendl;
      updateDrivers();
 }
 void OTGateway::scanNeighbourhood( OTDriver * D ) {
      if( Scanning ) {
        stopScanOfNeighbourhood();
      }
      if( D ) {
        setScanWith( D );
      }
      Scanning = new OTInquiry( scanWith() );
      connect( Scanning,
               SIGNAL( peerFound( OTPeer *, bool )),
               this,
               SLOT( SLOT_PeerDetected( OTPeer *, bool ) )
             );
      connect( Scanning,
               SIGNAL( finished()),
               this,
               SLOT( SLOT_FinishedDetecting() )
             );
      // start scanning
      Scanning->inquire( 30.0 );
 }
 OTPeer* OTGateway::findPeer( const OTDeviceAddress & Addr ) {
      for( unsigned int i = 0 ; i < AllPeers.count(); i ++ ) {
        if( AllPeers[i]->address() == Addr ) {
          return AllPeers[i];
        }
      }
      return 0;
 }
 OTDriver* OTGateway::findDriver( const OTDeviceAddress & Addr ) {
      for( unsigned int i = 0 ; i < AllDrivers.count(); i ++ ) {
        if( AllDrivers[i]->address() == Addr ) {
          return AllDrivers[i];
        }
      }
      return 0;
 }
 void OTGateway::SLOT_PeerDetected( OTPeer * P, bool IsNew ) {
      if( IsNew ) {
        // new peer
-        owarn << "New peer " << P->name() << oendl;
+        odebug << "New peer " << P->name() << oendl;
        addPeer( P );
      }
      emit detectedPeer( P, IsNew );
 }
 void OTGateway::addPeer( OTPeer * P ) {
      AllPeers.resize( AllPeers.size()+1);
      AllPeers.insert( AllPeers.size()-1, P );
      AllPeersModified = 1;
 }
 void OTGateway::removePeer( OTPeer * P ) {
      int i = AllPeers.find( P );
      if( i ) {
        AllPeers.remove( i );
        AllPeersModified = 1;
      }
 }
 void OTGateway::stopScanOfNeighbourhood( void ) {
      if( Scanning ) {
        delete Scanning;
        Scanning = 0;
      }
 }
 void OTGateway::SLOT_FinishedDetecting() {
      stopScanOfNeighbourhood();
      emit finishedDetecting();
 }
 const char * OTGateway::deviceTypeToName( int cls ) {
    switch ( (cls & 0x001F00) >> 8) {
      case 0x00:
        return "misc";
      case 0x01:
        return "computer";
      case 0x02:
        return "phone";
      case 0x03:
        return "lan";
      case 0x04:
        return "av";
      case 0x05:
        return "peripheral";
      case 0x06:
        return "imaging";
      case 0x07:
      default :
        break;
    }
    return "unknown";
 }
 PANConnectionVector OTGateway::getPANConnections( void ) {
        PANConnectionVector V;
        struct bnep_connlist_req req;
        struct bnep_conninfo ci[48];
        V.setAutoDelete(TRUE);
        int ctl = socket(PF_BLUETOOTH, SOCK_RAW, BTPROTO_BNEP);
        if (ctl < 0) {
-          owarn << "Failed to open control socket" << oendl;
+          odebug << "Failed to open control socket" << oendl;
          return V;
        }
        req.cnum = 48;
        req.ci   = ci;
        if (ioctl(ctl, BNEPGETCONNLIST, &req)) {
-          owarn << "Failed to get connection list" << oendl;
+          odebug << "Failed to get connection list" << oendl;
          ::close( ctl );
          return V;
        }
        for ( unsigned i=0; i < req.cnum; i++) {
          V.resize( V.size() + 1 );
          if( ci[i].role == BNEP_SVC_PANU ) {
            // we are the client
            V.insert( V.size()-1, new OTPANConnection(
                            ci[i].device,
                            batostr((bdaddr_t *) ci[i].dst)
                          ) );
          }
        }
        ::close( ctl );
        return V;
 }
 struct link_key {
        bdaddr_t sba;
        bdaddr_t dba;
        uint8_t  key[16];
        uint8_t  type;
        time_t   time;
 };
 void OTGateway::readLinkKeys( void ) {
        struct link_key k;
        int rv;
        AllKeys.truncate(0);
        QFile F( "/etc/bluetooth/link_key" );
        if( ! F.open( IO_ReadOnly ) ) {
          emit error( tr("Cannot open link_key file") );
          return;
        }
        while( 1 ) {
          rv = F.readBlock( (char *)&k, sizeof( k ) );
          if( rv == 0 )
            // EOF
            break;
          if( rv < 0 ) {
            emit error( tr("Read error in link key file") );
          }
          AllKeys.resize( AllKeys.size()+1 );
          AllKeys[ AllKeys.size()-1 ].From.setBDAddr( k.sba );
          AllKeys[ AllKeys.size()-1 ].To.setBDAddr( k.dba );
        }
 }
 bool OTGateway::removeLinkKey( unsigned int Index ) {
        OTLinkKey & LK = AllKeys[Index];
        struct link_key k;
        int rv;
        QFile F( "/etc/bluetooth/link_key" );
        QFile OutF( "/etc/bluetooth/newlink_key" );
        if( ! F.open( IO_ReadOnly ) ) {
          emit error( tr("Cannot open link_key file") );
          return 0;
        }
        if( ! OutF.open( IO_WriteOnly | IO_Truncate ) ) {
          emit error( tr("Cannot open temporary link_key file") );
          return 0;
        }
        while( 1 ) {
          rv = F.readBlock( (char *)&k, sizeof( k ) );
          if( rv == 0 )
            // EOF
            break;
          if( rv < 0 ) {
            emit error( tr("Read error in link key file") );
            return 0;
          }
          if( LK.from() != OTDeviceAddress( k.sba ) ||
              LK.to() != OTDeviceAddress( k.dba ) ) {
            // copy
            OutF.writeBlock( (char *)&k, sizeof( k ) );
          } // else remove this key
        }
        // rename files
        QDir D( "/etc/bluetooth" );
        D.remove( "link_key" );
        D.rename( "newlink_key", "link_key" );
        // restart hcid
        system( "/etc/init.d/hcid stop" );
        system( "/etc/init.d/hcid start" );
        // remove from table
        if( Index < (AllKeys.size()-1) ) {
          // collapse array
          AllKeys[Index] = AllKeys[AllKeys.size()-1];
        }
        // remove last element
        AllKeys.resize( AllKeys.size()-1 );
        return 1;
 }
 #define MAXCONNECTIONS 10
 void OTGateway::loadActiveConnections( void ) {
        struct hci_conn_list_req *cl;
        struct hci_conn_info *ci;
        OTDeviceAddress Addr;
        OTPeer * P;
        if (!(cl = (struct hci_conn_list_req *)malloc( 
                      MAXCONNECTIONS * sizeof(*ci) + sizeof(*cl)))) {
          emit error( tr("Can't allocate memory") );
          return;
        }
        memset( cl, 0, MAXCONNECTIONS * sizeof(*ci) + sizeof(*cl) );
        for( unsigned int i = 0;
             i < AllDrivers.count();
             i ++ ) {
          if( ! AllDrivers[i]->isUp() ) {
            continue;
          }
          // driver is up -> check connections
          cl->dev_id = AllDrivers[i]->devId();
          cl->conn_num = MAXCONNECTIONS;
          ci = cl->conn_info;
          if (ioctl( getSocket(), HCIGETCONNLIST, (void *) cl)) {
            emit error( tr("Can't get connection list") );
            break;
          }
          for ( int k = 0; k < cl->conn_num; k++, ci++) {
            if( ci->state != BT_CONNECTED ) {
              // not yet connected
              continue;
            }
            Addr.setBDAddr( ci->bdaddr );
            P = findPeer( Addr );
            if( ! P ) {
              // peer not yet known -> add
              P = new OTPeer( this );
              addPeer( P );
              P->setAddress( Addr );
              // infoQueue.push_back(info);
              P->setName( AllDrivers[i]->getPeerName( Addr ) ); 
            } 
            P->setState( OTPeer::Peer_Up );
            P->setConnectedTo( AllDrivers[i] );
          }
        }
        free( cl );
 }
 void OTGateway::loadKnownPeers( void ) {
    QDir SaveDir = QDir::home();
    if( ! SaveDir.exists( "Settings" ) ) {
      return;
    }
    SaveDir.cd( "Settings" );
    if( ! SaveDir.exists( "opietooth" ) ) {
      return;
    }
    SaveDir.cd( "opietooth" );
    QFile F( SaveDir.path() + "/SeenDevices.conf" );
    if( F.open( IO_ReadOnly ) ) {
      QTextStream TS(&F);
      long count;
      count = TS.readLine().toLong();
      while( count > 0 ) {
        addPeer( new OTPeer( TS, this ) );
        count --;
      }
    }
    AllPeersModified = 0;
 }
 void OTGateway::saveKnownPeers( void ) {
    QDir SaveDir = QDir::home();
    if( ! SaveDir.exists( "Settings" ) ) {
      SaveDir.mkdir( "Settings" );
    }
    SaveDir.cd( "Settings" );
    if( ! SaveDir.exists( "opietooth" ) ) {
      SaveDir.mkdir( "opietooth" );
    }
    SaveDir.cd( "opietooth" );
    QFile F( SaveDir.path() + "/SeenDevices.conf" );
    if( F.open( IO_WriteOnly | IO_Truncate ) ) {
      QTextStream TS(&F);
      QString S;
      TS << AllPeers.count() << endl;
      for( unsigned int i = 0;
           i < AllPeers.count();
           i ++ ) {
        AllPeers[i]->save( TS );
      }
      AllPeersModified = 0;
    }
    AllPeersModified = 0;
 }
 int OTGateway::connectedToRFCommChannel( const OTDeviceAddress & Addr, 
                                         int channel ) {
    int s;
    if( (s = ::socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_RFCOMM)) < 0 ) {
      emit error( tr("Can't open RFCOMM control socket") );
      return 0;
    }
    // get all rfcomm devices
    { struct rfcomm_dev_list_req *dl;
      struct rfcomm_dev_info *di, *dr;
      int i;
      dl = (struct rfcomm_dev_list_req *)alloca(
              sizeof(*dl) + RFCOMM_MAX_DEV * sizeof(*di));
      memset( dl, 0, sizeof(*dl) + RFCOMM_MAX_DEV * sizeof(*di) );
      dl->dev_num = RFCOMM_MAX_DEV;
      di = dl->dev_info;
      if( ::ioctl(s, RFCOMMGETDEVLIST, (void *) dl) < 0) {
        emit error( tr("Can't get device list") );
        ::close( s );
        return 0;
      }
      dr = di;
      for (i = 0; i < dl->dev_num; i++, dr++) {
        // connected to Peer
        if( Addr == OTDeviceAddress( dr->dst ) &&
            channel == dr->channel &&
            ( dr->state != 0 )
          ) {
          // return device ID
          return dr->id;
        }
      }
    }
    // no device
    return -1;
 }
 static int byID( struct rfcomm_dev_info * d1,
                 struct rfcomm_dev_info * d2 ) {
    return d1->id - d2->id;
 }
 int OTGateway::getFreeRFCommDevice( void ) {
    int s;
    if( (s = ::socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_RFCOMM)) < 0 ) {
      emit error( tr("Can't open RFCOMM control socket") );
      return 0;
    }
    // get all rfcomm devices
    { struct rfcomm_dev_list_req *dl;
      struct rfcomm_dev_info *di, *dr;
      int i;
      dl = (struct rfcomm_dev_list_req *)alloca(
              sizeof(*dl) + RFCOMM_MAX_DEV * sizeof(*di));
      dl->dev_num = RFCOMM_MAX_DEV;
      di = dl->dev_info;
      if( ::ioctl(s, RFCOMMGETDEVLIST, (void *) dl) < 0) {
        emit error( tr("Can't get device list") );
        ::close( s );
        return 0;
      }
      // s
      if( dl->dev_num ) {
        qsort( di, sizeof(struct rfcomm_dev_info), 
               dl->dev_num, (int(*)(const void*,const void*))byID );
        int id = 0;
        dr = di;
        // find lowest free device number
        for (i = 0; i < dl->dev_num; i++, dr++) {
          if( id != dr->id ) {
            return id;
          }
          id ++;
        }
        return id;
      } else {
        return 0;
      }
    }
 }
 int OTGateway::releaseRFCommDevice( int devnr ) {
    int s;
    if( (s = ::socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_RFCOMM)) < 0 ) {
      emit error( tr("Can't open RFCOMM control socket") );
      return 0;
    }
    // get all rfcomm devices
    { struct rfcomm_dev_list_req *dl;
      struct rfcomm_dev_info *di, *dr;
      int i;
      dl = (struct rfcomm_dev_list_req *)alloca(
              sizeof(*dl) + RFCOMM_MAX_DEV * sizeof(*di));
      memset( dl, 0, sizeof(*dl) + RFCOMM_MAX_DEV * sizeof(*di) );
      dl->dev_num = RFCOMM_MAX_DEV;
      di = dl->dev_info;
      if( ::ioctl(s, RFCOMMGETDEVLIST, (void *) dl) < 0) {
        emit error( tr("Can't get device list") );
        ::close( s );
        return 0;
      }
      dr = di;
      for (i = 0; i < dl->dev_num; i++, dr++) {
        if( dr->id == devnr ) {
          // still in connection list 
          struct rfcomm_dev_req req;
          int err;
          memset(&req, 0, sizeof(req));
          req.dev_id = devnr;
          if ((err = ioctl(s, RFCOMMRELEASEDEV, &req)) < 0 ) {
            return err;
          }
          return 0;
        }
      }
    }
    // no device -> nothing to release eiterh
    return 0;
 }
diff --git a/noncore/settings/networksettings2/opietooth2/OTHCISocket.cpp b/noncore/settings/networksettings2/opietooth2/OTHCISocket.cpp
index 471c3bf..1997b44 100644
--- a/noncore/settings/networksettings2/opietooth2/OTHCISocket.cpp
+++ b/noncore/settings/networksettings2/opietooth2/OTHCISocket.cpp
@@ -1,274 +1,274 @@
 //-*-c++-*-
 /***************************************************************************
 *   Copyright (C) 2003 by Fred Schaettgen                                 *
 *   kdebluetooth@schaettgen.de                                            *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 ***************************************************************************/
 #include <qbuffer.h>
 #include <qtimer.h>
 #include <qdatastream.h>
 #include <opie2/odebug.h>
 #include <bluezlib.h>
 // #include "deviceaddress.h"
 #include <OTHCISocket.h>
 #include <OTDriver.h>
 using namespace Opietooth2;
 OTHCISocket::OTHCISocket( OTDriver * D ) :
                            QObject( D, D->devname() ) {
    BStatusSet = false;
    Driver = D;
    HCIReadNotifier = 0;
 }
 OTHCISocket::~OTHCISocket() {
    close();
 }
 void OTHCISocket::close() {
-    owarn << "OTHCISocket::close()" << oendl;
+    odebug << "OTHCISocket::close()" << oendl;
    if( HCIReadNotifier ) {
        delete HCIReadNotifier;
    }
    if( HCISocket.isValid() ) {
        HCISocket.close();
    }
 }
 bool OTHCISocket::open() {
-    owarn << "OTHCISocket::open()" << oendl;
+    odebug << "OTHCISocket::open()" << oendl;
    int s;
    s = ::socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI);
    if (s < 0) {
      emit error( tr( "Error creating socket on %1 : %2 %3").
                    arg( Driver->devname() ).
                    arg( errno ).
                    arg( strerror(errno) )
                );
      return false;
    }
    /* Bind socket to the HCI device */
    struct sockaddr_hci sa;
    sa.hci_family = AF_BLUETOOTH;
    sa.hci_dev = Driver->devId();
    if (bind(s, (struct sockaddr *)&sa, sizeof(sa)) < 0) {
      ::close(s);
      emit error( tr( "Error binding to socket to %1 : %2 %3").
                    arg( Driver->devname() ).
                    arg( errno ).
                    arg( strerror(errno) )
                );
      return false;
    }
    struct hci_filter flt;
    hci_filter_clear(&flt);
    hci_filter_set_ptype(HCI_EVENT_PKT, &flt);
    hci_filter_all_events(&flt);
    if( setsockopt(s, SOL_HCI, HCI_FILTER, &flt, sizeof(flt)) < 0 ) {
      ::close(s);
      emit error( tr( "HCI filter setup failed on %1 : %2 %3").
                    arg( Driver->devname() ).
                    arg( errno ).
                    arg( strerror(errno) )
                );
      return false;
    }
    if( HCIReadNotifier ) {
      delete HCIReadNotifier;
    }
    HCISocket.setSocket(s, QSocketDevice::Datagram);
    HCIReadNotifier = new QSocketNotifier(
                  s, QSocketNotifier::Read, this);
    connect( HCIReadNotifier, 
             SIGNAL(activated(int)),
             this, 
             SLOT(slotSocketActivated())
           );
    //connect(hciSocket, SIGNAL(error(int)),
    //    this, SLOT(slotSocketError(int)));
    //connect(hciSocket, SIGNAL(connectionClosed()),
    //    this, SLOT(slotConnectionClosed()));
    //hciSocket->setSocket(s);
    return true;
 }
 void OTHCISocket::slotSocketError(int e) {
    close();
    emit error( tr( "HCI socket error 0x%1 on %1 : %2 %3").
                    arg(e,2,16).
                    arg( Driver->devname() ).
                    arg( errno ).
                    arg( strerror(errno) )
                );
 }
 void OTHCISocket::slotSocketActivated() {
    QSocketDevice::Error err = HCISocket.error();
    if( (err == QSocketDevice::NoError ) && 
        ( HCISocket.isValid() ) ) {
      //kdDebug() << "HCI socket ready read." << endl;
      unsigned char buf[512];
      int psize = HCISocket.readBlock((char*)buf, 512);
      if (psize <= 0) {
        slotSocketError(HCISocket.error());
        HCISocket.close();
        return;
      }
      //unsigned char packetType = buf[0];
      unsigned char eventCode = buf[1];
      unsigned char len = buf[2];
      if (psize-3 == len) {
        QByteArray databuf;
        databuf.duplicate((char*)(buf+3), len);
        emit event(eventCode, databuf);
        if (eventCode == EVT_CMD_STATUS) {
          updateStatus( databuf );
        }
      } else {
-        owarn << "Error reading hci packet: packetSize("
+        odebug << "Error reading hci packet: packetSize("
              << psize
              << ")-3 != dataSize("
              << len
              << ")" 
              << oendl;
      }
    } else if (err == QSocketDevice::NoError) {
      slotConnectionClosed();
    } else {
        HCISocket.close();
        slotSocketError(err);
    }
 }
 void OTHCISocket::updateStatus(const QByteArray& data) {
    QDataStream stream(data, IO_ReadOnly);
    stream.setByteOrder(QDataStream::LittleEndian);
    Q_UINT8 status, dummy;
    Q_UINT16 opcode;
    BStatusSet = true;
    stream >> status >> dummy >> opcode;
    //kdDebug() << "updatestatus opcode=" << uint32_t(opcode) << endl;
    LastStatus = status;
    LastStatusOgf = cmd_opcode_ogf(opcode);
    LastStatusOcf = cmd_opcode_ocf(opcode);
 }
 void OTHCISocket::slotConnectionClosed() {
-    owarn << "HCI connection closed." << oendl;
+    odebug << "HCI connection closed." << oendl;
    emit connectionClosed();
 }
 void OTHCISocket::readEvent() {
    if (HCIReadNotifier) {
        slotSocketActivated();
    }
 }
 bool OTHCISocket::sendCommand( unsigned char ogf,
                               unsigned short ocf, 
                               QByteArray buf
                             ) {
    QBuffer packet;
    QDataStream stream(&packet);
    stream.setByteOrder(QDataStream::LittleEndian);
    packet.open(IO_WriteOnly);
    if (buf.size() > 255) return false;
    //kdDebug() << "sendCommand. ogf=" << ogf << " ocf=" << ocf << endl;
    Q_UINT16 opcode = cmd_opcode_pack(ogf, ocf);
    Q_UINT8 pType = HCI_COMMAND_PKT;
    Q_UINT8 buflen = buf.size();
    stream << pType << opcode << buflen;
    stream.writeRawBytes(buf.data(), buflen);
    packet.close();
    HCISocket.writeBlock((const char*)packet.buffer(), 
                         packet.buffer().size());
    return true;
 }
 bool OTHCISocket::readStatus( unsigned char ogf, 
                              unsigned short ocf, 
                              int *status, 
                              int timeout_ms) {
    QTimer timer;
    timer.start(timeout_ms, true);
    BStatusSet = false;
    while (timer.isActive() && HCISocket.isValid()) {
-        owarn << "OTHCISocket::readStatus()" << oendl;
+        odebug << "OTHCISocket::readStatus()" << oendl;
        bool timeout = false;
        if( HCISocket.bytesAvailable() == 0) {
          int rv = HCISocket.waitForMore(timeout_ms);
          timeout = (rv == 0);
        }
        if (!timeout) {
          slotSocketActivated();
        }
        if( BStatusSet == true && 
            ogf == LastStatusOgf && 
            ocf == LastStatusOcf) {
            *status = LastStatus;
-            owarn << "OTHCISocket::readStatus(ogf="
+            odebug << "OTHCISocket::readStatus(ogf="
                  << ogf
                  << ",ocf="
                  << ocf
                  << ",timeout="
                  << LastStatus
                  << ")"
                  << oendl;
            return true;
        }
    }
-    owarn << "OTHCISocket::readStatus(ogf="
+    odebug << "OTHCISocket::readStatus(ogf="
          << ogf
          << ",ocf="
          << ocf
          << ",timeout="
          << LastStatus
          << ") : timeout "
          << oendl;
    return false;
 }
 int OTHCISocket::socket() {
    return HCISocket.socket();
 }
diff --git a/noncore/settings/networksettings2/opietooth2/OTInquiry.cpp b/noncore/settings/networksettings2/opietooth2/OTInquiry.cpp
index 8e94bbc..2bc63c7 100644
--- a/noncore/settings/networksettings2/opietooth2/OTInquiry.cpp
+++ b/noncore/settings/networksettings2/opietooth2/OTInquiry.cpp
@@ -1,219 +1,219 @@
 //-*-c++-*-
 /***************************************************************************
 *   Copyright (C) 2003 by Fred Schaettgen                                 *
 *   kdebluetooth@schaettgen.de                                            *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 ***************************************************************************/
 #include <qcstring.h>
 #include <qsocket.h>
 #include <qdatetime.h>
 #include <qtimer.h>
 #include <qthread.h>
 #include <qapplication.h>
 #include <bluezlib.h>
 #include <OTGateway.h>
 #include <OTDriver.h>
 #include <OTPeer.h>
 #include <OTHCISocket.h>
 #include <OTInquiry.h>
 #include <opie2/odebug.h>
 using namespace Opietooth2;
 #define max(a,b)        (((a)>(b)) ? (a) : (b))
 #define min(a,b)        (((a)>(b)) ? (b) : (a))
 OTInquiry::OTInquiry( OTDriver * Drv ) : QObject( Drv ) {
    reset();
    InquiryTimeoutTimer = new QTimer(this);
    connect( InquiryTimeoutTimer, 
             SIGNAL(timeout()),
             this, 
             SLOT(slotInquiryTimeout()));
    Driver = Drv;
    Socket = Drv->openSocket();
    Socket->open();
    connect( Socket, 
             SIGNAL( event(unsigned char, QByteArray)),
             this, 
             SLOT(slotHCIEvent(unsigned char, QByteArray)));
 }
 OTInquiry::~OTInquiry() {
    stopInquiring();
 }
 void OTInquiry::stopInquiring( void ) {
    if( Socket ) {
-      owarn << "Stop inquiry" << oendl;
+      odebug << "Stop inquiry" << oendl;
      Driver->closeSocket();
      Socket = 0;
    }
 }
 bool OTInquiry::inquire( double timeout, int numResponses, int lap) {
    QByteArray cmdBuf(5);
    cmdBuf[0] = lap & 0xFF;
    cmdBuf[1] = (lap >> 8) & 0xFF;
    cmdBuf[2] = (lap >> 16) & 0xFF;
    cmdBuf[3] = max(0x01, min(0x30, int(timeout/1.28)));
    cmdBuf[4] = (unsigned char)numResponses;
-    owarn << "Send HCI inquiry command. wait for " << cmdBuf[3] << oendl;
+    odebug << "Send HCI inquiry command. wait for " << cmdBuf[3] << oendl;
    Socket->sendCommand(0x01, 0x0001, cmdBuf);
    int status;
    if( Socket->readStatus(0x01, 0x0001, &status)) {
      if (status == 0) {
        SuccessfullyStarted = true;
        InquiryTimeoutTimer->start( int(1000*(timeout+1.0)), true);
        return true;
      }
      else {
        QString S =QString().sprintf( "%x", status );
-        owarn << "OTInquiry::inquiry() failed: 0x" << S << oendl;
+        odebug << "OTInquiry::inquiry() failed: 0x" << S << oendl;
        emit finished();
        return false;
      }
    } else {
-      owarn << "OTInquiry::inquiry(): Timeout." << oendl;
+      odebug << "OTInquiry::inquiry(): Timeout." << oendl;
      return false;
    }
 }
 bool OTInquiry::isInquiring() {
    return InquiryTimeoutTimer->isActive();
 }
 bool OTInquiry::isFinished() {
    return SuccessfullyStarted && SuccessfullyEnded;
 }
      
 void OTInquiry::reset() {
    SuccessfullyStarted = false;
    SuccessfullyEnded = false;
    //addrCache.clear();
    //infoQueue.clear();
 }
 void OTInquiry::onPeerFound( OTPeer * Peer, bool IsNew ) {
    emit peerFound( Peer, IsNew );
 }
 void OTInquiry::slotInquiryTimeout() {
    emit error( tr( "Timeout while waiting for end of inquiry.") );
 }
 void OTInquiry::slotHCIEvent(unsigned char eventCode, QByteArray buf) {
-    owarn << "OTInquiry: hci packet received: eventCode="
+    odebug << "OTInquiry: hci packet received: eventCode="
          << (unsigned int)eventCode 
          << " packetLength="
          << (unsigned int)buf.size() 
          << oendl;
    unsigned char *data = (unsigned char*)buf.data();
    switch (eventCode) {
      case EVT_INQUIRY_COMPLETE:
        { unsigned char status = data[0];
-          owarn << "EVT_INQUIRY_COMPLETE status=" << status << oendl;
+          odebug << "EVT_INQUIRY_COMPLETE status=" << status << oendl;
          InquiryTimeoutTimer->stop();
          if (status == 0) {
            if( SuccessfullyStarted == true) {
-              owarn << "OTInquiry ended successfully" << oendl;
+              odebug << "OTInquiry ended successfully" << oendl;
              SuccessfullyEnded = true;
            }
            emit finished();
          }
          else {
            emit error( tr( "OTInquiry completed with error (code %1)" ).
                          arg(status));
          }
        }
        break;
      case EVT_INQUIRY_RESULT:
        { int numResults = data[0];
          OTPeer * P = 0;
          bool IsNew;
          OTDeviceAddress Addr;
          QString N;
          inquiry_info *results = (inquiry_info*)(data+1);
          for (int n=0; n<numResults; n++) {
            Addr.setBDAddr( results[n].bdaddr );
-            owarn << "INQUIRY_RESULT: "
+            odebug << "INQUIRY_RESULT: "
                  << Addr.toString() 
                  << oendl;
            P = Driver->gateway()->findPeer( Addr );
            if( P ) {
              // peer known
              if( P->state() != OTPeer::Peer_Up ) {
                P->setState( OTPeer::Peer_Up );
              }
              IsNew = 0;
            } else {
              IsNew = 1;
              // push the address to the address queue
              // where it can be consumed by nextNeighbour()
              P = new OTPeer( Driver->gateway() );
              P->setState( OTPeer::Peer_Up ); // we just detected it
              P->setAddress( Addr );
              //if( addrCache.find(info.addr) == addrCache.end()) {
              // addrCache.insert(info.addr);
              P->setDeviceClass( (results[n].dev_class[0] << 16) |
                                 (results[n].dev_class[1] << 8) |
                                 (results[n].dev_class[2] << 0) );
              // infoQueue.push_back(info);
              P->setName( Driver->getPeerName( Addr ) ); 
            }
            // call the handler. Emits a signal if not overwritten
            onPeerFound( P, IsNew );
            // }
          }
        }
        break;
      case EVT_CMD_STATUS :
        { int status = data[0];
          int numHciCmdPkts = data[1];
          int cmdOpcode = *((uint16_t*)(data+2));
-          owarn << "EVT_CMD_STATUS status=" 
+          odebug << "EVT_CMD_STATUS status=" 
                << status
                << " numPkts=" 
                << numHciCmdPkts 
                << " cmdOpcode="
                << cmdOpcode 
                << oendl;
          if (cmdOpcode == OCF_INQUIRY) {
          }
        }
        break;
    }
 }
diff --git a/noncore/settings/networksettings2/opietooth2/OTPeer.cpp b/noncore/settings/networksettings2/opietooth2/OTPeer.cpp
index 0d7e943..2272f04 100644
--- a/noncore/settings/networksettings2/opietooth2/OTPeer.cpp
+++ b/noncore/settings/networksettings2/opietooth2/OTPeer.cpp
@@ -1,366 +1,366 @@
 //-*-c++-*-
 /***************************************************************************
 *   Copyright (C) 2003 by Fred Schaettgen                                 *
 *   kdebluetooth@schaettgen.de                                            *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 ***************************************************************************/
 #include <assert.h>
 #include <sys/poll.h>
 #include <string.h>
 #include <bluezlib.h>
 #include <qarray.h>
 #include <qtextstream.h>
 #include <opie2/odebug.h>
 #include <OTDeviceAddress.h>
 #include <OTSDPAttribute.h>
 #include <OTSDPService.h>
 #include <OTPeer.h>
 #include <OTGateway.h>
 #include <OTDriver.h>
 using namespace Opietooth2;
 OTPeer::OTPeer( OTGateway * _OT ) {
      OT = _OT;
      State = Peer_Unknown;
      ConnectedTo = 0;
 }
 OTPeer::OTPeer( QTextStream & TS, OTGateway * _OT ) {
      OT = _OT;
      State = Peer_Unknown;
      ConnectedTo = 0;
      load( TS );
 }
 OTPeer::~OTPeer( ) {
 }
 void OTPeer::updateServices( void ) {
    sdp_session_t *session;
    serviceList.clear();
-    owarn << "Get services from " << Addr.toString() << oendl;
+    odebug << "Get services from " << Addr.toString() << oendl;
    session = sdp_connect( &(OTDeviceAddress::any.getBDAddr()), 
                           &(Addr.getBDAddr()),
                           0);
    if (!session) {
-      owarn << "sdp_connect(" 
+      odebug << "sdp_connect(" 
            << Addr.toString()
            << ") failed"  
            << oendl;
        return; // error
    }
    uint32_t range = 0x0000ffff;
    sdp_list_t* attrId = sdp_list_append(0, &range);
    // search all public features
    uuid_t grp;
    sdp_uuid16_create( &grp, PUBLIC_BROWSE_GROUP );
    sdp_list_t * search = sdp_list_append(0, &grp );
    // get data from peer
    sdp_list_t* seq;
    if (sdp_service_search_attr_req( session, 
                                     search,
                                     SDP_ATTR_REQ_RANGE, 
                                     attrId, 
                                     &seq ) ) {
-      owarn << "Service Search failed" << oendl;
+      odebug << "Service Search failed" << oendl;
      sdp_close(session);
      return;
    }
    sdp_list_free(attrId, 0);
    sdp_list_free(search, 0);
    // process result
    sdp_list_t* next = NULL;
    for (; seq; seq = next) {
      sdp_record_t *rec = (sdp_record_t *) seq->data;
      sdp_list_t* attrlist = rec->attrlist;
      AttributeVector alist;
      OTSDPService * service;
      service = new OTSDPService();
      for (; attrlist; attrlist = attrlist->next) {
        int attrID = ((sdp_data_t*)(attrlist->data))->attrId;
        service->addAttribute( 
              attrID, 
              new OTSDPAttribute( (sdp_data_t*)(attrlist->data) )
            );
      }
      serviceList.resize( serviceList.size() + 1 );
      serviceList.insert( serviceList.size() - 1, service );
      next = seq->next;
      free(seq);
      sdp_record_free(rec);
    }
    sdp_close(session);
 }
 bool OTPeer::hasServiceClassID( const OTUUID & uuid) {
    for( unsigned int i = 0;
         i < serviceList.count();
         i ++ ) {
      if( serviceList[i]->hasClassID(uuid))
        return true;
    }
    return false;
 }
 /** Get a vector of Rfcomm channels of the services having "uuid" in the class ID List*/
 QArray<int> OTPeer::rfcommList( const OTUUID & uuid) {
    QArray<int> rfcommList;
    unsigned int channel;
    for( unsigned int i = 0;
         i < serviceList.count();
         i ++ ) {
      if( serviceList[i]->hasClassID(uuid)) {
        if( serviceList[i]->rfcommChannel(channel) ) {
          rfcommList.resize( rfcommList.size()+1 );
          rfcommList[rfcommList.size()-1] = channel;
        }
      }
    }
    return rfcommList;
 }
 void OTPeer::save( QTextStream & TS ) {
        TS << "bdaddr " << address().toString() << endl;
        TS << "name " << name() << endl;
        TS << "class " << deviceClass() << endl;
 }
 void OTPeer::load( QTextStream & TS ) {
      QString S;
      S = TS.readLine();
      setAddress( OTDeviceAddress( S.mid( 7 ) ) );
      S = TS.readLine();
      setName( S.mid( 5 ) );
      S = TS.readLine();
      setDeviceClass( S.mid( 6 ).toLong() );
 }
 #define MAGICNR         -99999
 #define POLLDELAY       1000
 #define PREMAGICNR      (MAGICNR+POLLDELAY)
 void OTPeer::findOutState( int timeoutInSec, bool Force ) {
      ProbeFD = -1;
      if( Force && ConnectedTo == 0 ) {
        State = OTPeer::Peer_Unknown;
      } // else keep state or is connected to us
      if( State == OTPeer::Peer_Unknown ) {
        ProbePhase = 0;
        ProbeTimeout = timeoutInSec*1000;
-        owarn << "Ping " << address().toString() << oendl;
+        odebug << "Ping " << address().toString() << oendl;
        startTimer( POLLDELAY );
      } else {
        ProbeTimeout = 0;
        startTimer( 0 );
      }
 }
 #define PINGSIZE        20
 void OTPeer::timerEvent( QTimerEvent * ev ) {
      ProbeTimeout -= POLLDELAY;
      if( State == OTPeer::Peer_Unknown ) {
        switch( ProbePhase ) {
          case 0 : // connect nonblock
            { struct sockaddr_l2 addr;
              if (( ProbeFD = ::socket(PF_BLUETOOTH, SOCK_RAW, BTPROTO_L2CAP)) < 0) {
                ProbeTimeout = 0;
                break;
              }
              memset(&addr, 0, sizeof(addr));
              addr.l2_family = AF_BLUETOOTH;
              addr.l2_bdaddr = OTDeviceAddress::any.getBDAddr();
              if( ::bind( ProbeFD, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
                ProbeTimeout = 0;
                break;
              }
              // non blocking
              if( ::fcntl( ProbeFD, F_SETFL, O_NONBLOCK ) < 0 ) {
                ProbeTimeout = 0;
                break;
              }
              // to this peer
              addr.l2_bdaddr = address().getBDAddr();
              if( ::connect( ProbeFD, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
                if( errno != EAGAIN && errno != EINPROGRESS ) {
                  ProbeTimeout = 0;
                  break;
                } // wait for connect to fail or succeed
              }
            }
            ProbePhase = 1; // wait for connect
            break;
          case 1 :
            { struct pollfd pf[1];
              char buf[L2CAP_CMD_HDR_SIZE + PINGSIZE + 20];
              int n;
              pf[0].fd = ProbeFD; 
              pf[0].events = POLLOUT;
              if( (n = ::poll(pf, 1, 0)) < 0 ) {
-                owarn << address().toString()
+                odebug << address().toString()
                      << " : errno " 
                      << errno 
                      << " " 
                      << strerror(errno)<<oendl;
                ProbeTimeout = 0;
                break;
              }
              if( ! n ) {
                // not ready -> try again
                break;
              }
              // send ping
              for( unsigned int i = L2CAP_CMD_HDR_SIZE; i < sizeof(buf); i++)
                  buf[i] = (i % 40) + 'A';
              l2cap_cmd_hdr *cmd = (l2cap_cmd_hdr *) buf;
              /* Build command header */
              cmd->code  = L2CAP_ECHO_REQ;
              cmd->ident = *(char *)this; // get some byte
              cmd->len   = PINGSIZE;
              /* Send Echo Request */
              if( ::send(ProbeFD, buf, PINGSIZE + L2CAP_CMD_HDR_SIZE, 0) <= 0) {
                if( errno == EACCES ) {
                  // permission denied means that we could not
                  // connect because the device does not allow us
                  // but it is UP
-                  owarn << address().toString()
+                  odebug << address().toString()
                        << " good send error " 
                        << errno 
                        << " " 
                        << strerror( errno) 
                        << oendl;
                  State = OTPeer::Peer_Up;
                  ProbeTimeout = 0;
                  break;
                } else if( errno != EBUSY ) {
-                  owarn << address().toString()
+                  odebug << address().toString()
                        << " : errno " 
                        << errno 
                        << " " 
                        << strerror(errno)
                        << oendl;
                  ProbeTimeout = 0;
                  break;
                } // else want some more
              }
              ProbePhase = 2; // wait for ping reply
            }
            break;
          case 2 : // wait for reply
            { struct pollfd pf[1];
              char buf[L2CAP_CMD_HDR_SIZE + PINGSIZE + 20];
              l2cap_cmd_hdr *cmd = (l2cap_cmd_hdr *) buf;
              int n;
              pf[0].fd = ProbeFD; 
              pf[0].events = POLLIN;
              if( (n = ::poll(pf, 1, 0)) < 0 ) {
-                owarn << address().toString()
+                odebug << address().toString()
                      << " : errno " 
                      << errno 
                      << " " 
                      << strerror(errno)
                      <<oendl;
                ProbeTimeout = 0;
                break;
              }
              if( ! n ) {
                // not ready -> try again
                break;
              }
              if( (n = ::recv( ProbeFD, buf, sizeof(buf), 0)) < 0) {
-                owarn << address().toString()
+                odebug << address().toString()
                      << "errno " 
                      << errno 
                      << " " 
                      << strerror(errno) 
                      << oendl;
                ProbeTimeout = 0;
                break;
              }
              /* Check for our id */
              if( cmd->ident != *(char *)this )
                // not our reply
                break;
-              owarn << "reply from " 
+              odebug << "reply from " 
                    << address().toString()
                    << oendl;
              // whatever reply we get is a valid reply 
              State = OTPeer::Peer_Up;
              ProbeTimeout = 0;
            }
            break;
        }
        if( State != OTPeer::Peer_Unknown ) {
          ProbeTimeout = 0;
        }
      } 
      if( ProbeTimeout <= 0 ) {
        // regular timeout
        emit peerStateReport( this );
        if( State == Peer_Unknown ) {
          State = Peer_Down;
        }
        if( ProbeFD >= 0 ) {
          // requested to stop by caller -> stop probing
          ::close( ProbeFD );
        } 
        // no more waiting
        killTimer( ev->timerId() );
      }  // else sleep some more
 }
 void OTPeer::stopFindingOutState( void ) {
      ProbeTimeout = PREMAGICNR;
 }
diff --git a/noncore/settings/networksettings2/opietooth2/Opietooth.cpp b/noncore/settings/networksettings2/opietooth2/Opietooth.cpp
index b14cc2f..8323549 100644
--- a/noncore/settings/networksettings2/opietooth2/Opietooth.cpp
+++ b/noncore/settings/networksettings2/opietooth2/Opietooth.cpp
@@ -1,1167 +1,1167 @@
 #include <opie2/odebug.h>
 #include <opie2/oledbox.h>
 #include <opie2/ofiledialog.h>
 using namespace Opie::Core;
 using namespace Opie::Ui;
 #include <qpe/resource.h>
 #include <qapplication.h>
 #include <qcheckbox.h>
 #include <qcombobox.h>
 #include <qdialog.h>
 #include <qdir.h>
 #include <qfile.h>
 #include <qgroupbox.h>
 #include <qheader.h>
 #include <qlabel.h>
 #include <qlayout.h>
 #include <qlistbox.h>
 #include <qlistview.h>
 #include <qmessagebox.h>
 #include <qprogressbar.h>
 #include <qpushbutton.h>
 #include <qscrollbar.h>
 #include <qtextstream.h>
 #include <qtextview.h>
 #include <Opietooth.h>
 #include <OTDriver.h>
 #include <OTPeer.h>
 #include <OTGateway.h>
 #include <OTSDPAttribute.h>
 #include <OTSDPService.h>
 #include <OTInquiry.h>
 #include <system.h>
 using namespace Opietooth2;
 namespace Opietooth2 {
 class PeerLVI : public QListViewItem {
 public :
      PeerLVI( OTPeer * P, QListView * it ) : QListViewItem (it) {
        Peer = P;
      }
      ~PeerLVI( void ) {
      }
      inline OTPeer * peer( void )
        { return Peer; }
 private :
      OTPeer * Peer;
 };
 class ChannelLVI : public QListViewItem {
 public :
      ChannelLVI( int Ch, QListViewItem * it ) : QListViewItem (it) {
        Channel = Ch;
      }
      ~ChannelLVI( void ) {
      }
      inline int channel( void )
        { return Channel; }
 private :
      int Channel;
 };
 class DriverLVI : public QListViewItem {
 public :
      DriverLVI( OTDriver * P, QListView * it ) : QListViewItem (it) {
        Driver = P;
      }
      ~DriverLVI( void ) {
      }
      inline OTDriver * driver( void )
        { return Driver; }
 private :
      OTDriver * Driver;
 };
 class LinkKeyLVI : public QListViewItem {
 public :
      LinkKeyLVI( int Ch, QListView * it ) : QListViewItem (it) {
        LinkKey = Ch;
      }
      ~LinkKeyLVI( void ) {
      }
      inline int index( void )
        { return LinkKey; }
 private :
      int LinkKey;
 };
 };
 //
 //
 //
 //
 //
 OTSniffing::OTSniffing( QWidget * parent ) : OTSniffGUI( parent ) {
      OT = OTGateway::getOTGateway();
      HciDump = 0;
 }
 OTSniffing::~OTSniffing() {
      SLOT_Trace( 0 );
 }
 void OTSniffing::SLOT_Trace( bool Run ) {
      if( ! Run ) {
        if ( HciDump ) {
          HciDump->process().kill();
          delete HciDump;
        }
        HciDump = 0;
        return;
      }
      HciDump = new MyProcess();
      QStringList SL;
      SL << "/usr/sbin/hcidump";
      switch( DataFormat_CB->currentItem() ) {
        case 0 : // Hex
          SL << "-x";
          break;
        case 1 : // Ascii
          SL << "-a";
          break;
        case 2 : // both
          SL << "-X";
          break;
      }
      SL << "-i";
      SL << OT->scanWith()->devname();
      connect( HciDump, 
               SIGNAL( stdoutLine( const QString & ) ),
               this, 
               SLOT( SLOT_Show( const QString & ) ) );
      connect( HciDump, 
               SIGNAL(processExited(MyProcess*) ),
               this, 
               SLOT( SLOT_ProcessExited(MyProcess*) ) );
      HciDump->process() << SL;
      if( ! HciDump->process().start( OProcess::DontCare, 
                                      OProcess::AllOutput )
        ) {
        QMessageBox::warning(0,
            tr("Run hcidump"),
            tr("Cannot start %1").arg(SL.join(" "))
        );
        delete HciDump;
        HciDump = 0;
      }
 }
 void OTSniffing::SLOT_Show( const QString & S ) {
      printf( "%s\n", S.latin1() );
      Output_TV->setText( Output_TV->text() + S + "\n" );
      QScrollBar *scroll = Output_TV->verticalScrollBar();
      scroll->setValue(scroll->maxValue());
      //Output_LB->insertItem( S );
      //Output_LB->setCurrentItem( Output_LB->count()-1 );
      //Output_LB->ensureCurrentVisible();
 }
 void OTSniffing::SLOT_ProcessExited( MyProcess * ) {
      printf( "Exited\n" );
      delete HciDump;
      HciDump = 0;
 }
 void OTSniffing::SLOT_Save( void ) {
      QString S = OFileDialog::getSaveFileName(
              OFileSelector::Extended,
              QDir::home().path(),
              QString::null,
              MimeTypes(),
              this );
      if( ! S.isEmpty() ) {
        QFile F( S );
        if( ! F.open( IO_WriteOnly ) ) {
          QMessageBox::warning(0,
              tr("Save log"),
              tr("Cannot open %1").arg(S) 
          );
          return;
        }
        QTextStream TS( &F );
        TS << S << endl;
      }
 }
 void OTSniffing::SLOT_Load( void ) {
      QString S = OFileDialog::getOpenFileName(
              OFileSelector::Extended,
              QDir::home().path(),
              QString::null,
              MimeTypes(),
              this );
      if( ! S.isEmpty() ) {
        QFile F( S );
        if( ! F.open( IO_ReadOnly ) ) {
          QMessageBox::warning(0,
              tr("Save log"),
              tr("Cannot open %1").arg(S)
          );
          return;
        }
        QTextStream TS ( &F );
        SLOT_ClearLog();
        S = TS.read(); 
        // Output_LB->insertStringList( QStringList::split( "\n", S ) );
        Output_TV->setText( S );
      }
 }
 void OTSniffing::SLOT_ClearLog( void ) {
      // Output_LB->clear();
      Output_TV->setText( "" );
 }
 //
 //
 //
 //
 //
 OTPairing::OTPairing( QWidget * parent, OTIcons * _IC ) :
                OTPairingGUI( parent ) {
      OT = OTGateway::getOTGateway();
      Icons = (_IC ) ? _IC : new OTIcons();
      MyIcons = (_IC == 0 );
      // unpairing can only be done if bluetooth is disabled
      Unpair_But->setEnabled( ! OT->isEnabled() );
      if( ! OT->isEnabled() ) {
        Unpair_LBL->hide();
      } else {
        Unpair_LBL->show();
      }
      // open linkkey file and load pairs
      LinkKeyArray Keys = OT->getLinkKeys();
      LinkKeyLVI * it;
      OTPeer * P;
      OTDriver * D;
      for( unsigned int i = 0 ;
           i < Keys.count();
           i ++ ) {
        it = new LinkKeyLVI( i, Pairs_LV );
        P = 0;
        D = OT->findDriver( Keys[i].from() );
        if( D ) {
          it->setText( 0, D->devname() );
          // we are source
          P = OT->findPeer( Keys[i].to() );
          if( P ) {
            // put name
            it->setText( 1, P->name() );
          } else {
            // unknown
            it->setText( 1, Keys[i].to().toString() );
          }
          // and put address as sub
          QListViewItem * Sub = new QListViewItem( it );
          Sub->setText( 0, D->address().toString() );
          Sub->setText( 1, Keys[i].to().toString() );
        } else {
          // perhaps we are destination
          D = OT->findDriver( Keys[i].to() );
          if( D ) {
            it->setText( 1, D->devname() );
            // we are source
            P = OT->findPeer( Keys[i].from() );
            if( P ) {
              // put name
              it->setText( 0, P->name() );
            } else {
              // unknown
              it->setText( 0, Keys[i].from().toString() );
            }
            // and put address as sub
            QListViewItem * Sub = new QListViewItem( it );
            Sub->setText( 0, Keys[i].from().toString() );
            Sub->setText( 1, D->address().toString() );
          } else {
            // nor source nor destination -> unknown
            it->setText( 0, Keys[i].from().toString() );
            it->setText( 1, Keys[i].to().toString() );
          }
        }
      }
 }
 OTPairing::~OTPairing() {
      if( MyIcons )
        delete Icons;
      OTGateway::releaseOTGateway();
 }
 void OTPairing::SLOT_Unpair( ) {
      // find selected pair
      QListViewItem * it = Pairs_LV->firstChild();
      while( it ) {
        if( it->isSelected() ) {
          // confirm ?
          if( QMessageBox::warning(0,
              tr("Break pairing"),
              tr("Sure ?"),
              tr("Yes, break"),
              tr("No, don't break") ) == 0 ) {
            LinkKeyLVI * KPIt = (LinkKeyLVI *)it;
            // break 
            OT->removeLinkKey( KPIt->index() );
            delete KPIt;
          }
          return;
        }
        it= it->nextSibling();
      }
 }
 //
 //
 //
 //
 //
 OTScan::OTScan( QWidget * parent, OTIcons * _IC ) :
                OTScanGUI( parent ), Filter() {
      OT = OTGateway::getOTGateway();
      Icons = (_IC ) ? _IC : new OTIcons();
      MyIcons = (_IC == 0 );
      DetectedPeers_LV->header()->hide();
      Current = 0;
      SelectedPeer = 0;
      SelectedChannel = 0;
      StrengthTimer = new QTimer( this );
      connect( StrengthTimer,
               SIGNAL( timeout()),
               this,
               SLOT( SLOT_UpdateStrength())
             );
      connect( OT,
               SIGNAL( detectedPeer( OTPeer *, bool )),
               this,
               SLOT( SLOT_NewPeer( OTPeer *, bool ))
             );
      connect( OT,
               SIGNAL( finishedDetecting()),
               this,
               SLOT( SLOT_FinishedDetecting())
             );
      // populate with peers we already know about
      const PeerVector & P = OT->peers();
      for( unsigned int i = 0;
           i < P.count();
           i ++ ) {
        SLOT_NewPeer( P[i], TRUE );
      }
      // populate State fram
      { QHBoxLayout * H =new QHBoxLayout( State_Frm );
        Paired_Led = new OLedBox( green, State_Frm );
        QLabel * L1 = new QLabel( tr( "Paired" ), State_Frm );
        H->addWidget( Paired_Led );
        H->addWidget( L1 );
        H->addStretch( 1 );
      }
 }
 OTScan::~OTScan() {
      if( MyIcons )
        delete Icons;
      OTGateway::releaseOTGateway();
      // send all peers that we do not care about states
      QListViewItem * Lit = DetectedPeers_LV->firstChild();
      while( Lit ) {
        ((PeerLVI *)Lit)->peer()->stopFindingOutState( );
        Lit = Lit->nextSibling();
      }
 }
 // static scan dialog function
 int OTScan::getDevice( OTPeer *& Peer, 
                       int & Channel, 
                       OTGateway * OT,
                       const UUIDVector & Filter,
                       QWidget* Parent ) {
      bool IsUp = 0;
      unsigned int i;
      // check if bluetooth is up
      OTDriverList & DL = OT->getDriverList();
      for( i = 0;
           i < DL.count();
           i ++ ) {
        if( DL[i]->isUp() ) {
          // one device that is up found
          IsUp = 1;
          break;
        }
      }
      // use this driver
      OT->setScanWith( OT->driver(i) );
      // create dialog
      QDialog * Dlg = new QDialog( Parent, 0, TRUE );
      QVBoxLayout * V = new QVBoxLayout( Dlg );
      OTScan * Scn = new OTScan( Dlg );
      connect( Scn,
               SIGNAL( selected() ),
               Dlg,
               SLOT( accept() )
             );
      if( Filter ) {
        Scn->setScanFilter( Filter );
      }
      V->addWidget( Scn );
      Dlg->setCaption( tr("Scan Neighbourhood" ) );
      Dlg->showMaximized();
      int rv = Dlg->exec();
      if( rv == QDialog::Accepted ) {
        // get peer
        Peer = Scn->selectedPeer();
        if( Peer == 0 ) {
          // no peer selected
          rv = QDialog::Rejected;
        } else {
          Channel = Scn->selectedChannel();
        }
      }
      delete Dlg;
      return rv;
 }
 void OTScan::setScanFilter( const UUIDVector & V ) {
      Filter = V;
 }
 void OTScan::resetScanFilter( void ) {
      Filter.truncate(0);
 }
 void OTScan::SLOT_DoScan( bool DoIt ) {
      if( DoIt ) {
        OT->scanNeighbourhood();
      } else {
        OT->stopScanOfNeighbourhood();
      }
      scanMode( DoIt );
 }
 // double clicked on a device
 void OTScan::SLOT_Selected( QListViewItem * it ) {
      if( ! it )
        return;
      if( Filter.count() > 0 ) {
        // filter on service 
        if( it->depth() == 0 ) {
          // select a service and not a device
          return;
        }
        // store result
        SelectedPeer = ((PeerLVI *)it->parent())->peer();
        SelectedChannel = ((ChannelLVI *)it)->channel();
      } else {
        // click on device
        if( it->depth() != 0 ) {
          return;
        }
        SelectedPeer = ((PeerLVI *)it)->peer();
        SelectedChannel = 0;
      }
-      owarn << "Selected " << SelectedPeer->address().toString() <<
+      odebug << "Selected " << SelectedPeer->address().toString() <<
            " Channel " << SelectedChannel << oendl;
      emit selected();
 }
 void OTScan::SLOT_FinishedDetecting( ) {
      scanMode( false );
 }
 void OTScan::SLOT_CleanupOld( ) {
      // iterate over all peers and find those that
      // are down and have no pairing info
      OTPeer * TheP;
      const LinkKeyArray & Keys = OT->getLinkKeys();
      QListViewItem * Lit = DetectedPeers_LV->firstChild();
      while( Lit ) {
        TheP = ((PeerLVI *)Lit)->peer();
        if( TheP->state() == OTPeer::Peer_Down ) {
          unsigned int k;
          // what about linkkeys ?
          for( k = 0; k < Keys.count(); k ++ ) {
            if( TheP->address() == Keys[k].to() ||
                TheP->address() == Keys[k].from() 
              ) {
              // part of linkkey
-              owarn << "LINKKEY " << TheP->address().toString() << oendl;
+              odebug << "LINKKEY " << TheP->address().toString() << oendl;
              break;
            }
          }
          if( k == Keys.count() ) {
-            owarn << "RM LINKKEY " << TheP->address().toString() << oendl;
+            odebug << "RM LINKKEY " << TheP->address().toString() << oendl;
            // not found -> remember to remove this peer
            QListViewItem * Nit;
            OT->removePeer( TheP );
            Nit = Lit->nextSibling(); 
            delete Lit;
            Lit = Nit;
            continue;
          }
        } else {
-          owarn << "NODOWN " << TheP->address().toString() << oendl;
+          odebug << "NODOWN " << TheP->address().toString() << oendl;
        }
        Lit = Lit->nextSibling();
      }
 }
 void OTScan::SLOT_NewPeer( OTPeer * P, bool IsNew ){
      PeerLVI * it = 0;
      if( IsNew ) {
        it = new PeerLVI( P, DetectedPeers_LV );
      } else {
        // find peer in table
        QListViewItem * Lit = DetectedPeers_LV->firstChild();
        while( Lit ) {
          if( ((PeerLVI *)Lit)->peer() == P ) {
            // this item
            it = (PeerLVI *)Lit;
            break;
          }
          Lit = Lit->nextSibling();
        }
        if( ! it ) {
-          owarn << "Should not occur" << oendl;
+          odebug << "Should not occur" << oendl;
          return;
        }
      }
      // update/show info
      it->setText( 0, P->name() );
      it->setPixmap(0, Icons->deviceIcon( 
          OT->deviceTypeToName( P->deviceClass() ) ) );
      // tell peer to report its state async
      connect( P, 
               SIGNAL( peerStateReport( OTPeer *)),
               this,
               SLOT( SLOT_PeerState( OTPeer *))
             );
      if( IsNew ) {
        // find state
        refreshState( (PeerLVI *)it, 1 );
      } else {
        // update staet
        SLOT_PeerState( P );
      }
 }
 void OTScan::SLOT_PeerState( OTPeer * P ) {
      PeerLVI * it = (PeerLVI *)DetectedPeers_LV->firstChild();
      while( it ) {
        if( it->peer() == P ) {
          break;
        }
        it = (PeerLVI * )it->nextSibling();
      }
      if( ! it )
        return;
      switch( P->state() ) {
        case OTPeer::Peer_Unknown :
        case OTPeer::Peer_Down :
        it->setPixmap( 1, 0 );
          break;
        case OTPeer::Peer_Up :
          it->setPixmap( 1, Icons->loadPixmap( 
            ( P->connectedTo() ) ?  "connected" : "notconnected" ) );
          if( it == Current && ! StrengthTimer->isActive() ) {
            // start showing strength
            StrengthTimer->start( 1000, FALSE );
            SLOT_UpdateStrength();
          }
          break;
      }
 }
 void OTScan::SLOT_RefreshState( void ) {
      QListViewItem * it = DetectedPeers_LV->firstChild();
      while( it ) {
        if( it->isSelected() ) {
          break;
        }
        it = it->nextSibling();
      }
      if( ! it )
        return;
      refreshState( (PeerLVI *)it, 1 );
 }
 void OTScan::refreshState( PeerLVI * it, bool Force ) {
      it->setPixmap( 1, Icons->loadPixmap( "find" ) );
      it->peer()->findOutState( 30, Force );
 }
 void OTScan::SLOT_Show( QListViewItem * it ) {
      if( ! it || it->depth() > 0 )
        return;
      QString S;
      Current = (PeerLVI *)it;
      Strength_PB->setProgress( 0 ); // reset
      Address_LBL->setText( Current->peer()->address().toString() );
      Peer_GB->setTitle( Current->peer()->name() );
      const LinkKeyArray & Keys = OT->getLinkKeys();
      Paired_Led->setOn( FALSE );
      for( unsigned int i = 0;
           i < Keys.count();
           i ++ ) {
        if( Current->peer()->address() == Keys[i].to() ) {
          Paired_Led->setOn( TRUE );
          break;
        }
      }
      if( Current->peer()->state() == OTPeer::Peer_Up ) {
        RefreshServices_But->setEnabled( TRUE );
        StrengthTimer->start( 1000, FALSE );
        SLOT_UpdateStrength();
      } else {
        RefreshServices_But->setEnabled( FALSE );
      }
 }
 void OTScan::SLOT_UpdateStrength( void ) {
      OTDriver * D = Current->peer()->connectedTo();
      if( D ) {
        long Q = D->getLinkQuality( Current->peer()->address() );
        Strength_PB->setProgress( Q );
        if( ! Q ) {
          // no quality 
          Strength_PB->setEnabled( TRUE );
          StrengthTimer->stop();
        }
      } else {
        Strength_PB->setEnabled( FALSE );
        Strength_PB->setProgress( 0 );
        // no point in continuing
        StrengthTimer->stop();
      }
 }
 void OTScan::SLOT_RefreshServices( void ) {
      QListViewItem * it = DetectedPeers_LV->firstChild();
      while( it ) {
        if( it->isSelected() ) {
          break;
        }
        it = it->nextSibling();
      }
      if( ! it )
        return;
      QString S;
      PeerLVI * PI = (PeerLVI *)it;
      scanMode( true );
      qApp->processEvents(0);
      ServiceVector & V = PI->peer()->services();
      while( PI->firstChild() ) {
        // remove children
        delete PI->firstChild();
      }
      for( unsigned int i = 0 ; 
           i < V.count();
           i ++ ) {
        QString S;
        S = V[i]->name();
        if( S.isEmpty() ) {
          continue;
        }
        { QListViewItem * SIt;
          UUIDVector UIDV; 
          QPixmap Pm;
          bool Done = 0;
          bool R;
          short ID;
          SIt = 0;
          UIDV = V[i]->classIDList();
          // first all UUID ! 1200 12ff (Genericprofiles)
          for( unsigned int j = 0;
               j < UIDV.count();
               j ++ ) {
            if( Filter.count() ) {
              bool FilterOut = 1;
              // filter out if not in list
              for( unsigned int ff = 0;
                   ff < Filter.count();
                   ff ++ ) {
                if( UIDV[j] == Filter[ff] ) {
                  FilterOut = 0;
                  break;
                }
              }
              if( FilterOut ) {
                // not in filter list
                continue;
              }
            } // else show
            ID = UIDV[j].toShort();
            if( ID < 0x1200 || ID > 0x12ff ) {
              // use this profile
              if( R ) {
                unsigned int ch;
                bool has;
                has = V[i]->rfcommChannel( ch );
                SIt = new ChannelLVI( (has) ? (int)ch : -1 , PI );
                SIt->setText(0, V[i]->name() );
                Pm = Icons->serviceIcon( ID, R );
                SIt->setPixmap(0, Pm );
                Done = 1;
                break;
              }
            }
          }
          if( ! Done ) {
            // check other range too
            for( unsigned int j = 0;
                 j < UIDV.count();
                 j ++ ) {
              if( Filter.count() ) {
                bool FilterOut = 1;
                // filter out if not in list
                for( unsigned int ff = 0;
                     ff < Filter.count();
                     ff ++ ) {
                  if( UIDV[j] == Filter[ff] ) {
                    FilterOut = 0;
                    break;
                  }
                }
                if( FilterOut ) {
                  // not in filter list
                  continue;
                }
              } // else show
              ID = UIDV[j].toShort();
              if( ID >= 0x1200 && ID <= 0x12ff ) {
                // use this profile
                unsigned int ch;
                bool has;
                has = V[i]->rfcommChannel( ch );
                SIt = new ChannelLVI( (has) ? (int)ch : -1 , PI );
                SIt->setText(0, V[i]->name() );
                Pm = Icons->serviceIcon( ID, R );
                SIt->setPixmap(0, Pm );
                break;
              }
            }
          }
        }
      }
      scanMode( false );
 }
 void OTScan::scanMode( bool M ) {
      // avoid infinite loop because it triggers DoScan
      Detect_But->blockSignals( TRUE );
      Detect_But->setOn( M );
      Detect_But->setText( (M) ? tr("Scanning") : tr("Scan") );
      Detect_But->blockSignals( FALSE );
 }
 //
 //
 //
 //
 //
 OTManage::OTManage( QWidget * parent, OTIcons * _IC ) :
            OTManageGUI( parent ) {
      OT = OTGateway::getOTGateway();
      Icons = (_IC ) ? _IC : new OTIcons();
      MyIcons = (_IC == 0 );
      AllDrivers_LV->setSorting(-1);
      connect( OT, 
               SIGNAL( driverListChanged() ),
               this,
               SLOT( SLOT_DriverListChanged() ) 
             );
      connect( OT,
               SIGNAL( stateChange( OTDriver *, bool ) ),
               this,
               SLOT( SLOT_StateChange( OTDriver *, bool ) )
             );
      SLOT_DriverListChanged();
      AllDrivers_LV->header()->hide();
 }
 OTManage::~OTManage() {
      if( MyIcons )
        delete Icons;
      OTGateway::releaseOTGateway();
 }
 void OTManage::SLOT_ShowDriver( QListViewItem * It ) {
      if( It == 0 || It->depth() > 0 ) 
        // not toplevel
        return;
      DriverLVI * it = (DriverLVI *) It;
      DriverIsUp_CB->setChecked( it->driver()->isUp() );
 }
 void OTManage::SLOT_UpDriver( bool Up ) {
      QListViewItem * it = AllDrivers_LV->firstChild();
      while( it ) {
        if( it->isSelected() ) {
          OTDriver * D = ((DriverLVI *)it)->driver();
-          owarn << "UP driver " << D->devname() << oendl;
+          odebug << "UP driver " << D->devname() << oendl;
          // this
          D->setUp( Up );
          return;
        }
        it = it->nextSibling();
      }
 }
 void OTManage::SLOT_StateChange( OTDriver * D, bool Up ) {
      QListViewItem * it = AllDrivers_LV->firstChild();
      while( it ) {
        if( ((DriverLVI *)it)->driver() == D ) {
          it->setPixmap( 0, 
               Icons->loadPixmap( ( Up ) ?  "bluezon" : "bluezoff" ) );
          return;
        }
        it = it->nextSibling();
      }
 }
 void OTManage::SLOT_DriverListChanged( ) {
      DriverLVI * It;
      QListViewItem * Sub;
      QListViewItem * First = 0;
      OTDriver* D;
      OTDriverList & DL = OT->getDriverList();
      AllDrivers_LV->clear();
      for( unsigned int i = 0;
           i < DL.count();
           i ++ ) {
        D = DL[i];
        It = new DriverLVI( D, AllDrivers_LV );
        if( ! First )
          First = It;
        It->setText( 0, D->devname() );
        It->setPixmap( 0, 
             Icons->loadPixmap( (D->isUp()) ? 
                                  "bluezon" : "bluezoff" ) );
        Sub = new QListViewItem( It );
        Sub->setText( 0, tr( "Name" ) );
        Sub->setText( 1, D->name() ); 
        Sub = new QListViewItem( It );
        Sub->setText( 0, tr( "Address" ) );
        Sub->setText( 1, D->address().toString() ); 
        Sub = new QListViewItem( It );
        Sub->setText( 0, tr( "Revision" ) );
        Sub->setText( 1, D->revision() ); 
        Sub = new QListViewItem( It );
        Sub->setText( 0, tr( "Manufacturer" ) );
        Sub->setText( 1, D->manufacturer() ); 
        QString Service, Device;
        D->getClass( Service, Device );
        Sub = new QListViewItem( It );
        Sub->setText( 0, tr( "Service classes" ) );
        Sub->setText( 1, Service ); 
        Sub = new QListViewItem( It );
        Sub->setText( 0, tr( "Device class" ) );
        Sub->setText( 1, Device ); 
      }
      if( DL.count() ) {
        AllDrivers_LV->setCurrentItem( First );
        DriverIsUp_CB->setEnabled( TRUE );
      } else {
        DriverIsUp_CB->setChecked( FALSE );
        DriverIsUp_CB->setEnabled( FALSE );
      }
 }
 void OTManage::SLOT_SetRefreshTimer( int v ) {
      OT->setRefreshTimer( v * 1000 );
 }
 //
 //
 //
 //
 //
 OTMain::OTMain( QWidget * parent ) : OTMainGUI( parent ) {
      Icons = new OTIcons();
      SnifWindow = 0;
      OT = OTGateway::getOTGateway();
      connect( OT,
               SIGNAL( deviceEnabled( bool ) ),
               this,
               SLOT( SLOT_DeviceIsEnabled( bool ) )
             );
      connect( OT, 
               SIGNAL( driverListChanged() ),
               this,
               SLOT( SLOT_DriverListChanged() ) 
             );
      connect( OT,
               SIGNAL( stateChange( OTDriver *, bool ) ),
               this,
               SLOT( SLOT_StateChange( OTDriver *, bool ) )
             );
      if( ! OT->needsEnabling() ) {
        MustBeEnabled_CB->hide();
      } else {
        // detect current state
        MustBeEnabled_CB->setChecked(
            OT->isEnabled() );
      }
      SLOT_DriverListChanged();
 }
 OTMain::~OTMain() {
      OTGateway::releaseOTGateway();
      delete Icons;
 }
 void OTMain::SLOT_DriverListChanged() {
      OTDriver * D;
      OTDriverList & DL = OT->getDriverList();
      DeviceList_CB->clear();
      for( unsigned int i = 0;
           i < DL.count();
           i ++ ) {
        D = DL[i];
        DeviceList_CB->insertItem(
           Icons->loadPixmap( (D->isUp()) ? 
                              "bluezon" : "bluezoff" ),
           D->devname() );
        if( D == OT->scanWith() ) {
          DeviceList_CB->setCurrentItem( i );
        }
      }
      Scan_But->setEnabled( OT->getDriverList().count() > 0 );
      DeviceList_CB->setEnabled( OT->getDriverList().count() > 0 );
 }
 void OTMain::SLOT_EnableBluetooth( bool Up ) {
      OT->SLOT_SetEnabled( Up );
 }
 void OTMain::SLOT_DeviceIsEnabled( bool Up ) {
      MustBeEnabled_CB->blockSignals( TRUE );
      MustBeEnabled_CB->setChecked( Up );
      MustBeEnabled_CB->blockSignals( FALSE );
 }
 void OTMain::SLOT_Manage( void ) {
      QDialog * Dlg = new QDialog( this, 0, TRUE );
      QVBoxLayout * V = new QVBoxLayout( Dlg );
      OTManage * Mng = new OTManage( Dlg, Icons );
      V->addWidget( Mng );
      Dlg->setCaption( tr("Manage local devices" ) );
      Dlg->showMaximized();
      Dlg->exec();
      delete Dlg;
 }
 void OTMain::SLOT_Scan( void ) {
      OTDriverList & DL = OT->getDriverList();
      for( unsigned int i = 0;
           i < DL.count();
           i ++ ) {
        if( DL[i]->isUp() &&
            DL[i]->devname() == DeviceList_CB->currentText()
          ) {
          QDialog * Dlg = new QDialog( this, 0, TRUE );
          QVBoxLayout * V = new QVBoxLayout( Dlg );
          OTScan * Scn = new OTScan( Dlg, Icons );
          OT->setScanWith( OT->driver(i) );
          V->addWidget( Scn );
          Dlg->setCaption( tr("Scan Neighbourhood" ) );
          Dlg->showMaximized();
          Dlg->exec();
          delete Dlg;
          return;
        }
      }
 }
 void OTMain::SLOT_StateChange( OTDriver * D, bool Up ) {
      for( int i = 0;
           i < DeviceList_CB->count();
           i ++ ) {
        if( DeviceList_CB->text(i) == D->devname() ) {
          DeviceList_CB->changeItem(
             Icons->loadPixmap( (Up) ? "bluezon" : "bluezoff" ),
             D->devname(),
             i );
          return;
        }
      }
 }
 void OTMain::SLOT_Pairing( void ) {
      QDialog * Dlg = new QDialog( this, 0, TRUE );
      QVBoxLayout * V = new QVBoxLayout( Dlg );
      OTPairing * Pair = new OTPairing( Dlg, Icons );
      V->addWidget( Pair );
      Dlg->showMaximized();
      Dlg->setCaption( tr("Manage pairing" ) );
      Dlg->exec();
      delete Dlg;
 }
 void OTMain::SLOT_Sniffing( void ) {
      if( SnifWindow == 0 ) {
        SnifWindow = new QDialog( this, 0, FALSE );
        QVBoxLayout * V = new QVBoxLayout( SnifWindow );
        OTSniffing * SN = new OTSniffing( SnifWindow );
        V->addWidget( SN );
      }
      SnifWindow->showMaximized();
      SnifWindow->show();
 }
diff --git a/noncore/settings/networksettings2/opietooth2/config.in b/noncore/settings/networksettings2/opietooth2/config.in
index 720f49a..084e8c0 100644
--- a/noncore/settings/networksettings2/opietooth2/config.in
+++ b/noncore/settings/networksettings2/opietooth2/config.in
@@ -1,5 +1,5 @@
 config NS2OPIETOOTH
-  boolean "opie-networksettings2 bluetooth library"
+  boolean "Opietooth2 bluetooth library"
  default "y"
-  depends ( LIBQPE || LIBQPE-X11 ) && LIBOPIE2CORE 
+  depends ( LIBQPE || LIBQPE-X11 ) && LIBOPIE2CORE && LIBBLUEZ_DEP && NS2CORE
diff --git a/noncore/settings/networksettings2/opietooth2/libopietooth2.postinst b/noncore/settings/networksettings2/opietooth2/libopietooth2.postinst
index cd605c2..2713c61 100755
--- a/noncore/settings/networksettings2/opietooth2/libopietooth2.postinst
+++ b/noncore/settings/networksettings2/opietooth2/libopietooth2.postinst
@@ -1,10 +1,10 @@
 #!/bin/sh
 QTPB=/opt/QtPalmtop/bin
 [ ! -L ${QTPB}/networksettings2-opietooth ] && ln -sf ${QTPB}/networksettings2 ${QTPB}/networksettings2-opietooth
 # qcop QPE/Taskbar "linkChanged(opietooth)"
-qcop QPE/Taskbar "reloadApps()"
+${QTPB}/qcop QPE/Taskbar "reloadApps()"
 exit 0
diff --git a/noncore/settings/networksettings2/opietooth2/opietooth2.pro b/noncore/settings/networksettings2/opietooth2/opietooth2.pro
index e0057a9..16277cf 100644
--- a/noncore/settings/networksettings2/opietooth2/opietooth2.pro
+++ b/noncore/settings/networksettings2/opietooth2/opietooth2.pro
@@ -1,37 +1,44 @@
 TEMPLATE        = lib
 CONFIG          += qt warn_on release
        #CONFIG         += qt warn_on debug
        DESTDIR         = $(OPIEDIR)/lib$(PROJMAK)
        HEADERS         = OTDevice.h  \
                  OTDriver.h  \
                  OTGateway.h \
                  OTHCISocket.h \
                  OTInquiry.h \
                  OTDeviceAddress.h \
                  OTIcons.h \
                  OTUUID.h \
                  OTSDPAttribute.h \
                  OTSDPService.h \
                  OTPeer.h \
                  Opietooth.h 
        SOURCES         = OTDevice.cpp \
                  OTDriver.cpp \
                  OTDriverList.cpp \
                  OTHCISocket.cpp \
                  OTInquiry.cpp \
                  OTDeviceAddress.cpp \
                  OTUUID.cpp \
                  OTSDPAttribute.cpp \
                  OTSDPService.cpp \
                  OTIcons.cpp \
                  OTPeer.cpp \
                  OTGateway.cpp \
                  Opietooth.cpp
        INCLUDEPATH+= $(OPIEDIR)/include ../networksettings2
        DEPENDPATH+= $(OPIEDIR)/include
 LIBS            += -lqpe -lopiecore2 -lbluetooth -lnetworksettings2
        INTERFACES= OTMainGUI.ui OTSniffGUI.ui OTScanGUI.ui OTManageGUI.ui OTPairingGUI.ui
        TARGET  = opietooth2
        VERSION         = 1.0.0
 include ( $(OPIEDIR)/include.pro )
+!isEmpty( LIBBLUEZ_INC_DIR ) {
+    INCLUDEPATH += $$LIBBLUEZ_INC_DIR
+}
+!isEmpty( LIBBLUEZ_LIB_DIR ) {
+    LIBS += -L$$LIBBLUEZ_LIB_DIR
+}
diff --git a/noncore/settings/networksettings2/profile/profilerun.cpp b/noncore/settings/networksettings2/profile/profilerun.cpp
index ab57a00..acb67bd 100644
--- a/noncore/settings/networksettings2/profile/profilerun.cpp
+++ b/noncore/settings/networksettings2/profile/profilerun.cpp
@@ -1,27 +1,27 @@
 #include <resources.h>
 #include "profilerun.h"
 State_t ProfileRun::detectState( void ) { 
    if( Data->Disabled ) {
      return Disabled;
    } 
    return Unknown;
 }
 QString ProfileRun::setMyState( NodeCollection * NC, Action_t A, bool ) { 
-    owarn << "Profile " << Data->Disabled << oendl;
+    odebug << "Profile " << Data->Disabled << oendl;
    if( A == Disable ) {
      if( ! Data->Disabled ) {
        Data->Disabled = 1;
        NC->setModified( 1 );
      }
    } else if( A == Enable ) {
      if( Data->Disabled ) { 
        Data->Disabled = 0;
        NC->setModified( 1 );
      }
    }
    return QString();
 }
diff --git a/noncore/settings/networksettings2/usb/usbrun.cpp b/noncore/settings/networksettings2/usb/usbrun.cpp
index eb439c1..de8c8a2 100644
--- a/noncore/settings/networksettings2/usb/usbrun.cpp
+++ b/noncore/settings/networksettings2/usb/usbrun.cpp
@@ -1,119 +1,120 @@
 #include <qfile.h>
 #include <qfileinfo.h>
 #include <qtextstream.h>
 #include <resources.h>
 #include "usbrun.h"
 State_t USBRun::detectState( void ) {
    // unavailable : no card found
    // available : card found and assigned to us or free
    // up : card found and assigned to us and up
    NodeCollection * NC = nodeCollection();
    QString S = QString( "/tmp/profile-%1.up" ).arg(NC->number());
    System & Sys = NSResources->system();
    InterfaceInfo * Run;
    QFile F( S );
    Log(("Detecting for %s\n", NC->name().latin1() ));
    if( F.open( IO_ReadOnly ) ) {
      // could open file -> read interface and assign
      QString X;
      QTextStream TS(&F);
      X = TS.readLine();
      Log(("%s exists\n", S.latin1() ));
      // find interface
      if( handlesInterface( X ) ) {
        for( QDictIterator<InterfaceInfo> It(Sys.interfaces());
             It.current();
             ++It ) {
          Run = It.current();
          if( X == Run->Name ) {
            NC->assignInterface( Run );
            return IsUp;
          }
        }
      }
    } 
    Log(("Assigned %p\n", NC->assignedInterface() ));
    if( ( Run = NC->assignedInterface() ) ) {
      // we already have an interface assigned -> still present ?
      if( ! Run->IsUp ) {
        // usb is still free -> keep assignment
        return Available;
      } // else interface is up but NOT us -> some other profile
    }
    // nothing (valid) assigned to us
    NC->assignInterface( 0 );
    // find possible interface
-    for( QDictIterator<InterfaceInfo> It(Sys.interfaces());
+    if( getInterface() ) {
-         It.current();
+      // proper type, and Not UP -> free
-         ++It ) {
+      // usb cables are currently always available when requested
-      Run = It.current();
+      // until we can detect if we are plugged in
+      return Available;
-      Log(("%s %d %d=%d %d\n",
-          Run->Name.latin1(),
-          handlesInterface( Run->Name ),
-              Run->CardType, ARPHRD_ETHER,
-              ! Run->IsUp ));
-      if( handlesInterface( Run->Name ) &&
-          Run->CardType == ARPHRD_ETHER &&
-          ! Run->IsUp
-        ) {
-        // proper type, and Not UP -> free
-        // usb cables are currently always available when requested
-        // until we can detect if we are plugged in
-        return Available;
-      }
    }
    return Unavailable;
 }
 QString USBRun::setMyState( NodeCollection * NC, Action_t A, bool ) {
-    // nothing needs to be done to 'activate' or 'deactivate' 
+    InterfaceInfo * I = getInterface();
-    // a cable
+    if( ! I ) {
+      return QString("No usb device available");
+    }
+    Log(( "Grabbed USB interface %s\n", I->Name.latin1() ));
+    // grab this interface
+    NC->assignInterface( I );
    return QString();
 }
 // get interface that is free or assigned to us
 InterfaceInfo * USBRun::getInterface( void ) {
    System & S = NSResources->system();
    InterfaceInfo * best = 0, * Run;
-    QRegExp R( "usb[0-9abcdef]" );
    for( QDictIterator<InterfaceInfo> It(S.interfaces());
         It.current();
         ++It ) {
      Run = It.current();
+      Log(("%s %d %d=%d %d\n",
+          Run->Name.latin1(),
+          handlesInterface( Run->Name ),
+              Run->CardType, ARPHRD_ETHER,
+              ! Run->IsUp ));
      if( handlesInterface( Run->Name ) &&
          Run->CardType == ARPHRD_ETHER
        ) {
        // this is a USB card
        if( Run->assignedConnection() == netNode()->connection() ) {
          // assigned to us
          return Run;
-        } else if( Run->assignedConnection() == 0 ) {
+        } else if( ! Run->IsUp &&
+                   Run->assignedConnection() == 0 ) {
          // free
          best = Run;
-        }
+        } // UP or not assigned to us
      }
    }
    return best; // can be 0
 }
 bool USBRun::handlesInterface( const QString & S ) {
    return Pat.match( S ) >= 0;
 }
 bool USBRun::handlesInterface( InterfaceInfo * I ) {
    return handlesInterface( I->Name );
 }