- no default args in method impls

- don't unconditionally define _XOPEN_SOURCE (added comment about this
  being wrong)
- fixed parameter shadowing problem in DesktopApplication ctor

3 files changed, 14 insertions, 10 deletions

diff --git a/core/launcher/desktop.cpp b/core/launcher/desktop.cpp
index 43006f1..d5c16b3 100644
--- a/core/launcher/desktop.cpp
+++ b/core/launcher/desktop.cpp
@@ -11,258 +11,258 @@
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
 #include "desktop.h"
 #include "info.h"
 #include "launcher.h"
 #include "mrulist.h"
 #include "qcopbridge.h"
 #include "shutdownimpl.h"
 #include "startmenu.h"
 #include "taskbar.h"
 #include "transferserver.h"
 #include "irserver.h"
 #include "packageslave.h"
 
 #include <qpe/applnk.h>
 #include <qpe/mimetype.h>
 #include <qpe/password.h>
 #include <qpe/config.h>
 #include <qpe/power.h>
 #include <qpe/timeconversion.h>
 #include <qpe/qcopenvelope_qws.h>
 #include <qpe/global.h>
 #ifdef QT_QWS_CUSTOM
 #include "qpe/custom.h"
 #endif
 
 #include <qgfx_qws.h>
 #include <qmainwindow.h>
 #include <qmessagebox.h>
 #include <qtimer.h>
 #include <qwindowsystem_qws.h>
 
 #include <qvaluelist.h>
 
 #include <stdlib.h>
 #include <unistd.h>
 
 class QCopKeyRegister
 {
 public:
   QCopKeyRegister() : keyCode(0) { }
   QCopKeyRegister(int k, const QString &c, const QString &m)
   : keyCode(k), channel(c), message(m) { }
 
   int getKeyCode() const { return keyCode; }
   QString getChannel() const { return channel; }
   QString getMessage() const { return message; }
 
 private:
   int keyCode;
   QString channel, message;
 };
 
 typedef QValueList<QCopKeyRegister> KeyRegisterList;
 KeyRegisterList keyRegisterList;
 
 static Desktop* qpedesktop = 0;
 static int loggedin=0;
 static void login(bool at_poweron)
 {
     if ( !loggedin ) {
   Global::terminateBuiltin("calibrate");
   Password::authenticate(at_poweron);
   loggedin=1;
   QCopEnvelope e( "QPE/Desktop", "unlocked()" );
     }
 }
 
 bool Desktop::screenLocked()
 {
     return loggedin == 0;
 }
 
 /*
   Priority is number of alerts that are needed to pop up
   alert.
  */
 class DesktopPowerAlerter : public QMessageBox
 {
 public:
     DesktopPowerAlerter( QWidget *parent, const char *name = 0 )
   : QMessageBox( tr("Battery Status"), "Low Battery",
            QMessageBox::Critical,
            QMessageBox::Ok | QMessageBox::Default,
            QMessageBox::NoButton, QMessageBox::NoButton,
            parent, name, FALSE )
     {
   currentPriority = INT_MAX;
   alertCount = 0;
     }
 
     void alert( const QString &text, int priority );
     void hideEvent( QHideEvent * );
 private:
     int currentPriority;
     int alertCount;
 };
 
 void DesktopPowerAlerter::alert( const QString &text, int priority )
 {
     alertCount++;
     if ( alertCount < priority )
   return;
     if ( priority > currentPriority )
   return;
     currentPriority = priority;
     setText( text );
     show();
 }
 
 
 void DesktopPowerAlerter::hideEvent( QHideEvent *e )
 {
     QMessageBox::hideEvent( e );
     alertCount = 0;
     currentPriority = INT_MAX;
 }
 
 
 
-DesktopApplication::DesktopApplication( int& argc, char **argv, Type t )
-    : QPEApplication( argc, argv, t )
+DesktopApplication::DesktopApplication( int& argc, char **argv, Type appType )
+    : QPEApplication( argc, argv, appType )
 {
 
     QTimer *t = new QTimer( this );
     connect( t, SIGNAL(timeout()), this, SLOT(psTimeout()) );
     t->start( 10000 );
     ps = new PowerStatus;
     pa = new DesktopPowerAlerter( 0 );
 
   channel = new QCopChannel( "QPE/Desktop", this );
   connect( channel, SIGNAL(received(const QCString&, const QByteArray&)),
        this, SLOT(receive(const QCString&, const QByteArray&)) );
 }
 
 
 DesktopApplication::~DesktopApplication()
 {
     delete ps;
     delete pa;
 }
 
 void DesktopApplication::receive( const QCString &msg, const QByteArray &data )
 {
   QDataStream stream( data, IO_ReadOnly );
   if (msg == "keyRegister(int key, QString channel, QString message)")
   {
     int k;
     QString c, m;
 
     stream >> k;
     stream >> c;
     stream >> m;
 
     qWarning("KeyRegisterRecieved: %i, %s, %s", k, (const char*)c, (const char *)m);
     keyRegisterList.append(QCopKeyRegister(k,c,m));
   }
   else if (msg == "suspend()"){
     emit power();
   }
 
 }
 
 enum MemState { Unknown, VeryLow, Low, Normal } memstate=Unknown;
 
 #ifdef Q_WS_QWS
 bool DesktopApplication::qwsEventFilter( QWSEvent *e )
 {
     qpedesktop->checkMemory();
 
     if ( e->type == QWSEvent::Key ) {
     QWSKeyEvent *ke = (QWSKeyEvent *)e;
     if ( !loggedin && ke->simpleData.keycode != Key_F34 )
       return TRUE;
     bool press = ke->simpleData.is_press;
 
     if (!keyRegisterList.isEmpty())
     {
       KeyRegisterList::Iterator it;
       for( it = keyRegisterList.begin(); it != keyRegisterList.end(); ++it )
       {
         if ((*it).getKeyCode() == ke->simpleData.keycode)
         QCopEnvelope((*it).getChannel().utf8(), (*it).getMessage().utf8());
       }
     }
 
     if ( !keyboardGrabbed() ) {
       if ( ke->simpleData.keycode == Key_F9 ) {
       if ( press ) emit datebook();
       return TRUE;
       }
       if ( ke->simpleData.keycode == Key_F10 ) {
         if ( !press && cardSendTimer ) {
         emit contacts();
         delete cardSendTimer;
       } else if ( press ) {
         cardSendTimer = new QTimer();
         cardSendTimer->start( 2000, TRUE );
         connect( cardSendTimer, SIGNAL( timeout() ), this, SLOT( sendCard() ) );
       }
       return TRUE;
       }
       /* menu key now opens application menu/toolbar
        if ( ke->simpleData.keycode == Key_F11 ) {
        if ( press ) emit menu();
        return TRUE;
        }
       */
       if ( ke->simpleData.keycode == Key_F12 ) {
       while( activePopupWidget() )
         activePopupWidget()->close();
       if ( press ) emit launch();
       return TRUE;
       }
       if ( ke->simpleData.keycode == Key_F13 ) {
       if ( press ) emit email();
       return TRUE;
       }
     }
 
     if ( ke->simpleData.keycode == Key_F34 ) {
       if ( press ) emit power();
       return TRUE;
     }
     if ( ke->simpleData.keycode == Key_SysReq ) {
       if ( press ) emit power();
       return TRUE;
     }
     if ( ke->simpleData.keycode == Key_F35 ) {
       if ( press ) emit backlight();
       return TRUE;
     }
     if ( ke->simpleData.keycode == Key_F32 ) {
       if ( press ) QCopEnvelope e( "QPE/Desktop", "startSync()" );
       return TRUE;
     }
     if ( ke->simpleData.keycode == Key_F31 && !ke->simpleData.modifiers ) {
       if ( press ) emit symbol();
       return TRUE;
     }
     if ( ke->simpleData.keycode == Key_NumLock ) {
       if ( press ) emit numLockStateToggle();
     }
     if ( ke->simpleData.keycode == Key_CapsLock ) {
       if ( press ) emit capsLockStateToggle();
     }
     if ( press )
       qpedesktop->keyClick();
     } else {
     if ( e->type == QWSEvent::Mouse ) {
diff --git a/core/launcher/qcopbridge.cpp b/core/launcher/qcopbridge.cpp
index c8af919..2d084fc 100644
--- a/core/launcher/qcopbridge.cpp
+++ b/core/launcher/qcopbridge.cpp
@@ -1,300 +1,304 @@
 /**********************************************************************
 ** Copyright (C) 2000 Trolltech AS.  All rights reserved.
 **
 ** This file is part of Qtopia Environment.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
 #include "qcopbridge.h"
 #include "transferserver.h"
 
 #include <qpe/qcopenvelope_qws.h>
 #include <qpe/qpeapplication.h>
 
 #include <qdir.h>
 #include <qfile.h>
 #include <qtextstream.h>
 #include <qdatastream.h>
 #include <qstringlist.h>
 #include <qfileinfo.h>
 #include <qregexp.h>
 #include <qcopchannel_qws.h>
 
+// actually this is wrong, _XOPEN_SOURCE should get defined on the commandline
+// and it should have a proper value assigned. (Simon)
+#if !defined(_XOPEN_SOURCE)
 #define _XOPEN_SOURCE
+#endif
 #include <pwd.h>
 #include <sys/types.h>
 #include <unistd.h>
 
 #if defined(_OS_LINUX_)
 #include <shadow.h>
 #endif
 
 //#define INSECURE
 
 const int block_size = 51200;
 
-QCopBridge::QCopBridge( Q_UINT16 port, QObject *parent = 0,
-        const char* name = 0)
+QCopBridge::QCopBridge( Q_UINT16 port, QObject *parent,
+        const char* name )
     : QServerSocket( port, 1, parent, name ),
       desktopChannel( 0 ),
       cardChannel( 0 )
 {
     if ( !ok() )
   qWarning( "Failed to bind to port %d", port );
     else {
   desktopChannel = new QCopChannel( "QPE/Desktop", this );
   connect( desktopChannel, SIGNAL(received(const QCString &, const QByteArray &)),
      this, SLOT(desktopMessage( const QCString &, const QByteArray &)) );
   cardChannel = new QCopChannel( "QPE/Card", this );
   connect( cardChannel, SIGNAL(received(const QCString &, const QByteArray &)),
      this, SLOT(desktopMessage( const QCString &, const QByteArray &)) );
     }
     sendSync = FALSE;
 }
 
 QCopBridge::~QCopBridge()
 {
     delete desktopChannel;
 }
 
 void QCopBridge::newConnection( int socket )
 {
     QCopBridgePI *pi = new QCopBridgePI( socket, this );
     openConnections.append( pi );
     connect ( pi, SIGNAL( connectionClosed( QCopBridgePI *) ), this, SLOT( connectionClosed( QCopBridgePI *) ) );
     QCopEnvelope( "QPE/System", "setScreenSaverMode(int)" ) << QPEApplication::DisableSuspend;
     
     if ( sendSync ) {
   pi ->startSync();
   sendSync = FALSE;
     }
 }
 
 void QCopBridge::connectionClosed( QCopBridgePI *pi )
 {
     openConnections.remove( pi );
     if ( openConnections.count() == 0 ) {
   QCopEnvelope( "QPE/System", "setScreenSaverMode(int)" ) << QPEApplication::Enable;
     }
 }    
 
 void QCopBridge::closeOpenConnections()
 {
     QCopBridgePI *pi;
     for ( pi = openConnections.first(); pi != 0; pi = openConnections.next() )
   pi->close();
 }
 
 
 void QCopBridge::desktopMessage( const QCString &command, const QByteArray &args )
 {
     command.stripWhiteSpace();
 
     int paren = command.find( "(" );
     if ( paren <= 0 ) {
   qDebug("DesktopMessage: bad qcop syntax");
   return;
     }
 
     QString params = command.mid( paren + 1 );
     if ( params[params.length()-1] != ')' ) {
   qDebug("DesktopMessage: bad qcop syntax");
   return;
     }
 
     params.truncate( params.length()-1 );
 
     QStringList paramList = QStringList::split( ",", params );
     QString data;
     if ( paramList.count() ) {
   QDataStream stream( args, IO_ReadOnly );
   for ( QStringList::Iterator it = paramList.begin(); it != paramList.end(); ++it ) {
       QString str;
       if ( *it == "QString" ) {
     stream >> str;
       } else if ( *it == "QCString" ) {
     QCString cstr;
     stream >> cstr;
     str = QString::fromLocal8Bit( cstr );
       } else if ( *it == "int" ) {
     int i;
     stream >> i;
     str = QString::number( i );
       } else if ( *it == "bool" ) {
     int i;
     stream >> i;
     str = QString::number( i );
       } else {
     qDebug(" cannot route the argument type %s through the qcop bridge", (*it).latin1() );
     return;
       }
       str.replace( QRegExp("&"), "&amp;" );
       str.replace( QRegExp(" "), "&0x20;" );
       str.replace( QRegExp("\n"), "&0x0d;" );
       str.replace( QRegExp("\r"), "&0x0a;" );
       data += " " + str;
   }
     }
     QString sendCommand = QString(command.data()) + data;
     // send the command to all open connections
     if ( command == "startSync()" ) {
   // we need to buffer it a bit
   sendSync = TRUE;
   startTimer( 20000 );
     }  
     
     QCopBridgePI *pi;
     for ( pi = openConnections.first(); pi != 0; pi = openConnections.next() ) {
   pi->sendDesktopMessage( sendCommand );
     }
 }
 
 void QCopBridge::timerEvent( QTimerEvent * )
 {
     sendSync = FALSE;
     killTimers();
 }
 
 
-QCopBridgePI::QCopBridgePI( int socket, QObject *parent = 0, const char* name = 0 )
+QCopBridgePI::QCopBridgePI( int socket, QObject *parent, const char* name )
     : QSocket( parent, name ) 
 {
     setSocket( socket );
 
     peerport = peerPort();
     peeraddress = peerAddress();
 
 #ifndef INSECURE
     if ( !accessAuthorized(peeraddress) ) {
   state = Forbidden;
   startTimer( 0 );
     } else 
 #endif  
     {
   state = Connected;
   sendSync = FALSE;
   connect( this, SIGNAL( readyRead() ), SLOT( read() ) );
   connect( this, SIGNAL( connectionClosed() ), SLOT( connectionClosed() ) );
 
   send( "220 Qtopia QCop bridge ready!" );
   state = Wait_USER;
 
   // idle timer to close connections when not used anymore
   startTimer( 60000 );
   connected = TRUE;
     }
 }
 
 
 QCopBridgePI::~QCopBridgePI()
 {
 
 }
 
 void QCopBridgePI::connectionClosed()
 {
     emit connectionClosed( this );
     // qDebug( "Debug: Connection closed" );
     delete this;
 }
 
 void QCopBridgePI::sendDesktopMessage( const QString &msg )
 {
     QString str = "CALL QPE/Desktop " + msg;
     send ( str );
 }
 
 
 void QCopBridgePI::send( const QString& msg )
 {
     QTextStream os( this );
     os << msg << endl;
     //qDebug( "sending qcop message: %s", msg.latin1() );
 }
 
 void QCopBridgePI::read()
 {
     while ( canReadLine() )
   process( readLine().stripWhiteSpace() );
 }
 
 bool QCopBridgePI::checkUser( const QString& user )
 {
     if ( user.isEmpty() ) return FALSE;
 
     struct passwd *pw;
     pw = getpwuid( geteuid() );
     QString euser = QString::fromLocal8Bit( pw->pw_name );
     return user == euser;
 }
 
 bool QCopBridgePI::checkPassword( const QString& password )
 {
     // ### HACK for testing on local host
     return true;
 
     /*
     struct passwd *pw = 0;
     struct spwd *spw = 0;
 
     pw = getpwuid( geteuid() );
     spw = getspnam( pw->pw_name );
 
     QString cpwd = QString::fromLocal8Bit( pw->pw_passwd );
     if ( cpwd == "x" && spw )
   cpwd = QString::fromLocal8Bit( spw->sp_pwdp );
 
     QString cpassword = QString::fromLocal8Bit( crypt( password.local8Bit(), cpwd.local8Bit() ) );
     return cpwd == cpassword;
 */
 }
 
 void QCopBridgePI::process( const QString& message )
 {
     //qDebug( "Command: %s", message.latin1() );
 
     // split message using "," as separator
     QStringList msg = QStringList::split( " ", message );
     if ( msg.isEmpty() ) return;
 
     // command token
     QString cmd = msg[0].upper();
 
     // argument token
     QString arg;
     if ( msg.count() >= 2 )
   arg = msg[1];
     
     // we always respond to QUIT, regardless of state
     if ( cmd == "QUIT" ) {
   send( "211 Have a nice day!" );
   delete this;
   return;
     }
 
     // connected to client
     if ( Connected == state )
   return;
 
     // waiting for user name
     if ( Wait_USER == state ) {
 
   if ( cmd != "USER" || msg.count() < 2 || !checkUser( arg ) ) {
       send( "530 Please login with USER and PASS" );
       return;
   }
   send( "331 User name ok, need password" );
   state = Wait_PASS;
diff --git a/core/launcher/transferserver.cpp b/core/launcher/transferserver.cpp
index 87a49eb..7294f9c 100644
--- a/core/launcher/transferserver.cpp
+++ b/core/launcher/transferserver.cpp
@@ -1,212 +1,212 @@
 /**********************************************************************
 ** Copyright (C) 2000 Trolltech AS.  All rights reserved.
 **
 ** This file is part of Qtopia Environment.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 #define _XOPEN_SOURCE
 #include <pwd.h>
 #include <sys/types.h>
 #include <unistd.h>
 #include <stdlib.h>
 
 #if defined(_OS_LINUX_)
 #include <shadow.h>
 #endif
 
 #include <qdir.h>
 #include <qfile.h>
 #include <qtextstream.h>
 #include <qdatastream.h>
 #include <qmessagebox.h>
 #include <qstringlist.h>
 #include <qfileinfo.h>
 #include <qregexp.h>
 //#include <qpe/qcopchannel_qws.h>
-#include <qpe/qprocess.h>
 #include <qpe/process.h>
 #include <qpe/config.h>
 #include <qpe/qcopenvelope_qws.h>
 
 #include "transferserver.h"
+#include "qprocess.h"
 
 const int block_size = 51200;
 
-TransferServer::TransferServer( Q_UINT16 port, QObject *parent = 0,
-        const char* name = 0)
+TransferServer::TransferServer( Q_UINT16 port, QObject *parent,
+        const char* name )
     : QServerSocket( port, 1, parent, name )
 {
     if ( !ok() )
         qWarning( "Failed to bind to port %d", port );
 }
 
 TransferServer::~TransferServer()
 {
 
 }
 
 void TransferServer::newConnection( int socket )
 {
     (void) new ServerPI( socket, this );
 }
 
 bool accessAuthorized(QHostAddress peeraddress)
 {
     Config cfg("Security");
     cfg.setGroup("Sync");
     uint auth_peer = cfg.readNumEntry("auth_peer",0xc0a80100);
     uint auth_peer_bits = cfg.readNumEntry("auth_peer_bits",24);
     bool ok = (peeraddress.ip4Addr() & (((1<<auth_peer_bits)-1)<<(32-auth_peer_bits)))
                     == auth_peer;
     /* Allows denial-of-service attack.
     if ( !ok ) {
         QMessageBox::warning(0,tr("Security"),
             tr("<p>An attempt to access this device from %1 has been denied.")
                 .arg(peeraddress.toString()));
     }
     */
     return ok;
 }
 
-ServerPI::ServerPI( int socket, QObject *parent = 0, const char* name = 0 )
+ServerPI::ServerPI( int socket, QObject *parent, const char* name )
     : QSocket( parent, name ) , dtp( 0 ), serversocket( 0 ), waitsocket( 0 )
 {
     state = Connected;
 
     setSocket( socket );
 
     peerport = peerPort();
     peeraddress = peerAddress();
 
 #ifndef INSECURE
     if ( !accessAuthorized(peeraddress) ) {
         state = Forbidden;
         startTimer( 0 );
     } else
         #endif
     {
         connect( this, SIGNAL( readyRead() ), SLOT( read() ) );
         connect( this, SIGNAL( connectionClosed() ), SLOT( connectionClosed() ) );
         
         passiv = FALSE;
         for( int i = 0; i < 4; i++ )
             wait[i] = FALSE;
 
         send( "220 Qtopia transfer service ready!" );
         state = Wait_USER;
 
         dtp = new ServerDTP( this );
         connect( dtp, SIGNAL( completed() ), SLOT( dtpCompleted() ) );
         connect( dtp, SIGNAL( failed() ), SLOT( dtpFailed() ) );
         connect( dtp, SIGNAL( error( int ) ), SLOT( dtpError( int ) ) );
 
 
         directory = QDir::currentDirPath();
 
         static int p = 1024;
 
         while ( !serversocket || !serversocket->ok() ) {
             delete serversocket;
             serversocket = new ServerSocket( ++p, this );
         }
         connect( serversocket, SIGNAL( newIncomming( int ) ),
                  SLOT( newConnection( int ) ) );
     }
 }
 
 ServerPI::~ServerPI()
 {
 
 }
 
 void ServerPI::connectionClosed()
 {
     // qDebug( "Debug: Connection closed" );
     delete this;
 }
 
 void ServerPI::send( const QString& msg )
 {
     QTextStream os( this );
     os << msg << endl;
     //qDebug( "Reply: %s", msg.latin1() );
 }
 
 void ServerPI::read()
 {
     while ( canReadLine() )
         process( readLine().stripWhiteSpace() );
 }
 
 bool ServerPI::checkUser( const QString& user )
 {
     if ( user.isEmpty() ) return FALSE;
 
     struct passwd *pw;
     pw = getpwuid( geteuid() );
     QString euser = QString::fromLocal8Bit( pw->pw_name );
     return user == euser;
 }
 
 bool ServerPI::checkPassword( const QString& /* password */ )
 {
     // ### HACK for testing on local host
     return true;
 
     /*
     struct passwd *pw = 0;
     struct spwd *spw = 0;
 
     pw = getpwuid( geteuid() );
     spw = getspnam( pw->pw_name );
 
     QString cpwd = QString::fromLocal8Bit( pw->pw_passwd );
     if ( cpwd == "x" && spw )
         cpwd = QString::fromLocal8Bit( spw->sp_pwdp );
 
     QString cpassword = QString::fromLocal8Bit( crypt( password.local8Bit(), cpwd.local8Bit() ) );
     return cpwd == cpassword;
 */
 }
 
 bool ServerPI::checkReadFile( const QString& file )
 {
     QString filename;
 
     if ( file[0] != "/" )
         filename = directory.path() + "/" + file;
     else
         filename = file;
 
     QFileInfo fi( filename );
     return ( fi.exists() && fi.isReadable() );
 }
 
 bool ServerPI::checkWriteFile( const QString& file )
 {
     QString filename;
 
     if ( file[0] != "/" )
         filename = directory.path() + "/" + file;
     else
         filename = file;
 
     QFileInfo fi( filename );
 
     if ( fi.exists() )
         if ( !QFile( filename ).remove() )
             return FALSE;
     return TRUE;
@@ -727,257 +727,257 @@ QString ServerPI::fileListing( QFileInfo *info )
     else
         s += "-";
 
     // permisson string
     s += permissionString( info ) + " ";
 
     // number of hardlinks
     int subdirs = 1;
 
     if ( info->isDir() )
         subdirs = 2;
     // FIXME : this is to slow
     //if ( info->isDir() )
     //subdirs = QDir( info->absFilePath() ).entryList( QDir::Dirs ).count();
 
     s += QString::number( subdirs ).rightJustify( 3, ' ', TRUE ) + " ";
 
     // owner
     s += info->owner().leftJustify( 8, ' ', TRUE ) + " ";
 
     // group
     s += info->group().leftJustify( 8, ' ', TRUE ) + " ";
 
     // file size in bytes
     s += QString::number( info->size() ).rightJustify( 9, ' ', TRUE ) + " ";
 
     // last modified date
     QDate date = info->lastModified().date();
     QTime time = info->lastModified().time();
     s += date.monthName( date.month() ) + " "
          + QString::number( date.day() ).rightJustify( 2, ' ', TRUE ) + " "
          + QString::number( time.hour() ).rightJustify( 2, '0', TRUE ) + ":"
          + QString::number( time.minute() ).rightJustify( 2,'0', TRUE ) + " ";
 
     // file name
     s += info->fileName();
 
     return s;
 }
 
 QString ServerPI::permissionString( QFileInfo *info )
 {
     if ( !info ) return QString( "---------" );
     QString s;
 
     // user
     if ( info->permission( QFileInfo::ReadUser ) ) s += "r";
     else s += "-";
     if ( info->permission( QFileInfo::WriteUser ) ) s += "w";
     else s += "-";
     if ( info->permission( QFileInfo::ExeUser ) ) s += "x";
     else s += "-";
 
     // group
     if ( info->permission( QFileInfo::ReadGroup ) ) s += "r";
     else s += "-";
     if ( info->permission( QFileInfo::WriteGroup ) )s += "w";
     else s += "-";
     if ( info->permission( QFileInfo::ExeGroup ) ) s += "x";
     else s += "-";
 
     // exec
     if ( info->permission( QFileInfo::ReadOther ) ) s += "r";
     else s += "-";
     if ( info->permission( QFileInfo::WriteOther ) ) s += "w";
     else s += "-";
     if ( info->permission( QFileInfo::ExeOther ) ) s += "x";
     else s += "-";
 
     return s;
 }
 
 void ServerPI::newConnection( int socket )
 {
     //qDebug( "New incomming connection" );
 
     if ( !passiv ) return;
 
     if ( wait[SendFile] ) {
         QStringList targets;
         if ( backupRestoreGzip( waitfile, targets ) )
             dtp->sendGzipFile( waitfile, targets );
         else
             dtp->sendFile( waitfile );
         dtp->setSocket( socket );
     }
     else if ( wait[RetrieveFile] ) {
       qDebug("check retrieve file");
       if ( backupRestoreGzip( waitfile ) )
         dtp->retrieveGzipFile( waitfile );
       else
         dtp->retrieveFile( waitfile );
       dtp->setSocket( socket );
     }
     else if ( wait[SendByteArray] ) {
         dtp->sendByteArray( waitarray );
         dtp->setSocket( socket );
     }
     else if ( wait[RetrieveByteArray] ) {
         qDebug("retrieve byte array");
         dtp->retrieveByteArray();
         dtp->setSocket( socket );
     }
     else
         waitsocket = socket;
 
     for( int i = 0; i < 4; i++ )
         wait[i] = FALSE;
 }
 
 QString ServerPI::absFilePath( const QString& file )
 {
     if ( file.isEmpty() ) return file;
 
     QString filepath( file );
     if ( file[0] != "/" )
         filepath = directory.path() + "/" + file;
 
     return filepath;
 }
 
 
 void ServerPI::timerEvent( QTimerEvent * )
 {
     connectionClosed();
 }
 
 
-ServerDTP::ServerDTP( QObject *parent = 0, const char* name = 0)
+ServerDTP::ServerDTP( QObject *parent, const char* name )
   : QSocket( parent, name ), mode( Idle ), createTargzProc( 0 ),
 retrieveTargzProc( 0 ), gzipProc( 0 )
 {
 
   connect( this, SIGNAL( connected() ), SLOT( connected() ) );
   connect( this, SIGNAL( connectionClosed() ), SLOT( connectionClosed() ) );
   connect( this, SIGNAL( bytesWritten( int ) ), SLOT( bytesWritten( int ) ) );
   connect( this, SIGNAL( readyRead() ), SLOT( readyRead() ) );
 
   gzipProc = new QProcess( this, "gzipProc" );
   gzipProc->setCommunication( QProcess::Stdin | QProcess::Stdout );
 
   createTargzProc = new QProcess( QString("tar"), this, "createTargzProc");
   createTargzProc->setCommunication( QProcess::Stdout );
   createTargzProc->setWorkingDirectory( QDir::rootDirPath() );
   connect( createTargzProc, SIGNAL( processExited() ), SLOT( targzDone() ) );
 
   QStringList args = "tar";
   args += "-xv";
   retrieveTargzProc = new QProcess( args, this, "retrieveTargzProc" );
   retrieveTargzProc->setCommunication( QProcess::Stdin );
   retrieveTargzProc->setWorkingDirectory( QDir::rootDirPath() );
   connect( retrieveTargzProc, SIGNAL( processExited() ),
            SIGNAL( completed() ) );
   connect( retrieveTargzProc, SIGNAL( processExited() ),
            SLOT( extractTarDone() ) );
 }
 
 ServerDTP::~ServerDTP()
 {
     buf.close();
     file.close();
     createTargzProc->kill();
 }
 
 void ServerDTP::extractTarDone()
 {
     qDebug("extract done");
     QCopEnvelope e( "QPE/Desktop", "restoreDone(QString)" );
     e << file.name();
 }
 
 void ServerDTP::connected()
 {
   // send file mode
   switch ( mode ) {
   case SendFile :
     if ( !file.exists() || !file.open( IO_ReadOnly) ) {
       emit failed();
       mode = Idle;
       return;
     }
 
     //qDebug( "Debug: Sending file '%s'", file.name().latin1() );
 
     bytes_written = 0;
     if ( file.size() == 0 ) {
       //make sure it doesn't hang on empty files
       file.close();
       emit completed();
       mode = Idle;
     } else {
 
       if( !file.atEnd() ) {
         QCString s;
         s.resize( block_size );
         int bytes = file.readBlock( s.data(), block_size );
         writeBlock( s.data(), bytes );
       }
     }
     break;
   case SendGzipFile:
     if ( createTargzProc->isRunning() ) {
       // SHOULDN'T GET HERE, BUT DOING A SAFETY CHECK ANYWAY
       qWarning("Previous tar --gzip process is still running; killing it...");
       createTargzProc->kill();
     }
 
     bytes_written = 0;
     qDebug("==>start send tar process");
     if ( !createTargzProc->start() )
       qWarning("Error starting %s or %s",
                createTargzProc->arguments().join(" ").latin1(),
                gzipProc->arguments().join(" ").latin1() );
     break;
   case SendBuffer:
     if ( !buf.open( IO_ReadOnly) ) {
       emit failed();
       mode = Idle;
       return;
     }
 
     // qDebug( "Debug: Sending byte array" );
     bytes_written = 0;
     while( !buf.atEnd() )
       putch( buf.getch() );
     buf.close();
     break;
   case RetrieveFile:
     // retrieve file mode
     if ( file.exists() && !file.remove() ) {
       emit failed();
       mode = Idle;
       return;
     }
 
     if ( !file.open( IO_WriteOnly) ) {
       emit failed();
       mode = Idle;
       return;
     }
     // qDebug( "Debug: Retrieving file %s", file.name().latin1() );
     break;
   case RetrieveGzipFile:
     qDebug("=-> starting tar process to receive .tgz file");
     break;
   case RetrieveBuffer:
     // retrieve buffer mode
     if ( !buf.open( IO_WriteOnly) ) {
       emit failed();
       mode = Idle;
       return;
     }
     // qDebug( "Debug: Retrieving byte array" );
     break;
   case Idle:
     qDebug("connection established but mode set to Idle; BUG!");
     break;