1 files changed, 10 insertions, 3 deletions

diff --git a/libkdepim/ksyncmanager.cpp b/libkdepim/ksyncmanager.cpp
index 61a9899..795cd30 100644
--- a/libkdepim/ksyncmanager.cpp
+++ b/libkdepim/ksyncmanager.cpp
@@ -1079,156 +1079,161 @@ void KSyncManager::showProgressBar(int percentage, QString caption, int total)
             bar->setTotalSteps (  total  ) ;
             bar->show();
         }
     bar->raise();
     bar->setProgress( percentage );
     qApp->processEvents();
 }
 
 void KSyncManager::hideProgressBar()
 {
     bar->hide();
     qApp->processEvents();
 }
 
 bool KSyncManager::isProgressBarCanceled()
 {
     return !bar->isVisible();
 }
 
 QString KSyncManager::syncFileName()
 {
 
     QString fn = "tempfile";
     switch(mTargetApp)
         {
         case (KAPI):
             fn = "tempsyncab.vcf";
             break;
         case (KOPI):
             fn = "tempsynccal.ics";
             break;
         case (PWMPI):
             fn = "tempsyncpw.pwm";
             break;
         default:
             break;
         }
 #ifdef DESKTOP_VERSION
     return  locateLocal( "tmp", fn );
 #else
     return (QString( "/tmp/" )+ fn );
 #endif
 }
 
 void KSyncManager::syncPi()
 {
     mIsKapiFile = true; 
     mPisyncFinished = false;
     qApp->processEvents();
     if ( mAskForPreferences )
         if ( !edit_pisync_options()) {
             mParent->topLevelWidget()->setCaption( i18n("Syncing aborted. Nothing synced.") );
             mPisyncFinished = true;
             return;
         }
     bool ok;
     Q_UINT16 port = mActiveSyncPort.toUInt(&ok);
     if ( ! ok ) {
         mParent->topLevelWidget()->setCaption( i18n("Sorry, no valid port.Syncing cancelled.") );
         mPisyncFinished = true;
         return;
     }
     mCurrentResourceLocal = "";
     mCurrentResourceRemote = "";
+    qDebug ( "KSM: sync pi %d",mSpecificResources.count()  );
     if ( mSpecificResources.count() ) {
         int lastSyncRes = mSpecificResources.count()/2;
         int ccc = mSpecificResources.count()-1;
         while ( lastSyncRes > 0 && ccc > 0 && mSpecificResources[ ccc ].isEmpty() ) {
             --ccc;
             --lastSyncRes;
+            qDebug ( "KSM: sync pi %d",ccc  );
         }
         int startLocal = 0;
         int startRemote = mSpecificResources.count()/2;
         emit multiResourceSyncStart( true );
         while ( startLocal < mSpecificResources.count()/2 ) {
             if (  startLocal+1 >= lastSyncRes )
                 emit multiResourceSyncStart( false );
             mPisyncFinished = false;
             mCurrentResourceLocal = mSpecificResources[ startLocal ];
-            mCurrentResourceRemote = mSpecificResources[ startRemote ];
+            mCurrentResourceRemote = mSpecificResources[ startRemote ]; 
+            qDebug ( "KSM: AAASyncing resources: Local: %s --- Remote: %s ",mCurrentResourceLocal.latin1(),  mCurrentResourceRemote.latin1() );
             if ( !mCurrentResourceRemote.isEmpty() ) {
                 qDebug ( "KSM: Syncing resources: Local: %s --- Remote: %s ",mCurrentResourceLocal.latin1(),  mCurrentResourceRemote.latin1() );
                 KCommandSocket* commandSocket = new KCommandSocket( mCurrentResourceRemote, mPassWordPiSync, port, mActiveSyncIP, this, mParent->topLevelWidget() );
                 connect( commandSocket, SIGNAL(commandFinished( KCommandSocket*, int )), this, SLOT(deleteCommandSocket(KCommandSocket*, int)) );
                 commandSocket->readFile(  syncFileName() );
                 while ( !mPisyncFinished ) {
                     //qDebug("waiting ");
                     qApp->processEvents();
                 }
             }
+            ++startRemote;
             ++startLocal;
         }
+        mPisyncFinished = true;
     } else {
         KCommandSocket* commandSocket = new KCommandSocket( "", mPassWordPiSync, port, mActiveSyncIP, this, mParent->topLevelWidget() );
         connect( commandSocket, SIGNAL(commandFinished( KCommandSocket*, int )), this, SLOT(deleteCommandSocket(KCommandSocket*, int)) );
         commandSocket->readFile(  syncFileName() );
     }
 }
 
 void KSyncManager::deleteCommandSocket(KCommandSocket*s, int state)
 {
     //enum { success, errorW, errorR, quiet };
 
 
 
     if ( state == KCommandSocket::errorR ||state == KCommandSocket::errorTO ||state == KCommandSocket::errorPW ||
          state == KCommandSocket::errorCA ||state == KCommandSocket::errorFI ||state == KCommandSocket::errorUN||state == KCommandSocket::errorED ) {
         if ( state == KCommandSocket::errorPW )
             mParent->topLevelWidget()->setCaption( i18n("Wrong password: Receiving remote file failed.") );
         else if ( state == KCommandSocket::errorR ||state == KCommandSocket::errorTO )
             mParent->topLevelWidget()->setCaption( i18n("ERROR: Receiving remote file failed.") );
         else if ( state == KCommandSocket::errorCA )
             mParent->topLevelWidget()->setCaption( i18n("Sync cancelled from remote.") );
         else if ( state == KCommandSocket::errorFI )
             mParent->topLevelWidget()->setCaption( i18n("File error on remote.") );
         else if ( state == KCommandSocket::errorED )
             mParent->topLevelWidget()->setCaption( i18n("Please close error dialog on remote.") );
         else if ( state == KCommandSocket::errorUN )
             mParent->topLevelWidget()->setCaption( i18n("Unknown error on remote.") );
         delete s;
         if ( state == KCommandSocket::errorR ) {
             KCommandSocket* commandSocket = new KCommandSocket( "",mPassWordPiSync, mActiveSyncPort.toUInt(), mActiveSyncIP, this, mParent->topLevelWidget());
             connect( commandSocket, SIGNAL(commandFinished( KCommandSocket*, int)), this, SLOT(deleteCommandSocket(KCommandSocket*, int )) );
             commandSocket->sendStop();
         }
         mPisyncFinished = true;
         return;
         
     } else  if ( state == KCommandSocket::errorW ) {
         mParent->topLevelWidget()->setCaption( i18n("ERROR:Writing back file failed.") );
         mPisyncFinished = true;
 
     } else  if ( state == KCommandSocket::successR ) {
         QTimer::singleShot( 1, this , SLOT ( readFileFromSocket()));
 
     } else  if ( state == KCommandSocket::successW ) {
         mParent->topLevelWidget()->setCaption( i18n("Pi-Sync successful!") );
         mPisyncFinished = true;
     } else  if ( state == KCommandSocket::quiet ){
         qDebug("KSS: quiet ");
         mPisyncFinished = true;
     } else {
         qDebug("KSS: Error: unknown state: %d ", state);
         mPisyncFinished = true;
     }
 
     delete s;
 }
 
 void KSyncManager::readFileFromSocket()
 {
     QString fileName = syncFileName();
     bool syncOK = true;
     mParent->topLevelWidget()->setCaption( i18n("Remote file saved to temp file.") );
     if ( ! syncWithFile( fileName , true ) ) {
         mParent->topLevelWidget()->setCaption( i18n("Syncing failed.") );
@@ -1455,230 +1460,232 @@ void KServerSocket::send_file()
 void KServerSocket::get_file()
 {
     mSyncActionDialog->setCaption( i18n("Receiving synced file...") );
    
     piTime.start();
     piFileString = "";
     QTimer::singleShot( 1, this , SLOT (readBackFileFromSocket( ) ));
 }
 
 
 void KServerSocket::readBackFileFromSocket()
 {
     //qDebug("readBackFileFromSocket() %d ", piTime.elapsed ());
     while ( mSocket->canReadLine ()  ) {
         piTime.restart();
         QString line = mSocket->readLine ();
         piFileString += line;
         //qDebug("readline: %s ", line.latin1());
         mSyncActionDialog->setCaption( i18n("Received %1 bytes").arg( piFileString.length()  ) );
 
     }
     if ( piTime.elapsed () < 3000 ) {
         // wait for more 
         //qDebug("waitformore ");
         QTimer::singleShot( 100, this , SLOT (readBackFileFromSocket( ) ));
         return;
     }
     QString fileName = mFileName;
     QFile file ( fileName );
     if (!file.open( IO_WriteOnly ) ) {
         delete mSyncActionDialog;
         mSyncActionDialog = 0;
         qDebug("KSS:Error open read back file ");
         piFileString = "";
         emit file_received( false, mResource);
         emit file_received( false);
         blockRC = false;
         return ;
                     
     } 
 
     // mView->setLoadedFileVersion(QDateTime::currentDateTime().addSecs( -1));
     QTextStream ts ( &file );
     ts.setEncoding( QTextStream::Latin1 );
     mSyncActionDialog->setCaption( i18n("Writing file to disk...") );
     ts << piFileString;
     mSocket->close();
     if ( mSocket->state() == QSocket::Idle )
         QTimer::singleShot( 10, this , SLOT ( discardClient()));
     file.close(); 
     piFileString = "";
     emit file_received( true, mResource );
     emit file_received( true);
     delete mSyncActionDialog;
     mSyncActionDialog = 0;
     blockRC = false;
 
 }
 
 KCommandSocket::KCommandSocket ( QString remres, QString password, Q_UINT16 port, QString host, QObject * parent, QWidget * cap,  const char * name ): QObject( parent, name )
 {
     mRemoteResource = remres;
     if ( mRemoteResource.isEmpty() )
         mRemoteResource = "ALL";
+    else
+        mRemoteResource.replace (QRegExp (" "),"_" );
     mPassWord = password;
     mSocket = 0;
     mFirst = false;
     mFirstLine = true;
     mPort = port;
     mHost = host;
     tlw = cap;
     mRetVal = quiet;
     mTimerSocket = new QTimer ( this );
     connect( mTimerSocket, SIGNAL ( timeout () ), this, SLOT ( updateConnectDialog() ) );
     mConnectProgress.setCaption( i18n("Pi-Sync") );
     connect( &mConnectProgress, SIGNAL ( cancelled () ), this, SLOT ( deleteSocket() ) );
     mConnectCount = -1;
 }
 void KCommandSocket::sendFileRequest()
 {
     if ( tlw )
         tlw->setCaption( i18n("Connected! Sending request for remote file ...") );
     mConnectProgress.hide();
     mConnectCount = 300;mConnectMax = 300;
     mConnectProgress.setCaption( i18n("Pi-Sync: Connected!") );
     mTimerSocket->start( 100, true );
     QTextStream os( mSocket );
     os.setEncoding( QTextStream::Latin1 );
 
     QString curDt = " " +KGlobal::locale()->formatDateTime(QDateTime::currentDateTime().addSecs(-1),true, true,KLocale::ISODate );
-    os << "GET " << mPassWord << curDt << mRemoteResource  << "\r\n\r\n";
+    os << "GET " << mPassWord << curDt << " " << mRemoteResource  << "\r\n\r\n";
 }
 
 void KCommandSocket::readFile( QString fn )
 {
     if ( !mSocket ) {
         mSocket = new QSocket( this );
         connect( mSocket, SIGNAL(readyRead()), this, SLOT(startReadFileFromSocket()) );
         connect( mSocket, SIGNAL(delayedCloseFinished ()), this, SLOT(deleteSocket()) );
         connect( mSocket, SIGNAL(connected ()), this, SLOT(sendFileRequest() ));
     }
     mFileString = "";
     mFileName = fn;
     mFirst = true;
     if ( tlw )
         tlw->setCaption( i18n("Trying to connect to remote...") );
     mConnectCount = 30;mConnectMax = 30;
     mTimerSocket->start( 1000, true );
     mSocket->connectToHost( mHost, mPort ); 
     qDebug("KSS: Waiting for connection");
 }
 void KCommandSocket::updateConnectDialog()
 {
     
     if ( mConnectCount == mConnectMax  ) {
         //qDebug("MAXX %d", mConnectMax);
         mConnectProgress.setTotalSteps ( 30 );
         mConnectProgress.show();
         mConnectProgress.setLabelText( i18n("Trying to connect to remote...") );
     }
     //qDebug("updateConnectDialog() %d", mConnectCount);
     mConnectProgress.raise();
     mConnectProgress.setProgress( (mConnectMax - mConnectCount)%30 );
     --mConnectCount;
     if ( mConnectCount > 0 )
         mTimerSocket->start( 1000, true );
     else
         deleteSocket(); 
     
 }
 void KCommandSocket::writeFile( QString fileName  )
 {
     if ( !mSocket ) {
         mSocket = new QSocket( this );
         connect( mSocket, SIGNAL(delayedCloseFinished ()), this, SLOT(deleteSocket()) );
         connect( mSocket, SIGNAL(connected ()), this, SLOT(writeFileToSocket()) );
     }
     mFileName = fileName ;
     mConnectCount = 30;mConnectMax = 30;
     mTimerSocket->start( 1000, true );
     mSocket->connectToHost( mHost, mPort ); 
 }
 void KCommandSocket::writeFileToSocket()
 {
     mTimerSocket->stop();
     QFile file2( mFileName );
     if (!file2.open( IO_ReadOnly ) ) {
         mConnectProgress.hide();
         mConnectCount = -1;
         mRetVal= errorW;
         mSocket->close();
         if ( mSocket->state() == QSocket::Idle )
             QTimer::singleShot( 10, this , SLOT ( deleteSocket()));
         return ;
     }  
     mConnectProgress.setTotalSteps ( file2.size() );
     mConnectProgress.show();
     int count = 0;
     mConnectProgress.setLabelText( i18n("Sending back synced file...") );
     mConnectProgress.setProgress( count );
     mConnectProgress.blockSignals( true );
     QTextStream ts2( &file2 );
     ts2.setEncoding( QTextStream::Latin1 );
     QTextStream os2( mSocket );
     os2.setEncoding( QTextStream::Latin1 );
-    os2 << "PUT " << mPassWord << mRemoteResource << "\r\n\r\n";;
+    os2 << "PUT " << mPassWord << " " << mRemoteResource << "\r\n\r\n";;
     int byteCount = 0;
     int byteMax = file2.size()/53;
     while ( ! ts2.atEnd() ) {
         qApp->processEvents();
         if ( byteCount > byteMax ) {
             byteCount = 0;
             mConnectProgress.setProgress( count );
         }
         QString temp = ts2.readLine();
         count += temp.length();
         byteCount += temp.length();
         os2 << temp << "\r\n";
     }
     file2.close();
     mConnectProgress.hide();
     mConnectCount = -1;
     os2 << "\r\n";
     mRetVal= successW;
     mSocket->close();
     if ( mSocket->state() == QSocket::Idle )
         QTimer::singleShot( 10, this , SLOT ( deleteSocket()));
     mConnectProgress.blockSignals( false );
 }
 void KCommandSocket::sendStop()
 {
     if ( !mSocket ) {
         mSocket = new QSocket( this );
         connect( mSocket, SIGNAL(delayedCloseFinished ()), this, SLOT(deleteSocket()) );
     }
     mSocket->connectToHost( mHost, mPort ); 
     QTextStream os2( mSocket );
     os2.setEncoding( QTextStream::Latin1 );
     os2 << "STOP\r\n\r\n";
     mSocket->close();
     if ( mSocket->state() == QSocket::Idle )
         QTimer::singleShot( 10, this , SLOT ( deleteSocket()));
 }
 
 void KCommandSocket::startReadFileFromSocket()
 {
     if ( ! mFirst )
         return;
     mConnectProgress.setLabelText( i18n("Receiving file from remote...") );
     mFirst = false;
     mFileString = "";
     mTime.start();
     mFirstLine = true;
     QTimer::singleShot( 1, this , SLOT (readFileFromSocket( ) ));
 
 }
 void KCommandSocket::readFileFromSocket()
 {
     //qDebug("readBackFileFromSocket() %d ", mTime.elapsed ());
     while ( mSocket->canReadLine ()  ) {
         mTime.restart();
         QString line = mSocket->readLine ();
         if ( mFirstLine ) {
             mFirstLine = false;
             if (  line.left( 6 ) == "ERROR_" ) {
                 mTimerSocket->stop();
                 mConnectCount = -1;
                 if (  line.left( 8 ) == "ERROR_PW" ) {
                     mRetVal = errorPW;
                     deleteSocket();